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 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 28 /* 29 * SATA Framework 30 * Generic SATA Host Adapter Implementation 31 */ 32 33 #include <sys/conf.h> 34 #include <sys/file.h> 35 #include <sys/ddi.h> 36 #include <sys/sunddi.h> 37 #include <sys/modctl.h> 38 #include <sys/cmn_err.h> 39 #include <sys/errno.h> 40 #include <sys/thread.h> 41 #include <sys/kstat.h> 42 #include <sys/note.h> 43 #include <sys/sysevent.h> 44 #include <sys/sysevent/eventdefs.h> 45 #include <sys/sysevent/dr.h> 46 #include <sys/taskq.h> 47 #include <sys/disp.h> 48 49 #include <sys/sata/impl/sata.h> 50 #include <sys/sata/sata_hba.h> 51 #include <sys/sata/sata_defs.h> 52 #include <sys/sata/sata_cfgadm.h> 53 #include <sys/sata/sata_blacklist.h> 54 #include <sys/sata/sata_satl.h> 55 56 #include <sys/scsi/impl/spc3_types.h> 57 58 /* Debug flags - defined in sata.h */ 59 int sata_debug_flags = 0; 60 int sata_msg = 0; 61 62 /* 63 * Flags enabling selected SATA HBA framework functionality 64 */ 65 #define SATA_ENABLE_QUEUING 1 66 #define SATA_ENABLE_NCQ 2 67 #define SATA_ENABLE_PROCESS_EVENTS 4 68 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */ 69 int sata_func_enable = 70 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; 71 72 /* 73 * Global variable setting default maximum queue depth (NCQ or TCQ) 74 * Note:minimum queue depth is 1 75 */ 76 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */ 77 78 /* 79 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver 80 * initialization, using value from sata_max_queue_depth 81 * It is adjusted to minimum supported by the controller and by the device, 82 * if queueing is enabled. 83 */ 84 static int sata_current_max_qdepth; 85 86 /* 87 * Global variable determining the default behavior after device hotpluggin. 88 * If non-zero, the hotplugged device is onlined (if possible) without explicit 89 * IOCTL request (AP_CONFIGURE). 90 * If zero, hotplugged device is identified, but not onlined. 91 * Enabling (AP_CONNECT) device port with an attached device does not result 92 * in device onlining regardless of the flag setting 93 */ 94 int sata_auto_online = 0; 95 96 #ifdef SATA_DEBUG 97 98 #define SATA_LOG_D(args) sata_log args 99 uint64_t mbuf_count = 0; 100 uint64_t mbuffail_count = 0; 101 102 sata_atapi_cmd_t sata_atapi_trace[64]; 103 uint32_t sata_atapi_trace_index = 0; 104 int sata_atapi_trace_save = 1; 105 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int); 106 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \ 107 sata_save_atapi_trace(spx, count); 108 109 #else 110 #define SATA_LOG_D(args) sata_trace_log args 111 #define SATAATAPITRACE(spx, count) 112 #endif 113 114 #if 0 115 static void 116 sata_test_atapi_packet_command(sata_hba_inst_t *, int); 117 #endif 118 119 #ifdef SATA_INJECT_FAULTS 120 121 #define SATA_INJECT_PKT_FAULT 1 122 uint32_t sata_inject_fault = 0; 123 124 uint32_t sata_inject_fault_count = 0; 125 uint32_t sata_inject_fault_pause_count = 0; 126 uint32_t sata_fault_type = 0; 127 uint32_t sata_fault_cmd = 0; 128 dev_info_t *sata_fault_ctrl = NULL; 129 sata_device_t sata_fault_device; 130 131 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int); 132 133 #endif 134 135 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */ 136 137 static char sata_rev_tag[] = {"1.46"}; 138 139 /* 140 * SATA cb_ops functions 141 */ 142 static int sata_hba_open(dev_t *, int, int, cred_t *); 143 static int sata_hba_close(dev_t, int, int, cred_t *); 144 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 145 146 /* 147 * SCSA required entry points 148 */ 149 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, 150 scsi_hba_tran_t *, struct scsi_device *); 151 static int sata_scsi_tgt_probe(struct scsi_device *, 152 int (*callback)(void)); 153 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, 154 scsi_hba_tran_t *, struct scsi_device *); 155 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); 156 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); 157 static int sata_scsi_reset(struct scsi_address *, int); 158 static int sata_scsi_getcap(struct scsi_address *, char *, int); 159 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); 160 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, 161 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), 162 caddr_t); 163 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); 164 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); 165 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); 166 167 /* 168 * SATA HBA interface functions are defined in sata_hba.h header file 169 */ 170 171 /* Event processing functions */ 172 static void sata_event_daemon(void *); 173 static void sata_event_thread_control(int); 174 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); 175 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t); 176 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); 177 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *); 178 static void sata_process_port_failed_event(sata_hba_inst_t *, 179 sata_address_t *); 180 static void sata_process_port_link_events(sata_hba_inst_t *, 181 sata_address_t *); 182 static void sata_process_pmport_link_events(sata_hba_inst_t *, 183 sata_address_t *); 184 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); 185 static void sata_process_pmdevice_detached(sata_hba_inst_t *, 186 sata_address_t *); 187 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); 188 static void sata_process_pmdevice_attached(sata_hba_inst_t *, 189 sata_address_t *); 190 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); 191 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); 192 static void sata_process_target_node_cleanup(sata_hba_inst_t *, 193 sata_address_t *); 194 static void sata_process_device_autoonline(sata_hba_inst_t *, 195 sata_address_t *saddr); 196 197 /* 198 * Local translation functions 199 */ 200 static int sata_txlt_inquiry(sata_pkt_txlate_t *); 201 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); 202 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); 203 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); 204 static int sata_txlt_request_sense(sata_pkt_txlate_t *); 205 static int sata_txlt_read(sata_pkt_txlate_t *); 206 static int sata_txlt_write(sata_pkt_txlate_t *); 207 static int sata_txlt_log_sense(sata_pkt_txlate_t *); 208 static int sata_txlt_log_select(sata_pkt_txlate_t *); 209 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); 210 static int sata_txlt_mode_select(sata_pkt_txlate_t *); 211 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *); 212 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); 213 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); 214 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); 215 216 static int sata_hba_start(sata_pkt_txlate_t *, int *); 217 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); 218 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t); 219 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); 220 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *); 221 static void sata_txlt_rw_completion(sata_pkt_t *); 222 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); 223 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt); 224 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *); 225 static int sata_emul_rw_completion(sata_pkt_txlate_t *); 226 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t, 227 uint8_t); 228 static struct scsi_extended_sense *sata_immediate_error_response( 229 sata_pkt_txlate_t *, int); 230 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); 231 232 static int sata_txlt_atapi(sata_pkt_txlate_t *); 233 static void sata_txlt_atapi_completion(sata_pkt_t *); 234 235 /* 236 * Local functions for ioctl 237 */ 238 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); 239 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, 240 devctl_ap_state_t *); 241 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t); 242 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *); 243 static dev_info_t *sata_devt_to_devinfo(dev_t); 244 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *); 245 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *); 246 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *); 247 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *); 248 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *); 249 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *); 250 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *); 251 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *); 252 static int sata_ioctl_reset_all(sata_hba_inst_t *); 253 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *); 254 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *, 255 sata_ioctl_data_t *, int mode); 256 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *, 257 sata_ioctl_data_t *, int mode); 258 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *, 259 sata_ioctl_data_t *, int mode); 260 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *, 261 sata_ioctl_data_t *, int mode); 262 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *, 263 sata_device_t *, sata_ioctl_data_t *, int mode); 264 265 /* 266 * Local functions 267 */ 268 static void sata_remove_hba_instance(dev_info_t *); 269 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); 270 static void sata_probe_ports(sata_hba_inst_t *); 271 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t); 272 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); 273 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int); 274 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int); 275 static int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *); 276 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *); 277 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *); 278 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *, 279 sata_drive_info_t *); 280 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, 281 sata_address_t *); 282 static void sata_remove_target_node(sata_hba_inst_t *, 283 sata_address_t *); 284 static int sata_validate_scsi_address(sata_hba_inst_t *, 285 struct scsi_address *, sata_device_t *); 286 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); 287 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); 288 static void sata_pkt_free(sata_pkt_txlate_t *); 289 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), 290 caddr_t, ddi_dma_attr_t *); 291 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *); 292 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); 293 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, 294 sata_device_t *); 295 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); 296 static void sata_reidentify_device(sata_pkt_txlate_t *); 297 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); 298 static void sata_free_local_buffer(sata_pkt_txlate_t *); 299 static uint64_t sata_check_capacity(sata_drive_info_t *); 300 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, 301 ddi_dma_attr_t *); 302 static int sata_fetch_device_identify_data(sata_hba_inst_t *, 303 sata_drive_info_t *); 304 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); 305 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *); 306 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); 307 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *); 308 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); 309 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int); 310 static int sata_set_drive_features(sata_hba_inst_t *, 311 sata_drive_info_t *, int flag); 312 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); 313 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); 314 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, 315 uint8_t *); 316 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *, 317 struct scsi_inquiry *); 318 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); 319 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); 320 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); 321 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); 322 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); 323 static int sata_mode_select_page_8(sata_pkt_txlate_t *, 324 struct mode_cache_scsi3 *, int, int *, int *, int *); 325 static int sata_mode_select_page_1a(sata_pkt_txlate_t *, 326 struct mode_info_power_cond *, int, int *, int *, int *); 327 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, 328 struct mode_info_excpt_page *, int, int *, int *, int *); 329 static int sata_mode_select_page_30(sata_pkt_txlate_t *, 330 struct mode_acoustic_management *, int, int *, int *, int *); 331 332 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); 333 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, 334 sata_hba_inst_t *); 335 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, 336 sata_hba_inst_t *); 337 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, 338 sata_hba_inst_t *); 339 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *, 340 sata_pkt_txlate_t *); 341 342 static void sata_set_arq_data(sata_pkt_t *); 343 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t); 344 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t); 345 static uint8_t sata_get_standby_timer(uint8_t *timer); 346 347 static void sata_save_drive_settings(sata_drive_info_t *); 348 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); 349 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *); 350 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); 351 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...); 352 static int sata_fetch_smart_return_status(sata_hba_inst_t *, 353 sata_drive_info_t *); 354 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, 355 struct smart_data *); 356 static int sata_smart_selftest_log(sata_hba_inst_t *, 357 sata_drive_info_t *, 358 struct smart_selftest_log *); 359 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, 360 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); 361 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, 362 uint8_t *, uint8_t, uint8_t); 363 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, 364 struct read_log_ext_directory *); 365 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); 366 static void sata_xlate_errors(sata_pkt_txlate_t *); 367 static void sata_decode_device_error(sata_pkt_txlate_t *, 368 struct scsi_extended_sense *); 369 static void sata_set_device_removed(dev_info_t *); 370 static boolean_t sata_check_device_removed(dev_info_t *); 371 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *); 372 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *, 373 sata_drive_info_t *); 374 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *, 375 sata_drive_info_t *); 376 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *); 377 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *); 378 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *); 379 static int sata_check_modser(char *, int); 380 381 382 383 /* 384 * SATA Framework will ignore SATA HBA driver cb_ops structure and 385 * register following one with SCSA framework. 386 * Open & close are provided, so scsi framework will not use its own 387 */ 388 static struct cb_ops sata_cb_ops = { 389 sata_hba_open, /* open */ 390 sata_hba_close, /* close */ 391 nodev, /* strategy */ 392 nodev, /* print */ 393 nodev, /* dump */ 394 nodev, /* read */ 395 nodev, /* write */ 396 sata_hba_ioctl, /* ioctl */ 397 nodev, /* devmap */ 398 nodev, /* mmap */ 399 nodev, /* segmap */ 400 nochpoll, /* chpoll */ 401 ddi_prop_op, /* cb_prop_op */ 402 0, /* streamtab */ 403 D_NEW | D_MP, /* cb_flag */ 404 CB_REV, /* rev */ 405 nodev, /* aread */ 406 nodev /* awrite */ 407 }; 408 409 410 extern struct mod_ops mod_miscops; 411 extern uchar_t scsi_cdb_size[]; 412 413 static struct modlmisc modlmisc = { 414 &mod_miscops, /* Type of module */ 415 "SATA Module" /* module name */ 416 }; 417 418 419 static struct modlinkage modlinkage = { 420 MODREV_1, 421 (void *)&modlmisc, 422 NULL 423 }; 424 425 /* 426 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, 427 * i.e. when scsi_pkt has not timeout specified. 428 */ 429 static int sata_default_pkt_time = 60; /* 60 seconds */ 430 431 /* 432 * Intermediate buffer device access attributes - they are required, 433 * but not necessarily used. 434 */ 435 static ddi_device_acc_attr_t sata_acc_attr = { 436 DDI_DEVICE_ATTR_V0, 437 DDI_STRUCTURE_LE_ACC, 438 DDI_STRICTORDER_ACC 439 }; 440 441 442 /* 443 * Mutexes protecting structures in multithreaded operations. 444 * Because events are relatively rare, a single global mutex protecting 445 * data structures should be sufficient. To increase performance, add 446 * separate mutex per each sata port and use global mutex only to protect 447 * common data structures. 448 */ 449 static kmutex_t sata_mutex; /* protects sata_hba_list */ 450 static kmutex_t sata_log_mutex; /* protects log */ 451 452 static char sata_log_buf[256]; 453 454 /* 455 * sata trace debug 456 */ 457 static sata_trace_rbuf_t *sata_debug_rbuf; 458 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void); 459 static void sata_trace_dmsg_free(void); 460 static void sata_trace_rbuf_alloc(void); 461 static void sata_trace_rbuf_free(void); 462 463 int dmsg_ring_size = DMSG_RING_SIZE; 464 465 /* Default write cache setting for SATA hard disks */ 466 int sata_write_cache = 1; /* enabled */ 467 468 /* Default write cache setting for SATA ATAPI CD/DVD */ 469 int sata_atapicdvd_write_cache = 1; /* enabled */ 470 471 /* Default write cache setting for SATA ATAPI tape */ 472 int sata_atapitape_write_cache = 1; /* enabled */ 473 474 /* Default write cache setting for SATA ATAPI disk */ 475 int sata_atapidisk_write_cache = 1; /* enabled */ 476 477 /* 478 * Linked list of HBA instances 479 */ 480 static sata_hba_inst_t *sata_hba_list = NULL; 481 static sata_hba_inst_t *sata_hba_list_tail = NULL; 482 /* 483 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran 484 * structure and in sata soft state. 485 */ 486 487 /* 488 * Event daemon related variables 489 */ 490 static kmutex_t sata_event_mutex; 491 static kcondvar_t sata_event_cv; 492 static kthread_t *sata_event_thread = NULL; 493 static int sata_event_thread_terminate = 0; 494 static int sata_event_pending = 0; 495 static int sata_event_thread_active = 0; 496 extern pri_t minclsyspri; 497 498 /* 499 * NCQ error recovery command 500 */ 501 static const sata_cmd_t sata_rle_cmd = { 502 SATA_CMD_REV, 503 NULL, 504 { 505 SATA_DIR_READ 506 }, 507 ATA_ADDR_LBA48, 508 0, 509 0, 510 0, 511 0, 512 0, 513 1, 514 READ_LOG_EXT_NCQ_ERROR_RECOVERY, 515 0, 516 0, 517 0, 518 SATAC_READ_LOG_EXT, 519 0, 520 0, 521 0, 522 }; 523 524 /* 525 * ATAPI error recovery CDB 526 */ 527 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = { 528 SCMD_REQUEST_SENSE, 529 0, /* Only fixed RQ format is supported */ 530 0, 531 0, 532 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */ 533 0 534 }; 535 536 537 /* Warlock directives */ 538 539 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) 540 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) 541 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) 542 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) 543 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) 544 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) 545 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) 546 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) 547 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state)) 548 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) 549 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) 550 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) 551 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) 552 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ 553 sata_hba_inst::satahba_scsi_tran)) 554 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) 555 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) 556 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) 557 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) 558 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, 559 sata_hba_inst::satahba_event_flags)) 560 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 561 sata_cport_info::cport_devp)) 562 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) 563 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) 564 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 565 sata_cport_info::cport_dev_type)) 566 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) 567 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 568 sata_cport_info::cport_state)) 569 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) 570 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 571 sata_pmport_info::pmport_state)) 572 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state)) 573 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 574 sata_pmport_info::pmport_dev_type)) 575 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) 576 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 577 sata_pmport_info::pmport_sata_drive)) 578 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 579 sata_pmport_info::pmport_tgtnode_clean)) 580 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 581 sata_pmport_info::pmport_event_flags)) 582 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) 583 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) 584 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) 585 #ifdef SATA_DEBUG 586 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) 587 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) 588 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace)) 589 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index)) 590 #endif 591 592 /* End of warlock directives */ 593 594 /* ************** loadable module configuration functions ************** */ 595 596 int 597 _init() 598 { 599 int rval; 600 601 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); 602 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); 603 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); 604 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); 605 sata_trace_rbuf_alloc(); 606 if ((rval = mod_install(&modlinkage)) != 0) { 607 #ifdef SATA_DEBUG 608 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); 609 #endif 610 sata_trace_rbuf_free(); 611 mutex_destroy(&sata_log_mutex); 612 cv_destroy(&sata_event_cv); 613 mutex_destroy(&sata_event_mutex); 614 mutex_destroy(&sata_mutex); 615 } 616 return (rval); 617 } 618 619 int 620 _fini() 621 { 622 int rval; 623 624 if ((rval = mod_remove(&modlinkage)) != 0) 625 return (rval); 626 627 sata_trace_rbuf_free(); 628 mutex_destroy(&sata_log_mutex); 629 cv_destroy(&sata_event_cv); 630 mutex_destroy(&sata_event_mutex); 631 mutex_destroy(&sata_mutex); 632 return (rval); 633 } 634 635 int 636 _info(struct modinfo *modinfop) 637 { 638 return (mod_info(&modlinkage, modinfop)); 639 } 640 641 642 643 /* ********************* SATA HBA entry points ********************* */ 644 645 646 /* 647 * Called by SATA HBA from _init(). 648 * Registers HBA driver instance/sata framework pair with scsi framework, by 649 * calling scsi_hba_init(). 650 * 651 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used 652 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver 653 * cb_ops pointer in SATA HBA driver dev_ops structure. 654 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. 655 * 656 * Return status of the scsi_hba_init() is returned to a calling SATA HBA 657 * driver. 658 */ 659 int 660 sata_hba_init(struct modlinkage *modlp) 661 { 662 int rval; 663 struct dev_ops *hba_ops; 664 665 SATADBG1(SATA_DBG_HBA_IF, NULL, 666 "sata_hba_init: name %s \n", 667 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 668 /* 669 * Fill-up cb_ops and dev_ops when necessary 670 */ 671 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 672 /* 673 * Provide pointer to SATA dev_ops 674 */ 675 hba_ops->devo_cb_ops = &sata_cb_ops; 676 677 /* 678 * Register SATA HBA with SCSI framework 679 */ 680 if ((rval = scsi_hba_init(modlp)) != 0) { 681 SATADBG1(SATA_DBG_HBA_IF, NULL, 682 "sata_hba_init: scsi hba init failed\n", NULL); 683 return (rval); 684 } 685 686 return (0); 687 } 688 689 690 /* HBA attach stages */ 691 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 692 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 693 #define HBA_ATTACH_STAGE_SETUP 4 694 #define HBA_ATTACH_STAGE_LINKED 8 695 696 697 /* 698 * 699 * Called from SATA HBA driver's attach routine to attach an instance of 700 * the HBA. 701 * 702 * For DDI_ATTACH command: 703 * sata_hba_inst structure is allocated here and initialized with pointers to 704 * SATA framework implementation of required scsi tran functions. 705 * The scsi_tran's tran_hba_private field is used by SATA Framework to point 706 * to the soft structure (sata_hba_inst) allocated by SATA framework for 707 * SATA HBA instance related data. 708 * The scsi_tran's tran_hba_private field is used by SATA framework to 709 * store a pointer to per-HBA-instance of sata_hba_inst structure. 710 * The sata_hba_inst structure is cross-linked to scsi tran structure. 711 * Among other info, a pointer to sata_hba_tran structure is stored in 712 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are 713 * linked together into the list, pointed to by sata_hba_list. 714 * On the first HBA instance attach the sata event thread is initialized. 715 * Attachment points are created for all SATA ports of the HBA being attached. 716 * All HBA instance's SATA ports are probed and type of plugged devices is 717 * determined. For each device of a supported type, a target node is created. 718 * 719 * DDI_SUCCESS is returned when attachment process is successful, 720 * DDI_FAILURE is returned otherwise. 721 * 722 * For DDI_RESUME command: 723 * Not implemented at this time (postponed until phase 2 of the development). 724 */ 725 int 726 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, 727 ddi_attach_cmd_t cmd) 728 { 729 sata_hba_inst_t *sata_hba_inst; 730 scsi_hba_tran_t *scsi_tran = NULL; 731 int hba_attach_state = 0; 732 char taskq_name[MAXPATHLEN]; 733 734 SATADBG3(SATA_DBG_HBA_IF, NULL, 735 "sata_hba_attach: node %s (%s%d)\n", 736 ddi_node_name(dip), ddi_driver_name(dip), 737 ddi_get_instance(dip)); 738 739 if (cmd == DDI_RESUME) { 740 /* 741 * Postponed until phase 2 of the development 742 */ 743 return (DDI_FAILURE); 744 } 745 746 if (cmd != DDI_ATTACH) { 747 return (DDI_FAILURE); 748 } 749 750 /* cmd == DDI_ATTACH */ 751 752 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { 753 SATA_LOG_D((NULL, CE_WARN, 754 "sata_hba_attach: invalid sata_hba_tran")); 755 return (DDI_FAILURE); 756 } 757 /* 758 * Allocate and initialize SCSI tran structure. 759 * SATA copy of tran_bus_config is provided to create port nodes. 760 */ 761 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 762 if (scsi_tran == NULL) 763 return (DDI_FAILURE); 764 /* 765 * Allocate soft structure for SATA HBA instance. 766 * There is a separate softstate for each HBA instance. 767 */ 768 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); 769 ASSERT(sata_hba_inst != NULL); /* this should not fail */ 770 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); 771 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; 772 773 /* 774 * scsi_trans's tran_hba_private is used by SATA Framework to point to 775 * soft structure allocated by SATA framework for 776 * SATA HBA instance related data. 777 */ 778 scsi_tran->tran_hba_private = sata_hba_inst; 779 scsi_tran->tran_tgt_private = NULL; 780 781 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; 782 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; 783 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; 784 785 scsi_tran->tran_start = sata_scsi_start; 786 scsi_tran->tran_reset = sata_scsi_reset; 787 scsi_tran->tran_abort = sata_scsi_abort; 788 scsi_tran->tran_getcap = sata_scsi_getcap; 789 scsi_tran->tran_setcap = sata_scsi_setcap; 790 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; 791 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; 792 793 scsi_tran->tran_dmafree = sata_scsi_dmafree; 794 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; 795 796 scsi_tran->tran_reset_notify = NULL; 797 scsi_tran->tran_get_bus_addr = NULL; 798 scsi_tran->tran_quiesce = NULL; 799 scsi_tran->tran_unquiesce = NULL; 800 scsi_tran->tran_bus_reset = NULL; 801 802 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, 803 scsi_tran, 0) != DDI_SUCCESS) { 804 #ifdef SATA_DEBUG 805 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", 806 ddi_driver_name(dip), ddi_get_instance(dip)); 807 #endif 808 goto fail; 809 } 810 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; 811 812 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { 813 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 814 "sata", 1) != DDI_PROP_SUCCESS) { 815 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " 816 "failed to create hba sata prop")); 817 goto fail; 818 } 819 } 820 821 /* 822 * Save pointers in hba instance soft state. 823 */ 824 sata_hba_inst->satahba_scsi_tran = scsi_tran; 825 sata_hba_inst->satahba_tran = sata_tran; 826 sata_hba_inst->satahba_dip = dip; 827 828 /* 829 * Create a task queue to handle emulated commands completion 830 * Use node name, dash, instance number as the queue name. 831 */ 832 taskq_name[0] = '\0'; 833 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, 834 sizeof (taskq_name)); 835 (void) snprintf(taskq_name + strlen(taskq_name), 836 sizeof (taskq_name) - strlen(taskq_name), 837 "-%d", DEVI(dip)->devi_instance); 838 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, 839 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4, 840 TASKQ_DYNAMIC); 841 842 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; 843 844 /* 845 * Create events thread if not created yet. 846 */ 847 sata_event_thread_control(1); 848 849 /* 850 * Link this hba instance into the list. 851 */ 852 mutex_enter(&sata_mutex); 853 854 if (sata_hba_list == NULL) { 855 /* 856 * The first instance of HBA is attached. 857 * Set current/active default maximum NCQ/TCQ queue depth for 858 * all SATA devices. It is done here and now, to eliminate the 859 * possibility of the dynamic, programatic modification of the 860 * queue depth via global (and public) sata_max_queue_depth 861 * variable (this would require special handling in HBA drivers) 862 */ 863 sata_current_max_qdepth = sata_max_queue_depth; 864 if (sata_current_max_qdepth > 32) 865 sata_current_max_qdepth = 32; 866 else if (sata_current_max_qdepth < 1) 867 sata_current_max_qdepth = 1; 868 } 869 870 sata_hba_inst->satahba_next = NULL; 871 sata_hba_inst->satahba_prev = sata_hba_list_tail; 872 if (sata_hba_list == NULL) { 873 sata_hba_list = sata_hba_inst; 874 } 875 if (sata_hba_list_tail != NULL) { 876 sata_hba_list_tail->satahba_next = sata_hba_inst; 877 } 878 sata_hba_list_tail = sata_hba_inst; 879 mutex_exit(&sata_mutex); 880 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; 881 882 /* 883 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl 884 * SATA HBA driver should not use its own open/close entry points. 885 * 886 * Make sure that instance number doesn't overflow 887 * when forming minor numbers. 888 */ 889 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); 890 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 891 INST2DEVCTL(ddi_get_instance(dip)), 892 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { 893 #ifdef SATA_DEBUG 894 cmn_err(CE_WARN, "sata_hba_attach: " 895 "cannot create devctl minor node"); 896 #endif 897 goto fail; 898 } 899 900 901 /* 902 * Set-up kstats here, if necessary. 903 * (postponed until future phase of the development). 904 */ 905 906 /* 907 * Indicate that HBA is attached. This will enable events processing 908 * for this HBA. 909 */ 910 sata_hba_inst->satahba_attached = 1; 911 /* 912 * Probe controller ports. This operation will describe a current 913 * controller/port/multipliers/device configuration and will create 914 * attachment points. 915 * We may end-up with just a controller with no devices attached. 916 * For the ports with a supported device attached, device target nodes 917 * are created and devices are initialized. 918 */ 919 sata_probe_ports(sata_hba_inst); 920 921 return (DDI_SUCCESS); 922 923 fail: 924 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { 925 (void) sata_remove_hba_instance(dip); 926 if (sata_hba_list == NULL) 927 sata_event_thread_control(0); 928 } 929 930 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { 931 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 932 taskq_destroy(sata_hba_inst->satahba_taskq); 933 } 934 935 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) 936 (void) scsi_hba_detach(dip); 937 938 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { 939 mutex_destroy(&sata_hba_inst->satahba_mutex); 940 kmem_free((void *)sata_hba_inst, 941 sizeof (struct sata_hba_inst)); 942 scsi_hba_tran_free(scsi_tran); 943 } 944 945 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", 946 ddi_driver_name(dip), ddi_get_instance(dip)); 947 948 return (DDI_FAILURE); 949 } 950 951 952 /* 953 * Called by SATA HBA from to detach an instance of the driver. 954 * 955 * For DDI_DETACH command: 956 * Free local structures allocated for SATA HBA instance during 957 * sata_hba_attach processing. 958 * 959 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. 960 * 961 * For DDI_SUSPEND command: 962 * Not implemented at this time (postponed until phase 2 of the development) 963 * Returnd DDI_SUCCESS. 964 * 965 * When the last HBA instance is detached, the event daemon is terminated. 966 * 967 * NOTE: Port multiplier is supported. 968 */ 969 int 970 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 971 { 972 dev_info_t *tdip; 973 sata_hba_inst_t *sata_hba_inst; 974 scsi_hba_tran_t *scsi_hba_tran; 975 sata_cport_info_t *cportinfo; 976 sata_pmult_info_t *pminfo; 977 sata_drive_info_t *sdinfo; 978 sata_device_t sdevice; 979 int ncport, npmport; 980 981 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", 982 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); 983 984 switch (cmd) { 985 case DDI_DETACH: 986 987 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 988 return (DDI_FAILURE); 989 990 sata_hba_inst = scsi_hba_tran->tran_hba_private; 991 if (sata_hba_inst == NULL) 992 return (DDI_FAILURE); 993 994 if (scsi_hba_detach(dip) == DDI_FAILURE) { 995 sata_hba_inst->satahba_attached = 1; 996 return (DDI_FAILURE); 997 } 998 999 /* 1000 * Free all target nodes - at this point 1001 * devices should be at least offlined 1002 * otherwise scsi_hba_detach() should not be called. 1003 */ 1004 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1005 ncport++) { 1006 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1007 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1008 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 1009 if (sdinfo != NULL) { 1010 tdip = sata_get_target_dip(dip, 1011 ncport, 0); 1012 if (tdip != NULL) { 1013 if (ndi_devi_offline(tdip, 1014 NDI_DEVI_REMOVE) != 1015 NDI_SUCCESS) { 1016 SATA_LOG_D(( 1017 sata_hba_inst, 1018 CE_WARN, 1019 "sata_hba_detach: " 1020 "Target node not " 1021 "removed !")); 1022 return (DDI_FAILURE); 1023 } 1024 } 1025 } 1026 } else { /* SATA_DTYPE_PMULT */ 1027 mutex_enter(&cportinfo->cport_mutex); 1028 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 1029 1030 if (pminfo == NULL) { 1031 SATA_LOG_D((sata_hba_inst, CE_WARN, 1032 "sata_hba_detach: Port multiplier " 1033 "not ready yet!")); 1034 mutex_exit(&cportinfo->cport_mutex); 1035 return (DDI_FAILURE); 1036 } 1037 1038 /* 1039 * Detach would fail if removal of any of the 1040 * target nodes is failed - albeit in that 1041 * case some of them may have been removed. 1042 */ 1043 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 1044 sata_hba_inst, ncport); npmport++) { 1045 tdip = sata_get_target_dip(dip, ncport, 1046 npmport); 1047 if (tdip != NULL) { 1048 if (ndi_devi_offline(tdip, 1049 NDI_DEVI_REMOVE) != 1050 NDI_SUCCESS) { 1051 SATA_LOG_D(( 1052 sata_hba_inst, 1053 CE_WARN, 1054 "sata_hba_detach: " 1055 "Target node not " 1056 "removed !")); 1057 mutex_exit(&cportinfo-> 1058 cport_mutex); 1059 return (DDI_FAILURE); 1060 } 1061 } 1062 } 1063 mutex_exit(&cportinfo->cport_mutex); 1064 } 1065 } 1066 /* 1067 * Disable sata event daemon processing for this HBA 1068 */ 1069 sata_hba_inst->satahba_attached = 0; 1070 1071 /* 1072 * Remove event daemon thread, if it is last HBA instance. 1073 */ 1074 1075 mutex_enter(&sata_mutex); 1076 if (sata_hba_list->satahba_next == NULL) { 1077 mutex_exit(&sata_mutex); 1078 sata_event_thread_control(0); 1079 mutex_enter(&sata_mutex); 1080 } 1081 mutex_exit(&sata_mutex); 1082 1083 /* Remove this HBA instance from the HBA list */ 1084 sata_remove_hba_instance(dip); 1085 1086 /* 1087 * At this point there should be no target nodes attached. 1088 * Detach and destroy device and port info structures. 1089 */ 1090 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1091 ncport++) { 1092 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1093 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1094 sdinfo = 1095 cportinfo->cport_devp.cport_sata_drive; 1096 if (sdinfo != NULL) { 1097 /* Release device structure */ 1098 kmem_free(sdinfo, 1099 sizeof (sata_drive_info_t)); 1100 } 1101 /* Release cport info */ 1102 mutex_destroy(&cportinfo->cport_mutex); 1103 kmem_free(cportinfo, 1104 sizeof (sata_cport_info_t)); 1105 } else { /* SATA_DTYPE_PMULT */ 1106 sdevice.satadev_addr.cport = (uint8_t)ncport; 1107 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 1108 sata_free_pmult(sata_hba_inst, &sdevice); 1109 } 1110 } 1111 1112 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); 1113 1114 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 1115 1116 taskq_destroy(sata_hba_inst->satahba_taskq); 1117 1118 mutex_destroy(&sata_hba_inst->satahba_mutex); 1119 kmem_free((void *)sata_hba_inst, 1120 sizeof (struct sata_hba_inst)); 1121 1122 return (DDI_SUCCESS); 1123 1124 case DDI_SUSPEND: 1125 /* 1126 * Postponed until phase 2 1127 */ 1128 return (DDI_FAILURE); 1129 1130 default: 1131 return (DDI_FAILURE); 1132 } 1133 } 1134 1135 1136 /* 1137 * Called by an HBA drive from _fini() routine. 1138 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. 1139 */ 1140 void 1141 sata_hba_fini(struct modlinkage *modlp) 1142 { 1143 SATADBG1(SATA_DBG_HBA_IF, NULL, 1144 "sata_hba_fini: name %s\n", 1145 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 1146 1147 scsi_hba_fini(modlp); 1148 } 1149 1150 1151 /* 1152 * Default open and close routine for sata_hba framework. 1153 * 1154 */ 1155 /* 1156 * Open devctl node. 1157 * 1158 * Returns: 1159 * 0 if node was open successfully, error code otherwise. 1160 * 1161 * 1162 */ 1163 1164 static int 1165 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 1166 { 1167 #ifndef __lock_lint 1168 _NOTE(ARGUNUSED(credp)) 1169 #endif 1170 int rv = 0; 1171 dev_info_t *dip; 1172 scsi_hba_tran_t *scsi_hba_tran; 1173 sata_hba_inst_t *sata_hba_inst; 1174 1175 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); 1176 1177 if (otyp != OTYP_CHR) 1178 return (EINVAL); 1179 1180 dip = sata_devt_to_devinfo(*devp); 1181 if (dip == NULL) 1182 return (ENXIO); 1183 1184 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1185 return (ENXIO); 1186 1187 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1188 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1189 return (ENXIO); 1190 1191 mutex_enter(&sata_mutex); 1192 if (flags & FEXCL) { 1193 if (sata_hba_inst->satahba_open_flag != 0) { 1194 rv = EBUSY; 1195 } else { 1196 sata_hba_inst->satahba_open_flag = 1197 SATA_DEVCTL_EXOPENED; 1198 } 1199 } else { 1200 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { 1201 rv = EBUSY; 1202 } else { 1203 sata_hba_inst->satahba_open_flag = 1204 SATA_DEVCTL_SOPENED; 1205 } 1206 } 1207 mutex_exit(&sata_mutex); 1208 1209 return (rv); 1210 } 1211 1212 1213 /* 1214 * Close devctl node. 1215 * Returns: 1216 * 0 if node was closed successfully, error code otherwise. 1217 * 1218 */ 1219 1220 static int 1221 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 1222 { 1223 #ifndef __lock_lint 1224 _NOTE(ARGUNUSED(credp)) 1225 _NOTE(ARGUNUSED(flag)) 1226 #endif 1227 dev_info_t *dip; 1228 scsi_hba_tran_t *scsi_hba_tran; 1229 sata_hba_inst_t *sata_hba_inst; 1230 1231 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); 1232 1233 if (otyp != OTYP_CHR) 1234 return (EINVAL); 1235 1236 dip = sata_devt_to_devinfo(dev); 1237 if (dip == NULL) 1238 return (ENXIO); 1239 1240 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1241 return (ENXIO); 1242 1243 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1244 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1245 return (ENXIO); 1246 1247 mutex_enter(&sata_mutex); 1248 sata_hba_inst->satahba_open_flag = 0; 1249 mutex_exit(&sata_mutex); 1250 return (0); 1251 } 1252 1253 1254 1255 /* 1256 * Standard IOCTL commands for SATA hotplugging. 1257 * Implemented DEVCTL_AP commands: 1258 * DEVCTL_AP_CONNECT 1259 * DEVCTL_AP_DISCONNECT 1260 * DEVCTL_AP_CONFIGURE 1261 * DEVCTL_UNCONFIGURE 1262 * DEVCTL_AP_CONTROL 1263 * 1264 * Commands passed to default ndi ioctl handler: 1265 * DEVCTL_DEVICE_GETSTATE 1266 * DEVCTL_DEVICE_ONLINE 1267 * DEVCTL_DEVICE_OFFLINE 1268 * DEVCTL_DEVICE_REMOVE 1269 * DEVCTL_DEVICE_INSERT 1270 * DEVCTL_BUS_GETSTATE 1271 * 1272 * All other cmds are passed to HBA if it provide ioctl handler, or failed 1273 * if not. 1274 * 1275 * Returns: 1276 * 0 if successful, 1277 * error code if operation failed. 1278 * 1279 * Port Multiplier support is supported now. 1280 * 1281 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT 1282 */ 1283 1284 static int 1285 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 1286 int *rvalp) 1287 { 1288 #ifndef __lock_lint 1289 _NOTE(ARGUNUSED(credp)) 1290 _NOTE(ARGUNUSED(rvalp)) 1291 #endif 1292 int rv = 0; 1293 int32_t comp_port = -1; 1294 dev_info_t *dip; 1295 devctl_ap_state_t ap_state; 1296 struct devctl_iocdata *dcp = NULL; 1297 scsi_hba_tran_t *scsi_hba_tran; 1298 sata_hba_inst_t *sata_hba_inst; 1299 sata_device_t sata_device; 1300 sata_cport_info_t *cportinfo; 1301 int cport, pmport, qual; 1302 int rval = SATA_SUCCESS; 1303 1304 dip = sata_devt_to_devinfo(dev); 1305 if (dip == NULL) 1306 return (ENXIO); 1307 1308 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1309 return (ENXIO); 1310 1311 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1312 if (sata_hba_inst == NULL) 1313 return (ENXIO); 1314 1315 if (sata_hba_inst->satahba_tran == NULL) 1316 return (ENXIO); 1317 1318 switch (cmd) { 1319 1320 case DEVCTL_DEVICE_GETSTATE: 1321 case DEVCTL_DEVICE_ONLINE: 1322 case DEVCTL_DEVICE_OFFLINE: 1323 case DEVCTL_DEVICE_REMOVE: 1324 case DEVCTL_BUS_GETSTATE: 1325 /* 1326 * There may be more cases that we want to pass to default 1327 * handler rather than fail them. 1328 */ 1329 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); 1330 } 1331 1332 /* read devctl ioctl data */ 1333 if (cmd != DEVCTL_AP_CONTROL) { 1334 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 1335 return (EFAULT); 1336 1337 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == 1338 -1) { 1339 if (dcp) 1340 ndi_dc_freehdl(dcp); 1341 return (EINVAL); 1342 } 1343 1344 /* 1345 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either 1346 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT. 1347 */ 1348 cport = SCSI_TO_SATA_CPORT(comp_port); 1349 pmport = SCSI_TO_SATA_PMPORT(comp_port); 1350 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port); 1351 1352 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, 1353 qual) != 0) { 1354 ndi_dc_freehdl(dcp); 1355 return (EINVAL); 1356 } 1357 1358 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1359 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1360 cport_mutex); 1361 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1362 /* 1363 * Cannot process ioctl request now. Come back later. 1364 */ 1365 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1366 cport_mutex); 1367 ndi_dc_freehdl(dcp); 1368 return (EBUSY); 1369 } 1370 /* Block event processing for this port */ 1371 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1372 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1373 1374 sata_device.satadev_addr.cport = cport; 1375 sata_device.satadev_addr.pmport = pmport; 1376 sata_device.satadev_addr.qual = qual; 1377 sata_device.satadev_rev = SATA_DEVICE_REV; 1378 } 1379 1380 switch (cmd) { 1381 1382 case DEVCTL_AP_DISCONNECT: 1383 1384 /* 1385 * Normally, cfgadm sata plugin will try to offline 1386 * (unconfigure) device before this request. Nevertheless, 1387 * if a device is still configured, we need to 1388 * attempt to offline and unconfigure device first, and we will 1389 * deactivate the port regardless of the unconfigure 1390 * operation results. 1391 * 1392 */ 1393 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device); 1394 1395 break; 1396 1397 case DEVCTL_AP_UNCONFIGURE: 1398 1399 /* 1400 * The unconfigure operation uses generic nexus operation to 1401 * offline a device. It leaves a target device node attached. 1402 * and obviously sata_drive_info attached as well, because 1403 * from the hardware point of view nothing has changed. 1404 */ 1405 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device); 1406 break; 1407 1408 case DEVCTL_AP_CONNECT: 1409 { 1410 /* 1411 * The sata cfgadm pluging will invoke this operation only if 1412 * port was found in the disconnect state (failed state 1413 * is also treated as the disconnected state). 1414 * If port activation is successful and a device is found 1415 * attached to the port, the initialization sequence is 1416 * executed to probe the port and attach 1417 * a device structure to a port structure. The device is not 1418 * set in configured state (system-wise) by this operation. 1419 */ 1420 1421 rv = sata_ioctl_connect(sata_hba_inst, &sata_device); 1422 1423 break; 1424 } 1425 1426 case DEVCTL_AP_CONFIGURE: 1427 { 1428 /* 1429 * A port may be in an active or shutdown state. 1430 * If port is in a failed state, operation is aborted. 1431 * If a port is in a shutdown state, sata_tran_port_activate() 1432 * is invoked prior to any other operation. 1433 * 1434 * Onlining the device involves creating a new target node. 1435 * If there is an old target node present (belonging to 1436 * previously removed device), the operation is aborted - the 1437 * old node has to be released and removed before configure 1438 * operation is attempted. 1439 */ 1440 1441 rv = sata_ioctl_configure(sata_hba_inst, &sata_device); 1442 1443 break; 1444 } 1445 1446 case DEVCTL_AP_GETSTATE: 1447 1448 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); 1449 1450 ap_state.ap_last_change = (time_t)-1; 1451 ap_state.ap_error_code = 0; 1452 ap_state.ap_in_transition = 0; 1453 1454 /* Copy the return AP-state information to the user space */ 1455 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { 1456 rv = EFAULT; 1457 } 1458 break; 1459 1460 case DEVCTL_AP_CONTROL: 1461 { 1462 /* 1463 * Generic devctl for hardware specific functionality 1464 */ 1465 sata_ioctl_data_t ioc; 1466 1467 ASSERT(dcp == NULL); 1468 1469 /* Copy in user ioctl data first */ 1470 #ifdef _MULTI_DATAMODEL 1471 if (ddi_model_convert_from(mode & FMODELS) == 1472 DDI_MODEL_ILP32) { 1473 1474 sata_ioctl_data_32_t ioc32; 1475 1476 if (ddi_copyin((void *)arg, (void *)&ioc32, 1477 sizeof (ioc32), mode) != 0) { 1478 rv = EFAULT; 1479 break; 1480 } 1481 ioc.cmd = (uint_t)ioc32.cmd; 1482 ioc.port = (uint_t)ioc32.port; 1483 ioc.get_size = (uint_t)ioc32.get_size; 1484 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; 1485 ioc.bufsiz = (uint_t)ioc32.bufsiz; 1486 ioc.misc_arg = (uint_t)ioc32.misc_arg; 1487 } else 1488 #endif /* _MULTI_DATAMODEL */ 1489 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), 1490 mode) != 0) { 1491 return (EFAULT); 1492 } 1493 1494 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 1495 "sata_hba_ioctl: DEVCTL_AP_CONTROL " 1496 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); 1497 1498 /* 1499 * To avoid BE/LE and 32/64 issues, a get_size always returns 1500 * a 32-bit number. 1501 */ 1502 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { 1503 return (EINVAL); 1504 } 1505 /* validate address */ 1506 cport = SCSI_TO_SATA_CPORT(ioc.port); 1507 pmport = SCSI_TO_SATA_PMPORT(ioc.port); 1508 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); 1509 1510 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst, 1511 "sata_hba_ioctl: target port is %d:%d (%d)", 1512 cport, pmport, qual); 1513 1514 if (sata_validate_sata_address(sata_hba_inst, cport, 1515 pmport, qual) != 0) 1516 return (EINVAL); 1517 1518 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1519 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1520 cport_mutex); 1521 /* Is the port locked by event processing daemon ? */ 1522 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1523 /* 1524 * Cannot process ioctl request now. Come back later 1525 */ 1526 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1527 cport_mutex); 1528 return (EBUSY); 1529 } 1530 /* Block event processing for this port */ 1531 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1532 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1533 1534 1535 sata_device.satadev_addr.cport = cport; 1536 sata_device.satadev_addr.pmport = pmport; 1537 sata_device.satadev_addr.qual = qual; 1538 sata_device.satadev_rev = SATA_DEVICE_REV; 1539 1540 switch (ioc.cmd) { 1541 1542 case SATA_CFGA_RESET_PORT: 1543 /* 1544 * There is no protection for configured device. 1545 */ 1546 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device); 1547 break; 1548 1549 case SATA_CFGA_RESET_DEVICE: 1550 /* 1551 * There is no protection for configured device. 1552 */ 1553 rv = sata_ioctl_reset_device(sata_hba_inst, 1554 &sata_device); 1555 break; 1556 1557 case SATA_CFGA_RESET_ALL: 1558 /* 1559 * There is no protection for configured devices. 1560 */ 1561 rv = sata_ioctl_reset_all(sata_hba_inst); 1562 /* 1563 * We return here, because common return is for 1564 * a single port operation - we have already unlocked 1565 * all ports and no dc handle was allocated. 1566 */ 1567 return (rv); 1568 1569 case SATA_CFGA_PORT_DEACTIVATE: 1570 /* 1571 * Arbitrarily unconfigure attached device, if any. 1572 * Even if the unconfigure fails, proceed with the 1573 * port deactivation. 1574 */ 1575 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device); 1576 1577 break; 1578 1579 case SATA_CFGA_PORT_ACTIVATE: 1580 1581 rv = sata_ioctl_activate(sata_hba_inst, &sata_device); 1582 break; 1583 1584 case SATA_CFGA_PORT_SELF_TEST: 1585 1586 rv = sata_ioctl_port_self_test(sata_hba_inst, 1587 &sata_device); 1588 break; 1589 1590 case SATA_CFGA_GET_DEVICE_PATH: 1591 1592 rv = sata_ioctl_get_device_path(sata_hba_inst, 1593 &sata_device, &ioc, mode); 1594 break; 1595 1596 case SATA_CFGA_GET_AP_TYPE: 1597 1598 rv = sata_ioctl_get_ap_type(sata_hba_inst, 1599 &sata_device, &ioc, mode); 1600 break; 1601 1602 case SATA_CFGA_GET_MODEL_INFO: 1603 1604 rv = sata_ioctl_get_model_info(sata_hba_inst, 1605 &sata_device, &ioc, mode); 1606 break; 1607 1608 case SATA_CFGA_GET_REVFIRMWARE_INFO: 1609 1610 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst, 1611 &sata_device, &ioc, mode); 1612 break; 1613 1614 case SATA_CFGA_GET_SERIALNUMBER_INFO: 1615 1616 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst, 1617 &sata_device, &ioc, mode); 1618 break; 1619 1620 default: 1621 rv = EINVAL; 1622 break; 1623 1624 } /* End of DEVCTL_AP_CONTROL cmd switch */ 1625 1626 break; 1627 } 1628 1629 default: 1630 { 1631 /* 1632 * If we got here, we got an IOCTL that SATA HBA Framework 1633 * does not recognize. Pass ioctl to HBA driver, in case 1634 * it could process it. 1635 */ 1636 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; 1637 dev_info_t *mydip = SATA_DIP(sata_hba_inst); 1638 1639 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1640 "IOCTL 0x%2x not supported in SATA framework, " 1641 "passthrough to HBA", cmd); 1642 1643 if (sata_tran->sata_tran_ioctl == NULL) { 1644 rv = EINVAL; 1645 break; 1646 } 1647 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); 1648 if (rval != 0) { 1649 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1650 "IOCTL 0x%2x failed in HBA", cmd); 1651 rv = rval; 1652 } 1653 break; 1654 } 1655 1656 } /* End of main IOCTL switch */ 1657 1658 if (dcp) { 1659 ndi_dc_freehdl(dcp); 1660 } 1661 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1662 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 1663 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1664 1665 return (rv); 1666 } 1667 1668 1669 /* 1670 * Create error retrieval sata packet 1671 * 1672 * A sata packet is allocated and set-up to contain specified error retrieval 1673 * command and appropriate dma-able data buffer. 1674 * No association with any scsi packet is made and no callback routine is 1675 * specified. 1676 * 1677 * Returns a pointer to sata packet upon successfull packet creation. 1678 * Returns NULL, if packet cannot be created. 1679 */ 1680 sata_pkt_t * 1681 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device, 1682 int pkt_type) 1683 { 1684 sata_hba_inst_t *sata_hba_inst; 1685 sata_pkt_txlate_t *spx; 1686 sata_pkt_t *spkt; 1687 sata_drive_info_t *sdinfo; 1688 1689 mutex_enter(&sata_mutex); 1690 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1691 sata_hba_inst = sata_hba_inst->satahba_next) { 1692 if (SATA_DIP(sata_hba_inst) == dip) 1693 break; 1694 } 1695 mutex_exit(&sata_mutex); 1696 ASSERT(sata_hba_inst != NULL); 1697 1698 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 1699 if (sdinfo == NULL) { 1700 sata_log(sata_hba_inst, CE_WARN, 1701 "sata: error recovery request for non-attached device at " 1702 "cport %d", sata_device->satadev_addr.cport); 1703 return (NULL); 1704 } 1705 1706 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1707 spx->txlt_sata_hba_inst = sata_hba_inst; 1708 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1709 spkt = sata_pkt_alloc(spx, NULL); 1710 if (spkt == NULL) { 1711 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1712 return (NULL); 1713 } 1714 /* address is needed now */ 1715 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr; 1716 1717 switch (pkt_type) { 1718 case SATA_ERR_RETR_PKT_TYPE_NCQ: 1719 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) 1720 return (spkt); 1721 break; 1722 1723 case SATA_ERR_RETR_PKT_TYPE_ATAPI: 1724 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) 1725 return (spkt); 1726 break; 1727 1728 default: 1729 break; 1730 } 1731 1732 sata_pkt_free(spx); 1733 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1734 return (NULL); 1735 1736 } 1737 1738 1739 /* 1740 * Free error retrieval sata packet 1741 * 1742 * Free sata packet and any associated resources allocated previously by 1743 * sata_get_error_retrieval_pkt(). 1744 * 1745 * Void return. 1746 */ 1747 void 1748 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt) 1749 { 1750 sata_pkt_txlate_t *spx = 1751 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1752 1753 ASSERT(sata_pkt != NULL); 1754 1755 sata_free_local_buffer(spx); 1756 sata_pkt_free(spx); 1757 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1758 1759 } 1760 1761 /* 1762 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet 1763 * 1764 * No association with any scsi packet is made and no callback routine is 1765 * specified. 1766 * 1767 * Returns a pointer to sata packet upon successfull packet creation. 1768 * Returns NULL, if packet cannot be created. 1769 * 1770 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6, 1771 * only lower 32 bits are available currently. 1772 */ 1773 sata_pkt_t * 1774 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd, 1775 uint8_t regn, uint32_t regv, uint32_t type) 1776 { 1777 sata_hba_inst_t *sata_hba_inst; 1778 sata_pkt_txlate_t *spx; 1779 sata_pkt_t *spkt; 1780 sata_cmd_t *scmd; 1781 1782 /* Only READ/WRITE commands are accepted. */ 1783 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ || 1784 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE); 1785 1786 mutex_enter(&sata_mutex); 1787 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1788 sata_hba_inst = sata_hba_inst->satahba_next) { 1789 if (SATA_DIP(sata_hba_inst) == dip) 1790 break; 1791 } 1792 mutex_exit(&sata_mutex); 1793 ASSERT(sata_hba_inst != NULL); 1794 1795 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1796 spx->txlt_sata_hba_inst = sata_hba_inst; 1797 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1798 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 1799 if (spkt == NULL) { 1800 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1801 return (NULL); 1802 } 1803 1804 /* 1805 * NOTE: We need to send this command to the port multiplier, 1806 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport 1807 * 1808 * sata_device contains the address of actual target device, and the 1809 * pmport number in the command comes from the sata_device structure. 1810 */ 1811 spkt->satapkt_device.satadev_addr = sd->satadev_addr; 1812 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 1813 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT; 1814 1815 /* Fill sata_pkt */ 1816 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING; 1817 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */ 1818 spkt->satapkt_time = 10; /* Timeout 10s */ 1819 1820 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */ 1821 scmd = &spkt->satapkt_cmd; 1822 scmd->satacmd_features_reg = regn & 0xff; 1823 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff; 1824 scmd->satacmd_device_reg = sd->satadev_addr.pmport; 1825 scmd->satacmd_addr_type = 0; /* N/A */ 1826 1827 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 1828 1829 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) { 1830 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT; 1831 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 1832 scmd->satacmd_flags.sata_special_regs = 1; 1833 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 1834 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 1835 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 1836 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 1837 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) { 1838 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT; 1839 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 1840 scmd->satacmd_sec_count_lsb = regv & 0xff; 1841 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff; 1842 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff; 1843 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff; 1844 } 1845 1846 return (spkt); 1847 } 1848 1849 /* 1850 * Free sata packet and any associated resources allocated previously by 1851 * sata_get_rdwr_pmult_pkt(). 1852 * 1853 * Void return. 1854 */ 1855 void 1856 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt) 1857 { 1858 sata_pkt_txlate_t *spx = 1859 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1860 1861 /* Free allocated resources */ 1862 sata_pkt_free(spx); 1863 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1864 } 1865 1866 /* 1867 * Register a port multiplier to framework. 1868 * 1) Store the GSCR values in the previous allocated pmult_info strctures. 1869 * 2) Search in the blacklist and update the number of the device ports of the 1870 * port multiplier. 1871 * 1872 * Void return. 1873 */ 1874 void 1875 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg) 1876 { 1877 sata_hba_inst_t *sata_hba_inst = NULL; 1878 sata_pmult_info_t *pmultinfo; 1879 sata_pmult_bl_t *blp; 1880 int cport = sd->satadev_addr.cport; 1881 1882 mutex_enter(&sata_mutex); 1883 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1884 sata_hba_inst = sata_hba_inst->satahba_next) { 1885 if (SATA_DIP(sata_hba_inst) == dip) 1886 if (sata_hba_inst->satahba_attached == 1) 1887 break; 1888 } 1889 mutex_exit(&sata_mutex); 1890 /* HBA not attached? */ 1891 if (sata_hba_inst == NULL) 1892 return; 1893 1894 /* Number of pmports */ 1895 sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK; 1896 1897 /* Check the blacklist */ 1898 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) { 1899 if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0) 1900 continue; 1901 if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1) 1902 continue; 1903 if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2) 1904 continue; 1905 1906 cmn_err(CE_WARN, "!Port multiplier is on the blacklist."); 1907 sd->satadev_add_info = blp->bl_flags; 1908 break; 1909 } 1910 1911 /* Register the port multiplier GSCR */ 1912 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 1913 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 1914 if (pmultinfo != NULL) { 1915 pmultinfo->pmult_gscr = *sg; 1916 pmultinfo->pmult_num_dev_ports = 1917 sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK; 1918 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 1919 "Port multiplier registered at port %d", cport); 1920 } 1921 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 1922 } 1923 1924 /* 1925 * sata_name_child is for composing the name of the node 1926 * the format of the name is "target,0". 1927 */ 1928 static int 1929 sata_name_child(dev_info_t *dip, char *name, int namelen) 1930 { 1931 int target; 1932 1933 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 1934 DDI_PROP_DONTPASS, "target", -1); 1935 if (target == -1) 1936 return (DDI_FAILURE); 1937 (void) snprintf(name, namelen, "%x,0", target); 1938 return (DDI_SUCCESS); 1939 } 1940 1941 1942 1943 /* ****************** SCSA required entry points *********************** */ 1944 1945 /* 1946 * Implementation of scsi tran_tgt_init. 1947 * sata_scsi_tgt_init() initializes scsi_device structure 1948 * 1949 * If successful, DDI_SUCCESS is returned. 1950 * DDI_FAILURE is returned if addressed device does not exist 1951 */ 1952 1953 static int 1954 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, 1955 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 1956 { 1957 #ifndef __lock_lint 1958 _NOTE(ARGUNUSED(hba_dip)) 1959 _NOTE(ARGUNUSED(tgt_dip)) 1960 #endif 1961 sata_device_t sata_device; 1962 sata_drive_info_t *sdinfo; 1963 struct sata_id *sid; 1964 sata_hba_inst_t *sata_hba_inst; 1965 char model[SATA_ID_MODEL_LEN + 1]; 1966 char fw[SATA_ID_FW_LEN + 1]; 1967 char *vid, *pid; 1968 int i; 1969 1970 /* 1971 * Fail tran_tgt_init for .conf stub node 1972 */ 1973 if (ndi_dev_is_persistent_node(tgt_dip) == 0) { 1974 (void) ndi_merge_node(tgt_dip, sata_name_child); 1975 ddi_set_name_addr(tgt_dip, NULL); 1976 return (DDI_FAILURE); 1977 } 1978 1979 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 1980 1981 /* Validate scsi device address */ 1982 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 1983 &sata_device) != 0) 1984 return (DDI_FAILURE); 1985 1986 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 1987 sata_device.satadev_addr.cport))); 1988 1989 /* sata_device now contains a valid sata address */ 1990 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 1991 if (sdinfo == NULL) { 1992 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 1993 sata_device.satadev_addr.cport))); 1994 return (DDI_FAILURE); 1995 } 1996 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 1997 sata_device.satadev_addr.cport))); 1998 1999 /* 2000 * Check if we need to create a legacy devid (i.e cmdk style) for 2001 * the target disks. 2002 * 2003 * HBA devinfo node will have the property "use-cmdk-devid-format" 2004 * if we need to create cmdk-style devid for all the disk devices 2005 * attached to this controller. This property may have been set 2006 * from HBA driver's .conf file or by the HBA driver in its 2007 * attach(9F) function. 2008 */ 2009 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 2010 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 2011 "use-cmdk-devid-format", 0) == 1)) { 2012 /* register a legacy devid for this target node */ 2013 sata_target_devid_register(tgt_dip, sdinfo); 2014 } 2015 2016 2017 /* 2018 * 'Identify Device Data' does not always fit in standard SCSI 2019 * INQUIRY data, so establish INQUIRY_* properties with full-form 2020 * of information. 2021 */ 2022 sid = &sdinfo->satadrv_id; 2023 #ifdef _LITTLE_ENDIAN 2024 swab(sid->ai_model, model, SATA_ID_MODEL_LEN); 2025 swab(sid->ai_fw, fw, SATA_ID_FW_LEN); 2026 #else /* _LITTLE_ENDIAN */ 2027 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN); 2028 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN); 2029 #endif /* _LITTLE_ENDIAN */ 2030 model[SATA_ID_MODEL_LEN] = 0; 2031 fw[SATA_ID_FW_LEN] = 0; 2032 2033 /* split model into into vid/pid */ 2034 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++) 2035 if ((*pid == ' ') || (*pid == '\t')) 2036 break; 2037 if (i < SATA_ID_MODEL_LEN) { 2038 vid = model; 2039 *pid++ = 0; /* terminate vid, establish pid */ 2040 } else { 2041 vid = NULL; /* vid will stay "ATA " */ 2042 pid = model; /* model is all pid */ 2043 } 2044 2045 if (vid) 2046 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID, 2047 vid, strlen(vid)); 2048 if (pid) 2049 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID, 2050 pid, strlen(pid)); 2051 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID, 2052 fw, strlen(fw)); 2053 2054 return (DDI_SUCCESS); 2055 } 2056 2057 /* 2058 * Implementation of scsi tran_tgt_probe. 2059 * Probe target, by calling default scsi routine scsi_hba_probe() 2060 */ 2061 static int 2062 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) 2063 { 2064 sata_hba_inst_t *sata_hba_inst = 2065 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); 2066 int rval; 2067 uint32_t pm_cap; 2068 2069 rval = scsi_hba_probe(sd, callback); 2070 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE | 2071 SATA_CAP_LOG_SENSE; 2072 2073 if (rval == SCSIPROBE_EXISTS) { 2074 /* 2075 * Set property "pm-capable" on the target device node, so that 2076 * the target driver will not try to fetch scsi cycle counters 2077 * before enabling device power-management. 2078 */ 2079 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 2080 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) { 2081 sata_log(sata_hba_inst, CE_WARN, 2082 "SATA device at port %d: " 2083 "will not be power-managed ", 2084 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); 2085 SATA_LOG_D((sata_hba_inst, CE_WARN, 2086 "failure updating pm-capable property")); 2087 } 2088 } 2089 return (rval); 2090 } 2091 2092 /* 2093 * Implementation of scsi tran_tgt_free. 2094 * Release all resources allocated for scsi_device 2095 */ 2096 static void 2097 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2098 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2099 { 2100 #ifndef __lock_lint 2101 _NOTE(ARGUNUSED(hba_dip)) 2102 #endif 2103 sata_device_t sata_device; 2104 sata_drive_info_t *sdinfo; 2105 sata_hba_inst_t *sata_hba_inst; 2106 ddi_devid_t devid; 2107 2108 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2109 2110 /* Validate scsi device address */ 2111 /* 2112 * Note: tgt_free relates to the SCSA view of a device. If called, there 2113 * was a device at this address, so even if the sata framework internal 2114 * resources were alredy released because a device was detached, 2115 * this function should be executed as long as its actions do 2116 * not require the internal sata view of a device and the address 2117 * refers to a valid sata address. 2118 * Validating the address here means that we do not trust SCSA... 2119 */ 2120 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2121 &sata_device) == -1) 2122 return; 2123 2124 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2125 sata_device.satadev_addr.cport))); 2126 2127 /* sata_device now should contain a valid sata address */ 2128 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2129 if (sdinfo == NULL) { 2130 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2131 sata_device.satadev_addr.cport))); 2132 return; 2133 } 2134 /* 2135 * We did not allocate any resources in sata_scsi_tgt_init() 2136 * other than few properties. 2137 * Free them. 2138 */ 2139 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2140 sata_device.satadev_addr.cport))); 2141 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable"); 2142 2143 /* 2144 * If devid was previously created but not freed up from 2145 * sd(7D) driver (i.e during detach(9F)) then do it here. 2146 */ 2147 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 2148 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 2149 "use-cmdk-devid-format", 0) == 1) && 2150 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) { 2151 ddi_devid_unregister(tgt_dip); 2152 ddi_devid_free(devid); 2153 } 2154 } 2155 2156 /* 2157 * Implementation of scsi tran_init_pkt 2158 * Upon successful return, scsi pkt buffer has DMA resources allocated. 2159 * 2160 * It seems that we should always allocate pkt, even if the address is 2161 * for non-existing device - just use some default for dma_attr. 2162 * The reason is that there is no way to communicate this to a caller here. 2163 * Subsequent call to sata_scsi_start may fail appropriately. 2164 * Simply returning NULL does not seem to discourage a target driver... 2165 * 2166 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. 2167 */ 2168 static struct scsi_pkt * 2169 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 2170 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, 2171 int (*callback)(caddr_t), caddr_t arg) 2172 { 2173 sata_hba_inst_t *sata_hba_inst = 2174 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2175 dev_info_t *dip = SATA_DIP(sata_hba_inst); 2176 sata_device_t sata_device; 2177 sata_drive_info_t *sdinfo; 2178 sata_pkt_txlate_t *spx; 2179 ddi_dma_attr_t cur_dma_attr; 2180 int rval; 2181 boolean_t new_pkt = TRUE; 2182 2183 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); 2184 2185 /* 2186 * We need to translate the address, even if it could be 2187 * a bogus one, for a non-existing device 2188 */ 2189 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 2190 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); 2191 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2192 sata_device.satadev_rev = SATA_DEVICE_REV; 2193 2194 if (pkt == NULL) { 2195 /* 2196 * Have to allocate a brand new scsi packet. 2197 * We need to operate with auto request sense enabled. 2198 */ 2199 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, 2200 MAX(statuslen, SATA_MAX_SENSE_LEN), 2201 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); 2202 2203 if (pkt == NULL) 2204 return (NULL); 2205 2206 /* Fill scsi packet structure */ 2207 pkt->pkt_comp = (void (*)())NULL; 2208 pkt->pkt_time = 0; 2209 pkt->pkt_resid = 0; 2210 pkt->pkt_statistics = 0; 2211 pkt->pkt_reason = 0; 2212 2213 /* 2214 * pkt_hba_private will point to sata pkt txlate structure 2215 */ 2216 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2217 bzero(spx, sizeof (sata_pkt_txlate_t)); 2218 2219 spx->txlt_scsi_pkt = pkt; 2220 spx->txlt_sata_hba_inst = sata_hba_inst; 2221 2222 /* Allocate sata_pkt */ 2223 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); 2224 if (spx->txlt_sata_pkt == NULL) { 2225 /* Could not allocate sata pkt */ 2226 scsi_hba_pkt_free(ap, pkt); 2227 return (NULL); 2228 } 2229 /* Set sata address */ 2230 spx->txlt_sata_pkt->satapkt_device.satadev_addr = 2231 sata_device.satadev_addr; 2232 spx->txlt_sata_pkt->satapkt_device.satadev_rev = 2233 sata_device.satadev_rev; 2234 2235 if ((bp == NULL) || (bp->b_bcount == 0)) 2236 return (pkt); 2237 2238 spx->txlt_total_residue = bp->b_bcount; 2239 } else { 2240 new_pkt = FALSE; 2241 /* 2242 * Packet was preallocated/initialized by previous call 2243 */ 2244 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2245 2246 if ((bp == NULL) || (bp->b_bcount == 0)) { 2247 return (pkt); 2248 } 2249 2250 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ 2251 } 2252 2253 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 2254 2255 /* 2256 * We use an adjusted version of the dma_attr, to account 2257 * for device addressing limitations. 2258 * sata_adjust_dma_attr() will handle sdinfo == NULL which may 2259 * happen when a device is not yet configured. 2260 */ 2261 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2262 sata_device.satadev_addr.cport))); 2263 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 2264 &spx->txlt_sata_pkt->satapkt_device); 2265 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ 2266 sata_adjust_dma_attr(sdinfo, 2267 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 2268 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2269 sata_device.satadev_addr.cport))); 2270 /* 2271 * Allocate necessary DMA resources for the packet's data buffer 2272 * NOTE: 2273 * In case of read/write commands, DMA resource allocation here is 2274 * based on the premise that the transfer length specified in 2275 * the read/write scsi cdb will match exactly DMA resources - 2276 * returning correct packet residue is crucial. 2277 */ 2278 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, 2279 &cur_dma_attr)) != DDI_SUCCESS) { 2280 /* 2281 * If a DMA allocation request fails with 2282 * DDI_DMA_NOMAPPING, indicate the error by calling 2283 * bioerror(9F) with bp and an error code of EFAULT. 2284 * If a DMA allocation request fails with 2285 * DDI_DMA_TOOBIG, indicate the error by calling 2286 * bioerror(9F) with bp and an error code of EINVAL. 2287 * For DDI_DMA_NORESOURCES, we may have some of them allocated. 2288 * Request may be repeated later - there is no real error. 2289 */ 2290 switch (rval) { 2291 case DDI_DMA_NORESOURCES: 2292 bioerror(bp, 0); 2293 break; 2294 case DDI_DMA_NOMAPPING: 2295 case DDI_DMA_BADATTR: 2296 bioerror(bp, EFAULT); 2297 break; 2298 case DDI_DMA_TOOBIG: 2299 default: 2300 bioerror(bp, EINVAL); 2301 break; 2302 } 2303 if (new_pkt == TRUE) { 2304 /* 2305 * Since this is a new packet, we can clean-up 2306 * everything 2307 */ 2308 sata_scsi_destroy_pkt(ap, pkt); 2309 } else { 2310 /* 2311 * This is a re-used packet. It will be target driver's 2312 * responsibility to eventually destroy it (which 2313 * will free allocated resources). 2314 * Here, we just "complete" the request, leaving 2315 * allocated resources intact, so the request may 2316 * be retried. 2317 */ 2318 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2319 sata_pkt_free(spx); 2320 } 2321 return (NULL); 2322 } 2323 /* Set number of bytes that are not yet accounted for */ 2324 pkt->pkt_resid = spx->txlt_total_residue; 2325 ASSERT(pkt->pkt_resid >= 0); 2326 2327 return (pkt); 2328 } 2329 2330 /* 2331 * Implementation of scsi tran_start. 2332 * Translate scsi cmd into sata operation and return status. 2333 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands 2334 * are supported. 2335 * For SATA hard disks, supported scsi commands: 2336 * SCMD_INQUIRY 2337 * SCMD_TEST_UNIT_READY 2338 * SCMD_START_STOP 2339 * SCMD_READ_CAPACITY 2340 * SCMD_REQUEST_SENSE 2341 * SCMD_LOG_SENSE_G1 2342 * SCMD_LOG_SELECT_G1 2343 * SCMD_MODE_SENSE (specific pages) 2344 * SCMD_MODE_SENSE_G1 (specific pages) 2345 * SCMD_MODE_SELECT (specific pages) 2346 * SCMD_MODE_SELECT_G1 (specific pages) 2347 * SCMD_SYNCHRONIZE_CACHE 2348 * SCMD_SYNCHRONIZE_CACHE_G1 2349 * SCMD_READ 2350 * SCMD_READ_G1 2351 * SCMD_READ_G4 2352 * SCMD_READ_G5 2353 * SCMD_WRITE 2354 * SCMD_WRITE_BUFFER 2355 * SCMD_WRITE_G1 2356 * SCMD_WRITE_G4 2357 * SCMD_WRITE_G5 2358 * SCMD_SEEK (noop) 2359 * SCMD_SDIAG 2360 * 2361 * All other commands are rejected as unsupported. 2362 * 2363 * Returns: 2364 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver 2365 * for execution. TRAN_ACCEPT may be returned also if device was removed but 2366 * a callback could be scheduled. 2367 * TRAN_BADPKT if cmd was directed to invalid address. 2368 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including 2369 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device 2370 * was removed and there was no callback specified in scsi pkt. 2371 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA 2372 * framework was busy performing some other operation(s). 2373 * 2374 */ 2375 static int 2376 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 2377 { 2378 sata_hba_inst_t *sata_hba_inst = 2379 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2380 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2381 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device; 2382 sata_drive_info_t *sdinfo; 2383 struct buf *bp; 2384 uint8_t cport, pmport; 2385 boolean_t dev_gone = B_FALSE; 2386 int rval; 2387 2388 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2389 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); 2390 2391 ASSERT(spx != NULL && 2392 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); 2393 2394 cport = SCSI_TO_SATA_CPORT(ap->a_target); 2395 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2396 2397 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2398 2399 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) { 2400 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2401 if (sdinfo == NULL || 2402 SATA_CPORT_INFO(sata_hba_inst, cport)-> 2403 cport_tgtnode_clean == B_FALSE || 2404 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2405 dev_gone = B_TRUE; 2406 } 2407 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) { 2408 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 2409 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 2410 cport) == NULL) { 2411 dev_gone = B_TRUE; 2412 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport, 2413 pmport) == NULL) { 2414 dev_gone = B_TRUE; 2415 } else { 2416 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2417 cport, pmport))); 2418 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2419 if (sdinfo == NULL || 2420 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)-> 2421 pmport_tgtnode_clean == B_FALSE || 2422 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2423 dev_gone = B_TRUE; 2424 } 2425 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2426 cport, pmport))); 2427 } 2428 } 2429 2430 if (dev_gone == B_TRUE) { 2431 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2432 pkt->pkt_reason = CMD_DEV_GONE; 2433 /* 2434 * The sd target driver is checking CMD_DEV_GONE pkt_reason 2435 * only in callback function (for normal requests) and 2436 * in the dump code path. 2437 * So, if the callback is available, we need to do 2438 * the callback rather than returning TRAN_FATAL_ERROR here. 2439 */ 2440 if (pkt->pkt_comp != NULL) { 2441 /* scsi callback required */ 2442 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2443 (task_func_t *)pkt->pkt_comp, 2444 (void *)pkt, TQ_NOSLEEP) == NULL) 2445 /* Scheduling the callback failed */ 2446 return (TRAN_BUSY); 2447 return (TRAN_ACCEPT); 2448 } 2449 /* No callback available */ 2450 return (TRAN_FATAL_ERROR); 2451 } 2452 2453 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 2454 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2455 rval = sata_txlt_atapi(spx); 2456 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2457 "sata_scsi_start atapi: rval %d\n", rval); 2458 return (rval); 2459 } 2460 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2461 2462 /* 2463 * Checking for power state, if it was on 2464 * STOPPED state, then the drive is not capable 2465 * of processing media access command. And 2466 * TEST_UNIT_READY, REQUEST_SENSE has special handling 2467 * in the function for different power state. 2468 */ 2469 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) || 2470 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) && 2471 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) { 2472 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 2473 SD_SCSI_ASC_LU_NOT_READY)); 2474 } 2475 2476 /* ATA Disk commands processing starts here */ 2477 2478 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2479 2480 switch (pkt->pkt_cdbp[0]) { 2481 2482 case SCMD_INQUIRY: 2483 /* Mapped to identify device */ 2484 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2485 bp_mapin(bp); 2486 rval = sata_txlt_inquiry(spx); 2487 break; 2488 2489 case SCMD_TEST_UNIT_READY: 2490 /* 2491 * SAT "SATA to ATA Translation" doc specifies translation 2492 * to ATA CHECK POWER MODE. 2493 */ 2494 rval = sata_txlt_test_unit_ready(spx); 2495 break; 2496 2497 case SCMD_START_STOP: 2498 /* Mapping depends on the command */ 2499 rval = sata_txlt_start_stop_unit(spx); 2500 break; 2501 2502 case SCMD_READ_CAPACITY: 2503 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2504 bp_mapin(bp); 2505 rval = sata_txlt_read_capacity(spx); 2506 break; 2507 2508 case SCMD_REQUEST_SENSE: 2509 /* 2510 * Always No Sense, since we force ARQ 2511 */ 2512 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2513 bp_mapin(bp); 2514 rval = sata_txlt_request_sense(spx); 2515 break; 2516 2517 case SCMD_LOG_SENSE_G1: 2518 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2519 bp_mapin(bp); 2520 rval = sata_txlt_log_sense(spx); 2521 break; 2522 2523 case SCMD_LOG_SELECT_G1: 2524 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2525 bp_mapin(bp); 2526 rval = sata_txlt_log_select(spx); 2527 break; 2528 2529 case SCMD_MODE_SENSE: 2530 case SCMD_MODE_SENSE_G1: 2531 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2532 bp_mapin(bp); 2533 rval = sata_txlt_mode_sense(spx); 2534 break; 2535 2536 2537 case SCMD_MODE_SELECT: 2538 case SCMD_MODE_SELECT_G1: 2539 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2540 bp_mapin(bp); 2541 rval = sata_txlt_mode_select(spx); 2542 break; 2543 2544 case SCMD_SYNCHRONIZE_CACHE: 2545 case SCMD_SYNCHRONIZE_CACHE_G1: 2546 rval = sata_txlt_synchronize_cache(spx); 2547 break; 2548 2549 case SCMD_READ: 2550 case SCMD_READ_G1: 2551 case SCMD_READ_G4: 2552 case SCMD_READ_G5: 2553 rval = sata_txlt_read(spx); 2554 break; 2555 case SCMD_WRITE_BUFFER: 2556 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2557 bp_mapin(bp); 2558 rval = sata_txlt_write_buffer(spx); 2559 break; 2560 2561 case SCMD_WRITE: 2562 case SCMD_WRITE_G1: 2563 case SCMD_WRITE_G4: 2564 case SCMD_WRITE_G5: 2565 rval = sata_txlt_write(spx); 2566 break; 2567 2568 case SCMD_SEEK: 2569 rval = sata_txlt_nodata_cmd_immediate(spx); 2570 break; 2571 2572 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 2573 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 2574 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2575 bp_mapin(bp); 2576 rval = sata_txlt_ata_pass_thru(spx); 2577 break; 2578 2579 /* Other cases will be filed later */ 2580 /* postponed until phase 2 of the development */ 2581 default: 2582 rval = sata_txlt_invalid_command(spx); 2583 break; 2584 } 2585 2586 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2587 "sata_scsi_start: rval %d\n", rval); 2588 2589 return (rval); 2590 } 2591 2592 /* 2593 * Implementation of scsi tran_abort. 2594 * Abort specific pkt or all packets. 2595 * 2596 * Returns 1 if one or more packets were aborted, returns 0 otherwise 2597 * 2598 * May be called from an interrupt level. 2599 */ 2600 static int 2601 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) 2602 { 2603 sata_hba_inst_t *sata_hba_inst = 2604 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2605 sata_device_t sata_device; 2606 sata_pkt_t *sata_pkt; 2607 2608 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2609 "sata_scsi_abort: %s at target: 0x%x\n", 2610 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); 2611 2612 /* Validate address */ 2613 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) 2614 /* Invalid address */ 2615 return (0); 2616 2617 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2618 sata_device.satadev_addr.cport))); 2619 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2620 /* invalid address */ 2621 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2622 sata_device.satadev_addr.cport))); 2623 return (0); 2624 } 2625 if (scsi_pkt == NULL) { 2626 /* 2627 * Abort all packets. 2628 * Although we do not have specific packet, we still need 2629 * dummy packet structure to pass device address to HBA. 2630 * Allocate one, without sleeping. Fail if pkt cannot be 2631 * allocated. 2632 */ 2633 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); 2634 if (sata_pkt == NULL) { 2635 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2636 sata_device.satadev_addr.cport))); 2637 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " 2638 "could not allocate sata_pkt")); 2639 return (0); 2640 } 2641 sata_pkt->satapkt_rev = SATA_PKT_REV; 2642 sata_pkt->satapkt_device = sata_device; 2643 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 2644 } else { 2645 if (scsi_pkt->pkt_ha_private == NULL) { 2646 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2647 sata_device.satadev_addr.cport))); 2648 return (0); /* Bad scsi pkt */ 2649 } 2650 /* extract pointer to sata pkt */ 2651 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> 2652 txlt_sata_pkt; 2653 } 2654 2655 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2656 sata_device.satadev_addr.cport))); 2657 /* Send abort request to HBA */ 2658 if ((*SATA_ABORT_FUNC(sata_hba_inst)) 2659 (SATA_DIP(sata_hba_inst), sata_pkt, 2660 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == 2661 SATA_SUCCESS) { 2662 if (scsi_pkt == NULL) 2663 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2664 /* Success */ 2665 return (1); 2666 } 2667 /* Else, something did not go right */ 2668 if (scsi_pkt == NULL) 2669 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2670 /* Failure */ 2671 return (0); 2672 } 2673 2674 2675 /* 2676 * Implementation of scsi tran_reset. 2677 * RESET_ALL request is translated into port reset. 2678 * RESET_TARGET requests is translated into a device reset, 2679 * RESET_LUN request is accepted only for LUN 0 and translated into 2680 * device reset. 2681 * The target reset should cause all HBA active and queued packets to 2682 * be terminated and returned with pkt reason SATA_PKT_RESET prior to 2683 * the return. HBA should report reset event for the device. 2684 * 2685 * Returns 1 upon success, 0 upon failure. 2686 */ 2687 static int 2688 sata_scsi_reset(struct scsi_address *ap, int level) 2689 { 2690 sata_hba_inst_t *sata_hba_inst = 2691 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2692 sata_device_t sata_device; 2693 int val; 2694 2695 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2696 "sata_scsi_reset: level %d target: 0x%x\n", 2697 level, ap->a_target); 2698 2699 /* Validate address */ 2700 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); 2701 if (val == -1) 2702 /* Invalid address */ 2703 return (0); 2704 2705 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2706 sata_device.satadev_addr.cport))); 2707 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2708 /* invalid address */ 2709 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2710 sata_device.satadev_addr.cport))); 2711 return (0); 2712 } 2713 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2714 sata_device.satadev_addr.cport))); 2715 if (level == RESET_ALL) { 2716 /* port reset */ 2717 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT) 2718 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2719 else 2720 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 2721 2722 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2723 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2724 return (1); 2725 else 2726 return (0); 2727 2728 } else if (val == 0 && 2729 (level == RESET_TARGET || level == RESET_LUN)) { 2730 /* reset device (device attached) */ 2731 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2732 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2733 return (1); 2734 else 2735 return (0); 2736 } 2737 return (0); 2738 } 2739 2740 2741 /* 2742 * Implementation of scsi tran_getcap (get transport/device capabilities). 2743 * Supported capabilities for SATA hard disks: 2744 * auto-rqsense (always supported) 2745 * tagged-qing (supported if HBA supports it) 2746 * untagged-qing (could be supported if disk supports it, but because 2747 * caching behavior allowing untagged queuing actually 2748 * results in reduced performance. sd tries to throttle 2749 * back to only 3 outstanding commands, which may 2750 * work for real SCSI disks, but with read ahead 2751 * caching, having more than 1 outstanding command 2752 * results in cache thrashing.) 2753 * sector_size 2754 * dma_max 2755 * interconnect-type (INTERCONNECT_SATA) 2756 * 2757 * Supported capabilities for ATAPI CD/DVD devices: 2758 * auto-rqsense (always supported) 2759 * sector_size 2760 * dma_max 2761 * max-cdb-length 2762 * interconnect-type (INTERCONNECT_SATA) 2763 * 2764 * Supported capabilities for ATAPI TAPE devices: 2765 * auto-rqsense (always supported) 2766 * dma_max 2767 * max-cdb-length 2768 * 2769 * Supported capabilities for SATA ATAPI hard disks: 2770 * auto-rqsense (always supported) 2771 * interconnect-type (INTERCONNECT_SATA) 2772 * max-cdb-length 2773 * 2774 * Request for other capabilities is rejected as unsupported. 2775 * 2776 * Returns supported capability value, or -1 if capability is unsuppported or 2777 * the address is invalid - no device. 2778 */ 2779 2780 static int 2781 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 2782 { 2783 2784 sata_hba_inst_t *sata_hba_inst = 2785 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2786 sata_device_t sata_device; 2787 sata_drive_info_t *sdinfo; 2788 ddi_dma_attr_t adj_dma_attr; 2789 int rval; 2790 2791 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2792 "sata_scsi_getcap: target: 0x%x, cap: %s\n", 2793 ap->a_target, cap); 2794 2795 /* 2796 * We want to process the capabilities on per port granularity. 2797 * So, we are specifically restricting ourselves to whom != 0 2798 * to exclude the controller wide handling. 2799 */ 2800 if (cap == NULL || whom == 0) 2801 return (-1); 2802 2803 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2804 /* Invalid address */ 2805 return (-1); 2806 } 2807 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2808 sata_device.satadev_addr.cport))); 2809 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == 2810 NULL) { 2811 /* invalid address */ 2812 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2813 sata_device.satadev_addr.cport))); 2814 return (-1); 2815 } 2816 2817 switch (scsi_hba_lookup_capstr(cap)) { 2818 case SCSI_CAP_ARQ: 2819 rval = 1; /* ARQ supported, turned on */ 2820 break; 2821 2822 case SCSI_CAP_SECTOR_SIZE: 2823 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) 2824 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ 2825 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) 2826 rval = SATA_ATAPI_SECTOR_SIZE; 2827 else rval = -1; 2828 break; 2829 2830 /* 2831 * untagged queuing cause a performance inversion because of 2832 * the way sd operates. Because of this reason we do not 2833 * use it when available. 2834 */ 2835 case SCSI_CAP_UNTAGGED_QING: 2836 if (sdinfo->satadrv_features_enabled & 2837 SATA_DEV_F_E_UNTAGGED_QING) 2838 rval = 1; /* Untagged queuing available */ 2839 else 2840 rval = -1; /* Untagged queuing not available */ 2841 break; 2842 2843 case SCSI_CAP_TAGGED_QING: 2844 if ((sdinfo->satadrv_features_enabled & 2845 SATA_DEV_F_E_TAGGED_QING) && 2846 (sdinfo->satadrv_max_queue_depth > 1)) 2847 rval = 1; /* Tagged queuing available */ 2848 else 2849 rval = -1; /* Tagged queuing not available */ 2850 break; 2851 2852 case SCSI_CAP_DMA_MAX: 2853 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), 2854 &adj_dma_attr); 2855 rval = (int)adj_dma_attr.dma_attr_maxxfer; 2856 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ 2857 break; 2858 2859 case SCSI_CAP_INTERCONNECT_TYPE: 2860 rval = INTERCONNECT_SATA; /* SATA interconnect type */ 2861 break; 2862 2863 case SCSI_CAP_CDB_LEN: 2864 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) 2865 rval = sdinfo->satadrv_atapi_cdb_len; 2866 else 2867 rval = -1; 2868 break; 2869 2870 default: 2871 rval = -1; 2872 break; 2873 } 2874 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2875 sata_device.satadev_addr.cport))); 2876 return (rval); 2877 } 2878 2879 /* 2880 * Implementation of scsi tran_setcap 2881 * 2882 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable. 2883 * 2884 */ 2885 static int 2886 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 2887 { 2888 sata_hba_inst_t *sata_hba_inst = 2889 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2890 sata_device_t sata_device; 2891 sata_drive_info_t *sdinfo; 2892 int rval; 2893 2894 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2895 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); 2896 2897 /* 2898 * We want to process the capabilities on per port granularity. 2899 * So, we are specifically restricting ourselves to whom != 0 2900 * to exclude the controller wide handling. 2901 */ 2902 if (cap == NULL || whom == 0) { 2903 return (-1); 2904 } 2905 2906 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2907 /* Invalid address */ 2908 return (-1); 2909 } 2910 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2911 sata_device.satadev_addr.cport))); 2912 if ((sdinfo = sata_get_device_info(sata_hba_inst, 2913 &sata_device)) == NULL) { 2914 /* invalid address */ 2915 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2916 sata_device.satadev_addr.cport))); 2917 return (-1); 2918 } 2919 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2920 sata_device.satadev_addr.cport))); 2921 2922 switch (scsi_hba_lookup_capstr(cap)) { 2923 case SCSI_CAP_ARQ: 2924 case SCSI_CAP_SECTOR_SIZE: 2925 case SCSI_CAP_DMA_MAX: 2926 case SCSI_CAP_INTERCONNECT_TYPE: 2927 rval = 0; 2928 break; 2929 case SCSI_CAP_UNTAGGED_QING: 2930 if (SATA_QDEPTH(sata_hba_inst) > 1) { 2931 rval = 1; 2932 if (value == 1) { 2933 sdinfo->satadrv_features_enabled |= 2934 SATA_DEV_F_E_UNTAGGED_QING; 2935 } else if (value == 0) { 2936 sdinfo->satadrv_features_enabled &= 2937 ~SATA_DEV_F_E_UNTAGGED_QING; 2938 } else { 2939 rval = -1; 2940 } 2941 } else { 2942 rval = 0; 2943 } 2944 break; 2945 case SCSI_CAP_TAGGED_QING: 2946 /* This can TCQ or NCQ */ 2947 if (sata_func_enable & SATA_ENABLE_QUEUING && 2948 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && 2949 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || 2950 (sata_func_enable & SATA_ENABLE_NCQ && 2951 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && 2952 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) && 2953 (sdinfo->satadrv_max_queue_depth > 1)) { 2954 rval = 1; 2955 if (value == 1) { 2956 sdinfo->satadrv_features_enabled |= 2957 SATA_DEV_F_E_TAGGED_QING; 2958 } else if (value == 0) { 2959 sdinfo->satadrv_features_enabled &= 2960 ~SATA_DEV_F_E_TAGGED_QING; 2961 } else { 2962 rval = -1; 2963 } 2964 } else { 2965 rval = 0; 2966 } 2967 break; 2968 default: 2969 rval = -1; 2970 break; 2971 } 2972 return (rval); 2973 } 2974 2975 /* 2976 * Implementations of scsi tran_destroy_pkt. 2977 * Free resources allocated by sata_scsi_init_pkt() 2978 */ 2979 static void 2980 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 2981 { 2982 sata_pkt_txlate_t *spx; 2983 2984 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2985 2986 sata_common_free_dma_rsrcs(spx); 2987 2988 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2989 sata_pkt_free(spx); 2990 2991 scsi_hba_pkt_free(ap, pkt); 2992 } 2993 2994 /* 2995 * Implementation of scsi tran_dmafree. 2996 * Free DMA resources allocated by sata_scsi_init_pkt() 2997 */ 2998 2999 static void 3000 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 3001 { 3002 #ifndef __lock_lint 3003 _NOTE(ARGUNUSED(ap)) 3004 #endif 3005 sata_pkt_txlate_t *spx; 3006 3007 ASSERT(pkt != NULL); 3008 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3009 3010 sata_common_free_dma_rsrcs(spx); 3011 } 3012 3013 /* 3014 * Implementation of scsi tran_sync_pkt. 3015 * 3016 * The assumption below is that pkt is unique - there is no need to check ap 3017 * 3018 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data 3019 * into/from the real buffer. 3020 */ 3021 static void 3022 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3023 { 3024 #ifndef __lock_lint 3025 _NOTE(ARGUNUSED(ap)) 3026 #endif 3027 int rval; 3028 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3029 struct buf *bp; 3030 int direction; 3031 3032 ASSERT(spx != NULL); 3033 if (spx->txlt_buf_dma_handle != NULL) { 3034 direction = spx->txlt_sata_pkt-> 3035 satapkt_cmd.satacmd_flags.sata_data_direction; 3036 if (spx->txlt_sata_pkt != NULL && 3037 direction != SATA_DIR_NODATA_XFER) { 3038 if (spx->txlt_tmp_buf != NULL) { 3039 /* Intermediate DMA buffer used */ 3040 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3041 3042 if (direction & SATA_DIR_WRITE) { 3043 bcopy(bp->b_un.b_addr, 3044 spx->txlt_tmp_buf, bp->b_bcount); 3045 } 3046 } 3047 /* Sync the buffer for device or for CPU */ 3048 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 3049 (direction & SATA_DIR_WRITE) ? 3050 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 3051 ASSERT(rval == DDI_SUCCESS); 3052 if (spx->txlt_tmp_buf != NULL && 3053 !(direction & SATA_DIR_WRITE)) { 3054 /* Intermediate DMA buffer used for read */ 3055 bcopy(spx->txlt_tmp_buf, 3056 bp->b_un.b_addr, bp->b_bcount); 3057 } 3058 3059 } 3060 } 3061 } 3062 3063 3064 3065 /* ******************* SATA - SCSI Translation functions **************** */ 3066 /* 3067 * SCSI to SATA pkt and command translation and SATA to SCSI status/error 3068 * translation. 3069 */ 3070 3071 /* 3072 * Checks if a device exists and can be access and translates common 3073 * scsi_pkt data to sata_pkt data. 3074 * 3075 * Flag argument indicates that a non-read/write ATA command may be sent 3076 * to HBA in arbitrary SYNC mode to execute this packet. 3077 * 3078 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and 3079 * sata_pkt was set-up. 3080 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not 3081 * exist and pkt_comp callback was scheduled. 3082 * Returns other TRAN_XXXXX values when error occured and command should be 3083 * rejected with the returned TRAN_XXXXX value. 3084 * 3085 * This function should be called with port mutex held. 3086 */ 3087 static int 3088 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag) 3089 { 3090 sata_drive_info_t *sdinfo; 3091 sata_device_t sata_device; 3092 const struct sata_cmd_flags sata_initial_cmd_flags = { 3093 SATA_DIR_NODATA_XFER, 3094 /* all other values to 0/FALSE */ 3095 }; 3096 /* 3097 * Pkt_reason has to be set if the pkt_comp callback is invoked, 3098 * and that implies TRAN_ACCEPT return value. Any other returned value 3099 * indicates that the scsi packet was not accepted (the reason will not 3100 * be checked by the scsi target driver). 3101 * To make debugging easier, we set pkt_reason to know value here. 3102 * It may be changed later when different completion reason is 3103 * determined. 3104 */ 3105 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 3106 *reason = CMD_TRAN_ERR; 3107 3108 /* Validate address */ 3109 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, 3110 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { 3111 3112 case -1: 3113 /* Invalid address or invalid device type */ 3114 return (TRAN_BADPKT); 3115 case 2: 3116 /* 3117 * Valid address but device type is unknown - Chack if it is 3118 * in the reset state and therefore in an indeterminate state. 3119 */ 3120 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3121 &spx->txlt_sata_pkt->satapkt_device); 3122 if (sdinfo != NULL && (sdinfo->satadrv_event_flags & 3123 (SATA_EVNT_DEVICE_RESET | 3124 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3125 if (!ddi_in_panic()) { 3126 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3127 *reason = CMD_INCOMPLETE; 3128 SATADBG1(SATA_DBG_SCSI_IF, 3129 spx->txlt_sata_hba_inst, 3130 "sata_scsi_start: rejecting command " 3131 "because of device reset state\n", NULL); 3132 return (TRAN_BUSY); 3133 } 3134 } 3135 /* FALLTHROUGH */ 3136 case 1: 3137 /* valid address but no valid device - it has disappeared */ 3138 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; 3139 *reason = CMD_DEV_GONE; 3140 /* 3141 * The sd target driver is checking CMD_DEV_GONE pkt_reason 3142 * only in callback function (for normal requests) and 3143 * in the dump code path. 3144 * So, if the callback is available, we need to do 3145 * the callback rather than returning TRAN_FATAL_ERROR here. 3146 */ 3147 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { 3148 /* scsi callback required */ 3149 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3150 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3151 (void *)spx->txlt_scsi_pkt, 3152 TQ_SLEEP) == NULL) 3153 /* Scheduling the callback failed */ 3154 return (TRAN_BUSY); 3155 3156 return (TRAN_ACCEPT); 3157 } 3158 return (TRAN_FATAL_ERROR); 3159 default: 3160 /* all OK; pkt reason will be overwritten later */ 3161 break; 3162 } 3163 /* 3164 * If pkt is to be executed in polling mode and a command will not be 3165 * emulated in SATA module (requires sending a non-read/write ATA 3166 * command to HBA driver in arbitrary SYNC mode) and we are in the 3167 * interrupt context and not in the panic dump, then reject the packet 3168 * to avoid a possible interrupt stack overrun or hang caused by 3169 * a potentially blocked interrupt. 3170 */ 3171 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) && 3172 servicing_interrupt() && !ddi_in_panic()) { 3173 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst, 3174 "sata_scsi_start: rejecting synchronous command because " 3175 "of interrupt context\n", NULL); 3176 return (TRAN_BUSY); 3177 } 3178 3179 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3180 &spx->txlt_sata_pkt->satapkt_device); 3181 3182 /* 3183 * If device is in reset condition, reject the packet with 3184 * TRAN_BUSY, unless: 3185 * 1. system is panicking (dumping) 3186 * In such case only one thread is running and there is no way to 3187 * process reset. 3188 * 2. cfgadm operation is is progress (internal APCTL lock is set) 3189 * Some cfgadm operations involve drive commands, so reset condition 3190 * needs to be ignored for IOCTL operations. 3191 */ 3192 if ((sdinfo->satadrv_event_flags & 3193 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3194 3195 if (!ddi_in_panic() && 3196 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, 3197 sata_device.satadev_addr.cport) & 3198 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { 3199 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3200 *reason = CMD_INCOMPLETE; 3201 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3202 "sata_scsi_start: rejecting command because " 3203 "of device reset state\n", NULL); 3204 return (TRAN_BUSY); 3205 } 3206 } 3207 3208 /* 3209 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by 3210 * sata_scsi_pkt_init() because pkt init had to work also with 3211 * non-existing devices. 3212 * Now we know that the packet was set-up for a real device, so its 3213 * type is known. 3214 */ 3215 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; 3216 3217 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; 3218 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, 3219 sata_device.satadev_addr.cport)->cport_event_flags & 3220 SATA_APCTL_LOCK_PORT_BUSY) != 0) { 3221 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3222 sata_ignore_dev_reset = B_TRUE; 3223 } 3224 /* 3225 * At this point the generic translation routine determined that the 3226 * scsi packet should be accepted. Packet completion reason may be 3227 * changed later when a different completion reason is determined. 3228 */ 3229 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3230 *reason = CMD_CMPLT; 3231 3232 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 3233 /* Synchronous execution */ 3234 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | 3235 SATA_OPMODE_POLLING; 3236 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3237 sata_ignore_dev_reset = ddi_in_panic(); 3238 } else { 3239 /* Asynchronous execution */ 3240 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | 3241 SATA_OPMODE_INTERRUPTS; 3242 } 3243 /* Convert queuing information */ 3244 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) 3245 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = 3246 B_TRUE; 3247 else if (spx->txlt_scsi_pkt->pkt_flags & 3248 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) 3249 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = 3250 B_TRUE; 3251 3252 /* Always limit pkt time */ 3253 if (spx->txlt_scsi_pkt->pkt_time == 0) 3254 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; 3255 else 3256 /* Pass on scsi_pkt time */ 3257 spx->txlt_sata_pkt->satapkt_time = 3258 spx->txlt_scsi_pkt->pkt_time; 3259 3260 return (TRAN_ACCEPT); 3261 } 3262 3263 3264 /* 3265 * Translate ATA Identify Device data to SCSI Inquiry data. 3266 * This function may be called only for ATA devices. 3267 * This function should not be called for ATAPI devices - they 3268 * respond directly to SCSI Inquiry command. 3269 * 3270 * SATA Identify Device data has to be valid in sata_drive_info. 3271 * Buffer has to accomodate the inquiry length (36 bytes). 3272 * 3273 * This function should be called with a port mutex held. 3274 */ 3275 static void 3276 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, 3277 sata_drive_info_t *sdinfo, uint8_t *buf) 3278 { 3279 3280 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 3281 struct sata_id *sid = &sdinfo->satadrv_id; 3282 3283 /* Start with a nice clean slate */ 3284 bzero((void *)inq, sizeof (struct scsi_inquiry)); 3285 3286 /* 3287 * Rely on the dev_type for setting paripheral qualifier. 3288 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices. 3289 * It could be that DTYPE_OPTICAL could also qualify in the future. 3290 * ATAPI Inquiry may provide more data to the target driver. 3291 */ 3292 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3293 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */ 3294 3295 /* CFA type device is not a removable media device */ 3296 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) && 3297 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0; 3298 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ 3299 inq->inq_iso = 0; /* ISO version */ 3300 inq->inq_ecma = 0; /* ECMA version */ 3301 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ 3302 inq->inq_aenc = 0; /* Async event notification cap. */ 3303 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */ 3304 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ 3305 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ 3306 inq->inq_len = 31; /* Additional length */ 3307 inq->inq_dualp = 0; /* dual port device - NO */ 3308 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ 3309 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ 3310 inq->inq_linked = 0; /* Supports linked commands - NO */ 3311 /* 3312 * Queuing support - controller has to 3313 * support some sort of command queuing. 3314 */ 3315 if (SATA_QDEPTH(sata_hba_inst) > 1) 3316 inq->inq_cmdque = 1; /* Supports command queueing - YES */ 3317 else 3318 inq->inq_cmdque = 0; /* Supports command queueing - NO */ 3319 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ 3320 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ 3321 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ 3322 3323 #ifdef _LITTLE_ENDIAN 3324 /* Swap text fields to match SCSI format */ 3325 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3326 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3327 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3328 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3329 else 3330 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3331 #else /* _LITTLE_ENDIAN */ 3332 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3333 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3334 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3335 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3336 else 3337 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3338 #endif /* _LITTLE_ENDIAN */ 3339 } 3340 3341 3342 /* 3343 * Scsi response set up for invalid command (command not supported) 3344 * 3345 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3346 */ 3347 static int 3348 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) 3349 { 3350 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3351 struct scsi_extended_sense *sense; 3352 3353 scsipkt->pkt_reason = CMD_CMPLT; 3354 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3355 STATE_SENT_CMD | STATE_GOT_STATUS; 3356 3357 *scsipkt->pkt_scbp = STATUS_CHECK; 3358 3359 sense = sata_arq_sense(spx); 3360 sense->es_key = KEY_ILLEGAL_REQUEST; 3361 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE; 3362 3363 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3364 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3365 3366 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3367 scsipkt->pkt_comp != NULL) 3368 /* scsi callback required */ 3369 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3370 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3371 (void *)spx->txlt_scsi_pkt, 3372 TQ_SLEEP) == NULL) 3373 /* Scheduling the callback failed */ 3374 return (TRAN_BUSY); 3375 return (TRAN_ACCEPT); 3376 } 3377 3378 /* 3379 * Scsi response set up for check condition with special sense key 3380 * and additional sense code. 3381 * 3382 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3383 */ 3384 static int 3385 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code) 3386 { 3387 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 3388 int cport = SATA_TXLT_CPORT(spx); 3389 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3390 struct scsi_extended_sense *sense; 3391 3392 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 3393 scsipkt->pkt_reason = CMD_CMPLT; 3394 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3395 STATE_SENT_CMD | STATE_GOT_STATUS; 3396 3397 *scsipkt->pkt_scbp = STATUS_CHECK; 3398 3399 sense = sata_arq_sense(spx); 3400 sense->es_key = key; 3401 sense->es_add_code = code; 3402 3403 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3404 3405 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3406 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3407 3408 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 3409 /* scsi callback required */ 3410 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3411 (task_func_t *)scsi_hba_pkt_comp, 3412 (void *)spx->txlt_scsi_pkt, 3413 TQ_SLEEP) == NULL) 3414 /* Scheduling the callback failed */ 3415 return (TRAN_BUSY); 3416 return (TRAN_ACCEPT); 3417 } 3418 3419 /* 3420 * Scsi response setup for 3421 * emulated non-data command that requires no action/return data 3422 * 3423 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3424 */ 3425 static int 3426 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) 3427 { 3428 int rval; 3429 int reason; 3430 3431 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3432 3433 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3434 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3435 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3436 return (rval); 3437 } 3438 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3439 3440 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3441 STATE_SENT_CMD | STATE_GOT_STATUS; 3442 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3443 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; 3444 3445 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3446 "Scsi_pkt completion reason %x\n", 3447 spx->txlt_scsi_pkt->pkt_reason); 3448 3449 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && 3450 spx->txlt_scsi_pkt->pkt_comp != NULL) 3451 /* scsi callback required */ 3452 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3453 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3454 (void *)spx->txlt_scsi_pkt, 3455 TQ_SLEEP) == NULL) 3456 /* Scheduling the callback failed */ 3457 return (TRAN_BUSY); 3458 return (TRAN_ACCEPT); 3459 } 3460 3461 3462 /* 3463 * SATA translate command: Inquiry / Identify Device 3464 * Use cached Identify Device data for now, rather than issuing actual 3465 * Device Identify cmd request. If device is detached and re-attached, 3466 * asynchronous event processing should fetch and refresh Identify Device 3467 * data. 3468 * Two VPD pages are supported now: 3469 * Vital Product Data page 3470 * Unit Serial Number page 3471 * 3472 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3473 */ 3474 3475 #define EVPD 1 /* Extended Vital Product Data flag */ 3476 #define CMDDT 2 /* Command Support Data - Obsolete */ 3477 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VDP Pages Page COde */ 3478 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ 3479 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ 3480 3481 static int 3482 sata_txlt_inquiry(sata_pkt_txlate_t *spx) 3483 { 3484 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3485 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3486 sata_drive_info_t *sdinfo; 3487 struct scsi_extended_sense *sense; 3488 int count; 3489 uint8_t *p; 3490 int i, j; 3491 uint8_t page_buf[0xff]; /* Max length */ 3492 int rval, reason; 3493 3494 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3495 3496 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3497 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3498 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3499 return (rval); 3500 } 3501 3502 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3503 &spx->txlt_sata_pkt->satapkt_device); 3504 3505 ASSERT(sdinfo != NULL); 3506 3507 scsipkt->pkt_reason = CMD_CMPLT; 3508 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3509 STATE_SENT_CMD | STATE_GOT_STATUS; 3510 3511 /* Reject not supported request */ 3512 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ 3513 *scsipkt->pkt_scbp = STATUS_CHECK; 3514 sense = sata_arq_sense(spx); 3515 sense->es_key = KEY_ILLEGAL_REQUEST; 3516 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3517 goto done; 3518 } 3519 3520 /* Valid Inquiry request */ 3521 *scsipkt->pkt_scbp = STATUS_GOOD; 3522 3523 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3524 3525 /* 3526 * Because it is fully emulated command storing data 3527 * programatically in the specified buffer, release 3528 * preallocated DMA resources before storing data in the buffer, 3529 * so no unwanted DMA sync would take place. 3530 */ 3531 sata_scsi_dmafree(NULL, scsipkt); 3532 3533 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { 3534 /* Standard Inquiry Data request */ 3535 struct scsi_inquiry inq; 3536 unsigned int bufsize; 3537 3538 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, 3539 sdinfo, (uint8_t *)&inq); 3540 /* Copy no more than requested */ 3541 count = MIN(bp->b_bcount, 3542 sizeof (struct scsi_inquiry)); 3543 bufsize = scsipkt->pkt_cdbp[4]; 3544 bufsize |= scsipkt->pkt_cdbp[3] << 8; 3545 count = MIN(count, bufsize); 3546 bcopy(&inq, bp->b_un.b_addr, count); 3547 3548 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3549 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3550 bufsize - count : 0; 3551 } else { 3552 /* 3553 * peripheral_qualifier = 0; 3554 * 3555 * We are dealing only with HD and will be 3556 * dealing with CD/DVD devices soon 3557 */ 3558 uint8_t peripheral_device_type = 3559 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3560 DTYPE_DIRECT : DTYPE_RODIRECT; 3561 3562 switch ((uint_t)scsipkt->pkt_cdbp[2]) { 3563 case INQUIRY_SUP_VPD_PAGE: 3564 /* 3565 * Request for suported Vital Product Data 3566 * pages - assuming only 2 page codes 3567 * supported. 3568 */ 3569 page_buf[0] = peripheral_device_type; 3570 page_buf[1] = INQUIRY_SUP_VPD_PAGE; 3571 page_buf[2] = 0; 3572 page_buf[3] = 2; /* page length */ 3573 page_buf[4] = INQUIRY_SUP_VPD_PAGE; 3574 page_buf[5] = INQUIRY_USN_PAGE; 3575 /* Copy no more than requested */ 3576 count = MIN(bp->b_bcount, 6); 3577 bcopy(page_buf, bp->b_un.b_addr, count); 3578 break; 3579 3580 case INQUIRY_USN_PAGE: 3581 /* 3582 * Request for Unit Serial Number page. 3583 * Set-up the page. 3584 */ 3585 page_buf[0] = peripheral_device_type; 3586 page_buf[1] = INQUIRY_USN_PAGE; 3587 page_buf[2] = 0; 3588 /* remaining page length */ 3589 page_buf[3] = SATA_ID_SERIAL_LEN; 3590 3591 /* 3592 * Copy serial number from Identify Device data 3593 * words into the inquiry page and swap bytes 3594 * when necessary. 3595 */ 3596 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); 3597 #ifdef _LITTLE_ENDIAN 3598 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3599 #else 3600 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3601 #endif 3602 /* 3603 * Least significant character of the serial 3604 * number shall appear as the last byte, 3605 * according to SBC-3 spec. 3606 * Count trailing spaces to determine the 3607 * necessary shift length. 3608 */ 3609 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1]; 3610 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) { 3611 if (*(p - j) != '\0' && 3612 *(p - j) != '\040') 3613 break; 3614 } 3615 3616 /* 3617 * Shift SN string right, so that the last 3618 * non-blank character would appear in last 3619 * byte of SN field in the page. 3620 * 'j' is the shift length. 3621 */ 3622 for (i = 0; 3623 i < (SATA_ID_SERIAL_LEN - j) && j != 0; 3624 i++, p--) 3625 *p = *(p - j); 3626 3627 /* 3628 * Add leading spaces - same number as the 3629 * shift size 3630 */ 3631 for (; j > 0; j--) 3632 page_buf[4 + j - 1] = '\040'; 3633 3634 count = MIN(bp->b_bcount, 3635 SATA_ID_SERIAL_LEN + 4); 3636 bcopy(page_buf, bp->b_un.b_addr, count); 3637 break; 3638 3639 case INQUIRY_DEV_IDENTIFICATION_PAGE: 3640 /* 3641 * We may want to implement this page, when 3642 * identifiers are common for SATA devices 3643 * But not now. 3644 */ 3645 /*FALLTHROUGH*/ 3646 3647 default: 3648 /* Request for unsupported VPD page */ 3649 *scsipkt->pkt_scbp = STATUS_CHECK; 3650 sense = sata_arq_sense(spx); 3651 sense->es_key = KEY_ILLEGAL_REQUEST; 3652 sense->es_add_code = 3653 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3654 goto done; 3655 } 3656 } 3657 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3658 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3659 scsipkt->pkt_cdbp[4] - count : 0; 3660 } 3661 done: 3662 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3663 3664 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3665 "Scsi_pkt completion reason %x\n", 3666 scsipkt->pkt_reason); 3667 3668 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3669 scsipkt->pkt_comp != NULL) { 3670 /* scsi callback required */ 3671 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3672 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 3673 TQ_SLEEP) == NULL) 3674 /* Scheduling the callback failed */ 3675 return (TRAN_BUSY); 3676 } 3677 return (TRAN_ACCEPT); 3678 } 3679 3680 /* 3681 * SATA translate command: Request Sense. 3682 * 3683 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3684 * At the moment this is an emulated command (ATA version for SATA hard disks). 3685 * May be translated into Check Power Mode command in the future. 3686 * 3687 * Note: There is a mismatch between already implemented Informational 3688 * Exception Mode Select page 0x1C and this function. 3689 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return 3690 * NO SENSE and set additional sense code to the exception code - this is not 3691 * implemented here. 3692 */ 3693 static int 3694 sata_txlt_request_sense(sata_pkt_txlate_t *spx) 3695 { 3696 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3697 struct scsi_extended_sense sense; 3698 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3699 sata_drive_info_t *sdinfo; 3700 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3701 int rval, reason, power_state = 0; 3702 3703 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3704 3705 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 3706 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3707 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3708 return (rval); 3709 } 3710 3711 scsipkt->pkt_reason = CMD_CMPLT; 3712 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3713 STATE_SENT_CMD | STATE_GOT_STATUS; 3714 *scsipkt->pkt_scbp = STATUS_GOOD; 3715 3716 /* 3717 * when CONTROL field's NACA bit == 1 3718 * return ILLEGAL_REQUEST 3719 */ 3720 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) { 3721 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3722 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 3723 SD_SCSI_ASC_CMD_SEQUENCE_ERR)); 3724 } 3725 3726 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3727 &spx->txlt_sata_pkt->satapkt_device); 3728 ASSERT(sdinfo != NULL); 3729 3730 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 3731 3732 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 3733 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 3734 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3735 if (sata_hba_start(spx, &rval) != 0) { 3736 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3737 return (rval); 3738 } else { 3739 if (scmd->satacmd_error_reg != 0) { 3740 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3741 return (sata_txlt_check_condition(spx, KEY_NO_SENSE, 3742 SD_SCSI_ASC_NO_ADD_SENSE)); 3743 } 3744 } 3745 3746 switch (scmd->satacmd_sec_count_lsb) { 3747 case SATA_PWRMODE_STANDBY: /* device in standby mode */ 3748 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED) 3749 power_state = SATA_POWER_STOPPED; 3750 else { 3751 power_state = SATA_POWER_STANDBY; 3752 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 3753 } 3754 break; 3755 case SATA_PWRMODE_IDLE: /* device in idle mode */ 3756 power_state = SATA_POWER_IDLE; 3757 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 3758 break; 3759 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */ 3760 default: /* 0x40, 0x41 active mode */ 3761 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE) 3762 power_state = SATA_POWER_IDLE; 3763 else { 3764 power_state = SATA_POWER_ACTIVE; 3765 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 3766 } 3767 break; 3768 } 3769 3770 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3771 3772 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3773 /* 3774 * Because it is fully emulated command storing data 3775 * programatically in the specified buffer, release 3776 * preallocated DMA resources before storing data in the buffer, 3777 * so no unwanted DMA sync would take place. 3778 */ 3779 int count = MIN(bp->b_bcount, 3780 sizeof (struct scsi_extended_sense)); 3781 sata_scsi_dmafree(NULL, scsipkt); 3782 bzero(&sense, sizeof (struct scsi_extended_sense)); 3783 sense.es_valid = 0; /* Valid LBA */ 3784 sense.es_class = 7; /* Response code 0x70 - current err */ 3785 sense.es_key = KEY_NO_SENSE; 3786 sense.es_add_len = 6; /* Additional length */ 3787 /* Copy no more than requested */ 3788 bcopy(&sense, bp->b_un.b_addr, count); 3789 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3790 scsipkt->pkt_resid = 0; 3791 switch (power_state) { 3792 case SATA_POWER_IDLE: 3793 case SATA_POWER_STANDBY: 3794 sense.es_add_code = 3795 SD_SCSI_ASC_LOW_POWER_CONDITION_ON; 3796 break; 3797 case SATA_POWER_STOPPED: 3798 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE; 3799 break; 3800 case SATA_POWER_ACTIVE: 3801 default: 3802 break; 3803 } 3804 } 3805 3806 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3807 "Scsi_pkt completion reason %x\n", 3808 scsipkt->pkt_reason); 3809 3810 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 3811 /* scsi callback required */ 3812 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3813 (task_func_t *)scsi_hba_pkt_comp, (void *) scsipkt, 3814 TQ_SLEEP) == NULL) 3815 /* Scheduling the callback failed */ 3816 return (TRAN_BUSY); 3817 return (TRAN_ACCEPT); 3818 } 3819 3820 /* 3821 * SATA translate command: Test Unit Ready 3822 * (ATA version for SATA hard disks). 3823 * It is translated into the Check Power Mode command. 3824 * 3825 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3826 */ 3827 static int 3828 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) 3829 { 3830 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3831 struct scsi_extended_sense *sense; 3832 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3833 sata_drive_info_t *sdinfo; 3834 int power_state; 3835 int rval, reason; 3836 3837 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3838 3839 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 3840 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3841 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3842 return (rval); 3843 } 3844 3845 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3846 &spx->txlt_sata_pkt->satapkt_device); 3847 ASSERT(sdinfo != NULL); 3848 3849 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 3850 3851 /* send CHECK POWER MODE command */ 3852 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 3853 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 3854 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3855 if (sata_hba_start(spx, &rval) != 0) { 3856 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3857 return (rval); 3858 } else { 3859 if (scmd->satacmd_error_reg != 0) { 3860 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3861 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 3862 SD_SCSI_ASC_LU_NOT_RESPONSE)); 3863 } 3864 } 3865 3866 power_state = scmd->satacmd_sec_count_lsb; 3867 3868 /* 3869 * return NOT READY when device in STOPPED mode 3870 */ 3871 if (power_state == SATA_PWRMODE_STANDBY && 3872 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) { 3873 *scsipkt->pkt_scbp = STATUS_CHECK; 3874 sense = sata_arq_sense(spx); 3875 sense->es_key = KEY_NOT_READY; 3876 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY; 3877 } else { 3878 /* 3879 * For other power mode, return GOOD status 3880 */ 3881 *scsipkt->pkt_scbp = STATUS_GOOD; 3882 } 3883 3884 scsipkt->pkt_reason = CMD_CMPLT; 3885 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3886 STATE_SENT_CMD | STATE_GOT_STATUS; 3887 3888 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3889 3890 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3891 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3892 3893 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 3894 /* scsi callback required */ 3895 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3896 (task_func_t *)scsi_hba_pkt_comp, (void *) scsipkt, 3897 TQ_SLEEP) == NULL) 3898 /* Scheduling the callback failed */ 3899 return (TRAN_BUSY); 3900 3901 return (TRAN_ACCEPT); 3902 } 3903 3904 /* 3905 * SATA translate command: Start Stop Unit 3906 * Translation depends on a command: 3907 * 3908 * Power condition bits will be supported 3909 * and the power level should be maintained by SATL, 3910 * When SATL received a command, it will check the 3911 * power level firstly, and return the status according 3912 * to SAT2 v2.6 and SAT-2 Standby Modifications 3913 * 3914 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC 3915 * ----------------------------------------------------------------------- 3916 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1 3917 * SSU_PC2 Idle <==> ATA Idle <==> N/A 3918 * SSU_PC3 Standby <==> ATA Standby <==> N/A 3919 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0 3920 * 3921 * Unload Media / NOT SUPPORTED YET 3922 * Load Media / NOT SUPPROTED YET 3923 * Immediate bit / NOT SUPPORTED YET (deferred error) 3924 * 3925 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 3926 * appropriate values in scsi_pkt fields. 3927 */ 3928 static int 3929 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) 3930 { 3931 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3932 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3933 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 3934 int cport = SATA_TXLT_CPORT(spx); 3935 int rval, reason; 3936 sata_drive_info_t *sdinfo; 3937 sata_id_t *sata_id; 3938 3939 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3940 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); 3941 3942 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 3943 3944 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 3945 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3946 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3947 return (rval); 3948 } 3949 3950 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) { 3951 /* IMMED bit - not supported */ 3952 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3953 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 3954 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 3955 } 3956 3957 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 3958 spx->txlt_sata_pkt->satapkt_comp = NULL; 3959 3960 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3961 &spx->txlt_sata_pkt->satapkt_device); 3962 ASSERT(sdinfo != NULL); 3963 sata_id = &sdinfo->satadrv_id; 3964 3965 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) { 3966 case 0: 3967 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) { 3968 /* Load/Unload Media - invalid request */ 3969 goto err_out; 3970 } 3971 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) { 3972 /* Start Unit */ 3973 sata_build_read_verify_cmd(scmd, 1, 5); 3974 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3975 /* Transfer command to HBA */ 3976 if (sata_hba_start(spx, &rval) != 0) { 3977 /* Pkt not accepted for execution */ 3978 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3979 return (rval); 3980 } else { 3981 if (scmd->satacmd_error_reg != 0) { 3982 goto err_out; 3983 } 3984 } 3985 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 3986 } else { 3987 /* Stop Unit */ 3988 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 3989 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3990 if (sata_hba_start(spx, &rval) != 0) { 3991 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3992 return (rval); 3993 } else { 3994 if (scmd->satacmd_error_reg != 0) { 3995 goto err_out; 3996 } 3997 } 3998 /* ata standby immediate command */ 3999 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4000 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4001 if (sata_hba_start(spx, &rval) != 0) { 4002 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4003 return (rval); 4004 } else { 4005 if (scmd->satacmd_error_reg != 0) { 4006 goto err_out; 4007 } 4008 } 4009 sdinfo->satadrv_power_level = SATA_POWER_STOPPED; 4010 } 4011 break; 4012 case 0x1: 4013 sata_build_generic_cmd(scmd, SATAC_IDLE); 4014 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4015 if (sata_hba_start(spx, &rval) != 0) { 4016 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4017 return (rval); 4018 } else { 4019 if (scmd->satacmd_error_reg != 0) { 4020 goto err_out; 4021 } 4022 } 4023 sata_build_read_verify_cmd(scmd, 1, 5); 4024 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4025 /* Transfer command to HBA */ 4026 if (sata_hba_start(spx, &rval) != 0) { 4027 /* Pkt not accepted for execution */ 4028 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4029 return (rval); 4030 } else { 4031 if (scmd->satacmd_error_reg != 0) { 4032 goto err_out; 4033 } 4034 } 4035 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4036 break; 4037 case 0x2: 4038 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4039 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4040 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4041 if (sata_hba_start(spx, &rval) != 0) { 4042 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4043 return (rval); 4044 } else { 4045 if (scmd->satacmd_error_reg != 0) { 4046 goto err_out; 4047 } 4048 } 4049 } 4050 sata_build_generic_cmd(scmd, SATAC_IDLE); 4051 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4052 if (sata_hba_start(spx, &rval) != 0) { 4053 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4054 return (rval); 4055 } else { 4056 if (scmd->satacmd_error_reg != 0) { 4057 goto err_out; 4058 } 4059 } 4060 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) { 4061 /* 4062 * POWER CONDITION MODIFIER bit set 4063 * to 0x1 or larger it will be handled 4064 * on the same way as bit = 0x1 4065 */ 4066 if (!(sata_id->ai_cmdset84 & 4067 SATA_IDLE_UNLOAD_SUPPORTED)) { 4068 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4069 break; 4070 } 4071 sata_build_generic_cmd(scmd, SATAC_IDLE_IM); 4072 scmd->satacmd_features_reg = 0x44; 4073 scmd->satacmd_lba_low_lsb = 0x4c; 4074 scmd->satacmd_lba_mid_lsb = 0x4e; 4075 scmd->satacmd_lba_high_lsb = 0x55; 4076 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4077 if (sata_hba_start(spx, &rval) != 0) { 4078 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4079 return (rval); 4080 } else { 4081 if (scmd->satacmd_error_reg != 0) { 4082 goto err_out; 4083 } 4084 } 4085 } 4086 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4087 break; 4088 case 0x3: 4089 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4090 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4091 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4092 if (sata_hba_start(spx, &rval) != 0) { 4093 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4094 return (rval); 4095 } else { 4096 if (scmd->satacmd_error_reg != 0) { 4097 goto err_out; 4098 } 4099 } 4100 } 4101 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4102 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4103 if (sata_hba_start(spx, &rval) != 0) { 4104 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4105 return (rval); 4106 } else { 4107 if (scmd->satacmd_error_reg != 0) { 4108 goto err_out; 4109 } 4110 } 4111 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 4112 break; 4113 case 0x7: 4114 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4115 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4116 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4117 if (sata_hba_start(spx, &rval) != 0) { 4118 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4119 return (rval); 4120 } else { 4121 if (scmd->satacmd_error_reg != 0) { 4122 goto err_out; 4123 } 4124 } 4125 switch (scmd->satacmd_sec_count_lsb) { 4126 case SATA_PWRMODE_STANDBY: 4127 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4128 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4129 sdinfo->satadrv_standby_timer); 4130 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4131 if (sata_hba_start(spx, &rval) != 0) { 4132 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4133 return (rval); 4134 } else { 4135 if (scmd->satacmd_error_reg != 0) { 4136 goto err_out; 4137 } 4138 } 4139 break; 4140 case SATA_PWRMODE_IDLE: 4141 sata_build_generic_cmd(scmd, SATAC_IDLE); 4142 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4143 sdinfo->satadrv_standby_timer); 4144 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4145 if (sata_hba_start(spx, &rval) != 0) { 4146 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4147 return (rval); 4148 } else { 4149 if (scmd->satacmd_error_reg != 0) { 4150 goto err_out; 4151 } 4152 } 4153 break; 4154 case SATA_PWRMODE_ACTIVE_SPINDOWN: 4155 case SATA_PWRMODE_ACTIVE_SPINUP: 4156 case SATA_PWRMODE_ACTIVE: 4157 sata_build_generic_cmd(scmd, SATAC_IDLE); 4158 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4159 sdinfo->satadrv_standby_timer); 4160 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4161 if (sata_hba_start(spx, &rval) != 0) { 4162 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4163 return (rval); 4164 } else { 4165 if (scmd->satacmd_error_reg != 0) { 4166 goto err_out; 4167 } 4168 } 4169 sata_build_read_verify_cmd(scmd, 1, 5); 4170 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4171 if (sata_hba_start(spx, &rval) != 0) { 4172 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4173 return (rval); 4174 } else { 4175 if (scmd->satacmd_error_reg != 0) { 4176 goto err_out; 4177 } 4178 } 4179 break; 4180 default: 4181 goto err_out; 4182 } 4183 break; 4184 case 0xb: 4185 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) == 4186 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) { 4187 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4188 return (sata_txlt_check_condition(spx, 4189 KEY_ILLEGAL_REQUEST, 4190 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4191 } 4192 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4193 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4194 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4195 if (sata_hba_start(spx, &rval) != 0) { 4196 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4197 return (rval); 4198 } else { 4199 if (scmd->satacmd_error_reg != 0) { 4200 goto err_out; 4201 } 4202 } 4203 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4204 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4205 if (sata_hba_start(spx, &rval) != 0) { 4206 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4207 return (rval); 4208 } else { 4209 if (scmd->satacmd_error_reg != 0) { 4210 goto err_out; 4211 } 4212 } 4213 } 4214 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4); 4215 break; 4216 default: 4217 err_out: 4218 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4219 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4220 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4221 } 4222 4223 /* 4224 * Since it was a synchronous command, 4225 * a callback function will be called directly. 4226 */ 4227 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4228 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4229 "synchronous execution status %x\n", 4230 spx->txlt_sata_pkt->satapkt_reason); 4231 4232 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) { 4233 sata_set_arq_data(spx->txlt_sata_pkt); 4234 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4235 (task_func_t *)scsi_hba_pkt_comp, (void *) scsipkt, 4236 TQ_SLEEP) == 0) { 4237 return (TRAN_BUSY); 4238 } 4239 } 4240 else 4241 4242 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 4243 4244 return (TRAN_ACCEPT); 4245 4246 } 4247 4248 /* 4249 * SATA translate command: Read Capacity. 4250 * Emulated command for SATA disks. 4251 * Capacity is retrieved from cached Idenifty Device data. 4252 * Identify Device data shows effective disk capacity, not the native 4253 * capacity, which may be limitted by Set Max Address command. 4254 * This is ATA version for SATA hard disks. 4255 * 4256 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4257 */ 4258 static int 4259 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) 4260 { 4261 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4262 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4263 sata_drive_info_t *sdinfo; 4264 uint64_t val; 4265 uchar_t *rbuf; 4266 int rval, reason; 4267 4268 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4269 "sata_txlt_read_capacity: ", NULL); 4270 4271 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4272 4273 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4274 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4275 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4276 return (rval); 4277 } 4278 4279 scsipkt->pkt_reason = CMD_CMPLT; 4280 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4281 STATE_SENT_CMD | STATE_GOT_STATUS; 4282 *scsipkt->pkt_scbp = STATUS_GOOD; 4283 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4284 /* 4285 * Because it is fully emulated command storing data 4286 * programatically in the specified buffer, release 4287 * preallocated DMA resources before storing data in the buffer, 4288 * so no unwanted DMA sync would take place. 4289 */ 4290 sata_scsi_dmafree(NULL, scsipkt); 4291 4292 sdinfo = sata_get_device_info( 4293 spx->txlt_sata_hba_inst, 4294 &spx->txlt_sata_pkt->satapkt_device); 4295 /* Last logical block address */ 4296 val = sdinfo->satadrv_capacity - 1; 4297 rbuf = (uchar_t *)bp->b_un.b_addr; 4298 /* Need to swap endians to match scsi format */ 4299 rbuf[0] = (val >> 24) & 0xff; 4300 rbuf[1] = (val >> 16) & 0xff; 4301 rbuf[2] = (val >> 8) & 0xff; 4302 rbuf[3] = val & 0xff; 4303 /* block size - always 512 bytes, for now */ 4304 rbuf[4] = 0; 4305 rbuf[5] = 0; 4306 rbuf[6] = 0x02; 4307 rbuf[7] = 0; 4308 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4309 scsipkt->pkt_resid = 0; 4310 4311 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", 4312 sdinfo->satadrv_capacity -1); 4313 } 4314 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4315 /* 4316 * If a callback was requested, do it now. 4317 */ 4318 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4319 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4320 4321 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4322 scsipkt->pkt_comp != NULL) 4323 /* scsi callback required */ 4324 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4325 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4326 TQ_SLEEP) == NULL) 4327 /* Scheduling the callback failed */ 4328 return (TRAN_BUSY); 4329 4330 return (TRAN_ACCEPT); 4331 } 4332 4333 /* 4334 * SATA translate command: Mode Sense. 4335 * Translated into appropriate SATA command or emulated. 4336 * Saved Values Page Control (03) are not supported. 4337 * 4338 * NOTE: only caching mode sense page is currently implemented. 4339 * 4340 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4341 */ 4342 4343 #define LLBAA 0x10 /* Long LBA Accepted */ 4344 4345 static int 4346 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) 4347 { 4348 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4349 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4350 sata_drive_info_t *sdinfo; 4351 sata_id_t *sata_id; 4352 struct scsi_extended_sense *sense; 4353 int len, bdlen, count, alc_len; 4354 int pc; /* Page Control code */ 4355 uint8_t *buf; /* mode sense buffer */ 4356 int rval, reason; 4357 4358 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4359 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", 4360 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4361 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4362 4363 buf = kmem_zalloc(1024, KM_SLEEP); 4364 4365 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4366 4367 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4368 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4369 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4370 kmem_free(buf, 1024); 4371 return (rval); 4372 } 4373 4374 scsipkt->pkt_reason = CMD_CMPLT; 4375 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4376 STATE_SENT_CMD | STATE_GOT_STATUS; 4377 4378 pc = scsipkt->pkt_cdbp[2] >> 6; 4379 4380 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4381 /* 4382 * Because it is fully emulated command storing data 4383 * programatically in the specified buffer, release 4384 * preallocated DMA resources before storing data in the buffer, 4385 * so no unwanted DMA sync would take place. 4386 */ 4387 sata_scsi_dmafree(NULL, scsipkt); 4388 4389 len = 0; 4390 bdlen = 0; 4391 if (!(scsipkt->pkt_cdbp[1] & 8)) { 4392 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && 4393 (scsipkt->pkt_cdbp[1] & LLBAA)) 4394 bdlen = 16; 4395 else 4396 bdlen = 8; 4397 } 4398 /* Build mode parameter header */ 4399 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4400 /* 4-byte mode parameter header */ 4401 buf[len++] = 0; /* mode data length */ 4402 buf[len++] = 0; /* medium type */ 4403 buf[len++] = 0; /* dev-specific param */ 4404 buf[len++] = bdlen; /* Block Descriptor length */ 4405 } else { 4406 /* 8-byte mode parameter header */ 4407 buf[len++] = 0; /* mode data length */ 4408 buf[len++] = 0; 4409 buf[len++] = 0; /* medium type */ 4410 buf[len++] = 0; /* dev-specific param */ 4411 if (bdlen == 16) 4412 buf[len++] = 1; /* long lba descriptor */ 4413 else 4414 buf[len++] = 0; 4415 buf[len++] = 0; 4416 buf[len++] = 0; /* Block Descriptor length */ 4417 buf[len++] = bdlen; 4418 } 4419 4420 sdinfo = sata_get_device_info( 4421 spx->txlt_sata_hba_inst, 4422 &spx->txlt_sata_pkt->satapkt_device); 4423 4424 /* Build block descriptor only if not disabled (DBD) */ 4425 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { 4426 /* Block descriptor - direct-access device format */ 4427 if (bdlen == 8) { 4428 /* build regular block descriptor */ 4429 buf[len++] = 4430 (sdinfo->satadrv_capacity >> 24) & 0xff; 4431 buf[len++] = 4432 (sdinfo->satadrv_capacity >> 16) & 0xff; 4433 buf[len++] = 4434 (sdinfo->satadrv_capacity >> 8) & 0xff; 4435 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4436 buf[len++] = 0; /* density code */ 4437 buf[len++] = 0; 4438 if (sdinfo->satadrv_type == 4439 SATA_DTYPE_ATADISK) 4440 buf[len++] = 2; 4441 else 4442 /* ATAPI */ 4443 buf[len++] = 8; 4444 buf[len++] = 0; 4445 } else if (bdlen == 16) { 4446 /* Long LBA Accepted */ 4447 /* build long lba block descriptor */ 4448 #ifndef __lock_lint 4449 buf[len++] = 4450 (sdinfo->satadrv_capacity >> 56) & 0xff; 4451 buf[len++] = 4452 (sdinfo->satadrv_capacity >> 48) & 0xff; 4453 buf[len++] = 4454 (sdinfo->satadrv_capacity >> 40) & 0xff; 4455 buf[len++] = 4456 (sdinfo->satadrv_capacity >> 32) & 0xff; 4457 #endif 4458 buf[len++] = 4459 (sdinfo->satadrv_capacity >> 24) & 0xff; 4460 buf[len++] = 4461 (sdinfo->satadrv_capacity >> 16) & 0xff; 4462 buf[len++] = 4463 (sdinfo->satadrv_capacity >> 8) & 0xff; 4464 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4465 buf[len++] = 0; 4466 buf[len++] = 0; /* density code */ 4467 buf[len++] = 0; 4468 buf[len++] = 0; 4469 if (sdinfo->satadrv_type == 4470 SATA_DTYPE_ATADISK) 4471 buf[len++] = 2; 4472 else 4473 /* ATAPI */ 4474 buf[len++] = 8; 4475 buf[len++] = 0; 4476 } 4477 } 4478 4479 sata_id = &sdinfo->satadrv_id; 4480 4481 /* 4482 * Add requested pages. 4483 * Page 3 and 4 are obsolete and we are not supporting them. 4484 * We deal now with: 4485 * caching (read/write cache control). 4486 * We should eventually deal with following mode pages: 4487 * error recovery (0x01), 4488 * power condition (0x1a), 4489 * exception control page (enables SMART) (0x1c), 4490 * enclosure management (ses), 4491 * protocol-specific port mode (port control). 4492 */ 4493 switch (scsipkt->pkt_cdbp[2] & 0x3f) { 4494 case MODEPAGE_RW_ERRRECOV: 4495 /* DAD_MODE_ERR_RECOV */ 4496 /* R/W recovery */ 4497 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 4498 break; 4499 case MODEPAGE_CACHING: 4500 /* DAD_MODE_CACHE */ 4501 /* Reject not supported request for saved parameters */ 4502 if (pc == 3) { 4503 *scsipkt->pkt_scbp = STATUS_CHECK; 4504 sense = sata_arq_sense(spx); 4505 sense->es_key = KEY_ILLEGAL_REQUEST; 4506 sense->es_add_code = 4507 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED; 4508 goto done; 4509 } 4510 4511 /* caching */ 4512 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 4513 break; 4514 case MODEPAGE_INFO_EXCPT: 4515 /* exception cntrl */ 4516 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 4517 len += sata_build_msense_page_1c(sdinfo, pc, 4518 buf+len); 4519 } 4520 else 4521 goto err; 4522 break; 4523 case MODEPAGE_POWER_COND: 4524 /* DAD_MODE_POWER_COND */ 4525 /* power condition */ 4526 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 4527 break; 4528 4529 case MODEPAGE_ACOUSTIC_MANAG: 4530 /* acoustic management */ 4531 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 4532 break; 4533 case MODEPAGE_ALLPAGES: 4534 /* all pages */ 4535 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 4536 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 4537 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 4538 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 4539 len += sata_build_msense_page_1c(sdinfo, pc, 4540 buf+len); 4541 } 4542 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 4543 break; 4544 default: 4545 err: 4546 /* Invalid request */ 4547 *scsipkt->pkt_scbp = STATUS_CHECK; 4548 sense = sata_arq_sense(spx); 4549 sense->es_key = KEY_ILLEGAL_REQUEST; 4550 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4551 goto done; 4552 } 4553 4554 /* fix total mode data length */ 4555 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4556 /* 4-byte mode parameter header */ 4557 buf[0] = len - 1; /* mode data length */ 4558 } else { 4559 buf[0] = (len -2) >> 8; 4560 buf[1] = (len -2) & 0xff; 4561 } 4562 4563 4564 /* Check allocation length */ 4565 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4566 alc_len = scsipkt->pkt_cdbp[4]; 4567 } else { 4568 alc_len = scsipkt->pkt_cdbp[7]; 4569 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 4570 } 4571 /* 4572 * We do not check for possible parameters truncation 4573 * (alc_len < len) assuming that the target driver works 4574 * correctly. Just avoiding overrun. 4575 * Copy no more than requested and possible, buffer-wise. 4576 */ 4577 count = MIN(alc_len, len); 4578 count = MIN(bp->b_bcount, count); 4579 bcopy(buf, bp->b_un.b_addr, count); 4580 4581 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4582 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 4583 } 4584 *scsipkt->pkt_scbp = STATUS_GOOD; 4585 done: 4586 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4587 (void) kmem_free(buf, 1024); 4588 4589 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4590 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4591 4592 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4593 scsipkt->pkt_comp != NULL) 4594 /* scsi callback required */ 4595 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4596 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4597 TQ_SLEEP) == NULL) 4598 /* Scheduling the callback failed */ 4599 return (TRAN_BUSY); 4600 4601 return (TRAN_ACCEPT); 4602 } 4603 4604 4605 /* 4606 * SATA translate command: Mode Select. 4607 * Translated into appropriate SATA command or emulated. 4608 * Saving parameters is not supported. 4609 * Changing device capacity is not supported (although theoretically 4610 * possible by executing SET FEATURES/SET MAX ADDRESS) 4611 * 4612 * Assumption is that the target driver is working correctly. 4613 * 4614 * More than one SATA command may be executed to perform operations specified 4615 * by mode select pages. The first error terminates further execution. 4616 * Operations performed successully are not backed-up in such case. 4617 * 4618 * NOTE: Implemented pages: 4619 * - caching page 4620 * - informational exception page 4621 * - acoustic management page 4622 * - power condition page 4623 * Caching setup is remembered so it could be re-stored in case of 4624 * an unexpected device reset. 4625 * 4626 * Returns TRAN_XXXX. 4627 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields. 4628 */ 4629 4630 static int 4631 sata_txlt_mode_select(sata_pkt_txlate_t *spx) 4632 { 4633 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4634 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4635 struct scsi_extended_sense *sense; 4636 int len, pagelen, count, pllen; 4637 uint8_t *buf; /* mode select buffer */ 4638 int rval, stat, reason; 4639 uint_t nointr_flag; 4640 int dmod = 0; 4641 4642 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4643 "sata_txlt_mode_select, pc %x page code 0x%02x\n", 4644 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4645 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4646 4647 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4648 4649 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4650 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4651 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4652 return (rval); 4653 } 4654 4655 rval = TRAN_ACCEPT; 4656 4657 scsipkt->pkt_reason = CMD_CMPLT; 4658 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4659 STATE_SENT_CMD | STATE_GOT_STATUS; 4660 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; 4661 4662 /* Reject not supported request */ 4663 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ 4664 *scsipkt->pkt_scbp = STATUS_CHECK; 4665 sense = sata_arq_sense(spx); 4666 sense->es_key = KEY_ILLEGAL_REQUEST; 4667 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4668 goto done; 4669 } 4670 4671 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 4672 pllen = scsipkt->pkt_cdbp[4]; 4673 } else { 4674 pllen = scsipkt->pkt_cdbp[7]; 4675 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; 4676 } 4677 4678 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 4679 4680 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { 4681 buf = (uint8_t *)bp->b_un.b_addr; 4682 count = MIN(bp->b_bcount, pllen); 4683 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4684 scsipkt->pkt_resid = 0; 4685 pllen = count; 4686 4687 /* 4688 * Check the header to skip the block descriptor(s) - we 4689 * do not support setting device capacity. 4690 * Existing macros do not recognize long LBA dscriptor, 4691 * hence manual calculation. 4692 */ 4693 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 4694 /* 6-bytes CMD, 4 bytes header */ 4695 if (count <= 4) 4696 goto done; /* header only */ 4697 len = buf[3] + 4; 4698 } else { 4699 /* 10-bytes CMD, 8 bytes header */ 4700 if (count <= 8) 4701 goto done; /* header only */ 4702 len = buf[6]; 4703 len = (len << 8) + buf[7] + 8; 4704 } 4705 if (len >= count) 4706 goto done; /* header + descriptor(s) only */ 4707 4708 pllen -= len; /* remaining data length */ 4709 4710 /* 4711 * We may be executing SATA command and want to execute it 4712 * in SYNCH mode, regardless of scsi_pkt setting. 4713 * Save scsi_pkt setting and indicate SYNCH mode 4714 */ 4715 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4716 scsipkt->pkt_comp != NULL) { 4717 scsipkt->pkt_flags |= FLAG_NOINTR; 4718 } 4719 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 4720 4721 /* 4722 * len is now the offset to a first mode select page 4723 * Process all pages 4724 */ 4725 while (pllen > 0) { 4726 switch ((int)buf[len]) { 4727 case MODEPAGE_CACHING: 4728 /* No support for SP (saving) */ 4729 if (scsipkt->pkt_cdbp[1] & 0x01) { 4730 *scsipkt->pkt_scbp = STATUS_CHECK; 4731 sense = sata_arq_sense(spx); 4732 sense->es_key = KEY_ILLEGAL_REQUEST; 4733 sense->es_add_code = 4734 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4735 goto done; 4736 } 4737 stat = sata_mode_select_page_8(spx, 4738 (struct mode_cache_scsi3 *)&buf[len], 4739 pllen, &pagelen, &rval, &dmod); 4740 /* 4741 * The pagelen value indicates the number of 4742 * parameter bytes already processed. 4743 * The rval is the return value from 4744 * sata_tran_start(). 4745 * The stat indicates the overall status of 4746 * the operation(s). 4747 */ 4748 if (stat != SATA_SUCCESS) 4749 /* 4750 * Page processing did not succeed - 4751 * all error info is already set-up, 4752 * just return 4753 */ 4754 pllen = 0; /* this breaks the loop */ 4755 else { 4756 len += pagelen; 4757 pllen -= pagelen; 4758 } 4759 break; 4760 4761 case MODEPAGE_INFO_EXCPT: 4762 stat = sata_mode_select_page_1c(spx, 4763 (struct mode_info_excpt_page *)&buf[len], 4764 pllen, &pagelen, &rval, &dmod); 4765 /* 4766 * The pagelen value indicates the number of 4767 * parameter bytes already processed. 4768 * The rval is the return value from 4769 * sata_tran_start(). 4770 * The stat indicates the overall status of 4771 * the operation(s). 4772 */ 4773 if (stat != SATA_SUCCESS) 4774 /* 4775 * Page processing did not succeed - 4776 * all error info is already set-up, 4777 * just return 4778 */ 4779 pllen = 0; /* this breaks the loop */ 4780 else { 4781 len += pagelen; 4782 pllen -= pagelen; 4783 } 4784 break; 4785 4786 case MODEPAGE_ACOUSTIC_MANAG: 4787 stat = sata_mode_select_page_30(spx, 4788 (struct mode_acoustic_management *) 4789 &buf[len], pllen, &pagelen, &rval, &dmod); 4790 /* 4791 * The pagelen value indicates the number of 4792 * parameter bytes already processed. 4793 * The rval is the return value from 4794 * sata_tran_start(). 4795 * The stat indicates the overall status of 4796 * the operation(s). 4797 */ 4798 if (stat != SATA_SUCCESS) 4799 /* 4800 * Page processing did not succeed - 4801 * all error info is already set-up, 4802 * just return 4803 */ 4804 pllen = 0; /* this breaks the loop */ 4805 else { 4806 len += pagelen; 4807 pllen -= pagelen; 4808 } 4809 4810 break; 4811 case MODEPAGE_POWER_COND: 4812 stat = sata_mode_select_page_1a(spx, 4813 (struct mode_info_power_cond *)&buf[len], 4814 pllen, &pagelen, &rval, &dmod); 4815 /* 4816 * The pagelen value indicates the number of 4817 * parameter bytes already processed. 4818 * The rval is the return value from 4819 * sata_tran_start(). 4820 * The stat indicates the overall status of 4821 * the operation(s). 4822 */ 4823 if (stat != SATA_SUCCESS) 4824 /* 4825 * Page processing did not succeed - 4826 * all error info is already set-up, 4827 * just return 4828 */ 4829 pllen = 0; /* this breaks the loop */ 4830 else { 4831 len += pagelen; 4832 pllen -= pagelen; 4833 } 4834 break; 4835 default: 4836 *scsipkt->pkt_scbp = STATUS_CHECK; 4837 sense = sata_arq_sense(spx); 4838 sense->es_key = KEY_ILLEGAL_REQUEST; 4839 sense->es_add_code = 4840 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 4841 goto done; 4842 } 4843 } 4844 } 4845 done: 4846 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4847 /* 4848 * If device parameters were modified, fetch and store the new 4849 * Identify Device data. Since port mutex could have been released 4850 * for accessing HBA driver, we need to re-check device existence. 4851 */ 4852 if (dmod != 0) { 4853 sata_drive_info_t new_sdinfo, *sdinfo; 4854 int rv = 0; 4855 4856 /* 4857 * Following statement has to be changed if this function is 4858 * used for devices other than SATA hard disks. 4859 */ 4860 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 4861 4862 new_sdinfo.satadrv_addr = 4863 spx->txlt_sata_pkt->satapkt_device.satadev_addr; 4864 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, 4865 &new_sdinfo); 4866 4867 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4868 /* 4869 * Since port mutex could have been released when 4870 * accessing HBA driver, we need to re-check that the 4871 * framework still holds the device info structure. 4872 */ 4873 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4874 &spx->txlt_sata_pkt->satapkt_device); 4875 if (sdinfo != NULL) { 4876 /* 4877 * Device still has info structure in the 4878 * sata framework. Copy newly fetched info 4879 */ 4880 if (rv == 0) { 4881 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 4882 sata_save_drive_settings(sdinfo); 4883 } else { 4884 /* 4885 * Could not fetch new data - invalidate 4886 * sata_drive_info. That makes device 4887 * unusable. 4888 */ 4889 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 4890 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 4891 } 4892 } 4893 if (rv != 0 || sdinfo == NULL) { 4894 /* 4895 * This changes the overall mode select completion 4896 * reason to a failed one !!!!! 4897 */ 4898 *scsipkt->pkt_scbp = STATUS_CHECK; 4899 sense = sata_arq_sense(spx); 4900 scsipkt->pkt_reason = CMD_INCOMPLETE; 4901 rval = TRAN_ACCEPT; 4902 } 4903 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4904 } 4905 /* Restore the scsi pkt flags */ 4906 scsipkt->pkt_flags &= ~FLAG_NOINTR; 4907 scsipkt->pkt_flags |= nointr_flag; 4908 4909 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4910 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4911 4912 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4913 scsipkt->pkt_comp != NULL) 4914 /* scsi callback required */ 4915 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4916 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4917 TQ_SLEEP) == NULL) 4918 /* Scheduling the callback failed */ 4919 return (TRAN_BUSY); 4920 4921 return (rval); 4922 } 4923 4924 /* 4925 * Translate command: ATA Pass Through 4926 * Incomplete implementation. Only supports No-Data, PIO Data-In, and 4927 * PIO Data-Out protocols. Also supports CK_COND bit. 4928 * 4929 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is 4930 * described in Table 111 of SAT-2 (Draft 9). 4931 */ 4932 static int 4933 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx) 4934 { 4935 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4936 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4937 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4938 int extend; 4939 uint64_t lba; 4940 uint16_t feature, sec_count; 4941 int t_len, synch; 4942 int rval, reason; 4943 4944 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4945 4946 rval = sata_txlt_generic_pkt_info(spx, &reason, 1); 4947 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4948 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4949 return (rval); 4950 } 4951 4952 /* T_DIR bit */ 4953 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR) 4954 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 4955 else 4956 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 4957 4958 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */ 4959 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) { 4960 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4961 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 4962 } 4963 4964 /* OFFLINE field. If non-zero, invalid command (for now). */ 4965 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) { 4966 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4967 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 4968 } 4969 4970 /* PROTOCOL field */ 4971 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) { 4972 case SATL_APT_P_HW_RESET: 4973 case SATL_APT_P_SRST: 4974 case SATL_APT_P_DMA: 4975 case SATL_APT_P_DMA_QUEUED: 4976 case SATL_APT_P_DEV_DIAG: 4977 case SATL_APT_P_DEV_RESET: 4978 case SATL_APT_P_UDMA_IN: 4979 case SATL_APT_P_UDMA_OUT: 4980 case SATL_APT_P_FPDMA: 4981 case SATL_APT_P_RET_RESP: 4982 /* Not yet implemented */ 4983 default: 4984 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4985 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 4986 4987 case SATL_APT_P_NON_DATA: 4988 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 4989 break; 4990 4991 case SATL_APT_P_PIO_DATA_IN: 4992 /* If PROTOCOL disagrees with T_DIR, invalid command */ 4993 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) { 4994 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4995 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 4996 } 4997 4998 /* if there is a buffer, release its DMA resources */ 4999 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5000 sata_scsi_dmafree(NULL, scsipkt); 5001 } else { 5002 /* if there is no buffer, how do you PIO in? */ 5003 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5004 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5005 } 5006 5007 break; 5008 5009 case SATL_APT_P_PIO_DATA_OUT: 5010 /* If PROTOCOL disagrees with T_DIR, invalid command */ 5011 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) { 5012 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5013 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5014 } 5015 5016 /* if there is a buffer, release its DMA resources */ 5017 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5018 sata_scsi_dmafree(NULL, scsipkt); 5019 } else { 5020 /* if there is no buffer, how do you PIO out? */ 5021 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5022 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5023 } 5024 5025 break; 5026 } 5027 5028 /* Parse the ATA cmd fields, transfer some straight to the satacmd */ 5029 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5030 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 5031 feature = scsipkt->pkt_cdbp[3]; 5032 5033 sec_count = scsipkt->pkt_cdbp[4]; 5034 5035 lba = scsipkt->pkt_cdbp[8] & 0xf; 5036 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5037 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5038 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5039 5040 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0; 5041 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9]; 5042 5043 break; 5044 5045 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 5046 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) { 5047 extend = 1; 5048 5049 feature = scsipkt->pkt_cdbp[3]; 5050 feature = (feature << 8) | scsipkt->pkt_cdbp[4]; 5051 5052 sec_count = scsipkt->pkt_cdbp[5]; 5053 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6]; 5054 5055 lba = scsipkt->pkt_cdbp[11]; 5056 lba = (lba << 8) | scsipkt->pkt_cdbp[12]; 5057 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5058 lba = (lba << 8) | scsipkt->pkt_cdbp[10]; 5059 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5060 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5061 5062 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13]; 5063 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14]; 5064 } else { 5065 feature = scsipkt->pkt_cdbp[3]; 5066 5067 sec_count = scsipkt->pkt_cdbp[5]; 5068 5069 lba = scsipkt->pkt_cdbp[13] & 0xf; 5070 lba = (lba << 8) | scsipkt->pkt_cdbp[12]; 5071 lba = (lba << 8) | scsipkt->pkt_cdbp[10]; 5072 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5073 5074 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 5075 0xf0; 5076 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14]; 5077 } 5078 5079 break; 5080 } 5081 5082 /* CK_COND bit */ 5083 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 5084 if (extend) { 5085 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1; 5086 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1; 5087 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1; 5088 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1; 5089 } 5090 5091 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 5092 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 5093 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 5094 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 5095 scmd->satacmd_flags.sata_copy_out_device_reg = 1; 5096 scmd->satacmd_flags.sata_copy_out_error_reg = 1; 5097 } 5098 5099 /* Transfer remaining parsed ATA cmd values to the satacmd */ 5100 if (extend) { 5101 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5102 5103 scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff; 5104 scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff; 5105 scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff; 5106 scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff; 5107 scmd->satacmd_lba_high_msb = lba >> 40; 5108 } else { 5109 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5110 5111 scmd->satacmd_features_reg_ext = 0; 5112 scmd->satacmd_sec_count_msb = 0; 5113 scmd->satacmd_lba_low_msb = 0; 5114 scmd->satacmd_lba_mid_msb = 0; 5115 scmd->satacmd_lba_high_msb = 0; 5116 } 5117 5118 scmd->satacmd_features_reg = feature & 0xff; 5119 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5120 scmd->satacmd_lba_low_lsb = lba & 0xff; 5121 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5122 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5123 5124 /* Determine transfer length */ 5125 switch (scsipkt->pkt_cdbp[2] & 0x3) { /* T_LENGTH field */ 5126 case 1: 5127 t_len = feature; 5128 break; 5129 case 2: 5130 t_len = sec_count; 5131 break; 5132 default: 5133 t_len = 0; 5134 break; 5135 } 5136 5137 /* Adjust transfer length for the Byte Block bit */ 5138 if ((scsipkt->pkt_cdbp[2] >> 2) & 1) 5139 t_len *= SATA_DISK_SECTOR_SIZE; 5140 5141 /* Start processing command */ 5142 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5143 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion; 5144 synch = FALSE; 5145 } else { 5146 synch = TRUE; 5147 } 5148 5149 if (sata_hba_start(spx, &rval) != 0) { 5150 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5151 return (rval); 5152 } 5153 5154 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5155 5156 if (synch) { 5157 sata_txlt_apt_completion(spx->txlt_sata_pkt); 5158 } 5159 5160 return (TRAN_ACCEPT); 5161 } 5162 5163 /* 5164 * Translate command: Log Sense 5165 */ 5166 static int 5167 sata_txlt_log_sense(sata_pkt_txlate_t *spx) 5168 { 5169 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5170 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5171 sata_drive_info_t *sdinfo; 5172 struct scsi_extended_sense *sense; 5173 int len, count, alc_len; 5174 int pc; /* Page Control code */ 5175 int page_code; /* Page code */ 5176 uint8_t *buf; /* log sense buffer */ 5177 int rval, reason; 5178 #define MAX_LOG_SENSE_PAGE_SIZE 512 5179 5180 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5181 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", 5182 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5183 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5184 5185 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); 5186 5187 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5188 5189 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5190 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5191 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5192 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5193 return (rval); 5194 } 5195 5196 scsipkt->pkt_reason = CMD_CMPLT; 5197 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5198 STATE_SENT_CMD | STATE_GOT_STATUS; 5199 5200 pc = scsipkt->pkt_cdbp[2] >> 6; 5201 page_code = scsipkt->pkt_cdbp[2] & 0x3f; 5202 5203 /* Reject not supported request for all but cumulative values */ 5204 switch (pc) { 5205 case PC_CUMULATIVE_VALUES: 5206 break; 5207 default: 5208 *scsipkt->pkt_scbp = STATUS_CHECK; 5209 sense = sata_arq_sense(spx); 5210 sense->es_key = KEY_ILLEGAL_REQUEST; 5211 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5212 goto done; 5213 } 5214 5215 switch (page_code) { 5216 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5217 case PAGE_CODE_SELF_TEST_RESULTS: 5218 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5219 case PAGE_CODE_SMART_READ_DATA: 5220 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 5221 break; 5222 default: 5223 *scsipkt->pkt_scbp = STATUS_CHECK; 5224 sense = sata_arq_sense(spx); 5225 sense->es_key = KEY_ILLEGAL_REQUEST; 5226 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5227 goto done; 5228 } 5229 5230 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 5231 /* 5232 * Because log sense uses local buffers for data retrieval from 5233 * the devices and sets the data programatically in the 5234 * original specified buffer, release preallocated DMA 5235 * resources before storing data in the original buffer, 5236 * so no unwanted DMA sync would take place. 5237 */ 5238 sata_id_t *sata_id; 5239 5240 sata_scsi_dmafree(NULL, scsipkt); 5241 5242 len = 0; 5243 5244 /* Build log parameter header */ 5245 buf[len++] = page_code; /* page code as in the CDB */ 5246 buf[len++] = 0; /* reserved */ 5247 buf[len++] = 0; /* Zero out page length for now (MSB) */ 5248 buf[len++] = 0; /* (LSB) */ 5249 5250 sdinfo = sata_get_device_info( 5251 spx->txlt_sata_hba_inst, 5252 &spx->txlt_sata_pkt->satapkt_device); 5253 5254 /* 5255 * Add requested pages. 5256 */ 5257 switch (page_code) { 5258 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5259 len = sata_build_lsense_page_0(sdinfo, buf + len); 5260 break; 5261 case PAGE_CODE_SELF_TEST_RESULTS: 5262 sata_id = &sdinfo->satadrv_id; 5263 if ((! (sata_id->ai_cmdset84 & 5264 SATA_SMART_SELF_TEST_SUPPORTED)) || 5265 (! (sata_id->ai_features87 & 5266 SATA_SMART_SELF_TEST_SUPPORTED))) { 5267 *scsipkt->pkt_scbp = STATUS_CHECK; 5268 sense = sata_arq_sense(spx); 5269 sense->es_key = KEY_ILLEGAL_REQUEST; 5270 sense->es_add_code = 5271 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5272 5273 goto done; 5274 } 5275 len = sata_build_lsense_page_10(sdinfo, buf + len, 5276 spx->txlt_sata_hba_inst); 5277 break; 5278 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5279 sata_id = &sdinfo->satadrv_id; 5280 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5281 *scsipkt->pkt_scbp = STATUS_CHECK; 5282 sense = sata_arq_sense(spx); 5283 sense->es_key = KEY_ILLEGAL_REQUEST; 5284 sense->es_add_code = 5285 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5286 5287 goto done; 5288 } 5289 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5290 *scsipkt->pkt_scbp = STATUS_CHECK; 5291 sense = sata_arq_sense(spx); 5292 sense->es_key = KEY_ABORTED_COMMAND; 5293 sense->es_add_code = 5294 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5295 sense->es_qual_code = 5296 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5297 5298 goto done; 5299 } 5300 5301 len = sata_build_lsense_page_2f(sdinfo, buf + len, 5302 spx->txlt_sata_hba_inst); 5303 break; 5304 case PAGE_CODE_SMART_READ_DATA: 5305 sata_id = &sdinfo->satadrv_id; 5306 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5307 *scsipkt->pkt_scbp = STATUS_CHECK; 5308 sense = sata_arq_sense(spx); 5309 sense->es_key = KEY_ILLEGAL_REQUEST; 5310 sense->es_add_code = 5311 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5312 5313 goto done; 5314 } 5315 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5316 *scsipkt->pkt_scbp = STATUS_CHECK; 5317 sense = sata_arq_sense(spx); 5318 sense->es_key = KEY_ABORTED_COMMAND; 5319 sense->es_add_code = 5320 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5321 sense->es_qual_code = 5322 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5323 5324 goto done; 5325 } 5326 5327 /* This page doesn't include a page header */ 5328 len = sata_build_lsense_page_30(sdinfo, buf, 5329 spx->txlt_sata_hba_inst); 5330 goto no_header; 5331 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 5332 sata_id = &sdinfo->satadrv_id; 5333 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5334 *scsipkt->pkt_scbp = STATUS_CHECK; 5335 sense = sata_arq_sense(spx); 5336 sense->es_key = KEY_ILLEGAL_REQUEST; 5337 sense->es_add_code = 5338 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5339 5340 goto done; 5341 } 5342 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5343 *scsipkt->pkt_scbp = STATUS_CHECK; 5344 sense = sata_arq_sense(spx); 5345 sense->es_key = KEY_ABORTED_COMMAND; 5346 sense->es_add_code = 5347 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5348 sense->es_qual_code = 5349 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5350 5351 goto done; 5352 } 5353 len = sata_build_lsense_page_0e(sdinfo, buf, spx); 5354 goto no_header; 5355 default: 5356 /* Invalid request */ 5357 *scsipkt->pkt_scbp = STATUS_CHECK; 5358 sense = sata_arq_sense(spx); 5359 sense->es_key = KEY_ILLEGAL_REQUEST; 5360 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5361 goto done; 5362 } 5363 5364 /* set parameter log sense data length */ 5365 buf[2] = len >> 8; /* log sense length (MSB) */ 5366 buf[3] = len & 0xff; /* log sense length (LSB) */ 5367 5368 len += SCSI_LOG_PAGE_HDR_LEN; 5369 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); 5370 5371 no_header: 5372 /* Check allocation length */ 5373 alc_len = scsipkt->pkt_cdbp[7]; 5374 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 5375 5376 /* 5377 * We do not check for possible parameters truncation 5378 * (alc_len < len) assuming that the target driver works 5379 * correctly. Just avoiding overrun. 5380 * Copy no more than requested and possible, buffer-wise. 5381 */ 5382 count = MIN(alc_len, len); 5383 count = MIN(bp->b_bcount, count); 5384 bcopy(buf, bp->b_un.b_addr, count); 5385 5386 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5387 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5388 } 5389 *scsipkt->pkt_scbp = STATUS_GOOD; 5390 done: 5391 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5392 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5393 5394 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5395 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5396 5397 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5398 scsipkt->pkt_comp != NULL) 5399 /* scsi callback required */ 5400 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5401 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5402 TQ_SLEEP) == NULL) 5403 /* Scheduling the callback failed */ 5404 return (TRAN_BUSY); 5405 5406 return (TRAN_ACCEPT); 5407 } 5408 5409 /* 5410 * Translate command: Log Select 5411 * Not implemented at this time - returns invalid command response. 5412 */ 5413 static int 5414 sata_txlt_log_select(sata_pkt_txlate_t *spx) 5415 { 5416 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5417 "sata_txlt_log_select\n", NULL); 5418 5419 return (sata_txlt_invalid_command(spx)); 5420 } 5421 5422 5423 /* 5424 * Translate command: Read (various types). 5425 * Translated into appropriate type of ATA READ command 5426 * for SATA hard disks. 5427 * Both the device capabilities and requested operation mode are 5428 * considered. 5429 * 5430 * Following scsi cdb fields are ignored: 5431 * rdprotect, dpo, fua, fua_nv, group_number. 5432 * 5433 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 5434 * enable variable sata_func_enable), the capability of the controller and 5435 * capability of a device are checked and if both support queueing, read 5436 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT 5437 * command rather than plain READ_XXX command. 5438 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 5439 * both the controller and device suport such functionality, the read 5440 * request will be translated to READ_FPDMA_QUEUED command. 5441 * In both cases the maximum queue depth is derived as minimum of: 5442 * HBA capability,device capability and sata_max_queue_depth variable setting. 5443 * The value passed to HBA driver is decremented by 1, because only 5 bits are 5444 * used to pass max queue depth value, and the maximum possible queue depth 5445 * is 32. 5446 * 5447 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5448 * appropriate values in scsi_pkt fields. 5449 */ 5450 static int 5451 sata_txlt_read(sata_pkt_txlate_t *spx) 5452 { 5453 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5454 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5455 sata_drive_info_t *sdinfo; 5456 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5457 int cport = SATA_TXLT_CPORT(spx); 5458 uint16_t sec_count; 5459 uint64_t lba; 5460 int rval, reason; 5461 int synch; 5462 5463 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5464 5465 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 5466 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5467 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5468 return (rval); 5469 } 5470 5471 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5472 &spx->txlt_sata_pkt->satapkt_device); 5473 5474 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 5475 /* 5476 * Extract LBA and sector count from scsi CDB. 5477 */ 5478 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5479 case SCMD_READ: 5480 /* 6-byte scsi read cmd : 0x08 */ 5481 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 5482 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 5483 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5484 sec_count = scsipkt->pkt_cdbp[4]; 5485 /* sec_count 0 will be interpreted as 256 by a device */ 5486 break; 5487 case SCMD_READ_G1: 5488 /* 10-bytes scsi read command : 0x28 */ 5489 lba = scsipkt->pkt_cdbp[2]; 5490 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5491 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5492 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5493 sec_count = scsipkt->pkt_cdbp[7]; 5494 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5495 break; 5496 case SCMD_READ_G5: 5497 /* 12-bytes scsi read command : 0xA8 */ 5498 lba = scsipkt->pkt_cdbp[2]; 5499 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5500 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5501 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5502 sec_count = scsipkt->pkt_cdbp[6]; 5503 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 5504 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5505 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 5506 break; 5507 case SCMD_READ_G4: 5508 /* 16-bytes scsi read command : 0x88 */ 5509 lba = scsipkt->pkt_cdbp[2]; 5510 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5511 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5512 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5513 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5514 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5515 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5516 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5517 sec_count = scsipkt->pkt_cdbp[10]; 5518 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 5519 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 5520 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 5521 break; 5522 default: 5523 /* Unsupported command */ 5524 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5525 return (sata_txlt_invalid_command(spx)); 5526 } 5527 5528 /* 5529 * Check if specified address exceeds device capacity 5530 */ 5531 if ((lba >= sdinfo->satadrv_capacity) || 5532 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 5533 /* LBA out of range */ 5534 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5535 return (sata_txlt_lba_out_of_range(spx)); 5536 } 5537 5538 /* 5539 * For zero-length transfer, emulate good completion of the command 5540 * (reasons for rejecting the command were already checked). 5541 * No DMA resources were allocated. 5542 */ 5543 if (spx->txlt_dma_cookie_list == NULL) { 5544 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5545 return (sata_emul_rw_completion(spx)); 5546 } 5547 5548 /* 5549 * Build cmd block depending on the device capability and 5550 * requested operation mode. 5551 * Do not bother with non-dma mode - we are working only with 5552 * devices supporting DMA. 5553 */ 5554 scmd->satacmd_addr_type = ATA_ADDR_LBA; 5555 scmd->satacmd_device_reg = SATA_ADH_LBA; 5556 scmd->satacmd_cmd_reg = SATAC_READ_DMA; 5557 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 5558 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5559 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; 5560 scmd->satacmd_sec_count_msb = sec_count >> 8; 5561 #ifndef __lock_lint 5562 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 5563 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 5564 scmd->satacmd_lba_high_msb = lba >> 40; 5565 #endif 5566 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 5567 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5568 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 5569 } 5570 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5571 scmd->satacmd_lba_low_lsb = lba & 0xff; 5572 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5573 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5574 scmd->satacmd_features_reg = 0; 5575 scmd->satacmd_status_reg = 0; 5576 scmd->satacmd_error_reg = 0; 5577 5578 /* 5579 * Check if queueing commands should be used and switch 5580 * to appropriate command if possible 5581 */ 5582 if (sata_func_enable & SATA_ENABLE_QUEUING) { 5583 boolean_t using_queuing; 5584 5585 /* Queuing supported by controller and device? */ 5586 if ((sata_func_enable & SATA_ENABLE_NCQ) && 5587 (sdinfo->satadrv_features_support & 5588 SATA_DEV_F_NCQ) && 5589 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5590 SATA_CTLF_NCQ)) { 5591 using_queuing = B_TRUE; 5592 5593 /* NCQ supported - use FPDMA READ */ 5594 scmd->satacmd_cmd_reg = 5595 SATAC_READ_FPDMA_QUEUED; 5596 scmd->satacmd_features_reg_ext = 5597 scmd->satacmd_sec_count_msb; 5598 scmd->satacmd_sec_count_msb = 0; 5599 } else if ((sdinfo->satadrv_features_support & 5600 SATA_DEV_F_TCQ) && 5601 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5602 SATA_CTLF_QCMD)) { 5603 using_queuing = B_TRUE; 5604 5605 /* Legacy queueing */ 5606 if (sdinfo->satadrv_features_support & 5607 SATA_DEV_F_LBA48) { 5608 scmd->satacmd_cmd_reg = 5609 SATAC_READ_DMA_QUEUED_EXT; 5610 scmd->satacmd_features_reg_ext = 5611 scmd->satacmd_sec_count_msb; 5612 scmd->satacmd_sec_count_msb = 0; 5613 } else { 5614 scmd->satacmd_cmd_reg = 5615 SATAC_READ_DMA_QUEUED; 5616 } 5617 } else /* NCQ nor legacy queuing not supported */ 5618 using_queuing = B_FALSE; 5619 5620 /* 5621 * If queuing, the sector count goes in the features register 5622 * and the secount count will contain the tag. 5623 */ 5624 if (using_queuing) { 5625 scmd->satacmd_features_reg = 5626 scmd->satacmd_sec_count_lsb; 5627 scmd->satacmd_sec_count_lsb = 0; 5628 scmd->satacmd_flags.sata_queued = B_TRUE; 5629 5630 /* Set-up maximum queue depth */ 5631 scmd->satacmd_flags.sata_max_queue_depth = 5632 sdinfo->satadrv_max_queue_depth - 1; 5633 } else if (sdinfo->satadrv_features_enabled & 5634 SATA_DEV_F_E_UNTAGGED_QING) { 5635 /* 5636 * Although NCQ/TCQ is not enabled, untagged queuing 5637 * may be still used. 5638 * Set-up the maximum untagged queue depth. 5639 * Use controller's queue depth from sata_hba_tran. 5640 * SATA HBA drivers may ignore this value and rely on 5641 * the internal limits.For drivers that do not 5642 * ignore untaged queue depth, limit the value to 5643 * SATA_MAX_QUEUE_DEPTH (32), as this is the 5644 * largest value that can be passed via 5645 * satacmd_flags.sata_max_queue_depth. 5646 */ 5647 scmd->satacmd_flags.sata_max_queue_depth = 5648 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 5649 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 5650 5651 } else { 5652 scmd->satacmd_flags.sata_max_queue_depth = 0; 5653 } 5654 } else 5655 scmd->satacmd_flags.sata_max_queue_depth = 0; 5656 5657 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, 5658 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", 5659 scmd->satacmd_cmd_reg, lba, sec_count); 5660 5661 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5662 /* Need callback function */ 5663 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 5664 synch = FALSE; 5665 } else 5666 synch = TRUE; 5667 5668 /* Transfer command to HBA */ 5669 if (sata_hba_start(spx, &rval) != 0) { 5670 /* Pkt not accepted for execution */ 5671 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5672 return (rval); 5673 } 5674 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5675 /* 5676 * If execution is non-synchronous, 5677 * a callback function will handle potential errors, translate 5678 * the response and will do a callback to a target driver. 5679 * If it was synchronous, check execution status using the same 5680 * framework callback. 5681 */ 5682 if (synch) { 5683 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5684 "synchronous execution status %x\n", 5685 spx->txlt_sata_pkt->satapkt_reason); 5686 sata_txlt_rw_completion(spx->txlt_sata_pkt); 5687 } 5688 return (TRAN_ACCEPT); 5689 } 5690 5691 5692 /* 5693 * SATA translate command: Write (various types) 5694 * Translated into appropriate type of ATA WRITE command 5695 * for SATA hard disks. 5696 * Both the device capabilities and requested operation mode are 5697 * considered. 5698 * 5699 * Following scsi cdb fields are ignored: 5700 * rwprotect, dpo, fua, fua_nv, group_number. 5701 * 5702 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 5703 * enable variable sata_func_enable), the capability of the controller and 5704 * capability of a device are checked and if both support queueing, write 5705 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT 5706 * command rather than plain WRITE_XXX command. 5707 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 5708 * both the controller and device suport such functionality, the write 5709 * request will be translated to WRITE_FPDMA_QUEUED command. 5710 * In both cases the maximum queue depth is derived as minimum of: 5711 * HBA capability,device capability and sata_max_queue_depth variable setting. 5712 * The value passed to HBA driver is decremented by 1, because only 5 bits are 5713 * used to pass max queue depth value, and the maximum possible queue depth 5714 * is 32. 5715 * 5716 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5717 * appropriate values in scsi_pkt fields. 5718 */ 5719 static int 5720 sata_txlt_write(sata_pkt_txlate_t *spx) 5721 { 5722 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5723 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5724 sata_drive_info_t *sdinfo; 5725 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5726 int cport = SATA_TXLT_CPORT(spx); 5727 uint16_t sec_count; 5728 uint64_t lba; 5729 int rval, reason; 5730 int synch; 5731 5732 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5733 5734 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 5735 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5736 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5737 return (rval); 5738 } 5739 5740 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5741 &spx->txlt_sata_pkt->satapkt_device); 5742 5743 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5744 /* 5745 * Extract LBA and sector count from scsi CDB 5746 */ 5747 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5748 case SCMD_WRITE: 5749 /* 6-byte scsi read cmd : 0x0A */ 5750 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 5751 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 5752 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5753 sec_count = scsipkt->pkt_cdbp[4]; 5754 /* sec_count 0 will be interpreted as 256 by a device */ 5755 break; 5756 case SCMD_WRITE_G1: 5757 /* 10-bytes scsi write command : 0x2A */ 5758 lba = scsipkt->pkt_cdbp[2]; 5759 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5760 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5761 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5762 sec_count = scsipkt->pkt_cdbp[7]; 5763 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5764 break; 5765 case SCMD_WRITE_G5: 5766 /* 12-bytes scsi read command : 0xAA */ 5767 lba = scsipkt->pkt_cdbp[2]; 5768 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5769 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5770 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5771 sec_count = scsipkt->pkt_cdbp[6]; 5772 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 5773 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5774 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 5775 break; 5776 case SCMD_WRITE_G4: 5777 /* 16-bytes scsi write command : 0x8A */ 5778 lba = scsipkt->pkt_cdbp[2]; 5779 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5780 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5781 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5782 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5783 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5784 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5785 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5786 sec_count = scsipkt->pkt_cdbp[10]; 5787 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 5788 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 5789 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 5790 break; 5791 default: 5792 /* Unsupported command */ 5793 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5794 return (sata_txlt_invalid_command(spx)); 5795 } 5796 5797 /* 5798 * Check if specified address and length exceeds device capacity 5799 */ 5800 if ((lba >= sdinfo->satadrv_capacity) || 5801 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 5802 /* LBA out of range */ 5803 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5804 return (sata_txlt_lba_out_of_range(spx)); 5805 } 5806 5807 /* 5808 * For zero-length transfer, emulate good completion of the command 5809 * (reasons for rejecting the command were already checked). 5810 * No DMA resources were allocated. 5811 */ 5812 if (spx->txlt_dma_cookie_list == NULL) { 5813 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5814 return (sata_emul_rw_completion(spx)); 5815 } 5816 5817 /* 5818 * Build cmd block depending on the device capability and 5819 * requested operation mode. 5820 * Do not bother with non-dma mode- we are working only with 5821 * devices supporting DMA. 5822 */ 5823 scmd->satacmd_addr_type = ATA_ADDR_LBA; 5824 scmd->satacmd_device_reg = SATA_ADH_LBA; 5825 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; 5826 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 5827 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5828 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; 5829 scmd->satacmd_sec_count_msb = sec_count >> 8; 5830 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 5831 #ifndef __lock_lint 5832 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 5833 scmd->satacmd_lba_high_msb = lba >> 40; 5834 #endif 5835 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 5836 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5837 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 5838 } 5839 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5840 scmd->satacmd_lba_low_lsb = lba & 0xff; 5841 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5842 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5843 scmd->satacmd_features_reg = 0; 5844 scmd->satacmd_status_reg = 0; 5845 scmd->satacmd_error_reg = 0; 5846 5847 /* 5848 * Check if queueing commands should be used and switch 5849 * to appropriate command if possible 5850 */ 5851 if (sata_func_enable & SATA_ENABLE_QUEUING) { 5852 boolean_t using_queuing; 5853 5854 /* Queuing supported by controller and device? */ 5855 if ((sata_func_enable & SATA_ENABLE_NCQ) && 5856 (sdinfo->satadrv_features_support & 5857 SATA_DEV_F_NCQ) && 5858 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5859 SATA_CTLF_NCQ)) { 5860 using_queuing = B_TRUE; 5861 5862 /* NCQ supported - use FPDMA WRITE */ 5863 scmd->satacmd_cmd_reg = 5864 SATAC_WRITE_FPDMA_QUEUED; 5865 scmd->satacmd_features_reg_ext = 5866 scmd->satacmd_sec_count_msb; 5867 scmd->satacmd_sec_count_msb = 0; 5868 } else if ((sdinfo->satadrv_features_support & 5869 SATA_DEV_F_TCQ) && 5870 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5871 SATA_CTLF_QCMD)) { 5872 using_queuing = B_TRUE; 5873 5874 /* Legacy queueing */ 5875 if (sdinfo->satadrv_features_support & 5876 SATA_DEV_F_LBA48) { 5877 scmd->satacmd_cmd_reg = 5878 SATAC_WRITE_DMA_QUEUED_EXT; 5879 scmd->satacmd_features_reg_ext = 5880 scmd->satacmd_sec_count_msb; 5881 scmd->satacmd_sec_count_msb = 0; 5882 } else { 5883 scmd->satacmd_cmd_reg = 5884 SATAC_WRITE_DMA_QUEUED; 5885 } 5886 } else /* NCQ nor legacy queuing not supported */ 5887 using_queuing = B_FALSE; 5888 5889 if (using_queuing) { 5890 scmd->satacmd_features_reg = 5891 scmd->satacmd_sec_count_lsb; 5892 scmd->satacmd_sec_count_lsb = 0; 5893 scmd->satacmd_flags.sata_queued = B_TRUE; 5894 /* Set-up maximum queue depth */ 5895 scmd->satacmd_flags.sata_max_queue_depth = 5896 sdinfo->satadrv_max_queue_depth - 1; 5897 } else if (sdinfo->satadrv_features_enabled & 5898 SATA_DEV_F_E_UNTAGGED_QING) { 5899 /* 5900 * Although NCQ/TCQ is not enabled, untagged queuing 5901 * may be still used. 5902 * Set-up the maximum untagged queue depth. 5903 * Use controller's queue depth from sata_hba_tran. 5904 * SATA HBA drivers may ignore this value and rely on 5905 * the internal limits. For drivera that do not 5906 * ignore untaged queue depth, limit the value to 5907 * SATA_MAX_QUEUE_DEPTH (32), as this is the 5908 * largest value that can be passed via 5909 * satacmd_flags.sata_max_queue_depth. 5910 */ 5911 scmd->satacmd_flags.sata_max_queue_depth = 5912 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 5913 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 5914 5915 } else { 5916 scmd->satacmd_flags.sata_max_queue_depth = 0; 5917 } 5918 } else 5919 scmd->satacmd_flags.sata_max_queue_depth = 0; 5920 5921 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5922 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", 5923 scmd->satacmd_cmd_reg, lba, sec_count); 5924 5925 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5926 /* Need callback function */ 5927 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 5928 synch = FALSE; 5929 } else 5930 synch = TRUE; 5931 5932 /* Transfer command to HBA */ 5933 if (sata_hba_start(spx, &rval) != 0) { 5934 /* Pkt not accepted for execution */ 5935 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5936 return (rval); 5937 } 5938 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5939 5940 /* 5941 * If execution is non-synchronous, 5942 * a callback function will handle potential errors, translate 5943 * the response and will do a callback to a target driver. 5944 * If it was synchronous, check execution status using the same 5945 * framework callback. 5946 */ 5947 if (synch) { 5948 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5949 "synchronous execution status %x\n", 5950 spx->txlt_sata_pkt->satapkt_reason); 5951 sata_txlt_rw_completion(spx->txlt_sata_pkt); 5952 } 5953 return (TRAN_ACCEPT); 5954 } 5955 5956 5957 /* 5958 * Implements SCSI SBC WRITE BUFFER command download microcode option 5959 */ 5960 static int 5961 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) 5962 { 5963 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 5964 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 5965 5966 sata_hba_inst_t *sata_hba_inst = SATA_TXLT_HBA_INST(spx); 5967 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5968 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt; 5969 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5970 5971 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5972 struct scsi_extended_sense *sense; 5973 int rval, mode, sector_count, reason; 5974 int cport = SATA_TXLT_CPORT(spx); 5975 5976 mode = scsipkt->pkt_cdbp[1] & 0x1f; 5977 5978 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5979 "sata_txlt_write_buffer, mode 0x%x\n", mode); 5980 5981 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5982 5983 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5984 TRAN_ACCEPT) { 5985 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5986 return (rval); 5987 } 5988 5989 /* Use synchronous mode */ 5990 spx->txlt_sata_pkt->satapkt_op_mode 5991 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 5992 5993 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5994 5995 scsipkt->pkt_reason = CMD_CMPLT; 5996 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5997 STATE_SENT_CMD | STATE_GOT_STATUS; 5998 5999 /* 6000 * The SCSI to ATA translation specification only calls 6001 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. 6002 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but 6003 * ATA 8 (draft) got rid of download microcode for temp 6004 * and it is even optional for ATA 7, so it may be aborted. 6005 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as 6006 * it is not specified and the buffer offset for SCSI is a 16-bit 6007 * value in bytes, but for ATA it is a 16-bit offset in 512 byte 6008 * sectors. Thus the offset really doesn't buy us anything. 6009 * If and when ATA 8 is stabilized and the SCSI to ATA specification 6010 * is revised, this can be revisisted. 6011 */ 6012 /* Reject not supported request */ 6013 switch (mode) { 6014 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: 6015 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; 6016 break; 6017 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: 6018 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; 6019 break; 6020 default: 6021 goto bad_param; 6022 } 6023 6024 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 6025 6026 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; 6027 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) 6028 goto bad_param; 6029 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; 6030 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; 6031 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; 6032 scmd->satacmd_lba_mid_lsb = 0; 6033 scmd->satacmd_lba_high_lsb = 0; 6034 scmd->satacmd_device_reg = 0; 6035 spx->txlt_sata_pkt->satapkt_comp = NULL; 6036 scmd->satacmd_addr_type = 0; 6037 6038 /* Transfer command to HBA */ 6039 if (sata_hba_start(spx, &rval) != 0) { 6040 /* Pkt not accepted for execution */ 6041 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 6042 return (rval); 6043 } 6044 6045 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 6046 6047 /* Then we need synchronous check the status of the disk */ 6048 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6049 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6050 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6051 scsipkt->pkt_reason = CMD_CMPLT; 6052 6053 /* Download commmand succeed, so probe and identify device */ 6054 sata_reidentify_device(spx); 6055 } else { 6056 /* Something went wrong, microcode download command failed */ 6057 scsipkt->pkt_reason = CMD_INCOMPLETE; 6058 *scsipkt->pkt_scbp = STATUS_CHECK; 6059 sense = sata_arq_sense(spx); 6060 switch (sata_pkt->satapkt_reason) { 6061 case SATA_PKT_PORT_ERROR: 6062 /* 6063 * We have no device data. Assume no data transfered. 6064 */ 6065 sense->es_key = KEY_HARDWARE_ERROR; 6066 break; 6067 6068 case SATA_PKT_DEV_ERROR: 6069 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6070 SATA_STATUS_ERR) { 6071 /* 6072 * determine dev error reason from error 6073 * reg content 6074 */ 6075 sata_decode_device_error(spx, sense); 6076 break; 6077 } 6078 /* No extended sense key - no info available */ 6079 break; 6080 6081 case SATA_PKT_TIMEOUT: 6082 scsipkt->pkt_reason = CMD_TIMEOUT; 6083 scsipkt->pkt_statistics |= 6084 STAT_TIMEOUT | STAT_DEV_RESET; 6085 /* No extended sense key ? */ 6086 break; 6087 6088 case SATA_PKT_ABORTED: 6089 scsipkt->pkt_reason = CMD_ABORTED; 6090 scsipkt->pkt_statistics |= STAT_ABORTED; 6091 /* No extended sense key ? */ 6092 break; 6093 6094 case SATA_PKT_RESET: 6095 /* pkt aborted by an explicit reset from a host */ 6096 scsipkt->pkt_reason = CMD_RESET; 6097 scsipkt->pkt_statistics |= STAT_DEV_RESET; 6098 break; 6099 6100 default: 6101 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6102 "sata_txlt_nodata_cmd_completion: " 6103 "invalid packet completion reason %d", 6104 sata_pkt->satapkt_reason)); 6105 scsipkt->pkt_reason = CMD_TRAN_ERR; 6106 break; 6107 } 6108 6109 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6110 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6111 6112 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6113 /* scsi callback required */ 6114 scsi_hba_pkt_comp(scsipkt); 6115 } 6116 return (TRAN_ACCEPT); 6117 6118 bad_param: 6119 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6120 *scsipkt->pkt_scbp = STATUS_CHECK; 6121 sense = sata_arq_sense(spx); 6122 sense->es_key = KEY_ILLEGAL_REQUEST; 6123 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6124 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6125 scsipkt->pkt_comp != NULL) { 6126 /* scsi callback required */ 6127 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6128 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 6129 TQ_SLEEP) == 0) { 6130 /* Scheduling the callback failed */ 6131 rval = TRAN_BUSY; 6132 } 6133 } 6134 return (rval); 6135 } 6136 6137 /* 6138 * Re-identify device after doing a firmware download. 6139 */ 6140 static void 6141 sata_reidentify_device(sata_pkt_txlate_t *spx) 6142 { 6143 #define DOWNLOAD_WAIT_TIME_SECS 60 6144 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 6145 int rval; 6146 int retry_cnt; 6147 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6148 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6149 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 6150 sata_drive_info_t *sdinfo; 6151 6152 /* 6153 * Before returning good status, probe device. 6154 * Device probing will get IDENTIFY DEVICE data, if possible. 6155 * The assumption is that the new microcode is applied by the 6156 * device. It is a caller responsibility to verify this. 6157 */ 6158 for (retry_cnt = 0; 6159 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; 6160 retry_cnt++) { 6161 rval = sata_probe_device(sata_hba_inst, &sata_device); 6162 6163 if (rval == SATA_SUCCESS) { /* Set default features */ 6164 sdinfo = sata_get_device_info(sata_hba_inst, 6165 &sata_device); 6166 if (sata_initialize_device(sata_hba_inst, sdinfo) != 6167 SATA_SUCCESS) { 6168 /* retry */ 6169 rval = sata_initialize_device(sata_hba_inst, 6170 sdinfo); 6171 if (rval == SATA_RETRY) 6172 sata_log(sata_hba_inst, CE_WARN, 6173 "SATA device at port %d pmport %d -" 6174 " default device features could not" 6175 " be set. Device may not operate " 6176 "as expected.", 6177 sata_device.satadev_addr.cport, 6178 sata_device.satadev_addr.pmport); 6179 } 6180 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6181 scsi_hba_pkt_comp(scsipkt); 6182 return; 6183 } else if (rval == SATA_RETRY) { 6184 delay(drv_usectohz(1000000 * 6185 DOWNLOAD_WAIT_INTERVAL_SECS)); 6186 continue; 6187 } else /* failed - no reason to retry */ 6188 break; 6189 } 6190 6191 /* 6192 * Something went wrong, device probing failed. 6193 */ 6194 SATA_LOG_D((sata_hba_inst, CE_WARN, 6195 "Cannot probe device after downloading microcode\n")); 6196 6197 /* Reset device to force retrying the probe. */ 6198 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 6199 (SATA_DIP(sata_hba_inst), &sata_device); 6200 6201 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6202 scsi_hba_pkt_comp(scsipkt); 6203 } 6204 6205 6206 /* 6207 * Translate command: Synchronize Cache. 6208 * Translates into Flush Cache command for SATA hard disks. 6209 * 6210 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6211 * appropriate values in scsi_pkt fields. 6212 */ 6213 static int 6214 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) 6215 { 6216 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6217 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6218 int cport = SATA_TXLT_CPORT(spx); 6219 int rval, reason; 6220 int synch; 6221 6222 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 6223 6224 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 6225 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6226 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6227 return (rval); 6228 } 6229 6230 scmd->satacmd_addr_type = 0; 6231 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; 6232 scmd->satacmd_device_reg = 0; 6233 scmd->satacmd_sec_count_lsb = 0; 6234 scmd->satacmd_lba_low_lsb = 0; 6235 scmd->satacmd_lba_mid_lsb = 0; 6236 scmd->satacmd_lba_high_lsb = 0; 6237 scmd->satacmd_features_reg = 0; 6238 scmd->satacmd_status_reg = 0; 6239 scmd->satacmd_error_reg = 0; 6240 6241 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6242 "sata_txlt_synchronize_cache\n", NULL); 6243 6244 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6245 /* Need to set-up a callback function */ 6246 spx->txlt_sata_pkt->satapkt_comp = 6247 sata_txlt_nodata_cmd_completion; 6248 synch = FALSE; 6249 } else 6250 synch = TRUE; 6251 6252 /* Transfer command to HBA */ 6253 if (sata_hba_start(spx, &rval) != 0) { 6254 /* Pkt not accepted for execution */ 6255 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6256 return (rval); 6257 } 6258 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6259 6260 /* 6261 * If execution non-synchronous, it had to be completed 6262 * a callback function will handle potential errors, translate 6263 * the response and will do a callback to a target driver. 6264 * If it was synchronous, check status, using the same 6265 * framework callback. 6266 */ 6267 if (synch) { 6268 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6269 "synchronous execution status %x\n", 6270 spx->txlt_sata_pkt->satapkt_reason); 6271 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 6272 } 6273 return (TRAN_ACCEPT); 6274 } 6275 6276 6277 /* 6278 * Send pkt to SATA HBA driver 6279 * 6280 * This function may be called only if the operation is requested by scsi_pkt, 6281 * i.e. scsi_pkt is not NULL. 6282 * 6283 * This function has to be called with cport mutex held. It does release 6284 * the mutex when it calls HBA driver sata_tran_start function and 6285 * re-acquires it afterwards. 6286 * 6287 * If return value is 0, pkt was accepted, -1 otherwise 6288 * rval is set to appropriate sata_scsi_start return value. 6289 * 6290 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not 6291 * have called the sata_pkt callback function for this packet. 6292 * 6293 * The scsi callback has to be performed by the caller of this routine. 6294 */ 6295 static int 6296 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) 6297 { 6298 int stat; 6299 uint8_t cport = SATA_TXLT_CPORT(spx); 6300 uint8_t pmport = SATA_TXLT_PMPORT(spx); 6301 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6302 sata_drive_info_t *sdinfo; 6303 sata_pmult_info_t *pminfo; 6304 sata_pmport_info_t *pmportinfo = NULL; 6305 sata_device_t *sata_device = NULL; 6306 uint8_t cmd; 6307 struct sata_cmd_flags cmd_flags; 6308 6309 ASSERT(spx->txlt_sata_pkt != NULL); 6310 6311 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6312 6313 sdinfo = sata_get_device_info(sata_hba_inst, 6314 &spx->txlt_sata_pkt->satapkt_device); 6315 ASSERT(sdinfo != NULL); 6316 6317 /* Clear device reset state? */ 6318 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */ 6319 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT || 6320 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) { 6321 6322 /* 6323 * Get the pmult_info of the its parent port multiplier, all 6324 * sub-devices share a common device reset flags on in 6325 * pmult_info. 6326 */ 6327 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport); 6328 pmportinfo = pminfo->pmult_dev_port[pmport]; 6329 ASSERT(pminfo != NULL); 6330 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { 6331 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6332 sata_clear_dev_reset = B_TRUE; 6333 pminfo->pmult_event_flags &= 6334 ~SATA_EVNT_CLEAR_DEVICE_RESET; 6335 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6336 "sata_hba_start: clearing device reset state" 6337 "on pmult.\n", NULL); 6338 } 6339 } else { 6340 if (sdinfo->satadrv_event_flags & 6341 SATA_EVNT_CLEAR_DEVICE_RESET) { 6342 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6343 sata_clear_dev_reset = B_TRUE; 6344 sdinfo->satadrv_event_flags &= 6345 ~SATA_EVNT_CLEAR_DEVICE_RESET; 6346 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6347 "sata_hba_start: clearing device reset state\n", 6348 NULL); 6349 } 6350 } 6351 6352 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; 6353 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; 6354 sata_device = &spx->txlt_sata_pkt->satapkt_device; 6355 6356 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6357 6358 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6359 "Sata cmd 0x%2x\n", cmd); 6360 6361 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 6362 spx->txlt_sata_pkt); 6363 6364 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6365 /* 6366 * If sata pkt was accepted and executed in asynchronous mode, i.e. 6367 * with the sata callback, the sata_pkt could be already destroyed 6368 * by the time we check ther return status from the hba_start() 6369 * function, because sata_scsi_destroy_pkt() could have been already 6370 * called (perhaps in the interrupt context). So, in such case, there 6371 * should be no references to it. In other cases, sata_pkt still 6372 * exists. 6373 */ 6374 if (stat == SATA_TRAN_ACCEPTED) { 6375 /* 6376 * pkt accepted for execution. 6377 * If it was executed synchronously, it is already completed 6378 * and pkt completion_reason indicates completion status. 6379 */ 6380 *rval = TRAN_ACCEPT; 6381 return (0); 6382 } 6383 6384 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6385 switch (stat) { 6386 case SATA_TRAN_QUEUE_FULL: 6387 /* 6388 * Controller detected queue full condition. 6389 */ 6390 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, 6391 "sata_hba_start: queue full\n", NULL); 6392 6393 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 6394 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; 6395 6396 *rval = TRAN_BUSY; 6397 break; 6398 6399 case SATA_TRAN_PORT_ERROR: 6400 /* 6401 * Communication/link with device or general port error 6402 * detected before pkt execution begun. 6403 */ 6404 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6405 SATA_ADDR_CPORT || 6406 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6407 SATA_ADDR_DCPORT) 6408 sata_log(sata_hba_inst, CE_CONT, 6409 "SATA port %d error", 6410 sata_device->satadev_addr.cport); 6411 else 6412 sata_log(sata_hba_inst, CE_CONT, 6413 "SATA port %d:%d error\n", 6414 sata_device->satadev_addr.cport, 6415 sata_device->satadev_addr.pmport); 6416 6417 /* 6418 * Update the port/device structure. 6419 * sata_pkt should be still valid. Since port error is 6420 * returned, sata_device content should reflect port 6421 * state - it means, that sata address have been changed, 6422 * because original packet's sata address refered to a device 6423 * attached to some port. 6424 */ 6425 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT || 6426 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) { 6427 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6428 mutex_enter(&pmportinfo->pmport_mutex); 6429 sata_update_pmport_info(sata_hba_inst, sata_device); 6430 mutex_exit(&pmportinfo->pmport_mutex); 6431 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6432 } else { 6433 sata_update_port_info(sata_hba_inst, sata_device); 6434 } 6435 6436 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 6437 *rval = TRAN_FATAL_ERROR; 6438 break; 6439 6440 case SATA_TRAN_CMD_UNSUPPORTED: 6441 /* 6442 * Command rejected by HBA as unsupported. It was HBA driver 6443 * that rejected the command, command was not sent to 6444 * an attached device. 6445 */ 6446 if ((sdinfo != NULL) && 6447 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) 6448 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6449 "sat_hba_start: cmd 0x%2x rejected " 6450 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); 6451 6452 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6453 (void) sata_txlt_invalid_command(spx); 6454 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6455 6456 *rval = TRAN_ACCEPT; 6457 break; 6458 6459 case SATA_TRAN_BUSY: 6460 /* 6461 * Command rejected by HBA because other operation prevents 6462 * accepting the packet, or device is in RESET condition. 6463 */ 6464 if (sdinfo != NULL) { 6465 sdinfo->satadrv_state = 6466 spx->txlt_sata_pkt->satapkt_device.satadev_state; 6467 6468 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { 6469 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6470 "sata_hba_start: cmd 0x%2x rejected " 6471 "because of device reset condition\n", 6472 cmd); 6473 } else { 6474 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6475 "sata_hba_start: cmd 0x%2x rejected " 6476 "with SATA_TRAN_BUSY status\n", 6477 cmd); 6478 } 6479 } 6480 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 6481 *rval = TRAN_BUSY; 6482 break; 6483 6484 default: 6485 /* Unrecognized HBA response */ 6486 SATA_LOG_D((sata_hba_inst, CE_WARN, 6487 "sata_hba_start: unrecognized HBA response " 6488 "to cmd : 0x%2x resp 0x%x", cmd, rval)); 6489 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 6490 *rval = TRAN_FATAL_ERROR; 6491 break; 6492 } 6493 6494 /* 6495 * If we got here, the packet was rejected. 6496 * Check if we need to remember reset state clearing request 6497 */ 6498 if (cmd_flags.sata_clear_dev_reset) { 6499 /* 6500 * Check if device is still configured - it may have 6501 * disapeared from the configuration 6502 */ 6503 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6504 if (sdinfo != NULL) { 6505 /* 6506 * Restore the flag that requests clearing of 6507 * the device reset state, 6508 * so the next sata packet may carry it to HBA. 6509 */ 6510 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT || 6511 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) { 6512 pminfo->pmult_event_flags |= 6513 SATA_EVNT_CLEAR_DEVICE_RESET; 6514 } else { 6515 sdinfo->satadrv_event_flags |= 6516 SATA_EVNT_CLEAR_DEVICE_RESET; 6517 } 6518 } 6519 } 6520 return (-1); 6521 } 6522 6523 /* 6524 * Scsi response setup for invalid LBA 6525 * 6526 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 6527 */ 6528 static int 6529 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) 6530 { 6531 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6532 struct scsi_extended_sense *sense; 6533 6534 scsipkt->pkt_reason = CMD_CMPLT; 6535 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6536 STATE_SENT_CMD | STATE_GOT_STATUS; 6537 *scsipkt->pkt_scbp = STATUS_CHECK; 6538 6539 *scsipkt->pkt_scbp = STATUS_CHECK; 6540 sense = sata_arq_sense(spx); 6541 sense->es_key = KEY_ILLEGAL_REQUEST; 6542 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 6543 6544 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6545 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6546 6547 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6548 scsipkt->pkt_comp != NULL) 6549 /* scsi callback required */ 6550 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6551 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 6552 TQ_SLEEP) == NULL) 6553 /* Scheduling the callback failed */ 6554 return (TRAN_BUSY); 6555 return (TRAN_ACCEPT); 6556 } 6557 6558 6559 /* 6560 * Analyze device status and error registers and translate them into 6561 * appropriate scsi sense codes. 6562 * NOTE: non-packet commands only for now 6563 */ 6564 static void 6565 sata_decode_device_error(sata_pkt_txlate_t *spx, 6566 struct scsi_extended_sense *sense) 6567 { 6568 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; 6569 6570 ASSERT(sense != NULL); 6571 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 6572 SATA_STATUS_ERR); 6573 6574 6575 if (err_reg & SATA_ERROR_ICRC) { 6576 sense->es_key = KEY_ABORTED_COMMAND; 6577 sense->es_add_code = 0x08; /* Communication failure */ 6578 return; 6579 } 6580 6581 if (err_reg & SATA_ERROR_UNC) { 6582 sense->es_key = KEY_MEDIUM_ERROR; 6583 /* Information bytes (LBA) need to be set by a caller */ 6584 return; 6585 } 6586 6587 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ 6588 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { 6589 sense->es_key = KEY_UNIT_ATTENTION; 6590 sense->es_add_code = 0x3a; /* No media present */ 6591 return; 6592 } 6593 6594 if (err_reg & SATA_ERROR_IDNF) { 6595 if (err_reg & SATA_ERROR_ABORT) { 6596 sense->es_key = KEY_ABORTED_COMMAND; 6597 } else { 6598 sense->es_key = KEY_ILLEGAL_REQUEST; 6599 sense->es_add_code = 0x21; /* LBA out of range */ 6600 } 6601 return; 6602 } 6603 6604 if (err_reg & SATA_ERROR_ABORT) { 6605 ASSERT(spx->txlt_sata_pkt != NULL); 6606 sense->es_key = KEY_ABORTED_COMMAND; 6607 return; 6608 } 6609 } 6610 6611 /* 6612 * Extract error LBA from sata_pkt.satapkt_cmd register fields 6613 */ 6614 static void 6615 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) 6616 { 6617 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; 6618 6619 *lba = 0; 6620 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { 6621 *lba = sata_cmd->satacmd_lba_high_msb; 6622 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; 6623 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; 6624 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { 6625 *lba = sata_cmd->satacmd_device_reg & 0xf; 6626 } 6627 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; 6628 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; 6629 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; 6630 } 6631 6632 /* 6633 * This is fixed sense format - if LBA exceeds the info field size, 6634 * no valid info will be returned (valid bit in extended sense will 6635 * be set to 0). 6636 */ 6637 static struct scsi_extended_sense * 6638 sata_arq_sense(sata_pkt_txlate_t *spx) 6639 { 6640 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6641 struct scsi_arq_status *arqs; 6642 struct scsi_extended_sense *sense; 6643 6644 /* Fill ARQ sense data */ 6645 scsipkt->pkt_state |= STATE_ARQ_DONE; 6646 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 6647 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 6648 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 6649 arqs->sts_rqpkt_reason = CMD_CMPLT; 6650 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6651 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 6652 arqs->sts_rqpkt_resid = 0; 6653 sense = &arqs->sts_sensedata; 6654 bzero(sense, sizeof (struct scsi_extended_sense)); 6655 sata_fixed_sense_data_preset(sense); 6656 return (sense); 6657 } 6658 6659 /* 6660 * ATA Pass Through support 6661 * Sets flags indicating that an invalid value was found in some 6662 * field in the command. It could be something illegal according to 6663 * the SAT-2 spec or it could be a feature that is not (yet?) 6664 * supported. 6665 */ 6666 static int 6667 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx) 6668 { 6669 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6670 struct scsi_extended_sense *sense = sata_arq_sense(spx); 6671 6672 scsipkt->pkt_reason = CMD_CMPLT; 6673 *scsipkt->pkt_scbp = STATUS_CHECK; 6674 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6675 STATE_SENT_CMD | STATE_GOT_STATUS; 6676 6677 sense = sata_arq_sense(spx); 6678 sense->es_key = KEY_ILLEGAL_REQUEST; 6679 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6680 6681 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6682 scsipkt->pkt_comp != NULL) 6683 /* scsi callback required */ 6684 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6685 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 6686 TQ_SLEEP) == NULL) 6687 /* Scheduling the callback failed */ 6688 return (TRAN_BUSY); 6689 6690 return (TRAN_ACCEPT); 6691 } 6692 6693 /* 6694 * Emulated SATA Read/Write command completion for zero-length requests. 6695 * This request always succedes, so in synchronous mode it always returns 6696 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the 6697 * callback cannot be scheduled. 6698 */ 6699 static int 6700 sata_emul_rw_completion(sata_pkt_txlate_t *spx) 6701 { 6702 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6703 6704 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6705 STATE_SENT_CMD | STATE_GOT_STATUS; 6706 scsipkt->pkt_reason = CMD_CMPLT; 6707 *scsipkt->pkt_scbp = STATUS_GOOD; 6708 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6709 /* scsi callback required - have to schedule it */ 6710 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6711 (task_func_t *)scsipkt->pkt_comp, 6712 (void *)scsipkt, TQ_SLEEP) == NULL) 6713 /* Scheduling the callback failed */ 6714 return (TRAN_BUSY); 6715 } 6716 return (TRAN_ACCEPT); 6717 } 6718 6719 6720 /* 6721 * Translate completion status of SATA read/write commands into scsi response. 6722 * pkt completion_reason is checked to determine the completion status. 6723 * Do scsi callback if necessary. 6724 * 6725 * Note: this function may be called also for synchronously executed 6726 * commands. 6727 * This function may be used only if scsi_pkt is non-NULL. 6728 */ 6729 static void 6730 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) 6731 { 6732 sata_pkt_txlate_t *spx = 6733 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6734 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 6735 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6736 struct scsi_extended_sense *sense; 6737 uint64_t lba; 6738 struct buf *bp; 6739 int rval; 6740 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6741 /* Normal completion */ 6742 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6743 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6744 scsipkt->pkt_reason = CMD_CMPLT; 6745 *scsipkt->pkt_scbp = STATUS_GOOD; 6746 if (spx->txlt_tmp_buf != NULL) { 6747 /* Temporary buffer was used */ 6748 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6749 if (bp->b_flags & B_READ) { 6750 rval = ddi_dma_sync( 6751 spx->txlt_buf_dma_handle, 0, 0, 6752 DDI_DMA_SYNC_FORCPU); 6753 ASSERT(rval == DDI_SUCCESS); 6754 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 6755 bp->b_bcount); 6756 } 6757 } 6758 } else { 6759 /* 6760 * Something went wrong - analyze return 6761 */ 6762 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6763 STATE_SENT_CMD | STATE_GOT_STATUS; 6764 scsipkt->pkt_reason = CMD_INCOMPLETE; 6765 *scsipkt->pkt_scbp = STATUS_CHECK; 6766 sense = sata_arq_sense(spx); 6767 ASSERT(sense != NULL); 6768 6769 /* 6770 * SATA_PKT_DEV_ERROR is the only case where we may be able to 6771 * extract from device registers the failing LBA. 6772 */ 6773 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 6774 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && 6775 (scmd->satacmd_lba_mid_msb != 0 || 6776 scmd->satacmd_lba_high_msb != 0)) { 6777 /* 6778 * We have problem reporting this cmd LBA 6779 * in fixed sense data format, because of 6780 * the size of the scsi LBA fields. 6781 */ 6782 sense->es_valid = 0; 6783 } else { 6784 sata_extract_error_lba(spx, &lba); 6785 sense->es_info_1 = (lba & 0xFF000000) >> 24; 6786 sense->es_info_2 = (lba & 0xFF0000) >> 16; 6787 sense->es_info_3 = (lba & 0xFF00) >> 8; 6788 sense->es_info_4 = lba & 0xFF; 6789 } 6790 } else { 6791 /* Invalid extended sense info */ 6792 sense->es_valid = 0; 6793 } 6794 6795 switch (sata_pkt->satapkt_reason) { 6796 case SATA_PKT_PORT_ERROR: 6797 /* We may want to handle DEV GONE state as well */ 6798 /* 6799 * We have no device data. Assume no data transfered. 6800 */ 6801 sense->es_key = KEY_HARDWARE_ERROR; 6802 break; 6803 6804 case SATA_PKT_DEV_ERROR: 6805 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6806 SATA_STATUS_ERR) { 6807 /* 6808 * determine dev error reason from error 6809 * reg content 6810 */ 6811 sata_decode_device_error(spx, sense); 6812 if (sense->es_key == KEY_MEDIUM_ERROR) { 6813 switch (scmd->satacmd_cmd_reg) { 6814 case SATAC_READ_DMA: 6815 case SATAC_READ_DMA_EXT: 6816 case SATAC_READ_DMA_QUEUED: 6817 case SATAC_READ_DMA_QUEUED_EXT: 6818 case SATAC_READ_FPDMA_QUEUED: 6819 /* Unrecovered read error */ 6820 sense->es_add_code = 6821 SD_SCSI_ASC_UNREC_READ_ERR; 6822 break; 6823 case SATAC_WRITE_DMA: 6824 case SATAC_WRITE_DMA_EXT: 6825 case SATAC_WRITE_DMA_QUEUED: 6826 case SATAC_WRITE_DMA_QUEUED_EXT: 6827 case SATAC_WRITE_FPDMA_QUEUED: 6828 /* Write error */ 6829 sense->es_add_code = 6830 SD_SCSI_ASC_WRITE_ERR; 6831 break; 6832 default: 6833 /* Internal error */ 6834 SATA_LOG_D(( 6835 spx->txlt_sata_hba_inst, 6836 CE_WARN, 6837 "sata_txlt_rw_completion :" 6838 "internal error - invalid " 6839 "command 0x%2x", 6840 scmd->satacmd_cmd_reg)); 6841 break; 6842 } 6843 } 6844 break; 6845 } 6846 /* No extended sense key - no info available */ 6847 scsipkt->pkt_reason = CMD_INCOMPLETE; 6848 break; 6849 6850 case SATA_PKT_TIMEOUT: 6851 scsipkt->pkt_reason = CMD_TIMEOUT; 6852 scsipkt->pkt_statistics |= 6853 STAT_TIMEOUT | STAT_DEV_RESET; 6854 sense->es_key = KEY_ABORTED_COMMAND; 6855 break; 6856 6857 case SATA_PKT_ABORTED: 6858 scsipkt->pkt_reason = CMD_ABORTED; 6859 scsipkt->pkt_statistics |= STAT_ABORTED; 6860 sense->es_key = KEY_ABORTED_COMMAND; 6861 break; 6862 6863 case SATA_PKT_RESET: 6864 scsipkt->pkt_reason = CMD_RESET; 6865 scsipkt->pkt_statistics |= STAT_DEV_RESET; 6866 sense->es_key = KEY_ABORTED_COMMAND; 6867 break; 6868 6869 default: 6870 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6871 "sata_txlt_rw_completion: " 6872 "invalid packet completion reason")); 6873 scsipkt->pkt_reason = CMD_TRAN_ERR; 6874 break; 6875 } 6876 } 6877 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6878 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6879 6880 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6881 /* scsi callback required */ 6882 scsi_hba_pkt_comp(scsipkt); 6883 } 6884 6885 6886 /* 6887 * Translate completion status of non-data commands (i.e. commands returning 6888 * no data). 6889 * pkt completion_reason is checked to determine the completion status. 6890 * Do scsi callback if necessary (FLAG_NOINTR == 0) 6891 * 6892 * Note: this function may be called also for synchronously executed 6893 * commands. 6894 * This function may be used only if scsi_pkt is non-NULL. 6895 */ 6896 6897 static void 6898 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) 6899 { 6900 sata_pkt_txlate_t *spx = 6901 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6902 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6903 6904 sata_set_arq_data(sata_pkt); 6905 6906 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6907 /* scsi callback required */ 6908 scsi_hba_pkt_comp(scsipkt); 6909 } 6910 6911 /* 6912 * Completion handler for ATA Pass Through command 6913 */ 6914 static void 6915 sata_txlt_apt_completion(sata_pkt_t *sata_pkt) 6916 { 6917 sata_pkt_txlate_t *spx = 6918 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6919 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 6920 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6921 struct buf *bp; 6922 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0; 6923 6924 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6925 /* Normal completion */ 6926 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6927 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6928 scsipkt->pkt_reason = CMD_CMPLT; 6929 *scsipkt->pkt_scbp = STATUS_GOOD; 6930 6931 /* 6932 * If the command has CK_COND set 6933 */ 6934 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 6935 *scsipkt->pkt_scbp = STATUS_CHECK; 6936 sata_fill_ata_return_desc(sata_pkt, 6937 KEY_RECOVERABLE_ERROR, 6938 SD_SCSI_ASC_ATP_INFO_AVAIL, 0); 6939 } 6940 6941 if (spx->txlt_tmp_buf != NULL) { 6942 /* Temporary buffer was used */ 6943 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6944 if (bp->b_flags & B_READ) { 6945 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 6946 bp->b_bcount); 6947 } 6948 } 6949 } else { 6950 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6951 STATE_SENT_CMD | STATE_GOT_STATUS; 6952 scsipkt->pkt_reason = CMD_INCOMPLETE; 6953 *scsipkt->pkt_scbp = STATUS_CHECK; 6954 6955 /* 6956 * If DF or ERR was set, the HBA should have copied out the 6957 * status and error registers to the satacmd structure. 6958 */ 6959 if (scmd->satacmd_status_reg & SATA_STATUS_DF) { 6960 sense_key = KEY_HARDWARE_ERROR; 6961 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE; 6962 addl_sense_qual = 0; 6963 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 6964 if (scmd->satacmd_error_reg & SATA_ERROR_NM) { 6965 sense_key = KEY_NOT_READY; 6966 addl_sense_code = 6967 SD_SCSI_ASC_MEDIUM_NOT_PRESENT; 6968 addl_sense_qual = 0; 6969 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) { 6970 sense_key = KEY_MEDIUM_ERROR; 6971 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR; 6972 addl_sense_qual = 0; 6973 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) { 6974 sense_key = KEY_DATA_PROTECT; 6975 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED; 6976 addl_sense_qual = 0; 6977 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) { 6978 sense_key = KEY_ILLEGAL_REQUEST; 6979 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 6980 addl_sense_qual = 0; 6981 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 6982 sense_key = KEY_ABORTED_COMMAND; 6983 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE; 6984 addl_sense_qual = 0; 6985 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) { 6986 sense_key = KEY_UNIT_ATTENTION; 6987 addl_sense_code = 6988 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED; 6989 addl_sense_qual = 0; 6990 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) { 6991 sense_key = KEY_UNIT_ATTENTION; 6992 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ; 6993 addl_sense_qual = 0; 6994 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) { 6995 sense_key = KEY_ABORTED_COMMAND; 6996 addl_sense_code = 6997 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR; 6998 addl_sense_qual = 0; 6999 } 7000 } 7001 7002 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code, 7003 addl_sense_qual); 7004 } 7005 7006 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7007 /* scsi callback required */ 7008 scsi_hba_pkt_comp(scsipkt); 7009 } 7010 7011 /* 7012 * j 7013 */ 7014 static void 7015 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key, 7016 uint8_t addl_sense_code, uint8_t addl_sense_qual) 7017 { 7018 sata_pkt_txlate_t *spx = 7019 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7020 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7021 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7022 struct sata_apt_sense_data *apt_sd = 7023 (struct sata_apt_sense_data *)scsipkt->pkt_scbp; 7024 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr); 7025 struct scsi_ata_status_ret_sense_descr *ata_ret_desc = 7026 &(apt_sd->apt_sd_sense); 7027 int extend = 0; 7028 7029 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) && 7030 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND)) 7031 extend = 1; 7032 7033 scsipkt->pkt_state |= STATE_ARQ_DONE; 7034 7035 /* update the residual count */ 7036 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK; 7037 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD; 7038 apt_sd->apt_rqpkt_reason = CMD_CMPLT; 7039 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7040 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 7041 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen - 7042 sizeof (struct sata_apt_sense_data); 7043 7044 /* 7045 * Fill in the Descriptor sense header 7046 */ 7047 bzero(sds, sizeof (struct scsi_descr_sense_hdr)); 7048 sds->ds_code = CODE_FMT_DESCR_CURRENT; 7049 sds->ds_class = CLASS_EXTENDED_SENSE; 7050 sds->ds_key = sense_key & 0xf; 7051 sds->ds_add_code = addl_sense_code; 7052 sds->ds_qual_code = addl_sense_qual; 7053 sds->ds_addl_sense_length = 7054 sizeof (struct scsi_ata_status_ret_sense_descr); 7055 7056 /* 7057 * Fill in the ATA Return descriptor sense data 7058 */ 7059 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr)); 7060 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN; 7061 ata_ret_desc->ars_addl_length = 0xc; 7062 ata_ret_desc->ars_error = scmd->satacmd_error_reg; 7063 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb; 7064 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb; 7065 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb; 7066 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb; 7067 ata_ret_desc->ars_device = scmd->satacmd_device_reg; 7068 ata_ret_desc->ars_status = scmd->satacmd_status_reg; 7069 7070 if (extend == 1) { 7071 ata_ret_desc->ars_extend = 1; 7072 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb; 7073 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb; 7074 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb; 7075 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb; 7076 } else { 7077 ata_ret_desc->ars_extend = 0; 7078 ata_ret_desc->ars_sec_count_msb = 0; 7079 ata_ret_desc->ars_lba_low_msb = 0; 7080 ata_ret_desc->ars_lba_mid_msb = 0; 7081 ata_ret_desc->ars_lba_high_msb = 0; 7082 } 7083 } 7084 7085 static void 7086 sata_set_arq_data(sata_pkt_t *sata_pkt) 7087 { 7088 sata_pkt_txlate_t *spx = 7089 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7090 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7091 struct scsi_extended_sense *sense; 7092 7093 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7094 STATE_SENT_CMD | STATE_GOT_STATUS; 7095 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7096 /* Normal completion */ 7097 scsipkt->pkt_reason = CMD_CMPLT; 7098 *scsipkt->pkt_scbp = STATUS_GOOD; 7099 } else { 7100 /* Something went wrong */ 7101 scsipkt->pkt_reason = CMD_INCOMPLETE; 7102 *scsipkt->pkt_scbp = STATUS_CHECK; 7103 sense = sata_arq_sense(spx); 7104 switch (sata_pkt->satapkt_reason) { 7105 case SATA_PKT_PORT_ERROR: 7106 /* 7107 * We have no device data. Assume no data transfered. 7108 */ 7109 sense->es_key = KEY_HARDWARE_ERROR; 7110 break; 7111 7112 case SATA_PKT_DEV_ERROR: 7113 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 7114 SATA_STATUS_ERR) { 7115 /* 7116 * determine dev error reason from error 7117 * reg content 7118 */ 7119 sata_decode_device_error(spx, sense); 7120 break; 7121 } 7122 /* No extended sense key - no info available */ 7123 break; 7124 7125 case SATA_PKT_TIMEOUT: 7126 scsipkt->pkt_reason = CMD_TIMEOUT; 7127 scsipkt->pkt_statistics |= 7128 STAT_TIMEOUT | STAT_DEV_RESET; 7129 /* No extended sense key ? */ 7130 break; 7131 7132 case SATA_PKT_ABORTED: 7133 scsipkt->pkt_reason = CMD_ABORTED; 7134 scsipkt->pkt_statistics |= STAT_ABORTED; 7135 /* No extended sense key ? */ 7136 break; 7137 7138 case SATA_PKT_RESET: 7139 /* pkt aborted by an explicit reset from a host */ 7140 scsipkt->pkt_reason = CMD_RESET; 7141 scsipkt->pkt_statistics |= STAT_DEV_RESET; 7142 break; 7143 7144 default: 7145 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 7146 "sata_txlt_nodata_cmd_completion: " 7147 "invalid packet completion reason %d", 7148 sata_pkt->satapkt_reason)); 7149 scsipkt->pkt_reason = CMD_TRAN_ERR; 7150 break; 7151 } 7152 7153 } 7154 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7155 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7156 } 7157 7158 7159 /* 7160 * Build Mode sense R/W recovery page 7161 * NOT IMPLEMENTED 7162 */ 7163 7164 static int 7165 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7166 { 7167 #ifndef __lock_lint 7168 _NOTE(ARGUNUSED(sdinfo)) 7169 _NOTE(ARGUNUSED(pcntrl)) 7170 _NOTE(ARGUNUSED(buf)) 7171 #endif 7172 return (0); 7173 } 7174 7175 /* 7176 * Build Mode sense caching page - scsi-3 implementation. 7177 * Page length distinguishes previous format from scsi-3 format. 7178 * buf must have space for 0x12 bytes. 7179 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. 7180 * 7181 */ 7182 static int 7183 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7184 { 7185 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; 7186 sata_id_t *sata_id = &sdinfo->satadrv_id; 7187 7188 /* 7189 * Most of the fields are set to 0, being not supported and/or disabled 7190 */ 7191 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); 7192 7193 /* Saved paramters not supported */ 7194 if (pcntrl == 3) 7195 return (0); 7196 if (pcntrl == 0 || pcntrl == 2) { 7197 /* 7198 * For now treat current and default parameters as same 7199 * That may have to change, if target driver will complain 7200 */ 7201 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ 7202 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 7203 7204 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) && 7205 !SATA_READ_AHEAD_ENABLED(*sata_id)) { 7206 page->dra = 1; /* Read Ahead disabled */ 7207 page->rcd = 1; /* Read Cache disabled */ 7208 } 7209 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) && 7210 SATA_WRITE_CACHE_ENABLED(*sata_id)) 7211 page->wce = 1; /* Write Cache enabled */ 7212 } else { 7213 /* Changeable parameters */ 7214 page->mode_page.code = MODEPAGE_CACHING; 7215 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 7216 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 7217 page->dra = 1; 7218 page->rcd = 1; 7219 } 7220 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) 7221 page->wce = 1; 7222 } 7223 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 7224 sizeof (struct mode_page)); 7225 } 7226 7227 /* 7228 * Build Mode sense exception cntrl page 7229 */ 7230 static int 7231 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7232 { 7233 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; 7234 sata_id_t *sata_id = &sdinfo->satadrv_id; 7235 7236 /* 7237 * Most of the fields are set to 0, being not supported and/or disabled 7238 */ 7239 bzero(buf, PAGELENGTH_INFO_EXCPT); 7240 7241 page->mode_page.code = MODEPAGE_INFO_EXCPT; 7242 page->mode_page.length = PAGELENGTH_INFO_EXCPT; 7243 7244 /* Indicate that this is page is saveable */ 7245 page->mode_page.ps = 1; 7246 7247 /* 7248 * We will return the same data for default, current and saved page. 7249 * The only changeable bit is dexcpt and that bit is required 7250 * by the ATA specification to be preserved across power cycles. 7251 */ 7252 if (pcntrl != 1) { 7253 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); 7254 page->mrie = MRIE_ONLY_ON_REQUEST; 7255 } 7256 else 7257 page->dexcpt = 1; /* Only changeable parameter */ 7258 7259 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)); 7260 } 7261 7262 7263 static int 7264 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7265 { 7266 struct mode_acoustic_management *page = 7267 (struct mode_acoustic_management *)buf; 7268 sata_id_t *sata_id = &sdinfo->satadrv_id; 7269 7270 /* 7271 * Most of the fields are set to 0, being not supported and/or disabled 7272 */ 7273 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); 7274 7275 switch (pcntrl) { 7276 case P_CNTRL_DEFAULT: 7277 /* default paramters not supported */ 7278 return (0); 7279 7280 case P_CNTRL_CURRENT: 7281 case P_CNTRL_SAVED: 7282 /* Saved and current are supported and are identical */ 7283 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 7284 page->mode_page.length = 7285 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 7286 page->mode_page.ps = 1; 7287 7288 /* Word 83 indicates if feature is supported */ 7289 /* If feature is not supported */ 7290 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { 7291 page->acoustic_manag_enable = 7292 ACOUSTIC_DISABLED; 7293 } else { 7294 page->acoustic_manag_enable = 7295 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) 7296 != 0); 7297 /* Word 94 inidicates the value */ 7298 #ifdef _LITTLE_ENDIAN 7299 page->acoustic_manag_level = 7300 (uchar_t)sata_id->ai_acoustic; 7301 page->vendor_recommended_value = 7302 sata_id->ai_acoustic >> 8; 7303 #else 7304 page->acoustic_manag_level = 7305 sata_id->ai_acoustic >> 8; 7306 page->vendor_recommended_value = 7307 (uchar_t)sata_id->ai_acoustic; 7308 #endif 7309 } 7310 break; 7311 7312 case P_CNTRL_CHANGEABLE: 7313 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 7314 page->mode_page.length = 7315 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 7316 page->mode_page.ps = 1; 7317 7318 /* Word 83 indicates if the feature is supported */ 7319 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { 7320 page->acoustic_manag_enable = 7321 ACOUSTIC_ENABLED; 7322 page->acoustic_manag_level = 0xff; 7323 } 7324 break; 7325 } 7326 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 7327 sizeof (struct mode_page)); 7328 } 7329 7330 7331 /* 7332 * Build Mode sense power condition page. 7333 */ 7334 static int 7335 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7336 { 7337 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf; 7338 sata_id_t *sata_id = &sdinfo->satadrv_id; 7339 7340 /* 7341 * Most of the fields are set to 0, being not supported and/or disabled 7342 * power condition page length was 0x0a 7343 */ 7344 bzero(buf, sizeof (struct mode_info_power_cond)); 7345 7346 if (pcntrl == P_CNTRL_DEFAULT) { 7347 /* default paramters not supported */ 7348 return (0); 7349 } 7350 7351 page->mode_page.code = MODEPAGE_POWER_COND; 7352 page->mode_page.length = sizeof (struct mode_info_power_cond); 7353 7354 if (sata_id->ai_cap && SATA_STANDBYTIMER) { 7355 page->standby = 1; 7356 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer, 7357 sizeof (uchar_t) * 4); 7358 } 7359 7360 return (sizeof (struct mode_info_power_cond)); 7361 } 7362 7363 /* 7364 * Process mode select caching page 8 (scsi3 format only). 7365 * Read Ahead (same as read cache) and Write Cache may be turned on and off 7366 * if these features are supported by the device. If these features are not 7367 * supported, the command will be terminated with STATUS_CHECK. 7368 * This function fails only if the SET FEATURE command sent to 7369 * the device fails. The page format is not varified, assuming that the 7370 * target driver operates correctly - if parameters length is too short, 7371 * we just drop the page. 7372 * Two command may be sent if both Read Cache/Read Ahead and Write Cache 7373 * setting have to be changed. 7374 * SET FEATURE command is executed synchronously, i.e. we wait here until 7375 * it is completed, regardless of the scsi pkt directives. 7376 * 7377 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. 7378 * changing DRA will change RCD. 7379 * 7380 * More than one SATA command may be executed to perform operations specified 7381 * by mode select pages. The first error terminates further execution. 7382 * Operations performed successully are not backed-up in such case. 7383 * 7384 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 7385 * If operation resulted in changing device setup, dmod flag should be set to 7386 * one (1). If parameters were not changed, dmod flag should be set to 0. 7387 * Upon return, if operation required sending command to the device, the rval 7388 * should be set to the value returned by sata_hba_start. If operation 7389 * did not require device access, rval should be set to TRAN_ACCEPT. 7390 * The pagelen should be set to the length of the page. 7391 * 7392 * This function has to be called with a port mutex held. 7393 * 7394 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 7395 */ 7396 int 7397 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, 7398 int parmlen, int *pagelen, int *rval, int *dmod) 7399 { 7400 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7401 sata_drive_info_t *sdinfo; 7402 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7403 sata_id_t *sata_id; 7404 struct scsi_extended_sense *sense; 7405 int wce, dra; /* Current settings */ 7406 7407 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 7408 &spx->txlt_sata_pkt->satapkt_device); 7409 sata_id = &sdinfo->satadrv_id; 7410 *dmod = 0; 7411 7412 /* Verify parameters length. If too short, drop it */ 7413 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 7414 sizeof (struct mode_page)) > parmlen) { 7415 *scsipkt->pkt_scbp = STATUS_CHECK; 7416 sense = sata_arq_sense(spx); 7417 sense->es_key = KEY_ILLEGAL_REQUEST; 7418 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7419 *pagelen = parmlen; 7420 *rval = TRAN_ACCEPT; 7421 return (SATA_FAILURE); 7422 } 7423 7424 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); 7425 7426 /* Current setting of Read Ahead (and Read Cache) */ 7427 if (SATA_READ_AHEAD_ENABLED(*sata_id)) 7428 dra = 0; /* 0 == not disabled */ 7429 else 7430 dra = 1; 7431 /* Current setting of Write Cache */ 7432 if (SATA_WRITE_CACHE_ENABLED(*sata_id)) 7433 wce = 1; 7434 else 7435 wce = 0; 7436 7437 if (page->dra == dra && page->wce == wce && page->rcd == dra) { 7438 /* nothing to do */ 7439 *rval = TRAN_ACCEPT; 7440 return (SATA_SUCCESS); 7441 } 7442 7443 /* 7444 * Need to flip some setting 7445 * Set-up Internal SET FEATURES command(s) 7446 */ 7447 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 7448 scmd->satacmd_addr_type = 0; 7449 scmd->satacmd_device_reg = 0; 7450 scmd->satacmd_status_reg = 0; 7451 scmd->satacmd_error_reg = 0; 7452 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 7453 if (page->dra != dra || page->rcd != dra) { 7454 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 7455 /* Need to flip read ahead setting */ 7456 if (dra == 0) 7457 /* Disable read ahead / read cache */ 7458 scmd->satacmd_features_reg = 7459 SATAC_SF_DISABLE_READ_AHEAD; 7460 else 7461 /* Enable read ahead / read cache */ 7462 scmd->satacmd_features_reg = 7463 SATAC_SF_ENABLE_READ_AHEAD; 7464 7465 /* Transfer command to HBA */ 7466 if (sata_hba_start(spx, rval) != 0) 7467 /* 7468 * Pkt not accepted for execution. 7469 */ 7470 return (SATA_FAILURE); 7471 7472 *dmod = 1; 7473 7474 /* Now process return */ 7475 if (spx->txlt_sata_pkt->satapkt_reason != 7476 SATA_PKT_COMPLETED) { 7477 goto failure; /* Terminate */ 7478 } 7479 } else { 7480 *scsipkt->pkt_scbp = STATUS_CHECK; 7481 sense = sata_arq_sense(spx); 7482 sense->es_key = KEY_ILLEGAL_REQUEST; 7483 sense->es_add_code = 7484 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7485 *pagelen = parmlen; 7486 *rval = TRAN_ACCEPT; 7487 return (SATA_FAILURE); 7488 } 7489 } 7490 7491 /* Note that the packet is not removed, so it could be re-used */ 7492 if (page->wce != wce) { 7493 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) { 7494 /* Need to flip Write Cache setting */ 7495 if (page->wce == 1) 7496 /* Enable write cache */ 7497 scmd->satacmd_features_reg = 7498 SATAC_SF_ENABLE_WRITE_CACHE; 7499 else 7500 /* Disable write cache */ 7501 scmd->satacmd_features_reg = 7502 SATAC_SF_DISABLE_WRITE_CACHE; 7503 7504 /* Transfer command to HBA */ 7505 if (sata_hba_start(spx, rval) != 0) 7506 /* 7507 * Pkt not accepted for execution. 7508 */ 7509 return (SATA_FAILURE); 7510 7511 *dmod = 1; 7512 7513 /* Now process return */ 7514 if (spx->txlt_sata_pkt->satapkt_reason != 7515 SATA_PKT_COMPLETED) { 7516 goto failure; 7517 } 7518 } else { 7519 *scsipkt->pkt_scbp = STATUS_CHECK; 7520 sense = sata_arq_sense(spx); 7521 sense->es_key = KEY_ILLEGAL_REQUEST; 7522 sense->es_add_code = 7523 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7524 *pagelen = parmlen; 7525 *rval = TRAN_ACCEPT; 7526 return (SATA_FAILURE); 7527 } 7528 } 7529 return (SATA_SUCCESS); 7530 7531 failure: 7532 sata_xlate_errors(spx); 7533 7534 return (SATA_FAILURE); 7535 } 7536 7537 /* 7538 * Process mode select informational exceptions control page 0x1c 7539 * 7540 * The only changeable bit is dexcpt (disable exceptions). 7541 * MRIE (method of reporting informational exceptions) must be 7542 * "only on request". 7543 * This page applies to informational exceptions that report 7544 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh 7545 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_). 7546 * Informational exception conditions occur as the result of background scan 7547 * errors, background self-test errors, or vendor specific events within a 7548 * logical unit. An informational exception condition may occur asynchronous 7549 * to any commands. 7550 * 7551 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 7552 * If operation resulted in changing device setup, dmod flag should be set to 7553 * one (1). If parameters were not changed, dmod flag should be set to 0. 7554 * Upon return, if operation required sending command to the device, the rval 7555 * should be set to the value returned by sata_hba_start. If operation 7556 * did not require device access, rval should be set to TRAN_ACCEPT. 7557 * The pagelen should be set to the length of the page. 7558 * 7559 * This function has to be called with a port mutex held. 7560 * 7561 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 7562 * 7563 * Cannot be called in the interrupt context. 7564 */ 7565 static int 7566 sata_mode_select_page_1c( 7567 sata_pkt_txlate_t *spx, 7568 struct mode_info_excpt_page *page, 7569 int parmlen, 7570 int *pagelen, 7571 int *rval, 7572 int *dmod) 7573 { 7574 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7575 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7576 sata_drive_info_t *sdinfo; 7577 sata_id_t *sata_id; 7578 struct scsi_extended_sense *sense; 7579 7580 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 7581 &spx->txlt_sata_pkt->satapkt_device); 7582 sata_id = &sdinfo->satadrv_id; 7583 7584 *dmod = 0; 7585 7586 /* Verify parameters length. If too short, drop it */ 7587 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) || 7588 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { 7589 *scsipkt->pkt_scbp = STATUS_CHECK; 7590 sense = sata_arq_sense(spx); 7591 sense->es_key = KEY_ILLEGAL_REQUEST; 7592 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7593 *pagelen = parmlen; 7594 *rval = TRAN_ACCEPT; 7595 return (SATA_FAILURE); 7596 } 7597 7598 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); 7599 7600 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 7601 *scsipkt->pkt_scbp = STATUS_CHECK; 7602 sense = sata_arq_sense(spx); 7603 sense->es_key = KEY_ILLEGAL_REQUEST; 7604 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 7605 *pagelen = parmlen; 7606 *rval = TRAN_ACCEPT; 7607 return (SATA_FAILURE); 7608 } 7609 7610 /* If already in the state requested, we are done */ 7611 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 7612 /* nothing to do */ 7613 *rval = TRAN_ACCEPT; 7614 return (SATA_SUCCESS); 7615 } 7616 7617 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 7618 7619 /* Build SMART_ENABLE or SMART_DISABLE command */ 7620 scmd->satacmd_addr_type = 0; /* N/A */ 7621 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 7622 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 7623 scmd->satacmd_features_reg = page->dexcpt ? 7624 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; 7625 scmd->satacmd_device_reg = 0; /* Always device 0 */ 7626 scmd->satacmd_cmd_reg = SATAC_SMART; 7627 7628 /* Transfer command to HBA */ 7629 if (sata_hba_start(spx, rval) != 0) 7630 /* 7631 * Pkt not accepted for execution. 7632 */ 7633 return (SATA_FAILURE); 7634 7635 *dmod = 1; /* At least may have been modified */ 7636 7637 /* Now process return */ 7638 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) 7639 return (SATA_SUCCESS); 7640 7641 /* Packet did not complete successfully */ 7642 sata_xlate_errors(spx); 7643 7644 return (SATA_FAILURE); 7645 } 7646 7647 /* 7648 * Process mode select acoustic management control page 0x30 7649 * 7650 * 7651 * This function has to be called with a port mutex held. 7652 * 7653 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 7654 * 7655 * Cannot be called in the interrupt context. 7656 */ 7657 int 7658 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct 7659 mode_acoustic_management *page, int parmlen, int *pagelen, 7660 int *rval, int *dmod) 7661 { 7662 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7663 sata_drive_info_t *sdinfo; 7664 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd