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