1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _SATA_HBA_H 28 #define _SATA_HBA_H 29 30 #pragma ident "%Z%%M% %I% %E% SMI" 31 32 #ifdef __cplusplus 33 extern "C" { 34 #endif 35 36 #include <sys/sata/sata_defs.h> 37 38 /* 39 * SATA Host Bus Adapter (HBA) driver transport definitions 40 */ 41 42 #include <sys/types.h> 43 44 #ifndef TRUE 45 #define TRUE 1 46 #define FALSE 0 47 #endif 48 49 #define SATA_SUCCESS 0 50 #define SATA_RETRY 1 51 #define SATA_FAILURE -1 52 53 54 /* SATA Framework definitions */ 55 56 #define SATA_MAX_CPORTS 32 /* Max number of controller ports */ 57 58 /* Multiplier (PMult) */ 59 #define SATA_MAX_PMPORTS 16 /* Maximum number of ports on PMult */ 60 #define SATA_PMULT_HOSTPORT 0xf /* Port Multiplier host port number */ 61 62 63 /* 64 * SATA device address 65 * Address qualifier flags are used to specify what is addressed (device 66 * or port) and where (controller or port multiplier data port). 67 */ 68 struct sata_address { 69 uint8_t cport; /* Controller's SATA port number */ 70 uint8_t pmport; /* Port Multiplier SATA port number */ 71 uint8_t qual; /* Address Qualifier flags */ 72 uint8_t pad; /* Reserved */ 73 }; 74 75 typedef struct sata_address sata_address_t; 76 77 /* 78 * SATA address Qualifier flags (in qual field of sata_address struct). 79 * They are mutually exclusive. 80 */ 81 82 #define SATA_ADDR_NULL 0x00 /* No address */ 83 #define SATA_ADDR_DCPORT 0x01 /* Device attched to controller port */ 84 #define SATA_ADDR_DPMPORT 0x02 /* Device attched to PM device port */ 85 #define SATA_ADDR_CPORT 0x04 /* Controller's device port */ 86 #define SATA_ADDR_PMPORT 0x08 /* Port Multiplier's device port */ 87 #define SATA_ADDR_CNTRL 0x10 /* Controller */ 88 #define SATA_ADDR_PMULT 0x20 /* Port Multiplier */ 89 90 /* 91 * SATA port status and control register block. 92 * The sstatus, serror, scontrol, sactive and snotific 93 * are the copies of the SATA port status and control registers. 94 * (Port SStatus, SError, SControl, SActive and SNotification are 95 * defined by Serial ATA r1.0a sepc and Serial ATA II spec. 96 */ 97 98 struct sata_port_scr 99 { 100 uint32_t sstatus; /* Port SStatus register */ 101 uint32_t serror; /* Port SError register */ 102 uint32_t scontrol; /* Port SControl register */ 103 uint32_t sactive; /* Port SActive register */ 104 uint32_t snotific; /* Port SNotification register */ 105 }; 106 107 typedef struct sata_port_scr sata_port_scr_t; 108 109 /* 110 * SATA Device Structure (rev 1) 111 * Used to request/return state of the controller, port, port multiplier 112 * or an attached drive: 113 * The satadev_addr.cport, satadev_addr.pmport and satadev_addr.qual 114 * fields are used to specify SATA address (see sata_address structure 115 * description). 116 * The satadev_scr structure is used to pass the content of a port 117 * status and control registers. 118 * The satadev_add_info field is used by SATA HBA driver to return an 119 * additional information, which type depends on the function using 120 * sata_device as argument. For example: 121 * - in case of sata_tran_probe_port() this field should contain 122 * a number of available Port Multiplier device ports; 123 * - in case of sata_hba_event_notify() this field may contain 124 * a value specific for a reported event. 125 */ 126 #define SATA_DEVICE_REV_1 1 127 #define SATA_DEVICE_REV SATA_DEVICE_REV_1 128 129 struct sata_device 130 { 131 int satadev_rev; /* structure version */ 132 struct sata_address satadev_addr; /* sata port/device address */ 133 uint32_t satadev_state; /* Port or device state */ 134 uint32_t satadev_type; /* Attached device type */ 135 struct sata_port_scr satadev_scr; /* Port status and ctrl regs */ 136 uint32_t satadev_add_info; /* additional information, */ 137 /* function specific */ 138 }; 139 140 typedef struct sata_device sata_device_t; 141 142 _NOTE(SCHEME_PROTECTS_DATA("unshared data", sata_device)) 143 144 145 /* 146 * satadev_state field of sata_device structure. 147 * Common flags specifying current state of a port or an attached drive. 148 * These states are mutually exclusive, except SATA_STATE_PROBED and 149 * SATA_STATE_READY that may be set at the same time. 150 */ 151 #define SATA_STATE_UNKNOWN 0x000000 152 #define SATA_STATE_PROBING 0x000001 153 #define SATA_STATE_PROBED 0x000002 154 #define SATA_STATE_READY 0x000010 155 156 /* 157 * Attached drive specific states (satadev_state field of the sata_device 158 * structure). 159 * SATA_DSTATE_PWR_ACTIVE, SATA_DSTATE_PWR_IDLE and SATA_DSTATE_PWR_STANDBY 160 * are mutually exclusive. All other states may be combined with each other 161 * and with one of the power states. 162 * These flags may be used only if the address qualifier (satadev_addr.qual) is 163 * set to SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT value. 164 */ 165 166 #define SATA_DSTATE_PWR_ACTIVE 0x000100 167 #define SATA_DSTATE_PWR_IDLE 0x000200 168 #define SATA_DSTATE_PWR_STANDBY 0x000400 169 #define SATA_DSTATE_RESET 0x001000 170 #define SATA_DSTATE_FAILED 0x008000 171 172 /* Mask for drive power states */ 173 #define SATA_DSTATE_PWR (SATA_DSTATE_PWR_ACTIVE | \ 174 SATA_DSTATE_PWR_IDLE | \ 175 SATA_DSTATE_PWR_STANDBY) 176 /* 177 * SATA Port specific states (satadev_state field of sata_device structure). 178 * SATA_PSTATE_PWRON and SATA_PSTATE_PWROFF are mutually exclusive. 179 * All other states may be combined with each other and with one of the power 180 * level state. 181 * These flags may be used only if the address qualifier (satadev_addr.qual) is 182 * set to SATA_ADDR_CPORT or SATA_ADDR_PMPORT value. 183 */ 184 185 #define SATA_PSTATE_PWRON 0x010000 186 #define SATA_PSTATE_PWROFF 0X020000 187 #define SATA_PSTATE_SHUTDOWN 0x040000 188 #define SATA_PSTATE_FAILED 0x080000 189 190 /* Mask for the valid port-specific state flags */ 191 #define SATA_PSTATE_VALID (SATA_PSTATE_PWRON | \ 192 SATA_PSTATE_PWROFF | \ 193 SATA_PSTATE_SHUTDOWN | \ 194 SATA_PSTATE_FAILED) 195 196 /* Mask for a port power states */ 197 #define SATA_PSTATE_PWR (SATA_PSTATE_PWRON | \ 198 SATA_PSTATE_PWROFF) 199 /* 200 * Device type (in satadev_type field of sata_device structure). 201 * More device types may be added in the future. 202 */ 203 204 #define SATA_DTYPE_NONE 0x00 /* No device attached */ 205 #define SATA_DTYPE_ATADISK 0x01 /* ATA Disk */ 206 #define SATA_DTYPE_ATAPICD 0x02 /* Atapi CD/DVD device */ 207 #define SATA_DTYPE_ATAPINONCD 0x03 /* Atapi non-CD/DVD device */ 208 #define SATA_DTYPE_PMULT 0x10 /* Port Multiplier */ 209 #define SATA_DTYPE_UNKNOWN 0x20 /* Device attached, unkown */ 210 211 212 /* 213 * SATA cmd structure (rev 1) 214 * 215 * SATA HBA framework always sets all fields except status_reg and error_reg. 216 * SATA HBA driver action depends on the addressing type specified by 217 * addr_type field: 218 * If LBA48 addressing is indicated, SATA HBA driver has to load values from 219 * satacmd_sec_count_msb_reg, satacmd_lba_low_msb_reg, 220 * satacmd_lba_mid_msb_reg and satacmd_lba_hi_msb_reg 221 * to appropriate registers prior to loading other registers. 222 * For other addressing modes, SATA HBA driver should skip loading values 223 * from satacmd_sec_count_msb_reg, satacmd_lba_low_msb_reg, 224 * satacmd_lba_mid_msb_reg and satacmd_lba_hi_msb_reg 225 * fields and load only remaining field values to corresponding registers. 226 * 227 * satacmd_sec_count_msb and satamcd_sec_count_lsb values are loaded into 228 * sec_count register, satacmd_sec_count_msb loaded first (if LBA48 229 * addressing is used). 230 * satacmd_lba_low_msb and satacmd_lba_low_lsb values are loaded into the 231 * lba_low register, satacmd_lba_low_msb loaded first (if LBA48 addressing 232 * is used). The lba_low register is the newer name for the old 233 * sector_number register. 234 * satacmd_lba_mid_msb and satacmd_lba_mid_lsb values are loaded into lba_mid 235 * register, satacmd_lba_mid_msb loaded first (if LBA48 addressing is used). 236 * The lba_mid register is the newer name for the old cylinder_low register. 237 * satacmd_lba_high_msb and satacmd_lba_high_lsb values are loaded into 238 * the lba_high regster, satacmd_lba_high_msb loaded first (if LBA48 239 * addressing is used). The lba_high register is a newer name for the old 240 * cylinder_high register. 241 * 242 * No addressing mode is selected when an ata command does not involve actual 243 * reading/writing data from/to the media (for example IDENTIFY DEVICE or 244 * SET FEATURE command), or the ATAPI PACKET command is sent. 245 * If ATAPI PACKET command is sent and tagged commands are used, 246 * SATA HBA driver has to provide and manage a tag value and 247 * set it into the sector_count register. 248 * 249 * Device Control register is not specified in sata_cmd structure - SATA HBA 250 * driver shall set it accordingly to current mode of operation (interrupt 251 * enable/disable). 252 * 253 * Buffer structure's b_flags should be used to determine the 254 * address type of b_un.b_addr. However, there is no need to allocate DMA 255 * resources for the buffer in SATA HBA driver. 256 * DMA resources for a buffer structure are allocated by the SATA HBA 257 * framework. Scatter/gather list is to be used only for DMA transfers 258 * and it should be based on the DMA cookies list. 259 * 260 * Upon completion of a command, SATA HBA driver has to update 261 * satacmd_status_reg and satacmd_error_reg to reflect the contents of 262 * the corresponding device status and error registers. 263 * If the command completed with error, SATA HBA driver has to update 264 * satacmd_sec_count_msb, satacmd_sec_count_lsb, satacmd_lba_low_msb, 265 * satacmd_lba_low_lsb, satacmd_lba_mid_msb, satacmd_lba_mid_lsb, 266 * satacmd_lba_high_msb and satacmd_lba_high_lsb to values read from the 267 * corresponding device registers. 268 * If an operation could not complete because of the port error, the 269 * sata_pkt.satapkt_device.satadev_scr structure has to be updated. 270 * 271 * If ATAPI PACKET command was sent and command completed with error, 272 * rqsense structure has to be filed by SATA HBA driver. The satacmd_arq_cdb 273 * points to pre-set request sense cdb that may be used for issuing request 274 * sense data from the device. 275 * 276 * If FPDMA-type command was sent and command completed with error, the HBA 277 * driver may use pre-set command READ LOG EXTENDED command pointed to 278 * by satacmd_rle_sata_cmd field to retrieve error data from a device. 279 * Only ATA register fields of the sata_cmd are set-up for that purpose. 280 * 281 * If the READ MULTIPLIER command was specified in cmd_reg (command directed 282 * to a port multiplier host port rather then to an attached device), 283 * upon the command completion SATA HBA driver has to update_sector count 284 * and lba fields of the sata_cmd structure to values returned via 285 * command block registers (task file registers). 286 */ 287 #define SATA_CMD_REV_1 1 288 #define SATA_CMD_REV_2 2 289 #define SATA_CMD_REV SATA_CMD_REV_2 290 291 #define SATA_ATAPI_MAX_CDB_LEN 16 /* Covers both 12 and 16 byte cdbs */ 292 #define SATA_ATAPI_RQSENSE_LEN 24 /* Fixed size Request Sense data */ 293 294 struct sata_cmd { 295 int satacmd_rev; /* version */ 296 struct buf *satacmd_bp; /* ptr to buffer structure */ 297 struct sata_cmd_flags { 298 uint32_t sata_data_direction : 3; /* 0-2 */ 299 uint32_t : 1; /* reserved */ /* 3 */ 300 uint32_t sata_queue_stag : 1; /* 4 */ 301 uint32_t sata_queue_otag : 1; /* 5 */ 302 uint32_t : 2; /* reserved */ /* 6-7 */ 303 uint32_t sata_queued : 1; /* 8 */ 304 uint32_t : 3; /* reserved */ /* 9-11 */ 305 uint32_t sata_ignore_dev_reset : 1; /* 12 */ 306 uint32_t sata_clear_dev_reset : 1; /* 13 */ 307 uint32_t : 2; /* reserved */ /* 14-15 */ 308 uint32_t sata_special_regs : 1; /* 16 */ 309 uint32_t sata_copy_out_sec_count_msb : 1; /* 17 */ 310 uint32_t sata_copy_out_lba_low_msb : 1; /* 18 */ 311 uint32_t sata_copy_out_lba_mid_msb : 1; /* 19 */ 312 uint32_t sata_copy_out_lba_high_msb : 1; /* 20 */ 313 uint32_t sata_copy_out_sec_count_lsb : 1; /* 21 */ 314 uint32_t sata_copy_out_lba_low_lsb : 1; /* 22 */ 315 uint32_t sata_copy_out_lba_mid_lsb : 1; /* 23 */ 316 uint32_t sata_copy_out_lba_high_lsb : 1; /* 24 */ 317 uint32_t sata_copy_out_device_reg : 1; /* 25 */ 318 uint32_t sata_copy_out_error_reg : 1; /* 26 */ 319 uint32_t : 5; /* reserved */ /* 27-31 */ 320 } satacmd_flags; 321 uint8_t satacmd_addr_type; /* addr type: LBA28, LBA48 */ 322 uint8_t satacmd_features_reg_ext; /* features reg extended */ 323 uint8_t satacmd_sec_count_msb; /* sector count MSB (LBA48) */ 324 uint8_t satacmd_lba_low_msb; /* LBA Low MSB (LBA48) */ 325 uint8_t satacmd_lba_mid_msb; /* LBA Mid MSB (LBA48) */ 326 uint8_t satacmd_lba_high_msb; /* LBA High MSB (LBA48) */ 327 uint8_t satacmd_sec_count_lsb; /* sector count LSB */ 328 uint8_t satacmd_lba_low_lsb; /* LBA Low LSB */ 329 uint8_t satacmd_lba_mid_lsb; /* LBA Mid LSB */ 330 uint8_t satacmd_lba_high_lsb; /* LBA High LSB */ 331 uint8_t satacmd_device_reg; /* ATA dev reg & LBA28 MSB */ 332 uint8_t satacmd_cmd_reg; /* ata command code */ 333 uint8_t satacmd_features_reg; /* ATA features register */ 334 uint8_t satacmd_status_reg; /* ATA status register */ 335 uint8_t satacmd_error_reg; /* ATA error register */ 336 uint8_t satacmd_acdb_len; /* ATAPI cdb length */ 337 uint8_t satacmd_acdb[SATA_ATAPI_MAX_CDB_LEN]; /* ATAPI cdb */ 338 339 /* 340 * Ptr to request sense cdb 341 * request sense buf 342 */ 343 uint8_t *satacmd_arq_cdb; 344 345 uint8_t satacmd_rqsense[SATA_ATAPI_RQSENSE_LEN]; 346 347 /* 348 * Ptr to FPDMA error 349 * retrieval cmd 350 */ 351 const struct sata_cmd *satacmd_rle_sata_cmd; 352 353 int satacmd_num_dma_cookies; /* number of dma cookies */ 354 /* ptr to dma cookie list */ 355 ddi_dma_cookie_t *satacmd_dma_cookie_list; 356 }; 357 358 typedef struct sata_cmd sata_cmd_t; 359 360 _NOTE(SCHEME_PROTECTS_DATA("unshared data", sata_cmd)) 361 362 363 /* ATA address type (in satacmd_addr_type field */ 364 #define ATA_ADDR_LBA 0x1 365 #define ATA_ADDR_LBA28 0x2 366 #define ATA_ADDR_LBA48 0x4 367 368 /* 369 * satacmd_flags : contain data transfer direction flags, 370 * tagged queuing type flags, queued command flag, and reset state handling 371 * flag. 372 */ 373 374 /* 375 * Data transfer direction flags (satacmd_flags.sata_data_direction) 376 * Direction flags are mutually exclusive. 377 */ 378 #define SATA_DIR_NODATA_XFER 0x0001 /* No data transfer */ 379 #define SATA_DIR_READ 0x0002 /* Reading data from a device */ 380 #define SATA_DIR_WRITE 0x0004 /* Writing data to a device */ 381 382 /* 383 * Tagged Queuing type flags 384 * satacmd_flags.sata_queue_stag 385 * satacmd_flags.sata_queue_otag 386 * 387 * These flags indicate how the SATA command should be queued. 388 * 389 * sata_queue_stag 390 * Simple-queue-tagged command. It may be executed out-of-order in respect 391 * to other queued commands. 392 * sata_queue_otag 393 * Ordered-queue-tagged command. It cannot be executed out-of-order in 394 * respect to other commands, i.e. it should be executed in the order of 395 * being transported to the HBA. 396 * 397 * Translated head-of-queue-tagged scsi commands and commands that are 398 * to be put at the head of the queue are treated as SATA_QUEUE_OTAG_CMD 399 * tagged commands. 400 */ 401 402 403 /* 404 * Queuing command set-up flag (satacmd_flags.sata_queued). 405 * This flag indicates that sata_cmd was set-up for DMA Queued command 406 * (either READ_DMA_QUEUED, READ_DMA_QUEUED_EXT, WRITE_DMA_QUEUED or 407 * WRITE_DMA_QUEUED_EXT command) or one of the Native Command Queuing commands 408 * (either READ_FPDMA_QUEUED or WRITE_FPDMA_QUEUED). 409 * This flag will be used only if sata_tran_hba_flags indicates controller 410 * support for queuing and the device for which sata_cmd is prepared supports 411 * either legacy queuing (indicated by Device Identify data word 83 bit 2) 412 * or NCQ (indicated by word 76 of Device Identify data). 413 */ 414 415 /* 416 * Reset state handling 417 * satacmd_flags.sata_ignore_dev_reset 418 * satacmd_flags.sata_clear_dev_reset 419 * 420 * SATA HBA device enters reset state if the device was subjected to 421 * the Device Reset (may also enter this state if the device was reset 422 * as a side effect of port reset). SATA HBA driver sets this state. 423 * Device stays in this condition until explicit request from SATA HBA 424 * framework to clear the state. 425 */ 426 427 /* 428 * SATA Packet structure (rev 1) 429 * hba_driver_private is for a private use of the SATA HBA driver; 430 * satapkt_framework_private is used only by SATA HBA framework; 431 * satapkt_comp is a callback function to be called when packet 432 * execution is completed (for any reason) if mode of operation is not 433 * synchronous (SATA_OPMODE_SYNCH); 434 * satapkt_reason specifies why the packet operation was completed 435 * 436 * NOTE: after the packet completion callback SATA HBA driver should not 437 * attempt to access any sata_pkt fields because sata_pkt is not valid anymore 438 * (it could have been destroyed). 439 * Since satapkt_hba_driver_private field cannot be retrieved, any hba private 440 * data respources allocated per packet and accessed via this pointer should 441 * either be freed before the completion callback is done, or the pointer has 442 * to be saved by the HBA driver before the completion callback. 443 */ 444 #define SATA_PKT_REV_1 1 445 #define SATA_PKT_REV SATA_PKT_REV_1 446 447 struct sata_pkt { 448 int satapkt_rev; /* version */ 449 struct sata_device satapkt_device; /* Device address/type */ 450 451 /* HBA driver private data */ 452 void *satapkt_hba_driver_private; 453 454 /* SATA framework priv data */ 455 void *satapkt_framework_private; 456 457 /* Rqsted mode of operation */ 458 uint32_t satapkt_op_mode; 459 460 struct sata_cmd satapkt_cmd; /* composite sata command */ 461 int satapkt_time; /* time allotted to command */ 462 void (*satapkt_comp)(struct sata_pkt *); /* callback */ 463 int satapkt_reason; /* completion reason */ 464 }; 465 466 typedef struct sata_pkt sata_pkt_t; 467 468 _NOTE(SCHEME_PROTECTS_DATA("unshared data", sata_pkt)) 469 470 471 /* 472 * Operation mode flags (in satapkt_op_mode field of sata_pkt structure). 473 * Use to specify what should be a mode of operation for specified command. 474 * Default (000b) means use Interrupt and Asynchronous mode to 475 * perform an operation. 476 * Synchronous operation menas that the packet operation has to be completed 477 * before the function called to initiate the operation returns. 478 */ 479 #define SATA_OPMODE_INTERRUPTS 0 /* Use interrupts (hint) */ 480 #define SATA_OPMODE_POLLING 1 /* Use polling instead of interrupts */ 481 #define SATA_OPMODE_ASYNCH 0 /* Return immediately after accepting pkt */ 482 #define SATA_OPMODE_SYNCH 4 /* Perform synchronous operation */ 483 484 /* 485 * satapkt_reason values: 486 * 487 * SATA_PKT_QUEUE_FULL - cmd not sent because of queue full (detected 488 * by the controller). If a device reject command for this reason, it 489 * should be reported as SATA_PKT_DEV_ERROR 490 * 491 * SATA_PKT_CMD_NOT_SUPPORTED - command not supported by a controller 492 * Controller is unable to send such command to a device. 493 * If device rejects a command, it should be reported as 494 * SATA_PKT_DEV_ERROR. 495 * 496 * SATA_PKT_DEV_ERROR - cmd failed because of device reported an error. 497 * The content of status_reg (ERROR bit has to be set) and error_reg 498 * fields of the sata_cmd structure have to be set and will be used 499 * by SATA HBA Framework to determine the error cause. 500 * 501 * SATA_PKT_PORT_ERROR - cmd failed because of a link or a port error. 502 * Link failed / no communication with a device / communication error 503 * or other port related error was detected by a controller. 504 * sata_pkt.satapkt_device.satadev_scr.sXXXXXXX words have to be set. 505 * 506 * SATA_PKT_ABORTED - cmd execution was aborted by the request from the 507 * framework. Abort mechanism is HBA driver specific. 508 * 509 * SATA_PKT_TIMEOUT - cmd execution has timed-out. Timeout specified by 510 * pkt_time was exceeded. The command was terminated by the SATA HBA 511 * driver. 512 * 513 * SATA_PKT_COMPLETED - this is a value returned when an operation 514 * completes without errors. 515 * 516 * SATA_PKT_BUSY - packet was not accepted for execution because the 517 * driver was busy performing some other operation(s). 518 * 519 * SATA_PKT_RESET - packet execution was aborted because of device 520 * reset originated by either the HBA driver or the SATA framework. 521 * 522 */ 523 524 #define SATA_PKT_BUSY -1 /* Not completed, busy */ 525 #define SATA_PKT_COMPLETED 0 /* No error */ 526 #define SATA_PKT_DEV_ERROR 1 /* Device reported error */ 527 #define SATA_PKT_QUEUE_FULL 2 /* Not accepted, queue full */ 528 #define SATA_PKT_PORT_ERROR 3 /* Not completed, port error */ 529 #define SATA_PKT_CMD_UNSUPPORTED 4 /* Cmd unsupported */ 530 #define SATA_PKT_ABORTED 5 /* Aborted by request */ 531 #define SATA_PKT_TIMEOUT 6 /* Operation timeut */ 532 #define SATA_PKT_RESET 7 /* Aborted by reset request */ 533 534 /* 535 * Hoplug functions vector structure (rev 1) 536 */ 537 #define SATA_TRAN_HOTPLUG_OPS_REV_1 1 538 539 struct sata_tran_hotplug_ops { 540 int sata_tran_hotplug_ops_rev; /* version */ 541 int (*sata_tran_port_activate)(dev_info_t *, sata_device_t *); 542 int (*sata_tran_port_deactivate)(dev_info_t *, sata_device_t *); 543 }; 544 545 typedef struct sata_tran_hotplug_ops sata_tran_hotplug_ops_t; 546 547 548 /* 549 * Power management functions vector structure (rev 1) 550 * The embedded function returns information about the controller's 551 * power level. 552 * Additional functions may be added in the future without changes to 553 * sata_tran structure. 554 */ 555 #define SATA_TRAN_PWRMGT_OPS_REV_1 1 556 557 struct sata_tran_pwrmgt_ops { 558 int sata_tran_pwrmgt_ops_rev; /* version */ 559 int (*sata_tran_get_pwr_level)(dev_info_t *, sata_device_t *); 560 }; 561 562 typedef struct sata_tran_pwrmgt_ops sata_tran_pwrmgt_ops_t; 563 564 565 /* 566 * SATA port PHY Power Level 567 * These states correspond to the interface power management state as defined 568 * in Serial ATA spec. 569 */ 570 #define SATA_TRAN_PORTPWR_LEVEL1 1 /* Interface in active PM state */ 571 #define SATA_TRAN_PORTPWR_LEVEL2 2 /* Interface in PARTIAL PM state */ 572 #define SATA_TRAN_PORTPWR_LEVEL3 3 /* Interface in SLUMBER PM state */ 573 574 /* 575 * SATA HBA Tran structure (rev 1) 576 * Registered with SATA Framework 577 * 578 * dma_attr is a pointer to data (buffer) dma attibutes of the controller 579 * DMA engine. 580 * 581 * The qdepth field specifies number of commands that may be accepted by 582 * the controller. Value range 1-32. A value greater than 1 indicates that 583 * the controller supports queuing. Support for Native Command Queuing 584 * indicated by SATA_CTLF_NCQ flag also requires qdepth set to a value 585 * greater then 1. 586 * 587 */ 588 #define SATA_TRAN_HBA_REV_1 1 589 #define SATA_TRAN_HBA_REV SATA_TRAN_HBA_REV_1 590 591 struct sata_hba_tran { 592 int sata_tran_hba_rev; /* version */ 593 dev_info_t *sata_tran_hba_dip; /* Controler dev info */ 594 ddi_dma_attr_t *sata_tran_hba_dma_attr; /* DMA attributes */ 595 int sata_tran_hba_num_cports; /* Num of HBA device ports */ 596 uint16_t sata_tran_hba_features_support; /* HBA features */ 597 uint16_t sata_tran_hba_qdepth; /* HBA-supported queue depth */ 598 599 int (*sata_tran_probe_port)(dev_info_t *, sata_device_t *); 600 int (*sata_tran_start)(dev_info_t *, sata_pkt_t *); 601 int (*sata_tran_abort)(dev_info_t *, sata_pkt_t *, int); 602 int (*sata_tran_reset_dport)(dev_info_t *, 603 sata_device_t *); 604 int (*sata_tran_selftest)(dev_info_t *, sata_device_t *); 605 606 /* Hotplug vector */ 607 struct sata_tran_hotplug_ops *sata_tran_hotplug_ops; 608 609 /* Power mgt vector */ 610 struct sata_tran_pwrmgt_ops *sata_tran_pwrmgt_ops; 611 612 int (*sata_tran_ioctl)(dev_info_t *, int, intptr_t); 613 }; 614 615 typedef struct sata_hba_tran sata_hba_tran_t; 616 617 618 /* 619 * Controller's features support flags (sata_tran_hba_features_support). 620 * Note: SATA_CTLF_NCQ indicates that SATA controller supports NCQ in addition 621 * to legacy queuing commands, indicated by SATA_CTLF_QCMD flag. 622 */ 623 624 #define SATA_CTLF_ATAPI 0x001 /* ATAPI support */ 625 #define SATA_CTLF_PORT_MULTIPLIER 0x010 /* Port Multiplier suport */ 626 #define SATA_CTLF_HOTPLUG 0x020 /* Hotplug support */ 627 #define SATA_CTLF_ASN 0x040 /* Asynchronous Event Support */ 628 #define SATA_CTLF_QCMD 0x080 /* Queued commands support */ 629 #define SATA_CTLF_NCQ 0x100 /* NCQ support */ 630 631 /* 632 * sata_tran_start() return values. 633 * When pkt is not accepted, the satapkt_reason has to be updated 634 * before function returns - it should reflect the same reason for not being 635 * executed as the return status of above functions. 636 * If pkt was accepted and executed synchronously, 637 * satapk_reason should indicate a completion status. 638 */ 639 #define SATA_TRAN_ACCEPTED 0 /* accepted */ 640 #define SATA_TRAN_QUEUE_FULL 1 /* not accepted, queue full */ 641 #define SATA_TRAN_PORT_ERROR 2 /* not accepted, port error */ 642 #define SATA_TRAN_CMD_UNSUPPORTED 3 /* not accepted, cmd not supported */ 643 #define SATA_TRAN_BUSY 4 /* not accepted, busy */ 644 645 646 /* 647 * sata_tran_abort() abort type flag 648 */ 649 #define SATA_ABORT_PACKET 0 650 #define SATA_ABORT_ALL_PACKETS 1 651 652 653 /* 654 * Events handled by SATA HBA Framework 655 * More then one event may be reported at the same time 656 * 657 * SATA_EVNT__DEVICE_ATTACHED 658 * HBA detected the presence of a device ( electrical connection with 659 * a device was detected ). 660 * 661 * SATA_EVNT_DEVICE_DETACHED 662 * HBA detected the detachment of a device (electrical connection with 663 * a device was broken) 664 * 665 * SATA_EVNT_LINK_LOST 666 * HBA lost link with an attached device 667 * 668 * SATA_EVNT_LINK_ESTABLISHED 669 * HBA established a link with an attached device 670 * 671 * SATA_EVNT_PORT_FAILED 672 * HBA has determined that the port failed and is unuseable 673 * 674 * SATA_EVENT_DEVICE_RESET 675 * SATA device was reset, causing loss of the device setting 676 * 677 * SATA_EVNT_PWR_LEVEL_CHANGED 678 * A port or entire SATA controller power level has changed 679 * 680 */ 681 #define SATA_EVNT_DEVICE_ATTACHED 0x01 682 #define SATA_EVNT_DEVICE_DETACHED 0x02 683 #define SATA_EVNT_LINK_LOST 0x04 684 #define SATA_EVNT_LINK_ESTABLISHED 0x08 685 #define SATA_EVNT_PORT_FAILED 0x10 686 #define SATA_EVNT_DEVICE_RESET 0x20 687 #define SATA_EVNT_PWR_LEVEL_CHANGED 0x40 688 689 /* 690 * SATA Framework interface entry points 691 */ 692 int sata_hba_init(struct modlinkage *); 693 int sata_hba_attach(dev_info_t *, sata_hba_tran_t *, ddi_attach_cmd_t); 694 int sata_hba_detach(dev_info_t *, ddi_detach_cmd_t); 695 void sata_hba_fini(struct modlinkage *); 696 void sata_hba_event_notify(dev_info_t *, sata_device_t *, int); 697 698 699 #ifdef __cplusplus 700 } 701 #endif 702 703 #endif /* _SATA_HBA_H */ 704