FreeBSD/Linux Kernel Cross Reference
sys/dev/isci/scil/sati_unmap.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$");
    
    /**
     * @file
     * @brief This file contains the method implementations required to
     *        translate the SCSI unmap command.
     */
    
    #if !defined(DISABLE_SATI_UNMAP)
    
    #include <dev/isci/scil/sati_unmap.h>
    #include <dev/isci/scil/sati_callbacks.h>
    #include <dev/isci/scil/sati_translator_sequence.h>
    #include <dev/isci/scil/sati_util.h>
    #include <dev/isci/scil/intel_ata.h>
    #include <dev/isci/scil/intel_scsi.h>
    #include <dev/isci/scil/intel_sat.h>
    
    //******************************************************************************
    //* P R I V A T E   M E T H O D S
    //******************************************************************************
    
    /**
     * @brief This method translates a given number of DSM
     *        requests into DSM blocks based on the devices logical block size
     *
     * @return Number of DSM blocks required for the DSM descriptor count
     */
    U32 sati_unmap_calculate_dsm_blocks(
       SATI_TRANSLATOR_SEQUENCE_T * sequence,
       U32                          dsm_descriptor_count
    )
    {
       U32 blocks = (dsm_descriptor_count * sizeof(TRIM_PAIR))/sequence->device->logical_block_size;
       if ((dsm_descriptor_count * sizeof(TRIM_PAIR)) % sequence->device->logical_block_size)
       {
           blocks++;
       }
       return blocks;
    }
    
    /**
     * @brief This method performs the SCSI Unmap command translation
     *        functionality.
    *        This includes:
    *        - setting the command register
    *        - setting the device head register
    *        - filling in fields in the SATI_TRANSLATOR_SEQUENCE object.
    *        For more information on the parameters passed to this method,
    *        please reference sati_translate_command().
    *
    * @return Indicate if the method was successfully completed.
    * @retval SATI_SUCCESS This is returned in all other cases.
    */
   SATI_STATUS sati_unmap_construct(
      SATI_TRANSLATOR_SEQUENCE_T * sequence,
      void                       * scsi_io,
      void                       * ata_io,
      U32                          sector_count
   )
   {
      U8 * h2d_register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
      U8 * d2h_register_fis = sati_cb_get_d2h_register_fis_address(ata_io);
   
      sati_set_ata_command(h2d_register_fis, ATA_DATA_SET_MANAGEMENT);
      sati_set_ata_features(h2d_register_fis, 0x01);
      sati_set_ata_sector_count(h2d_register_fis, (U8)sector_count);
      sati_set_ata_device_head(h2d_register_fis, ATA_DEV_HEAD_REG_LBA_MODE_ENABLE);
   
      // Set the completion status since the core will not do that for
      // the udma fast path.
      sati_set_ata_status(d2h_register_fis, 0x00);
   
      // Set up the direction and protocol for SCIC
      sequence->data_direction                 = SATI_DATA_DIRECTION_OUT;
      sequence->protocol                       = SAT_PROTOCOL_UDMA_DATA_OUT;
      // The UNMAP translation will always require a callback
      // on every response so it can free memory if an error
      // occurs.
      sequence->is_translate_response_required = TRUE;
   
      ASSERT(sector_count < 0x100);
   
      return SATI_SUCCESS;
   }
   
   /**
    * @brief This method updates the unmap sequence state to the next
    *        unmap descriptor
    *
    * @return Indicate if the method was successfully completed.
    * @retval SATI_SUCCESS This is returned in all other cases.
    */
   SATI_STATUS sati_unmap_load_next_descriptor(
      SATI_TRANSLATOR_SEQUENCE_T * sequence,
      void                       * scsi_io
   )
   {
      SATI_UNMAP_PROCESSING_STATE_T * unmap_process_state;
      U32                             index;
      U8                              unmap_block_descriptor[16];
   
      unmap_process_state = &sequence->command_specific_data.unmap_process_state;
   
      // Load the next descriptor
      for(index = unmap_process_state->current_unmap_block_descriptor_index;
          index < unmap_process_state->current_unmap_block_descriptor_index +
                  SATI_UNMAP_SIZEOF_SCSI_UNMAP_BLOCK_DESCRIPTOR;
          index++)
      {
         sati_get_data_byte(sequence,
            scsi_io,
            index,
            &unmap_block_descriptor[index-unmap_process_state->current_unmap_block_descriptor_index]);
      }
   
      // Update the internal state for the next translation pass
      unmap_process_state->current_lba_count = (unmap_block_descriptor[8] << 24) |
                                               (unmap_block_descriptor[9] << 16) |
                                               (unmap_block_descriptor[10] << 8) |
                                               (unmap_block_descriptor[11]);
      unmap_process_state->current_lba       = ((SATI_LBA)(unmap_block_descriptor[0]) << 56) |
                                               ((SATI_LBA)(unmap_block_descriptor[1]) << 48) |
                                               ((SATI_LBA)(unmap_block_descriptor[2]) << 40) |
                                               ((SATI_LBA)(unmap_block_descriptor[3]) << 32) |
                                               ((SATI_LBA)(unmap_block_descriptor[4]) << 24) |
                                               ((SATI_LBA)(unmap_block_descriptor[5]) << 16) |
                                               ((SATI_LBA)(unmap_block_descriptor[6]) << 8) |
                                               ((SATI_LBA)(unmap_block_descriptor[7]));
      unmap_process_state->next_lba          = 0;
   
      // Update the index for the next descriptor to translate
      unmap_process_state->current_unmap_block_descriptor_index += SATI_UNMAP_SIZEOF_SCSI_UNMAP_BLOCK_DESCRIPTOR;
   
      return SATI_SUCCESS;
   }
   
   /**
    * @brief This method determines the max number of blocks of DSM data
    *        that can be satisfied by the device and the SW
    *
    * @return Number of blocks supported
    * @retval Number of blocks supported
    */
   U32 sati_unmap_get_max_buffer_size_in_blocks(
      SATI_TRANSLATOR_SEQUENCE_T * sequence
   )
   {
      // Currently this SATI implementation only supports a single
      // 4k block of memory for the DMA write operation for simplicity
      // (no need to handle more than one SG element).
      // Since most run time UNMAP requests use 1K or less buffer space,
      // there is no performance degradation with only supporting a
      // single physical page.  For best results allocate the maximum
      // amount of memory the device can handle up to the maximum of 4K.
      return MIN(SATI_DSM_MAX_BUFFER_SIZE/sequence->device->logical_block_size,
                 sequence->device->max_lba_range_entry_blocks);
   }
   
   /**
    * @brief This method will be called before starting the first unmap translation
    *
    * @return Indicate if the translation was successful.
    * @retval SATI_SUCCESS This is returned if the command translation was
    *         successful and no further processing.
    * @retval SATI_COMPLETE - The initial processing was completed successfully
    * @retval SATI_FAILURE_CHECK_RESPONSE_DATA - Failed the initial processing
    */
   SATI_STATUS sati_unmap_initial_processing(
      SATI_TRANSLATOR_SEQUENCE_T * sequence,
      void                       * scsi_io,
      void                       * ata_io
   )
   {
      SATI_UNMAP_PROCESSING_STATE_T * unmap_process_state;
      U8 * cdb;
      U16 unmap_length;
      U32 descriptor_length;
      U32 index;
      U32 max_dsm_blocks;
      U8  unmap_param_list[8];
   
      unmap_process_state = &sequence->command_specific_data.unmap_process_state;
   
      // Set up the sequence type for unmap translation
      sequence->type = SATI_SEQUENCE_UNMAP;
   
      // Make sure the device is TRIM capable
      if ((sequence->device->capabilities & SATI_DEVICE_CAP_DSM_TRIM_SUPPORT)
          != SATI_DEVICE_CAP_DSM_TRIM_SUPPORT)
      {
         // Can't send TRIM request to device that does not support it
         sati_scsi_sense_data_construct(
            sequence,
            scsi_io,
            SCSI_STATUS_CHECK_CONDITION,
            SCSI_SENSE_ILLEGAL_REQUEST,
            SCSI_ASC_INVALID_FIELD_IN_CDB,
            SCSI_ASCQ_INVALID_FIELD_IN_CDB
         );
         return SATI_FAILURE_CHECK_RESPONSE_DATA;
      }
   
      // get the amount of data being sent from the cdb
      cdb = sati_cb_get_cdb_address(scsi_io);
      unmap_length = (sati_get_cdb_byte(cdb, 7) << 8) | sati_get_cdb_byte(cdb, 8);
   
      // If nothing has been requested return success now.
      if (unmap_length == 0)
      {
          // SAT: This is not an error
          return SATI_SUCCESS;
      }
      if (unmap_length < SATI_UNMAP_SIZEOF_SCSI_UNMAP_PARAMETER_LIST)
      {
         // Not enough length specified in the CDB
         sati_scsi_sense_data_construct(
            sequence,
            scsi_io,
            SCSI_STATUS_CHECK_CONDITION,
            SCSI_SENSE_ILLEGAL_REQUEST,
            SCSI_ASC_INVALID_FIELD_IN_CDB,
            SCSI_ASCQ_INVALID_FIELD_IN_CDB
         );
         return SATI_FAILURE_CHECK_RESPONSE_DATA;
      }
   
      sequence->allocation_length = unmap_length;
   
      // Get the unmap parameter header
      for(index = 0; index < SATI_UNMAP_SIZEOF_SCSI_UNMAP_PARAMETER_LIST; index++)
      {
         sati_get_data_byte(sequence, scsi_io, index,   &unmap_param_list[index]);
      }
      descriptor_length = (unmap_param_list[2] << 8) | unmap_param_list[3];
   
      // Check length again
      if (descriptor_length == 0)
      {
          // SAT: This is not an error
          return SATI_SUCCESS;
      }
   
      if ((U32)(unmap_length - SATI_UNMAP_SIZEOF_SCSI_UNMAP_PARAMETER_LIST) < descriptor_length)
      {
         // Not enough length specified in the CDB
         sati_scsi_sense_data_construct(
            sequence,
            scsi_io,
            SCSI_STATUS_CHECK_CONDITION,
            SCSI_SENSE_ILLEGAL_REQUEST,
            SCSI_ASC_INVALID_FIELD_IN_CDB,
            SCSI_ASCQ_INVALID_FIELD_IN_CDB
         );
         return SATI_FAILURE_CHECK_RESPONSE_DATA;
      }
   
      // Save the maximum unmap block descriptors in this request
      unmap_process_state->max_unmap_block_descriptors =
          descriptor_length/SATI_UNMAP_SIZEOF_SCSI_UNMAP_BLOCK_DESCRIPTOR;
   
      // Determine the maximum size of the write buffer that will be required
      // for the translation in terms of number of blocks
      max_dsm_blocks = sati_unmap_get_max_buffer_size_in_blocks(sequence);
   
      // Save the maximum number of DSM descriptors we can send during the translation
      unmap_process_state->max_lba_range_entries =
          (max_dsm_blocks*sequence->device->logical_block_size)/sizeof(TRIM_PAIR);
   
      // Get the write buffer for the translation
      sati_cb_allocate_dma_buffer(
         scsi_io,
         max_dsm_blocks*sequence->device->logical_block_size,
         &(unmap_process_state->virtual_unmap_buffer),
         &(unmap_process_state->physical_unmap_buffer_low),
         &(unmap_process_state->physical_unmap_buffer_high));
   
      // Makes sure we have a buffer
      if (unmap_process_state->virtual_unmap_buffer == NULL)
      {
         // Resource failure
         sati_scsi_sense_data_construct(
            sequence,
            scsi_io,
            SCSI_STATUS_BUSY,
            SCSI_SENSE_NO_SENSE,
            SCSI_ASC_NO_ADDITIONAL_SENSE,
            SCSI_ASCQ_NO_ADDITIONAL_SENSE
         );
         return SATI_FAILURE_CHECK_RESPONSE_DATA;
      }
   
      // Get the first SGL entry.  This code will only use one 4K page so will
      // only utilize the first sge.
      sati_cb_sgl_next_sge(scsi_io,
                           ata_io,
                           NULL,
                           &(unmap_process_state->unmap_buffer_sgl_pair));
   
      // Load the first descriptor to start the translation loop
      unmap_process_state->current_unmap_block_descriptor_index =
         SATI_UNMAP_SIZEOF_SCSI_UNMAP_PARAMETER_LIST;
      sati_unmap_load_next_descriptor(sequence,scsi_io);
   
      // Next state will be incomplete since translation
      // will require a callback and possibly more requests.
      sequence->state = SATI_SEQUENCE_STATE_INCOMPLETE;
   
      return SATI_COMPLETE;
   }
   
   /**
    * @brief This method will process each unmap sequence.
    *
    * @return Indicate if the translation was successful.
    * @retval SATI_SUCCESS
    */
   SATI_STATUS sati_unmap_process(
      SATI_TRANSLATOR_SEQUENCE_T * sequence,
      void                       * scsi_io,
      void                       * ata_io
   )
   {
      SATI_UNMAP_PROCESSING_STATE_T * unmap_process_state;
      SATI_LBA dsm_descriptor_lba_count;
      U32 dsm_descriptor;
      U32 dsm_bytes;
      U32 dsm_remainder_bytes;
      U32 dsm_blocks;
      U32 max_dsm_blocks;
   
      unmap_process_state = &sequence->command_specific_data.unmap_process_state;
   
      // Set up the starting address of the buffer for this portion of the translation
      unmap_process_state->current_dsm_descriptor = unmap_process_state->virtual_unmap_buffer;
      dsm_descriptor = 0;
   
      // Translate as much as we can
      while ((dsm_descriptor < unmap_process_state->max_lba_range_entries) &&
             (unmap_process_state->current_lba_count > 0)) {
         // See if the LBA count will fit in to a single descriptor
         if (unmap_process_state->current_lba_count > SATI_DSM_MAX_SECTOR_COUNT) {
            // Can't fit all of the lbas for this descriptor in to
            // one DSM request.  Adjust the current LbaCount and total
            // remaining for the next descriptor
            dsm_descriptor_lba_count = SATI_DSM_MAX_SECTOR_COUNT;
            unmap_process_state->current_lba_count -= SATI_DSM_MAX_SECTOR_COUNT;
            unmap_process_state->next_lba =
                unmap_process_state->current_lba + SATI_DSM_MAX_SECTOR_COUNT;
         } else {
            // It all fits in to one descriptor
            dsm_descriptor_lba_count = unmap_process_state->current_lba_count;
            unmap_process_state->current_lba_count = 0;
         }
   
         // Fill in the ATA DSM descriptor
         ((PTRIM_PAIR)(unmap_process_state->current_dsm_descriptor))->sector_address =
             unmap_process_state->current_lba;
         ((PTRIM_PAIR)(unmap_process_state->current_dsm_descriptor))->sector_count =
             dsm_descriptor_lba_count;
   
         // See if we can move on to the next descriptor
         if (unmap_process_state->current_lba_count == 0) {
            // See if there is another descriptor
            --unmap_process_state->max_unmap_block_descriptors;
            if (unmap_process_state->max_unmap_block_descriptors > 0) {
               // Move on to the next descriptor
               sati_unmap_load_next_descriptor(sequence,scsi_io);
            }
         } else {
            // Move to the next LBA in this descriptor
            unmap_process_state->current_lba = unmap_process_state->next_lba;
         }
   
         // Make sure the LBA does not exceed 48 bits...
         ASSERT(unmap_process_state->current_lba <= SATI_DSM_MAX_SECTOR_ADDRESS);
   
         // Increment the number of descriptors used and point to the next entry
         dsm_descriptor++;
         unmap_process_state->current_dsm_descriptor =
             (U8 *)(unmap_process_state->current_dsm_descriptor) + sizeof(TRIM_PAIR);
      }
   
      // Calculate number of blocks we have filled in
      dsm_blocks     = sati_unmap_calculate_dsm_blocks(sequence,dsm_descriptor);
      dsm_bytes      = dsm_blocks * sequence->device->logical_block_size;
      max_dsm_blocks = sati_unmap_get_max_buffer_size_in_blocks(sequence);
   
      // The current_dsm_descriptor points to the next location in the buffer
      // Get the remaining bytes from the last translated descriptor
      // to the end of the 4k buffer.
      dsm_remainder_bytes = sequence->device->logical_block_size;
      dsm_remainder_bytes -= (U32)((POINTER_UINT)unmap_process_state->current_dsm_descriptor &
                                   (sequence->device->logical_block_size-1));
   
      // If there was no remainder, the complete buffer was filled in.
      if (dsm_remainder_bytes != sequence->device->logical_block_size)
      {
          // Add on the remaining unfilled blocks
          dsm_remainder_bytes += (sequence->device->logical_block_size * (max_dsm_blocks - dsm_blocks));
   
          // According to ATA-8, if the DSM buffer is not completely filled with
          // valid DSM descriptor data, the remaining portion of the
          // buffer must be filled in with zeros.
          memset((U8 *)unmap_process_state->current_dsm_descriptor, 0, dsm_remainder_bytes);
      }
   
      // Tell scic to utilize this sgl pair for write DMA processing of
      // the SCSI UNMAP translation with the total number of bytes for this transfer
      sati_cb_sge_write(unmap_process_state->unmap_buffer_sgl_pair,
                        unmap_process_state->physical_unmap_buffer_low,
                        unmap_process_state->physical_unmap_buffer_high,
                        dsm_bytes);
   
      // Construct the unmap ATA request
      sati_unmap_construct(sequence,
                           scsi_io,
                           ata_io,
                           dsm_blocks);
   
      // Determine sequence next state based on whether there is more translation
      // to complete
      if (unmap_process_state->current_lba_count == 0)
      {
          // used for completion routine to determine if there is more processing
          sequence->state = SATI_SEQUENCE_STATE_FINAL;
      }
      // This requests has already translated the SGL, have SCIC skip SGL translataion
      return SATI_SUCCESS_SGL_TRANSLATED;
   }
   
   //******************************************************************************
   //* P U B L I C   M E T H O D S
   //******************************************************************************
   
   /**
    * @brief This method will handle termination of the
    *        SCSI unmap translation and frees previously allocated
    *        dma buffer.
    *
    * @return None
    */
   void sati_unmap_terminate(
      SATI_TRANSLATOR_SEQUENCE_T * sequence,
      void                       * scsi_io,
      void                       * ata_io
   )
   {
      SATI_UNMAP_PROCESSING_STATE_T * unmap_process_state;
      unmap_process_state = &sequence->command_specific_data.unmap_process_state;
   
      if (unmap_process_state->virtual_unmap_buffer != NULL)
      {
         sati_cb_free_dma_buffer(scsi_io, unmap_process_state->virtual_unmap_buffer);
         unmap_process_state->virtual_unmap_buffer = NULL;
      }
   }
   
   /**
    * @brief This method will translate the SCSI Unmap command
    *        into corresponding ATA commands.  Depending upon the capabilities
    *        supported by the target different ATA commands can be selected.
    *        Additionally, in some cases more than a single ATA command may
    *        be required.
    *
    * @return Indicate if the command translation succeeded.
    * @retval SATI_SUCCESS This is returned if the command translation was
    *         successful.
    * @retval SATI_COMPLETE This is returned if the command translation was
    *         successful and no ATA commands need to be set.
    * @retval SATI_FAILURE_CHECK_RESPONSE_DATA This value is returned if
    *         sense data has been created as a result of something specified
    *         in the parameter data fields.
    */
   SATI_STATUS sati_unmap_translate_command(
      SATI_TRANSLATOR_SEQUENCE_T * sequence,
      void                       * scsi_io,
      void                       * ata_io
   )
   {
      SATI_STATUS status = SATI_FAILURE_CHECK_RESPONSE_DATA;
      SATI_UNMAP_PROCESSING_STATE_T * unmap_process_state;
   
      unmap_process_state = &sequence->command_specific_data.unmap_process_state;
   
      // Determine if this is the first step in the unmap sequence
      if ( sequence->state == SATI_SEQUENCE_STATE_INITIAL )
      {
          status = sati_unmap_initial_processing(sequence,scsi_io,ata_io);
          if (status != SATI_COMPLETE)
          {
             return status;
          }
      }
      // Translate the next portion of the UNMAP request
      return sati_unmap_process(sequence, scsi_io, ata_io);
   }
   
   /**
    * @brief This method will translate the ATA command register FIS
    *        response into an appropriate SCSI response for Unmap.
    *        For more information on the parameters passed to this method,
    *        please reference sati_translate_response().
    *
    * @return Indicate if the response translation succeeded.
    * @retval SATI_SUCCESS This is returned if the command translation was
    *         successful.
    * @retval SATI_COMPLETE This is returned if the command translation was
    *         successful and no ATA commands need to be set.
    * @retval SATI_FAILURE_CHECK_RESPONSE_DATA This value is returned if
    *         sense data has been created as a result of something specified
    *         in the parameter data fields.
    */
   SATI_STATUS sati_unmap_translate_response(
      SATI_TRANSLATOR_SEQUENCE_T * sequence,
      void                       * scsi_io,
      void                       * ata_io
   )
   {
      U8 * register_fis = sati_cb_get_d2h_register_fis_address(ata_io);
      SATI_UNMAP_PROCESSING_STATE_T * unmap_process_state;
      SATI_STATUS sati_status = SATI_COMPLETE;
   
      unmap_process_state = &sequence->command_specific_data.unmap_process_state;
   
      if (sati_get_ata_status(register_fis) & ATA_STATUS_REG_ERROR_BIT)
      {
         sequence->state = SATI_SEQUENCE_STATE_FINAL;
         sati_scsi_sense_data_construct(
            sequence,
            scsi_io,
            SCSI_STATUS_CHECK_CONDITION,
            SCSI_SENSE_ABORTED_COMMAND,
            SCSI_ASC_NO_ADDITIONAL_SENSE,
            SCSI_ASCQ_NO_ADDITIONAL_SENSE
         );
         // All done, terminate the translation
         sati_unmap_terminate(sequence, scsi_io, ata_io);
      }
      else
      {
         if (sequence->state != SATI_SEQUENCE_STATE_INCOMPLETE)
         {
             // All done, terminate the translation
             sati_unmap_terminate(sequence, scsi_io, ata_io);
         }
         else
         {
             // Still translating
             sati_status = SATI_SEQUENCE_STATE_INCOMPLETE;
         }
      }
      return sati_status;
   }
   
   #endif // !defined(DISABLE_SATI_UNMAP)

Cache object: 67a799c25373c57162c25ecb72a45f38