| Current Path : /sys/amd64/compile/hs32/modules/usr/src/sys/modules/sound/driver/driver/@/dev/isci/scil/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //sys/amd64/compile/hs32/modules/usr/src/sys/modules/sound/driver/driver/@/dev/isci/scil/scic_sds_stp_packet_request.c |
/*-
* 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.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: release/9.1.0/sys/dev/isci/scil/scic_sds_stp_packet_request.c 231689 2012-02-14 15:58:49Z jimharris $");
#if !defined(DISABLE_ATAPI)
#include <dev/isci/scil/scic_sds_stp_packet_request.h>
#include <dev/isci/scil/scic_sds_logger.h>
#include <dev/isci/scil/scic_sds_controller.h>
#include <dev/isci/scil/scic_sds_remote_device.h>
#include <dev/isci/scil/scic_remote_device.h>
#include <dev/isci/scil/sci_util.h>
#include <dev/isci/scil/intel_sas.h>
#include <dev/isci/scil/intel_ata.h>
#include <dev/isci/scil/intel_sata.h>
#include <dev/isci/scil/scic_user_callback.h>
#include <dev/isci/sci_environment.h>
#include <dev/isci/scil/intel_sat.h>
#include <dev/isci/scil/scic_sds_request.h>
#include <dev/isci/scil/scic_controller.h>
#include <dev/isci/scil/scu_completion_codes.h>
#include <dev/isci/scil/scu_task_context.h>
#include <dev/isci/scil/scic_sds_stp_packet_request.h>
#include <dev/isci/scil/sci_base_state.h>
/**
* @brief This method will fill in the SCU Task Context for a PACKET fis. And
* construct the request STARTED sub-state machine for Packet Protocol
* IO.
*
* @param[in] this_request This parameter specifies the stp packet request object
* being constructed.
*
* @return none
*/
SCI_STATUS scic_sds_stp_packet_request_construct(
SCIC_SDS_REQUEST_T *this_request
)
{
SATA_FIS_REG_H2D_T * h2d_fis =
scic_stp_io_request_get_h2d_reg_address(
this_request
);
// Work around, we currently only support PACKET DMA protocol, so we
// need to make change to Packet Fis features field.
h2d_fis->features = h2d_fis->features | ATA_PACKET_FEATURE_DMA;
scic_sds_stp_non_ncq_request_construct(this_request);
// Build the Packet Fis task context structure
scu_stp_raw_request_construct_task_context(
(SCIC_SDS_STP_REQUEST_T*) this_request,
this_request->task_context_buffer
);
sci_base_state_machine_construct(
&this_request->started_substate_machine,
&this_request->parent.parent,
scic_sds_stp_packet_request_started_substate_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
);
return SCI_SUCCESS;
}
/**
* @brief This method will fill in the SCU Task Context for a Packet request
* command phase in PACKET DMA DATA (IN/OUT) type. The following
* important settings are utilized:
*
* -# task_type == SCU_TASK_TYPE_PACKET_DMA. This simply indicates
* that a normal request type (i.e. non-raw frame) is being
* utilized to perform task management.
* -# control_frame == 1. This ensures that the proper endianess
* is set so that the bytes are transmitted in the right order
* for a smp request frame.
*
* @param[in] this_request This parameter specifies the smp request object
* being constructed.
* @param[in] task_context The task_context to be reconstruct for packet
* request command phase.
* @return none
*/
void scu_stp_packet_request_command_phase_construct_task_context(
SCIC_SDS_REQUEST_T * this_request,
SCU_TASK_CONTEXT_T * task_context
)
{
void * atapi_cdb;
U32 atapi_cdb_length;
SCIC_SDS_STP_REQUEST_T * stp_request = (SCIC_SDS_STP_REQUEST_T *)this_request;
// reference: SSTL 1.13.4.2
// task_type, sata_direction
if ( scic_cb_io_request_get_data_direction(this_request->user_request)
== SCI_IO_REQUEST_DATA_OUT )
{
task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_OUT;
task_context->sata_direction = 0;
}
else // todo: for NO_DATA command, we need to send out raw frame.
{
task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_IN;
task_context->sata_direction = 1;
}
// sata header
memset(&(task_context->type.stp), 0, sizeof(struct STP_TASK_CONTEXT));
task_context->type.stp.fis_type = SATA_FIS_TYPE_DATA;
// Copy in the command IU with CDB so that the commandIU address doesn't
// change.
memset(this_request->command_buffer, 0, sizeof(SATA_FIS_REG_H2D_T));
atapi_cdb =
scic_cb_stp_packet_io_request_get_cdb_address(this_request->user_request);
atapi_cdb_length =
scic_cb_stp_packet_io_request_get_cdb_length(this_request->user_request);
memcpy(((U8 *)this_request->command_buffer+sizeof(U32)), atapi_cdb, atapi_cdb_length);
atapi_cdb_length =
MAX(atapi_cdb_length, stp_request->type.packet.device_preferred_cdb_length);
task_context->ssp_command_iu_length =
((atapi_cdb_length % 4) == 0) ?
(atapi_cdb_length / 4) : ((atapi_cdb_length / 4) + 1);
// task phase is set to TX_CMD
task_context->task_phase = 0x1;
// retry counter
task_context->stp_retry_count = 0;
if (scic_cb_request_is_initial_construction(this_request->user_request))
{
// data transfer size.
task_context->transfer_length_bytes =
scic_cb_io_request_get_transfer_length(this_request->user_request);
// sgls were already built when request was constructed, so don't need to
// to do it here
}
else
{
// data transfer size, need to be 4 bytes aligned.
task_context->transfer_length_bytes = (SCSI_FIXED_SENSE_DATA_BASE_LENGTH + 2);
scic_sds_stp_packet_internal_request_sense_build_sgl(this_request);
}
}
/**
* @brief This method will fill in the SCU Task Context for a DATA fis
* containing CDB in Raw Frame type. The TC for previous Packet
* fis was already there, we only need to change the H2D fis content.
*
* @param[in] this_request This parameter specifies the smp request object
* being constructed.
* @param[in] task_context The task_context to be reconstruct for packet
* request command phase.
* @return none
*/
void scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
SCIC_SDS_REQUEST_T * this_request,
SCU_TASK_CONTEXT_T * task_context
)
{
void * atapi_cdb =
scic_cb_stp_packet_io_request_get_cdb_address(this_request->user_request);
U32 atapi_cdb_length =
scic_cb_stp_packet_io_request_get_cdb_length(this_request->user_request);
memset(this_request->command_buffer, 0, sizeof(SATA_FIS_REG_H2D_T));
memcpy( ((U8 *)this_request->command_buffer+sizeof(U32)), atapi_cdb, atapi_cdb_length);
memset(&(task_context->type.stp), 0, sizeof(struct STP_TASK_CONTEXT));
task_context->type.stp.fis_type = SATA_FIS_TYPE_DATA;
//Note the data send out has to be 4 bytes aligned. Or else out hardware will
//patch non-zero bytes and cause the target device unhappy.
task_context->transfer_length_bytes = 12;
}
/*
*@brief This methods decode the D2H status FIS and retrieve the sense data,
* then pass the sense data to user request.
*
*@param[in] this_request The request receive D2H status FIS.
*@param[in] status_fis The D2H status fis to be processed.
*
*/
SCI_STATUS scic_sds_stp_packet_request_process_status_fis(
SCIC_SDS_REQUEST_T * this_request,
SATA_FIS_REG_D2H_T * status_fis
)
{
SCI_STATUS status = SCI_SUCCESS;
//TODO: Process the error status fis, retrieve sense data.
if (status_fis->status & ATA_STATUS_REG_ERROR_BIT)
status = SCI_FAILURE_IO_RESPONSE_VALID;
return status;
}
/*
*@brief This methods builds sgl for internal REQUEST SENSE stp packet
* command using this request response buffer, only one sge is
* needed.
*
*@param[in] this_request The request receive request sense data.
*
*/
void scic_sds_stp_packet_internal_request_sense_build_sgl(
SCIC_SDS_REQUEST_T * this_request
)
{
void *sge;
SCU_SGL_ELEMENT_PAIR_T *scu_sgl_list = NULL;
SCU_TASK_CONTEXT_T *task_context;
SCI_PHYSICAL_ADDRESS physical_address;
SCI_SSP_RESPONSE_IU_T * rsp_iu =
(SCI_SSP_RESPONSE_IU_T *)this_request->response_buffer;
sge = (void*)&rsp_iu->data[0];
task_context = (SCU_TASK_CONTEXT_T *)this_request->task_context_buffer;
scu_sgl_list = &task_context->sgl_pair_ab;
scic_cb_io_request_get_physical_address(
scic_sds_request_get_controller(this_request),
this_request,
((char *)sge),
&physical_address
);
scu_sgl_list->A.address_upper = sci_cb_physical_address_upper(physical_address);
scu_sgl_list->A.address_lower = sci_cb_physical_address_lower(physical_address);
scu_sgl_list->A.length = task_context->transfer_length_bytes;
scu_sgl_list->A.address_modifier = 0;
SCU_SGL_ZERO(scu_sgl_list->B);
}
//******************************************************************************
//* STP PACKET REQUEST STATE MACHINES
//******************************************************************************
/**
* @brief This method processes the completions transport layer (TL) status
* to determine if the Packet FIS was sent successfully. If the Packet
* FIS was sent successfully, then the state for the Packet request
* transits to waiting for a PIO SETUP frame.
*
* @param[in] this_request This parameter specifies the request for which
* the TC completion was received.
* @param[in] completion_code This parameter indicates the completion status
* information for the TC.
*
* @return Indicate if the tc completion handler was successful.
* @retval SCI_SUCCESS currently this method always returns success.
*/
static
SCI_STATUS scic_sds_stp_packet_request_packet_phase_await_tc_completion_tc_completion_handler(
SCIC_SDS_REQUEST_T * this_request,
U32 completion_code
)
{
SCI_STATUS status = SCI_SUCCESS;
SCIC_LOG_TRACE((
sci_base_object_get_logger(this_request),
SCIC_LOG_OBJECT_STP_IO_REQUEST,
"scic_sds_stp_packet_request_packet_phase_await_tc_completion_tc_completion_handler(0x%x, 0x%x) enter\n",
this_request, completion_code
));
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code))
{
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_request_set_status(
this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
&this_request->started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_PIO_SETUP_SUBSTATE
);
break;
default:
// All other completion status cause the IO to be complete. If a NAK
// was received, then it is up to the user to retry the request.
scic_sds_request_set_status(
this_request,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
sci_base_state_machine_change_state(
&this_request->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
break;
}
return status;
}
/**
* @brief This method processes an unsolicited frame while the Packet request
* is waiting for a PIO SETUP FIS. It will release
* the unsolicited frame, and transition the request to the
* COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE state.
*
* @param[in] this_request This parameter specifies the request for which
* the unsolicited frame was received.
* @param[in] frame_index This parameter indicates the unsolicited frame
* index that should contain the response.
*
* @return This method returns an indication of whether the pio setup
* frame was handled successfully or not.
* @retval SCI_SUCCESS Currently this value is always returned and indicates
* successful processing of the TC response.
*
*/
static
SCI_STATUS scic_sds_stp_packet_request_packet_phase_await_pio_setup_frame_handler(
SCIC_SDS_REQUEST_T * request,
U32 frame_index
)
{
SCI_STATUS status;
SATA_FIS_HEADER_T * frame_header;
U32 * frame_buffer;
SCIC_SDS_STP_REQUEST_T * this_request;
this_request = (SCIC_SDS_STP_REQUEST_T *)request;
SCIC_LOG_TRACE((
sci_base_object_get_logger(this_request),
SCIC_LOG_OBJECT_STP_IO_REQUEST,
"scic_sds_stp_packet_request_packet_phase_await_pio_setup_frame_handler(0x%x, 0x%x) enter\n",
this_request, frame_index
));
status = scic_sds_unsolicited_frame_control_get_header(
&(this_request->parent.owning_controller->uf_control),
frame_index,
(void**) &frame_header
);
if (status == SCI_SUCCESS)
{
ASSERT(frame_header->fis_type == SATA_FIS_TYPE_PIO_SETUP);
// Get from the frame buffer the PIO Setup Data, although we don't need
// any info from this pio setup fis.
scic_sds_unsolicited_frame_control_get_buffer(
&(this_request->parent.owning_controller->uf_control),
frame_index,
(void**) &frame_buffer
);
// Get the data from the PIO Setup
// The SCU Hardware returns first word in the frame_header and the rest
// of the data is in the frame buffer so we need to back up one dword
this_request->type.packet.device_preferred_cdb_length =
(U16)((SATA_FIS_PIO_SETUP_T *)(&frame_buffer[-1]))->transfter_count;
// Frame has been decoded return it to the controller
scic_sds_controller_release_frame(
this_request->parent.owning_controller, frame_index
);
sci_base_state_machine_change_state(
&this_request->parent.started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
);
}
else
{
SCIC_LOG_ERROR((
sci_base_object_get_logger(this_request),
SCIC_LOG_OBJECT_STP_IO_REQUEST,
"SCIC IO Request 0x%x could not get frame header for frame index %d, status %x\n",
this_request, frame_index, status
));
}
return status;
}
/**
* @brief This method processes the completions transport layer (TL) status
* to determine if the PACKET command data FIS was sent successfully.
* If successfully, then the state for the packet request
* transits to COMPLETE state. If not successfuly, the request transits
* to COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE.
*
* @param[in] this_request This parameter specifies the request for which
* the TC completion was received.
* @param[in] completion_code This parameter indicates the completion status
* information for the TC.
*
* @return Indicate if the tc completion handler was successful.
* @retval SCI_SUCCESS currently this method always returns success.
*/
static
SCI_STATUS scic_sds_stp_packet_request_command_phase_await_tc_completion_tc_completion_handler(
SCIC_SDS_REQUEST_T * this_request,
U32 completion_code
)
{
SCI_STATUS status = SCI_SUCCESS;
U8 sat_packet_protocol = this_request->sat_protocol;
SCIC_LOG_TRACE((
sci_base_object_get_logger(this_request),
SCIC_LOG_OBJECT_STP_IO_REQUEST,
"scic_sds_stp_packet_request_command_phase_await_tc_completion_tc_completion_handler(0x%x, 0x%x) enter\n",
this_request, completion_code
));
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code))
{
case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
scic_sds_request_set_status(
this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
if ( sat_packet_protocol == SAT_PROTOCOL_PACKET_DMA_DATA_IN
|| sat_packet_protocol == SAT_PROTOCOL_PACKET_DMA_DATA_OUT
)
sci_base_state_machine_change_state(
&this_request->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
else
sci_base_state_machine_change_state(
&this_request->started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
);
break;
case (SCU_TASK_DONE_UNEXP_FIS << SCU_COMPLETION_TL_STATUS_SHIFT):
if (scic_io_request_get_number_of_bytes_transferred(this_request) <
scic_cb_io_request_get_transfer_length(this_request->user_request))
{
scic_sds_request_set_status(
this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS_IO_DONE_EARLY
);
sci_base_state_machine_change_state(
&this_request->started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMPLETION_DELAY_SUBSTATE
);
//change the device state to ATAPI_ERROR.
sci_base_state_machine_change_state(
&this_request->target_device->ready_substate_machine,
SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_ATAPI_ERROR
);
status = this_request->sci_status;
}
break;
case (SCU_TASK_DONE_EXCESS_DATA << SCU_COMPLETION_TL_STATUS_SHIFT):
//In this case, there is no UF coming after. compelte the IO now.
scic_sds_request_set_status(
this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
&this_request->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
break;
default:
if (this_request->sci_status != SCI_SUCCESS)
{ //The io status was set already. This means an UF for the status
//fis was received already.
//A device suspension event is expected, we need to have the device
//coming out of suspension, then complete the IO.
sci_base_state_machine_change_state(
&this_request->started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMPLETION_DELAY_SUBSTATE
);
//change the device state to ATAPI_ERROR.
sci_base_state_machine_change_state(
&this_request->target_device->ready_substate_machine,
SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_ATAPI_ERROR
);
status = this_request->sci_status;
}
else
{ //If receiving any non-sucess TC status, no UF received yet, then an UF for
//the status fis is coming after.
scic_sds_request_set_status(
this_request,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
sci_base_state_machine_change_state(
&this_request->started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
);
}
break;
}
return status;
}
/**
* @brief This method processes an unsolicited frame.
*
* @param[in] this_request This parameter specifies the request for which
* the unsolicited frame was received.
* @param[in] frame_index This parameter indicates the unsolicited frame
* index that should contain the response.
*
* @return This method returns an indication of whether the UF
* frame was handled successfully or not.
* @retval SCI_SUCCESS Currently this value is always returned and indicates
* successful processing of the TC response.
*
*/
static
SCI_STATUS scic_sds_stp_packet_request_command_phase_common_frame_handler(
SCIC_SDS_REQUEST_T * request,
U32 frame_index
)
{
SCI_STATUS status;
SATA_FIS_HEADER_T * frame_header;
U32 * frame_buffer;
SCIC_SDS_STP_REQUEST_T * this_request;
this_request = (SCIC_SDS_STP_REQUEST_T *)request;
SCIC_LOG_TRACE((
sci_base_object_get_logger(this_request),
SCIC_LOG_OBJECT_STP_IO_REQUEST,
"scic_sds_stp_packet_request_command_phase_await_d2h_frame_handler(0x%x, 0x%x) enter\n",
this_request, frame_index
));
status = scic_sds_unsolicited_frame_control_get_header(
&(this_request->parent.owning_controller->uf_control),
frame_index,
(void**) &frame_header
);
if (status == SCI_SUCCESS)
{
ASSERT(frame_header->fis_type == SATA_FIS_TYPE_REGD2H);
// Get from the frame buffer the PIO Setup Data, although we don't need
// any info from this pio setup fis.
scic_sds_unsolicited_frame_control_get_buffer(
&(this_request->parent.owning_controller->uf_control),
frame_index,
(void**) &frame_buffer
);
scic_sds_controller_copy_sata_response(
&this_request->d2h_reg_fis, (U32 *)frame_header, frame_buffer
);
// Frame has been decoded return it to the controller
scic_sds_controller_release_frame(
this_request->parent.owning_controller, frame_index
);
}
return status;
}
/**
* @brief This method processes an unsolicited frame while the packet request is
* expecting TC completion. It will process the FIS and construct sense
* data.
*
* @param[in] this_request This parameter specifies the request for which
* the unsolicited frame was received.
* @param[in] frame_index This parameter indicates the unsolicited frame
* index that should contain the response.
*
* @return This method returns an indication of whether the UF
* frame was handled successfully or not.
* @retval SCI_SUCCESS Currently this value is always returned and indicates
* successful processing of the TC response.
*
*/
static
SCI_STATUS scic_sds_stp_packet_request_command_phase_await_tc_completion_frame_handler(
SCIC_SDS_REQUEST_T * request,
U32 frame_index
)
{
SCIC_SDS_STP_REQUEST_T * this_request = (SCIC_SDS_STP_REQUEST_T *)request;
SCI_STATUS status =
scic_sds_stp_packet_request_command_phase_common_frame_handler(
request, frame_index);
if (status == SCI_SUCCESS)
{
// The command has completed with error status from target device.
status = scic_sds_stp_packet_request_process_status_fis(
request, &this_request->d2h_reg_fis);
if (status != SCI_SUCCESS)
{
scic_sds_request_set_status(
&this_request->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
status
);
}
else
scic_sds_request_set_status(
&this_request->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
}
return status;
}
/**
* @brief This method processes an unsolicited frame while the packet request is
* expecting TC completion. It will process the FIS and construct sense
* data.
*
* @param[in] this_request This parameter specifies the request for which
* the unsolicited frame was received.
* @param[in] frame_index This parameter indicates the unsolicited frame
* index that should contain the response.
*
* @return This method returns an indication of whether the UF
* frame was handled successfully or not.
* @retval SCI_SUCCESS Currently this value is always returned and indicates
* successful processing of the TC response.
*
*/
static
SCI_STATUS scic_sds_stp_packet_request_command_phase_await_d2h_fis_frame_handler(
SCIC_SDS_REQUEST_T * request,
U32 frame_index
)
{
SCI_STATUS status =
scic_sds_stp_packet_request_command_phase_common_frame_handler(
request, frame_index);
SCIC_SDS_STP_REQUEST_T * this_request = (SCIC_SDS_STP_REQUEST_T *)request;
if (status == SCI_SUCCESS)
{
// The command has completed with error status from target device.
status = scic_sds_stp_packet_request_process_status_fis(
request, &this_request->d2h_reg_fis);
if (status != SCI_SUCCESS)
{
scic_sds_request_set_status(
request,
SCU_TASK_DONE_CHECK_RESPONSE,
status
);
}
else
scic_sds_request_set_status(
request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
//Always complete the NON_DATA command right away, no need to delay completion
//even an error status fis came from target device.
sci_base_state_machine_change_state(
&request->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
}
return status;
}
static
SCI_STATUS scic_sds_stp_packet_request_started_completion_delay_complete_handler(
SCI_BASE_REQUEST_T *request
)
{
SCIC_SDS_REQUEST_T * this_request = (SCIC_SDS_REQUEST_T *)request;
sci_base_state_machine_change_state(
&this_request->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
return this_request->sci_status;
}
// ---------------------------------------------------------------------------
SCIC_SDS_IO_REQUEST_STATE_HANDLER_T
scic_sds_stp_packet_request_started_substate_handler_table
[SCIC_SDS_STP_PACKET_REQUEST_STARTED_MAX_SUBSTATES] =
{
// SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
{
{
scic_sds_request_default_start_handler,
scic_sds_request_started_state_abort_handler,
scic_sds_request_default_complete_handler,
scic_sds_request_default_destruct_handler
},
scic_sds_stp_packet_request_packet_phase_await_tc_completion_tc_completion_handler,
scic_sds_request_default_event_handler,
scic_sds_request_default_frame_handler
},
// SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_PIO_SETUP_SUBSTATE
{
{
scic_sds_request_default_start_handler,
scic_sds_request_started_state_abort_handler,
scic_sds_request_default_complete_handler,
scic_sds_request_default_destruct_handler
},
scic_sds_request_default_tc_completion_handler,
scic_sds_request_default_event_handler,
scic_sds_stp_packet_request_packet_phase_await_pio_setup_frame_handler
},
// SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
{
{
scic_sds_request_default_start_handler,
scic_sds_request_started_state_abort_handler,
scic_sds_request_default_complete_handler,
scic_sds_request_default_destruct_handler
},
scic_sds_stp_packet_request_command_phase_await_tc_completion_tc_completion_handler,
scic_sds_request_default_event_handler,
scic_sds_stp_packet_request_command_phase_await_tc_completion_frame_handler
},
// SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
{
{
scic_sds_request_default_start_handler,
scic_sds_request_started_state_abort_handler,
scic_sds_request_default_complete_handler,
scic_sds_request_default_destruct_handler
},
scic_sds_request_default_tc_completion_handler,
scic_sds_request_default_event_handler,
scic_sds_stp_packet_request_command_phase_await_d2h_fis_frame_handler
},
// SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMPLETION_DELAY_SUBSTATE
{
{
scic_sds_request_default_start_handler,
scic_sds_request_started_state_abort_handler,
scic_sds_stp_packet_request_started_completion_delay_complete_handler,
scic_sds_request_default_destruct_handler
},
scic_sds_request_default_tc_completion_handler,
scic_sds_request_default_event_handler,
scic_sds_request_default_frame_handler
}
};
/**
* @file
*
* @brief This file contains the Packet IO started substate machine
* for the SCIC_SDS_IO_REQUEST object.
*/
static
void scic_sds_stp_packet_request_started_packet_phase_await_tc_completion_enter(
SCI_BASE_OBJECT_T *object
)
{
SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
SET_STATE_HANDLER(
this_request,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
);
scic_sds_remote_device_set_working_request(
this_request->target_device, this_request
);
}
static
void scic_sds_stp_packet_request_started_packet_phase_await_pio_setup_enter(
SCI_BASE_OBJECT_T *object
)
{
SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
SET_STATE_HANDLER(
this_request,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_PIO_SETUP_SUBSTATE
);
}
static
void scic_sds_stp_packet_request_started_command_phase_await_tc_completion_enter(
SCI_BASE_OBJECT_T *object
)
{
SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
U8 sat_packet_protocol = this_request->sat_protocol;
SCU_TASK_CONTEXT_T *task_context;
SCI_STATUS status;
// Recycle the TC and reconstruct it for sending out data fis containing
// CDB.
task_context = scic_sds_controller_get_task_context_buffer(
this_request->owning_controller, this_request->io_tag);
if (sat_packet_protocol == SAT_PROTOCOL_PACKET_NON_DATA)
scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
this_request, task_context);
else
scu_stp_packet_request_command_phase_construct_task_context(
this_request, task_context);
// send the new TC out.
status = this_request->owning_controller->state_handlers->parent.continue_io_handler(
&this_request->owning_controller->parent,
&this_request->target_device->parent,
&this_request->parent
);
if (status == SCI_SUCCESS)
SET_STATE_HANDLER(
this_request,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
);
}
static
void scic_sds_stp_packet_request_started_command_phase_await_d2h_fis_enter(
SCI_BASE_OBJECT_T *object
)
{
SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
SET_STATE_HANDLER(
this_request,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
);
}
static
void scic_sds_stp_packet_request_started_completion_delay_enter(
SCI_BASE_OBJECT_T *object
)
{
SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
SET_STATE_HANDLER(
this_request,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMPLETION_DELAY_SUBSTATE
);
}
// ---------------------------------------------------------------------------
SCI_BASE_STATE_T
scic_sds_stp_packet_request_started_substate_table
[SCIC_SDS_STP_PACKET_REQUEST_STARTED_MAX_SUBSTATES] =
{
{
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_TC_COMPLETION_SUBSTATE,
scic_sds_stp_packet_request_started_packet_phase_await_tc_completion_enter,
NULL
},
{
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_PIO_SETUP_SUBSTATE,
scic_sds_stp_packet_request_started_packet_phase_await_pio_setup_enter,
NULL
},
{
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE,
scic_sds_stp_packet_request_started_command_phase_await_tc_completion_enter,
NULL
},
{
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE,
scic_sds_stp_packet_request_started_command_phase_await_d2h_fis_enter,
NULL
},
{
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMPLETION_DELAY_SUBSTATE,
scic_sds_stp_packet_request_started_completion_delay_enter,
NULL
}
};
#endif //#if !defined(DISABLE_ATAPI)