718cf2ccb9
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts.
612 lines
23 KiB
C
612 lines
23 KiB
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)
|