/* * 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. * * Neither the name of Intel Corporation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * 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. */ #ifndef _SCIC_SDS_IO_REQUEST_H_ #define _SCIC_SDS_IO_REQUEST_H_ /** * This file contains the structures, constants and prototypes for the * SCIC_SDS_IO_REQUEST object. * * */ #include "scic_io_request.h" #include "sci_base_request.h" #include "scu_task_context.h" #include "intel_sas.h" struct scic_sds_controller; struct scic_sds_remote_device; struct scic_sds_io_request_state_handler; /** * enum _SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATES - This enumeration * depicts all of the substates for a task management request to be * performed in the STARTED super-state. * * */ enum scic_sds_raw_request_started_task_mgmt_substates { /** * The AWAIT_TC_COMPLETION sub-state indicates that the started raw * task management request is waiting for the transmission of the * initial frame (i.e. command, task, etc.). */ SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION, /** * This sub-state indicates that the started task management request * is waiting for the reception of an unsolicited frame * (i.e. response IU). */ SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE, }; /** * enum _SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATES - This enumeration depicts all * of the substates for a SMP request to be performed in the STARTED * super-state. * * */ enum scic_sds_smp_request_started_substates { /** * This sub-state indicates that the started task management request * is waiting for the reception of an unsolicited frame * (i.e. response IU). */ SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE, /** * The AWAIT_TC_COMPLETION sub-state indicates that the started SMP request is * waiting for the transmission of the initial frame (i.e. command, task, etc.). */ SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION, }; /** * struct SCIC_SDS_IO_REQUEST - This structure contains or references all of * the data necessary to process a task management or normal IO request. * * */ struct scic_sds_request { /** * This field indictes the parent object of the request. */ struct sci_base_request parent; void *user_request; /** * This field simply points to the controller to which this IO request * is associated. */ struct scic_sds_controller *owning_controller; /** * This field simply points to the remote device to which this IO request * is associated. */ struct scic_sds_remote_device *target_device; /** * This field is utilized to determine if the SCI user is managing * the IO tag for this request or if the core is managing it. */ bool was_tag_assigned_by_user; /** * This field indicates the IO tag for this request. The IO tag is * comprised of the task_index and a sequence count. The sequence count * is utilized to help identify tasks from one life to another. */ u16 io_tag; /** * This field specifies the protocol being utilized for this * IO request. */ SCIC_TRANSPORT_PROTOCOL protocol; /** * This field indicates the completion status taken from the SCUs * completion code. It indicates the completion result for the SCU hardware. */ u32 scu_status; /** * This field indicates the completion status returned to the SCI user. It * indicates the users view of the io request completion. */ u32 sci_status; /** * This field contains the value to be utilized when posting (e.g. Post_TC, * Post_TC_Abort) this request to the silicon. */ u32 post_context; void *command_buffer; void *response_buffer; struct scu_task_context *task_context_buffer; struct scu_sgl_element_pair *sgl_element_pair_buffer; /** * This field indicates if this request is a task management request or * normal IO request. */ bool is_task_management_request; /** * This field indicates that this request contains an initialized started * substate machine. */ bool has_started_substate_machine; /** * This field is a pointer to the stored rx frame data. It is used in STP * internal requests and SMP response frames. If this field is non-NULL the * saved frame must be released on IO request completion. * * @todo In the future do we want to keep a list of RX frame buffers? */ u32 saved_rx_frame_index; /** * This field specifies the data necessary to manage the sub-state * machine executed while in the SCI_BASE_REQUEST_STATE_STARTED state. */ struct sci_base_state_machine started_substate_machine; /** * This field specifies the current state handlers in place for this * IO Request object. This field is updated each time the request * changes state. */ const struct scic_sds_io_request_state_handler *state_handlers; /** * This field in the recorded device sequence for the io request. This is * recorded during the build operation and is compared in the start * operation. If the sequence is different then there was a change of * devices from the build to start operations. */ u8 device_sequence; }; typedef enum sci_status (*scic_sds_io_request_frame_handler_t)(struct scic_sds_request *req, u32 frame); typedef enum sci_status (*scic_sds_io_request_event_handler_t)(struct scic_sds_request *req, u32 event); typedef enum sci_status (*scic_sds_io_request_task_completion_handler_t)(struct scic_sds_request *req, u32 completion_code); /** * struct scic_sds_io_request_state_handler - This is the SDS core definition * of the state handlers. * * */ struct scic_sds_io_request_state_handler { struct sci_base_request_state_handler parent; scic_sds_io_request_task_completion_handler_t tc_completion_handler; scic_sds_io_request_event_handler_t event_handler; scic_sds_io_request_frame_handler_t frame_handler; }; extern const struct sci_base_state scic_sds_request_state_table[]; extern const struct scic_sds_io_request_state_handler scic_sds_request_state_handler_table[]; extern const struct sci_base_state scic_sds_io_request_started_task_mgmt_substate_table[]; extern const struct scic_sds_io_request_state_handler scic_sds_ssp_task_request_started_substate_handler_table[]; extern const struct sci_base_state scic_sds_smp_request_started_substate_table[]; extern const struct scic_sds_io_request_state_handler scic_sds_smp_request_started_substate_handler_table[]; /** * * * This macro returns the maximum number of SGL element paris that we will * support in a single IO request. */ #define SCU_MAX_SGL_ELEMENT_PAIRS ((SCU_IO_REQUEST_SGE_COUNT + 1) / 2) /** * scic_sds_request_get_controller() - * * This macro will return the controller for this io request object */ #define scic_sds_request_get_controller(this_request) \ ((this_request)->owning_controller) /** * scic_sds_request_get_device() - * * This macro will return the device for this io request object */ #define scic_sds_request_get_device(this_request) \ ((this_request)->target_device) /** * scic_sds_request_get_port() - * * This macro will return the port for this io request object */ #define scic_sds_request_get_port(this_request) \ scic_sds_remote_device_get_port(scic_sds_request_get_device(this_request)) /** * scic_sds_request_get_post_context() - * * This macro returns the constructed post context result for the io request. */ #define scic_sds_request_get_post_context(this_request) \ ((this_request)->post_context) /** * scic_sds_request_get_task_context() - * * This is a helper macro to return the os handle for this request object. */ #define scic_sds_request_get_task_context(request) \ ((request)->task_context_buffer) #define CACHE_LINE_SIZE (64) #define scic_sds_request_align_task_context_buffer(address) \ ((struct scu_task_context *)(\ (((unsigned long)(address)) + (CACHE_LINE_SIZE - 1)) \ & ~(CACHE_LINE_SIZE - 1) \ )) /** * scic_sds_request_align_sgl_element_buffer() - * * This macro will align the memory address so that it is correct for the SCU * hardware to DMA the SGL element pairs. */ #define scic_sds_request_align_sgl_element_buffer(address) \ ((struct scu_sgl_element_pair *)(\ ((char *)(address)) \ + (\ ((~(unsigned long)(address)) + 1) \ & (sizeof(struct scu_sgl_element_pair) - 1) \ ) \ )) /** * scic_sds_request_set_status() - * * This macro will set the scu hardware status and sci request completion * status for an io request. */ #define scic_sds_request_set_status(request, scu_status_code, sci_status_code) \ { \ (request)->scu_status = (scu_status_code); \ (request)->sci_status = (sci_status_code); \ } #define scic_sds_request_complete(a_request) \ ((a_request)->state_handlers->parent.complete_handler(&(a_request)->parent)) /** * scic_sds_io_request_tc_completion() - * * This macro invokes the core state task completion handler for the * SCIC_SDS_IO_REQUEST_T object. */ #define scic_sds_io_request_tc_completion(this_request, completion_code) \ { \ if (this_request->parent.state_machine.current_state_id \ == SCI_BASE_REQUEST_STATE_STARTED \ && this_request->has_started_substate_machine \ == false) \ scic_sds_request_started_state_tc_completion_handler(this_request, completion_code); \ else \ this_request->state_handlers->tc_completion_handler(this_request, completion_code); \ } /** * SCU_SGL_ZERO() - * * This macro zeros the hardware SGL element data */ #define SCU_SGL_ZERO(scu_sge) \ { \ (scu_sge).length = 0; \ (scu_sge).address_lower = 0; \ (scu_sge).address_upper = 0; \ (scu_sge).address_modifier = 0; \ } /** * SCU_SGL_COPY() - * * This macro copys the SGL Element data from the host os to the hardware SGL * elment data */ #define SCU_SGL_COPY(scu_sge, os_sge) \ { \ (scu_sge).length = sg_dma_len(sg); \ (scu_sge).address_upper = \ upper_32_bits(sg_dma_address(sg)); \ (scu_sge).address_lower = \ lower_32_bits(sg_dma_address(sg)); \ (scu_sge).address_modifier = 0; \ } /** * scic_sds_request_get_user_request() - * * This is a helper macro to return the os handle for this request object. */ #define scic_sds_request_get_user_request(request) \ ((request)->user_request) /* * ***************************************************************************** * * CORE REQUEST PROTOTYPES * ***************************************************************************** */ void scic_sds_request_build_sgl( struct scic_sds_request *this_request); void scic_sds_stp_request_assign_buffers( struct scic_sds_request *this_request); void scic_sds_smp_request_assign_buffers( struct scic_sds_request *this_request); /* --------------------------------------------------------------------------- */ enum sci_status scic_sds_request_start( struct scic_sds_request *this_request); enum sci_status scic_sds_io_request_terminate( struct scic_sds_request *this_request); enum sci_status scic_sds_io_request_complete( struct scic_sds_request *this_request); void scic_sds_io_request_copy_response( struct scic_sds_request *this_request); enum sci_status scic_sds_io_request_event_handler( struct scic_sds_request *this_request, u32 event_code); enum sci_status scic_sds_io_request_frame_handler( struct scic_sds_request *this_request, u32 frame_index); enum sci_status scic_sds_task_request_terminate( struct scic_sds_request *this_request); /* * ***************************************************************************** * * DEFAULT STATE HANDLERS * ***************************************************************************** */ enum sci_status scic_sds_request_default_start_handler( struct sci_base_request *this_request); enum sci_status scic_sds_request_default_complete_handler( struct sci_base_request *this_request); enum sci_status scic_sds_request_default_destruct_handler( struct sci_base_request *this_request); enum sci_status scic_sds_request_default_tc_completion_handler( struct scic_sds_request *this_request, u32 completion_code); enum sci_status scic_sds_request_default_event_handler( struct scic_sds_request *this_request, u32 event_code); enum sci_status scic_sds_request_default_frame_handler( struct scic_sds_request *this_request, u32 frame_index); /* * ***************************************************************************** * * STARTED STATE HANDLERS * ***************************************************************************** */ enum sci_status scic_sds_request_started_state_abort_handler( struct sci_base_request *this_request); enum sci_status scic_sds_request_started_state_tc_completion_handler( struct scic_sds_request *this_request, u32 completion_code); #endif /* _SCIC_SDS_IO_REQUEST_H_ */