diff options
Diffstat (limited to 'sys/dev/isci/scil/scu_task_context.h')
| -rw-r--r-- | sys/dev/isci/scil/scu_task_context.h | 965 |
1 files changed, 965 insertions, 0 deletions
diff --git a/sys/dev/isci/scil/scu_task_context.h b/sys/dev/isci/scil/scu_task_context.h new file mode 100644 index 0000000..f73ce64 --- /dev/null +++ b/sys/dev/isci/scil/scu_task_context.h @@ -0,0 +1,965 @@ +/*- + * This file is provided under a dual BSD/GPLv2 license. When using or + * redistributing this file, you may do so under either license. + * + * GPL LICENSE SUMMARY + * + * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. + * The full GNU General Public License is included in this distribution + * in the file called LICENSE.GPL. + * + * BSD LICENSE + * + * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $FreeBSD$ + */ +#ifndef _SCU_TASK_CONTEXT_H_ +#define _SCU_TASK_CONTEXT_H_ + +/** + * @file + * + * @brief This file contains the structures and constants for the SCU hardware + * task context. + */ + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +#include <dev/isci/scil/sci_types.h> + +/** + * @enum SCU_SSP_TASK_TYPE + * + * @brief This enumberation defines the various SSP task types the SCU + * hardware will accept. + * + * The definition for the various task types the SCU hardware will accept can + * be found in the DS specification. + */ +typedef enum +{ + SCU_TASK_TYPE_IOREAD, ///< IO READ direction or no direction + SCU_TASK_TYPE_IOWRITE, ///< IO Write direction + SCU_TASK_TYPE_SMP_REQUEST, ///< SMP Request type + SCU_TASK_TYPE_RESPONSE, ///< Driver generated response frame (targt mode) + SCU_TASK_TYPE_RAW_FRAME, ///< Raw frame request type + SCU_TASK_TYPE_PRIMITIVE ///< Request for a primitive to be transmitted +} SCU_SSP_TASK_TYPE; + +/** + * @enum SCU_SATA_TASK_TYPE + * + * @brief This enumeration defines the various SATA task types the SCU + * hardware will accept. + * + * The definition for the various task types the SCU hardware will accept can + * be found in the DS specification. + */ +typedef enum +{ + SCU_TASK_TYPE_DMA_IN, ///< Read request + SCU_TASK_TYPE_FPDMAQ_READ, ///< NCQ read request + SCU_TASK_TYPE_PACKET_DMA_IN, ///< Packet read request + SCU_TASK_TYPE_SATA_RAW_FRAME, ///< Raw frame request + RESERVED_4, + RESERVED_5, + RESERVED_6, + RESERVED_7, + SCU_TASK_TYPE_DMA_OUT, ///< Write request + SCU_TASK_TYPE_FPDMAQ_WRITE, ///< NCQ write Request + SCU_TASK_TYPE_PACKET_DMA_OUT ///< Packet write request +} SCU_SATA_TASK_TYPE; + + +/** + * @name SCU_CONTEXT_TYPE + */ +/*@{*/ +#define SCU_TASK_CONTEXT_TYPE 0 +#define SCU_RNC_CONTEXT_TYPE 1 +/*@}*/ + +/** + * @name SCU_TASK_CONTEXT_VALIDITY + */ +/*@{*/ +#define SCU_TASK_CONTEXT_INVALID 0 +#define SCU_TASK_CONTEXT_VALID 1 +/*@}*/ + +/** + * @name SCU_COMMAND_CODE + */ +/*@{*/ +#define SCU_COMMAND_CODE_INITIATOR_NEW_TASK 0 +#define SCU_COMMAND_CODE_ACTIVE_TASK 1 +#define SCU_COMMAND_CODE_PRIMITIVE_SEQ_TASK 2 +#define SCU_COMMAND_CODE_TARGET_RAW_FRAMES 3 +/*@}*/ + +/** + * @name SCU_TASK_PRIORITY + */ +/*@{*/ +/** + * This priority is used when there is no priority request for this request. + */ +#define SCU_TASK_PRIORITY_NORMAL 0 + +/** + * This priority indicates that the task should be scheduled to the head + * of the queue. The task will NOT be executed if the TX is suspended for + * the remote node. + */ +#define SCU_TASK_PRIORITY_HEAD_OF_Q 1 + +/** + * This priority indicates that the task will be executed before all + * SCU_TASK_PRIORITY_NORMAL and SCU_TASK_PRIORITY_HEAD_OF_Q tasks. + * The task WILL be executed if the TX is suspended for the remote node. + */ +#define SCU_TASK_PRIORITY_HIGH 2 + +/** + * This task priority is reserved and should not be used. + */ +#define SCU_TASK_PRIORITY_RESERVED 3 +/*@}*/ + +#define SCU_TASK_INITIATOR_MODE 1 +#define SCU_TASK_TARGET_MODE 0 + +#define SCU_TASK_REGULAR 0 +#define SCU_TASK_ABORTED 1 + +//direction bit defintion +/** + * @name SATA_DIRECTION + */ +/*@{*/ +#define SCU_SATA_WRITE_DATA_DIRECTION 0 +#define SCU_SATA_READ_DATA_DIRECTION 1 +/*@}*/ + +/** + * @name SCU_COMMAND_CONTEXT_MACROS + * + * These macros provide the mask and shift operations to construct the various + * SCU commands + */ +/*@{*/ +#define SCU_CONTEXT_COMMAND_REQUEST_TYPE_SHIFT 21UL +#define SCU_CONTEXT_COMMAND_REQUEST_TYPE_MASK 0x00E00000UL +#define scu_get_command_request_type(x) \ + ((x) & SCU_CONTEXT_COMMAND_REQUEST_TYPE_MASK) + +#define SCU_CONTEXT_COMMAND_REQUEST_SUBTYPE_SHIFT 18UL +#define SCU_CONTEXT_COMMAND_REQUEST_SUBTYPE_MASK 0x001C0000UL +#define scu_get_command_request_subtype(x) \ + ((x) & SCU_CONTEXT_COMMAND_REQUEST_SUBTYPE_MASK) + +#define SCU_CONTEXT_COMMAND_REQUEST_FULLTYPE_MASK \ + ( \ + SCU_CONTEXT_COMMAND_REQUEST_TYPE_MASK \ + | SCU_CONTEXT_COMMAND_REQUEST_SUBTYPE_MASK \ + ) +#define scu_get_command_request_full_type(x) \ + ((x) & SCU_CONTEXT_COMMAND_REQUEST_FULLTYPE_MASK) + +#define SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT 16UL +#define SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_MASK 0x00010000UL +#define scu_get_command_protocl_engine_group(x) \ + ((x) & SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_MASK) + +#define SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT 12UL +#define SCU_CONTEXT_COMMAND_LOGICAL_PORT_MASK 0x00007000UL +#define scu_get_command_reqeust_logical_port(x) \ + ((x) & SCU_CONTEXT_COMMAND_LOGICAL_PORT_MASK) + + +#define MAKE_SCU_CONTEXT_COMMAND_TYPE(type) \ + ((U32)(type) << SCU_CONTEXT_COMMAND_REQUEST_TYPE_SHIFT) +/*@}*/ + +/** + * @name SCU_COMMAND_TYPES + * + * These constants provide the grouping of the different SCU command types. + */ +/*@{*/ +#define SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC MAKE_SCU_CONTEXT_COMMAND_TYPE(0UL) +#define SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_TC MAKE_SCU_CONTEXT_COMMAND_TYPE(1UL) +#define SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_RNC MAKE_SCU_CONTEXT_COMMAND_TYPE(2UL) +#define SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_RNC MAKE_SCU_CONTEXT_COMMAND_TYPE(3UL) +#define SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC MAKE_SCU_CONTEXT_COMMAND_TYPE(6UL) +/*@}*/ + +#define MAKE_SCU_CONTEXT_COMMAND_REQUEST(type, command) \ + ((type) | (((U32)(command)) << SCU_CONTEXT_COMMAND_REQUEST_SUBTYPE_SHIFT)) + +/** + * @name SCU_REQUEST_TYPES + * + * These constants are the various request types that can be posted to the SCU + * hardware. + */ +/*@{*/ +#define SCU_CONTEXT_COMMAND_REQUST_POST_TC \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC, 0)) + +#define SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC, 1)) + +#define SCU_CONTEXT_COMMAND_REQUST_DUMP_TC \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_TC, 0)) + +#define SCU_CONTEXT_COMMAND_POST_RNC_32 \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_RNC, 0)) + +#define SCU_CONTEXT_COMMAND_POST_RNC_96 \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_RNC, 1)) + +#define SCU_CONTEXT_COMMAND_POST_RNC_INVALIDATE \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_RNC, 2)) + +#define SCU_CONTEXT_COMMAND_DUMP_RNC_32 \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_RNC, 0)) + +#define SCU_CONTEXT_COMMAND_DUMP_RNC_96 \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_RNC, 1)) + +#define SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC, 0)) + +#define SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX_RX \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC, 1)) + +#define SCU_CONTEXT_COMMAND_POST_RNC_RESUME \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC, 2)) + +#define SCU_CONTEXT_IT_NEXUS_LOSS_TIMER_ENABLE \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC, 3)) + +#define SCU_CONTEXT_IT_NEXUS_LOSS_TIMER_DISABLE \ + (MAKE_SCU_CONTEXT_COMMAND_REQUEST(SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC, 4)) +/*@}*/ + +/** + * @name SCU_TASK_CONTEXT_PROTOCOL + * SCU Task context protocol types this is uesd to program the SCU Task + * context protocol field in word 0x00. + */ +/*@{*/ +#define SCU_TASK_CONTEXT_PROTOCOL_SMP 0x00 +#define SCU_TASK_CONTEXT_PROTOCOL_SSP 0x01 +#define SCU_TASK_CONTEXT_PROTOCOL_STP 0x02 +#define SCU_TASK_CONTEXT_PROTOCOL_NONE 0x07 +/*@}*/ + +/** + * @struct SSP_TASK_CONTEXT + * + * @brief This is the SCU hardware definition for an SSP request. + */ +struct SSP_TASK_CONTEXT +{ + // OFFSET 0x18 + U32 reserved00 : 24; + U32 frame_type : 8; + + // OFFSET 0x1C + U32 reserved01; + + // OFFSET 0x20 + U32 fill_bytes : 2; + U32 reserved02 : 6; + U32 changing_data_pointer : 1; + U32 retransmit : 1; + U32 retry_data_frame : 1; + U32 tlr_control : 2; + U32 reserved03 : 19; + + // OFFSET 0x24 + U32 uiRsvd4; + + // OFFSET 0x28 + U32 target_port_transfer_tag : 16; + U32 tag : 16; + + // OFFSET 0x2C + U32 data_offset; +}; + +/** + * @struct STP_TASK_CONTEXT + * + * @brief This is the SCU hardware definition for an STP request. + */ +struct STP_TASK_CONTEXT +{ + // OFFSET 0x18 + U32 fis_type : 8; + U32 pm_port : 4; + U32 reserved0 : 3; + U32 control : 1; + U32 command : 8; + U32 features : 8; + + // OFFSET 0x1C + U32 reserved1; + + // OFFSET 0x20 + U32 reserved2; + + // OFFSET 0x24 + U32 reserved3; + + // OFFSET 0x28 + U32 ncq_tag : 5; + U32 reserved4 : 27; + + // OFFSET 0x2C + U32 data_offset; // TODO: What is this used for? +}; + +/** + * @struct SMP_TASK_CONTEXT + * + * @brief This is the SCU hardware definition for an SMP request. + */ +struct SMP_TASK_CONTEXT +{ + // OFFSET 0x18 + U32 response_length : 8; + U32 function_result : 8; + U32 function : 8; + U32 frame_type : 8; + + // OFFSET 0x1C + U32 smp_response_ufi : 12; + U32 reserved1 : 20; + + // OFFSET 0x20 + U32 reserved2; + + // OFFSET 0x24 + U32 reserved3; + + // OFFSET 0x28 + U32 reserved4; + + // OFFSET 0x2C + U32 reserved5; +}; + +/** + * @struct PRIMITIVE_TASK_CONTEXT + * + * @brief This is the SCU hardware definition used when the driver wants to + * send a primitive on the link. + */ +struct PRIMITIVE_TASK_CONTEXT +{ + // OFFSET 0x18 + /** + * This field is the control word and it must be 0. + */ + U32 control; ///< must be set to 0 + + // OFFSET 0x1C + /** + * This field specifies the primitive that is to be transmitted. + */ + U32 sequence; + + // OFFSET 0x20 + U32 reserved0; + + // OFFSET 0x24 + U32 reserved1; + + // OFFSET 0x28 + U32 reserved2; + + // OFFSET 0x2C + U32 reserved3; +}; + +/** + * @union PROTOCOL_CONTEXT + * + * @brief The union of the protocols that can be selected in the SCU task + * context field. + */ +union PROTOCOL_CONTEXT +{ + struct SSP_TASK_CONTEXT ssp; + struct STP_TASK_CONTEXT stp; + struct SMP_TASK_CONTEXT smp; + struct PRIMITIVE_TASK_CONTEXT primitive; + U32 words[6]; +}; + +/** + * @struct SCU_SGL_ELEMENT + * @typedef SCU_SGL_ELEMENT_T + * + * @brief This structure represents a single SCU defined SGL element. + * + * SCU SGLs contain a 64 bit address with the maximum data transfer being 24 + * bits in size. The SGL can not cross a 4GB boundary. + */ +typedef struct SCU_SGL_ELEMENT +{ + /** + * This field is the upper 32 bits of the 64 bit physical address. + */ + U32 address_upper; + + /** + * This field is the lower 32 bits of the 64 bit physical address. + */ + U32 address_lower; + + /** + * This field is the number of bytes to transfer. + */ + U32 length: 24; + + /** + * This field is the address modifier to be used when a virtual function is + * requesting a data transfer. + */ + U32 address_modifier: 8; + +} SCU_SGL_ELEMENT_T; + +#define SCU_SGL_ELEMENT_PAIR_A 0 +#define SCU_SGL_ELEMENT_PAIR_B 1 + +/** + * @struct SCU_SGL_ELEMENT_PAIR + * + * @brief This structure is the SCU hardware definition of a pair of SGL + * elements. + * + * The SCU hardware always works on SGL pairs. They are refered to in the DS + * specification as SGL A and SGL B. Each SGL pair is followed by the address + * of the next pair. + */ +typedef struct SCU_SGL_ELEMENT_PAIR +{ + // OFFSET 0x60-0x68 + /** + * This field is the SGL element A of the SGL pair. + */ + SCU_SGL_ELEMENT_T A; + + // OFFSET 0x6C-0x74 + /** + * This field is the SGL element B of the SGL pair. + */ + SCU_SGL_ELEMENT_T B; + + // OFFSET 0x78-0x7C + /** + * This field is the upper 32 bits of the 64 bit address to the next SGL + * element pair. + */ + U32 next_pair_upper; + + /** + * This field is the lower 32 bits of the 64 bit address to the next SGL + * element pair. + */ + U32 next_pair_lower; + +} SCU_SGL_ELEMENT_PAIR_T; + +/** + * @struct TRANSPORT_SNAPSHOT + * + * @brief This structure is the SCU hardware scratch area for the task + * context. + * + * This is set to 0 by the driver but can be read by issuing a dump TC request + * to the SCU. + */ +struct TRANSPORT_SNAPSHOT +{ + // OFFSET 0x48 + U32 xfer_rdy_write_data_length; + + // OFFSET 0x4C + U32 data_offset; + + // OFFSET 0x50 + U32 data_transfer_size : 24; + U32 reserved_50_0 : 8; + + // OFFSET 0x54 + U32 next_initiator_write_data_offset; + + // OFFSET 0x58 + U32 next_initiator_write_data_xfer_size : 24; + U32 reserved_58_0 : 8; +}; + +/** + * @struct SCU_TASK_CONTEXT + * + * @brief This structure defines the contents of the SCU silicon task context. + * It lays out all of the fields according to the expected order and + * location for the Storage Controller unit. + */ +typedef struct SCU_TASK_CONTEXT +{ + // OFFSET 0x00 ------ + /** + * This field must be encoded to one of the valid SCU task priority values + * - SCU_TASK_PRIORITY_NORMAL + * - SCU_TASK_PRIORITY_HEAD_OF_Q + * - SCU_TASK_PRIORITY_HIGH + */ + U32 priority : 2; + + /** + * This field must be set to TRUE if this is an initiator generated request. + * Until target mode is supported all task requests are initiator requests. + */ + U32 initiator_request : 1; + + /** + * This field must be set to one of the valid connection rates valid values + * are 0x8, 0x9, and 0xA. + */ + U32 connection_rate : 4; + + /** + * This field muse be programed when generating an SMP response since the SMP + * connection remains open until the SMP response is generated. + */ + U32 protocol_engine_index : 3; + + /** + * This field must contain the logical port for the task request. + */ + U32 logical_port_index : 3; + + /** + * This field must be set to one of the SCU_TASK_CONTEXT_PROTOCOL values + * - SCU_TASK_CONTEXT_PROTOCOL_SMP + * - SCU_TASK_CONTEXT_PROTOCOL_SSP + * - SCU_TASK_CONTEXT_PROTOCOL_STP + * - SCU_TASK_CONTEXT_PROTOCOL_NONE + */ + U32 protocol_type : 3; + + /** + * This filed must be set to the TCi allocated for this task + */ + U32 task_index : 12; + + /** + * This field is reserved and must be set to 0x00 + */ + U32 reserved_00_0 : 1; + + /** + * For a normal task request this must be set to 0. If this is an abort of + * this task request it must be set to 1. + */ + U32 abort : 1; + + /** + * This field must be set to TRUE for the SCU hardware to process the task. + */ + U32 valid : 1; + + /** + * This field must be set to SCU_TASK_CONTEXT_TYPE + */ + U32 context_type : 1; + + // OFFSET 0x04 + /** + * This field contains the RNi that is the target of this request. + */ + U32 remote_node_index : 12; + + /** + * This field is programmed if this is a mirrored request, which we are not + * using, in which case it is the RNi for the mirrored target. + */ + U32 mirrored_node_index : 12; + + /** + * This field is programmed with the direction of the SATA reqeust + * - SCU_SATA_WRITE_DATA_DIRECTION + * - SCU_SATA_READ_DATA_DIRECTION + */ + U32 sata_direction : 1; + + /** + * This field is programmsed with one of the following SCU_COMMAND_CODE + * - SCU_COMMAND_CODE_INITIATOR_NEW_TASK + * - SCU_COMMAND_CODE_ACTIVE_TASK + * - SCU_COMMAND_CODE_PRIMITIVE_SEQ_TASK + * - SCU_COMMAND_CODE_TARGET_RAW_FRAMES + */ + U32 command_code : 2; + + /** + * This field is set to TRUE if the remote node should be suspended. + * This bit is only valid for SSP & SMP target devices. + */ + U32 suspend_node : 1; + + /** + * This field is programmed with one of the following command type codes + * + * For SAS requests use the SCU_SSP_TASK_TYPE + * - SCU_TASK_TYPE_IOREAD + * - SCU_TASK_TYPE_IOWRITE + * - SCU_TASK_TYPE_SMP_REQUEST + * - SCU_TASK_TYPE_RESPONSE + * - SCU_TASK_TYPE_RAW_FRAME + * - SCU_TASK_TYPE_PRIMITIVE + * + * For SATA requests use the SCU_SATA_TASK_TYPE + * - SCU_TASK_TYPE_DMA_IN + * - SCU_TASK_TYPE_FPDMAQ_READ + * - SCU_TASK_TYPE_PACKET_DMA_IN + * - SCU_TASK_TYPE_SATA_RAW_FRAME + * - SCU_TASK_TYPE_DMA_OUT + * - SCU_TASK_TYPE_FPDMAQ_WRITE + * - SCU_TASK_TYPE_PACKET_DMA_OUT + */ + U32 task_type : 4; + + // OFFSET 0x08 + /** + * This field is reserved and the must be set to 0x00 + */ + U32 link_layer_control : 8; // presently all reserved + + /** + * This field is set to TRUE when TLR is to be enabled + */ + U32 ssp_tlr_enable : 1; + + /** + * This is field specifies if the SCU DMAs a response frame to host + * memory for good response frames when operating in target mode. + */ + U32 dma_ssp_target_good_response : 1; + + /** + * This field indicates if the SCU should DMA the response frame to + * host memory. + */ + U32 do_not_dma_ssp_good_response : 1; + + /** + * This field is set to TRUE when strict ordering is to be enabled + */ + U32 strict_ordering : 1; + + /** + * This field indicates the type of endianess to be utilized for the + * frame. command, task, and response frames utilized control_frame + * set to 1. + */ + U32 control_frame : 1; + + /** + * This field is reserved and the driver should set to 0x00 + */ + U32 tl_control_reserved : 3; + + /** + * This field is set to TRUE when the SCU hardware task timeout control is to + * be enabled + */ + U32 timeout_enable : 1; + + /** + * This field is reserved and the driver should set it to 0x00 + */ + U32 pts_control_reserved : 7; + + /** + * This field should be set to TRUE when block guard is to be enabled + */ + U32 block_guard_enable : 1; + + /** + * This field is reserved and the driver should set to 0x00 + */ + U32 sdma_control_reserved : 7; + + // OFFSET 0x0C + /** + * This field is the address modifier for this io request it should be + * programmed with the virtual function that is making the request. + */ + U32 address_modifier : 16; + + /** + * @todo What we support mirrored SMP response frame? + */ + U32 mirrored_protocol_engine : 3; // mirrored protocol Engine Index + + /** + * If this is a mirrored request the logical port index for the mirrored RNi + * must be programmed. + */ + U32 mirrored_logical_port : 4; // mirrored local port index + + /** + * This field is reserved and the driver must set it to 0x00 + */ + U32 reserved_0C_0 : 8; + + /** + * This field must be set to TRUE if the mirrored request processing is to be + * enabled. + */ + U32 mirror_request_enable : 1; // Mirrored request Enable + + // OFFSET 0x10 + /** + * This field is the command iu length in dwords + */ + U32 ssp_command_iu_length : 8; + + /** + * This is the target TLR enable bit it must be set to 0 when creatning the + * task context. + */ + U32 xfer_ready_tlr_enable : 1; + + /** + * This field is reserved and the driver must set it to 0x00 + */ + U32 reserved_10_0 : 7; + + /** + * This is the maximum burst size that the SCU hardware will send in one + * connection its value is (N x 512) and N must be a multiple of 2. If the + * value is 0x00 then maximum burst size is disabled. + */ + U32 ssp_max_burst_size : 16; + + // OFFSET 0x14 + /** + * This filed is set to the number of bytes to be transfered in the request. + */ + U32 transfer_length_bytes : 24; // In terms of bytes + + /** + * This field is reserved and the driver should set it to 0x00 + */ + U32 reserved_14_0 : 8; + + // OFFSET 0x18-0x2C + /** + * This union provides for the protocol specif part of the SCU Task Context. + */ + union PROTOCOL_CONTEXT type; + + // OFFSET 0x30-0x34 + /** + * This field is the upper 32 bits of the 64 bit physical address of the + * command iu buffer + */ + U32 command_iu_upper; + + /** + * This field is the lower 32 bits of the 64 bit physical address of the + * command iu buffer + */ + U32 command_iu_lower; + + // OFFSET 0x38-0x3C + /** + * This field is the upper 32 bits of the 64 bit physical address of the + * response iu buffer + */ + U32 response_iu_upper; + + /** + * This field is the lower 32 bits of the 64 bit physical address of the + * response iu buffer + */ + U32 response_iu_lower; + + // OFFSET 0x40 + /** + * This field is set to the task phase of the SCU hardware. The driver must + * set this to 0x01 + */ + U32 task_phase : 8; + + /** + * This field is set to the transport layer task status. The driver must set + * this to 0x00 + */ + U32 task_status : 8; + + /** + * This field is used during initiator write TLR + */ + U32 previous_extended_tag : 4; + + /** + * This field is set the maximum number of retries for a STP non-data FIS + */ + U32 stp_retry_count : 2; + + /** + * This field is reserved and the driver must set it to 0x00 + */ + U32 reserved_40_1 : 2; + + /** + * This field is used by the SCU TL to determine when to take a snapshot when + * tranmitting read data frames. + * - 0x00 The entire IO + * - 0x01 32k + * - 0x02 64k + * - 0x04 128k + * - 0x08 256k + */ + U32 ssp_tlr_threshold : 4; + + /** + * This field is reserved and the driver must set it to 0x00 + */ + U32 reserved_40_2 : 4; + + // OFFSET 0x44 + U32 write_data_length; // read only set to 0 + + // OFFSET 0x48-0x58 + struct TRANSPORT_SNAPSHOT snapshot; // read only set to 0 + + // OFFSET 0x5C + U32 block_protection_enable : 1; + U32 block_size : 2; + U32 block_protection_function : 2; + U32 reserved_5C_0 : 9; + U32 active_sgl_element : 2; // read only set to 0 + U32 sgl_exhausted : 1; // read only set to 0 + U32 payload_data_transfer_error : 4; // read only set to 0 + U32 frame_buffer_offset : 11; // read only set to 0 + + // OFFSET 0x60-0x7C + /** + * This field is the first SGL element pair found in the TC data structure. + */ + SCU_SGL_ELEMENT_PAIR_T sgl_pair_ab; + // OFFSET 0x80-0x9C + /** + * This field is the second SGL element pair found in the TC data structure. + */ + SCU_SGL_ELEMENT_PAIR_T sgl_pair_cd; + + // OFFSET 0xA0-BC + SCU_SGL_ELEMENT_PAIR_T sgl_snapshot_ac; + + // OFFSET 0xC0 + U32 active_sgl_element_pair; // read only set to 0 + + // OFFSET 0xC4-0xCC + U32 reserved_C4_CC[3]; + + // OFFSET 0xD0 + U32 intermediate_crc_value : 16; + U32 initial_crc_seed : 16; + + // OFFSET 0xD4 + U32 application_tag_for_verify : 16; + U32 application_tag_for_generate : 16; + + // OFFSET 0xD8 + U32 reference_tag_seed_for_verify_function; + + // OFFSET 0xDC + U32 reserved_DC; + + // OFFSET 0xE0 + U32 reserved_E0_0 : 16; + U32 application_tag_mask_for_generate: 16; + + // OFFSET 0xE4 + U32 block_protection_control : 16; + U32 application_tag_mask_for_verify : 16; + + // OFFSET 0xE8 + U32 block_protection_error : 8; + U32 reserved_E8_0 :24; + + // OFFSET 0xEC + U32 reference_tag_seed_for_verify; + + // OFFSET 0xF0 + U32 intermediate_crc_valid_snapshot : 16; + U32 reserved_F0_0 : 16; + + // OFFSET 0xF4 + U32 reference_tag_seed_for_verify_function_snapshot; + + // OFFSET 0xF8 + U32 snapshot_of_reserved_dword_DC_of_tc; + + // OFFSET 0xFC + U32 reference_tag_seed_for_generate_function_snapshot; + +} SCU_TASK_CONTEXT_T; + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif // _SCU_TASK_CONTEXT_H_ |
