FreeBSD/Linux Kernel Cross Reference
sys/dev/isci/scil/scic_sds_stp_packet_request.c

     /*-
      * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
      *
      * 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$");
    
    #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 endianness
    *             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 successfully, 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)
   

Cache object: 34c73fe43dd0762e82b510fa35d198cf