1537078d8f
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.
2011 lines
72 KiB
C
2011 lines
72 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 all of the method implementations that
|
|
* provide generic support for SATI. Some methods can be utilized
|
|
* by a user to construct ATA/ATAPI commands, copy ATA device
|
|
* structure data, fill in sense data, etc.
|
|
*/
|
|
|
|
#include <dev/isci/scil/sati_util.h>
|
|
#include <dev/isci/scil/sati_callbacks.h>
|
|
#include <dev/isci/scil/intel_scsi.h>
|
|
#include <dev/isci/scil/intel_ata.h>
|
|
#include <dev/isci/scil/intel_sat.h>
|
|
#include <dev/isci/scil/intel_sas.h>
|
|
|
|
/**
|
|
* @brief This method will set the data direction, protocol, and transfer
|
|
* kength for an ATA non-data command.
|
|
*
|
|
* @pre It is expected that the user will use this method for setting these
|
|
* values in a non-data ATA command constuct.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the IDENTIFY DEVICE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_non_data_command(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
sequence->data_direction = SATI_DATA_DIRECTION_NONE;
|
|
sequence->protocol = SAT_PROTOCOL_NON_DATA;
|
|
sequence->ata_transfer_length = 0;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA identify device command.
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the IDENTIFY DEVICE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_identify_device_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_IDENTIFY_DEVICE);
|
|
sequence->data_direction = SATI_DATA_DIRECTION_IN;
|
|
sequence->protocol = SAT_PROTOCOL_PIO_DATA_IN;
|
|
sequence->ata_transfer_length = sizeof(ATA_IDENTIFY_DEVICE_DATA_T);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA Execute Device Diagnostic command.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the IDENTIFY DEVICE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_execute_device_diagnostic_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_EXECUTE_DEVICE_DIAG);
|
|
|
|
sequence->data_direction = SATI_DATA_DIRECTION_IN;
|
|
sequence->protocol = SAT_PROTOCOL_DEVICE_DIAGNOSTIC;
|
|
sequence->ata_transfer_length = 16;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will set data bytes in the user data area. If the
|
|
* caller requests it, the data written will be forced to ascii
|
|
* printable characters if it isn't already a printable character.
|
|
* A printable character is considered to be >= 0x20 and <= 0x70.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to copy and swap the data.
|
|
* @param[out] destination_scsi_io This parameter specifies the SCSI IO
|
|
* request containing the destination buffer into which to copy.
|
|
* @param[in] destination_offset This parameter specifies the offset into
|
|
* the data buffer where the information will be copied to.
|
|
* @param[in] source_value This parameter specifies the value retrieved
|
|
* from the source buffer that is to be copied into the user
|
|
* buffer area.
|
|
* @param[in] use_printable_chars This parameter indicates if the copy should
|
|
* ensure that the value copied is considered an ASCII printable
|
|
* character (e.g. A, B, " ", etc.). These characters reside
|
|
* in the 0x20 - 0x7E ASCII range.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_set_ascii_data_byte(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * destination_scsi_io,
|
|
U32 destination_offset,
|
|
U8 source_value,
|
|
BOOL use_printable_chars
|
|
)
|
|
{
|
|
// if the user requests that the copied data be ascii printable, then
|
|
// default to " " (i.e. 0x20) for all non-ascii printable characters.
|
|
if((use_printable_chars == TRUE)
|
|
&& ((source_value < 0x20) || (source_value > 0x7E)))
|
|
{
|
|
source_value = 0x20;
|
|
}
|
|
|
|
sati_set_data_byte(
|
|
sequence, destination_scsi_io, destination_offset, source_value
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief This method performs a copy operation using an offset into the
|
|
* source buffer, an offset into the destination buffer, and a length.
|
|
* It will perform the byte swap from the 16-bit identify field
|
|
* into the network byte order SCSI location.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to copy and swap the data.
|
|
* @param[out] destination_scsi_io This parameter specifies the SCSI IO
|
|
* request containing the destination buffer into which to copy.
|
|
* @param[in] destination_offset This parameter specifies the offset into
|
|
* the data buffer where the information will be copied to.
|
|
* @param[in] source_buffer This parameter specifies the source buffer from
|
|
* which the data will be copied.
|
|
* @param[in] source_offset This parameter specifies the offset into the
|
|
* source buffer where the copy shall begin.
|
|
* @param[in] length This parameter specifies the number of bytes to copy
|
|
* during this operation.
|
|
* @param[in] use_printable_chars This parameter indicates if the copy should
|
|
* ensure that the value copied is considered an ASCII printable
|
|
* character (e.g. A, B, " ", etc.). These characters reside
|
|
* in the 0x20 - 0x7E ASCII range.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_ata_identify_device_copy_data(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * destination_scsi_io,
|
|
U32 destination_offset,
|
|
U8 * source_buffer,
|
|
U32 source_offset,
|
|
U32 length,
|
|
BOOL use_printable_chars
|
|
)
|
|
{
|
|
source_buffer += source_offset;
|
|
while (length > 0)
|
|
{
|
|
sati_set_ascii_data_byte(
|
|
sequence,
|
|
destination_scsi_io,
|
|
destination_offset,
|
|
*(source_buffer+1),
|
|
use_printable_chars
|
|
);
|
|
|
|
sati_set_ascii_data_byte(
|
|
sequence,
|
|
destination_scsi_io,
|
|
destination_offset+1,
|
|
*source_buffer,
|
|
use_printable_chars
|
|
);
|
|
|
|
destination_offset += 2;
|
|
source_buffer += 2;
|
|
length -= 2;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method performs a copy operation using a source buffer,
|
|
* an offset into the destination buffer, and a length.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to copy and swap the data.
|
|
* @param[out] destination_scsi_io This parameter specifies the SCSI IO
|
|
* request containing the destination buffer into which to copy.
|
|
* @param[in] destination_offset This parameter specifies the offset into
|
|
* the data buffer where the information will be copied to.
|
|
* @param[in] source_buffer This parameter specifies the source buffer from
|
|
* which the data will be copied.
|
|
* @param[in] length This parameter specifies the number of bytes to copy
|
|
* during this operation.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_copy_data(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * destination_scsi_io,
|
|
U32 destination_offset,
|
|
U8 * source_buffer,
|
|
U32 length
|
|
)
|
|
{
|
|
while (length > 0)
|
|
{
|
|
sati_set_data_byte(
|
|
sequence, destination_scsi_io, destination_offset, *source_buffer
|
|
);
|
|
|
|
destination_offset++;
|
|
source_buffer++;
|
|
length--;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method extracts the Logical Block Address high and low 32-bit
|
|
* values and the sector count 32-bit value from the ATA identify
|
|
* device data.
|
|
*
|
|
* @param[in] identify This parameter specifies the ATA_IDENTIFY_DEVICE_DATA
|
|
* from which to extract the sector information.
|
|
* @param[out] lba_high This parameter specifies the upper 32 bits for the
|
|
* number of logical block addresses for the device. The upper
|
|
* 16-bits should always be 0, since 48-bits of LBA is the most
|
|
* supported by an ATA device.
|
|
* @param[out] lba_low This parameter specifies the lower 32 bits for the
|
|
* number of logical block addresses for the device.
|
|
* @param[out] sector_size This parameter specifies the 32-bits of sector
|
|
* size. If the ATA device doesn't support reporting it's
|
|
* sector size, then 512 bytes is utilized as the default value.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_ata_identify_device_get_sector_info(
|
|
ATA_IDENTIFY_DEVICE_DATA_T * identify,
|
|
U32 * lba_high,
|
|
U32 * lba_low,
|
|
U32 * sector_size
|
|
)
|
|
{
|
|
// Calculate the values to be returned
|
|
// Calculation will be different if the SATA device supports
|
|
// 48-bit addressing. Bit 10 of Word 86 of ATA Identify
|
|
if (identify->command_set_enabled1
|
|
& ATA_IDENTIFY_COMMAND_SET_SUPPORTED1_48BIT_ENABLE)
|
|
{
|
|
// This drive supports 48-bit addressing
|
|
|
|
*lba_high = identify->max_48bit_lba[7] << 24;
|
|
*lba_high |= identify->max_48bit_lba[6] << 16;
|
|
*lba_high |= identify->max_48bit_lba[5] << 8;
|
|
*lba_high |= identify->max_48bit_lba[4];
|
|
|
|
*lba_low = identify->max_48bit_lba[3] << 24;
|
|
*lba_low |= identify->max_48bit_lba[2] << 16;
|
|
*lba_low |= identify->max_48bit_lba[1] << 8;
|
|
*lba_low |= identify->max_48bit_lba[0];
|
|
}
|
|
else
|
|
{
|
|
// This device doesn't support 48-bit addressing
|
|
// Pull out the largest LBA from words 60 and 61.
|
|
*lba_high = 0;
|
|
*lba_low = identify->total_num_sectors[3] << 24;
|
|
*lba_low |= identify->total_num_sectors[2] << 16;
|
|
*lba_low |= identify->total_num_sectors[1] << 8;
|
|
*lba_low |= identify->total_num_sectors[0];
|
|
}
|
|
|
|
// If the ATA device reports its sector size (bit 12 of Word 106),
|
|
// then use that instead.
|
|
if (identify->physical_logical_sector_info
|
|
& ATA_IDENTIFY_SECTOR_LARGER_THEN_512_ENABLE)
|
|
{
|
|
*sector_size = identify->words_per_logical_sector[3] << 24;
|
|
*sector_size |= identify->words_per_logical_sector[2] << 16;
|
|
*sector_size |= identify->words_per_logical_sector[1] << 8;
|
|
*sector_size |= identify->words_per_logical_sector[0];
|
|
}
|
|
else
|
|
{
|
|
// Default the sector size to 512 bytes
|
|
*sector_size = 512;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA check power mode command.
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the CHECK POWER MODE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_check_power_mode_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_CHECK_POWER_MODE);
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method is utilized to set a specific byte in the sense
|
|
* data area. It will ensure that the supplied byte offset
|
|
* isn't larger then the length of the requested sense data.
|
|
*
|
|
* @param[in] scsi_io This parameter specifies the user SCSI IO request
|
|
* for which to set the sense data byte.
|
|
* @param[in] byte_offset This parameter specifies the byte offset into
|
|
* the sense data buffer where the data should be written.
|
|
* @param[in] value This parameter specifies the 8-bit value to be written
|
|
* into the sense data area.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_set_sense_data_byte(
|
|
U8 * sense_data,
|
|
U32 max_sense_data_len,
|
|
U32 byte_offset,
|
|
U8 value
|
|
)
|
|
{
|
|
// Ensure that we don't attempt to write past the end of the sense
|
|
// data buffer.
|
|
if (byte_offset < max_sense_data_len)
|
|
sense_data[byte_offset] = value;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the common response IU in the user
|
|
* request's response IU location.
|
|
*
|
|
* @param[out] rsp_iu This parameter specifies the user request's
|
|
* response IU to be constructed.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[in] sense_data_length This parameter specifies the sense data
|
|
* length for response IU.
|
|
* @param[in] data_present The parameter specifies the specific
|
|
* data present value for response IU.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_scsi_common_response_iu_construct(
|
|
SCI_SSP_RESPONSE_IU_T * rsp_iu,
|
|
U8 scsi_status,
|
|
U8 sense_data_length,
|
|
U8 data_present
|
|
)
|
|
{
|
|
rsp_iu->sense_data_length[3] = sense_data_length;
|
|
rsp_iu->sense_data_length[2] = 0;
|
|
rsp_iu->sense_data_length[1] = 0;
|
|
rsp_iu->sense_data_length[0] = 0;
|
|
rsp_iu->status = scsi_status;
|
|
rsp_iu->data_present = data_present;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the buffer for sense data
|
|
* sense data buffer location. Additionally, it will set the user's
|
|
* SCSI status.
|
|
*
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the buffer for sense data.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[out] sense_data This paramater
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_get_sense_data_buffer(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U8 scsi_status,
|
|
U8 ** sense_data,
|
|
U32 * sense_len)
|
|
{
|
|
#ifdef SATI_TRANSPORT_SUPPORTS_SAS
|
|
SCI_SSP_RESPONSE_IU_T * rsp_iu = (SCI_SSP_RESPONSE_IU_T*)
|
|
sati_cb_get_response_iu_address(scsi_io);
|
|
|
|
sati_scsi_common_response_iu_construct(
|
|
rsp_iu,
|
|
scsi_status,
|
|
sati_scsi_get_sense_data_length(sequence, scsi_io),
|
|
SCSI_RESPONSE_DATA_PRES_SENSE_DATA
|
|
);
|
|
|
|
*sense_data = (U8*) rsp_iu->data;
|
|
*sense_len = SSP_RESPONSE_IU_MAX_DATA * 4; // dwords to bytes
|
|
#else
|
|
*sense_data = sati_cb_get_sense_data_address(scsi_io);
|
|
*sense_len = sati_cb_get_sense_data_length(scsi_io);
|
|
sati_cb_set_scsi_status(scsi_io, scsi_status);
|
|
#endif // SATI_TRANSPORT_SUPPORTS_SAS
|
|
}
|
|
|
|
/**
|
|
* @brief This method extract response code based on on device settings.
|
|
*
|
|
* @return response code
|
|
*/
|
|
static
|
|
U8 sati_scsi_get_sense_data_response_code(SATI_TRANSLATOR_SEQUENCE_T * sequence)
|
|
{
|
|
if (sequence->device->descriptor_sense_enable)
|
|
{
|
|
return SCSI_DESCRIPTOR_CURRENT_RESPONSE_CODE;
|
|
}
|
|
else
|
|
{
|
|
return SCSI_FIXED_CURRENT_RESPONSE_CODE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method will return length of descriptor sense data for executed command.
|
|
*
|
|
* @return sense data length
|
|
*/
|
|
static
|
|
U8 sati_scsi_get_descriptor_sense_data_length(SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io)
|
|
{
|
|
U8 * cdb = sati_cb_get_cdb_address(scsi_io);
|
|
//Initial value is descriptor header length
|
|
U8 length = 8;
|
|
|
|
switch (sati_get_cdb_byte(cdb, 0))
|
|
{
|
|
#if !defined(DISABLE_SATI_WRITE_LONG)
|
|
case SCSI_WRITE_LONG_10:
|
|
case SCSI_WRITE_LONG_16:
|
|
length += SCSI_BLOCK_DESCRIPTOR_LENGTH +
|
|
SCSI_INFORMATION_DESCRIPTOR_LENGTH;
|
|
break;
|
|
#endif // !defined(DISABLE_SATI_WRITE_LONG)
|
|
#if !defined(DISABLE_SATI_REASSIGN_BLOCKS)
|
|
case SCSI_REASSIGN_BLOCKS:
|
|
length += SCSI_CMD_SPECIFIC_DESCRIPTOR_LENGTH +
|
|
SCSI_INFORMATION_DESCRIPTOR_LENGTH;
|
|
break;
|
|
#endif // !defined(DISABLE_SATI_REASSIGN_BLOCKS)
|
|
case SCSI_READ_6:
|
|
case SCSI_READ_10:
|
|
case SCSI_READ_12:
|
|
case SCSI_READ_16:
|
|
case SCSI_WRITE_6:
|
|
case SCSI_WRITE_10:
|
|
case SCSI_WRITE_12:
|
|
case SCSI_WRITE_16:
|
|
#if !defined(DISABLE_SATI_VERIFY)
|
|
case SCSI_VERIFY_10:
|
|
case SCSI_VERIFY_12:
|
|
case SCSI_VERIFY_16:
|
|
#endif // !defined(DISABLE_SATI_VERIFY)
|
|
#if !defined(DISABLE_SATI_WRITE_AND_VERIFY) \
|
|
&& !defined(DISABLE_SATI_VERIFY) \
|
|
&& !defined(DISABLE_SATI_WRITE)
|
|
|
|
case SCSI_WRITE_AND_VERIFY_10:
|
|
case SCSI_WRITE_AND_VERIFY_12:
|
|
case SCSI_WRITE_AND_VERIFY_16:
|
|
#endif // !defined(DISABLE_SATI_WRITE_AND_VERIFY)
|
|
// && !defined(DISABLE_SATI_VERIFY)
|
|
// && !defined(DISABLE_SATI_WRITE)
|
|
length += SCSI_INFORMATION_DESCRIPTOR_LENGTH;
|
|
break;
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will return length of sense data.
|
|
*
|
|
* @return sense data length
|
|
*/
|
|
U8 sati_scsi_get_sense_data_length(SATI_TRANSLATOR_SEQUENCE_T * sequence, void * scsi_io)
|
|
{
|
|
U8 response_code;
|
|
|
|
response_code = sati_scsi_get_sense_data_response_code(sequence);
|
|
|
|
switch (response_code)
|
|
{
|
|
case SCSI_FIXED_CURRENT_RESPONSE_CODE:
|
|
case SCSI_FIXED_DEFERRED_RESPONSE_CODE:
|
|
return SCSI_FIXED_SENSE_DATA_BASE_LENGTH;
|
|
break;
|
|
case SCSI_DESCRIPTOR_CURRENT_RESPONSE_CODE:
|
|
case SCSI_DESCRIPTOR_DEFERRED_RESPONSE_CODE:
|
|
return sati_scsi_get_descriptor_sense_data_length(sequence, scsi_io);
|
|
break;
|
|
}
|
|
|
|
return SCSI_FIXED_SENSE_DATA_BASE_LENGTH;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the sense data buffer in the user's
|
|
* sense data buffer location. Additionally, it will set the user's
|
|
* SCSI status.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to construct the sense data.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[in] sense_key This parameter specifies the sense key to
|
|
* be set for the user's IO request.
|
|
* @param[in] additional_sense_code This parameter specifies the
|
|
* additional sense code (ASC) key to be set for the user's
|
|
* IO request.
|
|
* @param[in] additional_sense_code_qualifier This parameter specifies
|
|
* the additional sense code qualifier (ASCQ) key to be set
|
|
* for the user's IO request.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_scsi_sense_data_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U8 scsi_status,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
U8 response_code;
|
|
|
|
response_code = sati_scsi_get_sense_data_response_code(sequence);
|
|
|
|
switch (response_code)
|
|
{
|
|
case SCSI_FIXED_CURRENT_RESPONSE_CODE:
|
|
case SCSI_FIXED_DEFERRED_RESPONSE_CODE:
|
|
sati_scsi_fixed_sense_data_construct(sequence, scsi_io, scsi_status, response_code,
|
|
sense_key, additional_sense_code, additional_sense_code_qualifier);
|
|
break;
|
|
case SCSI_DESCRIPTOR_CURRENT_RESPONSE_CODE:
|
|
case SCSI_DESCRIPTOR_DEFERRED_RESPONSE_CODE:
|
|
sati_scsi_descriptor_sense_data_construct(sequence, scsi_io, scsi_status, response_code,
|
|
sense_key, additional_sense_code, additional_sense_code_qualifier);
|
|
break;
|
|
}
|
|
|
|
sequence->is_sense_response_set = TRUE;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the block descriptor in the user's descriptor
|
|
* sense data buffer location.
|
|
*
|
|
* @param[in] sense_data This parameter specifies the user SCSI IO request
|
|
* for which to set the sense data byte.
|
|
* @param[in] sense_len This parameter specifies length of the sense data
|
|
* to be returned by SATI.
|
|
* @param[out] descriptor_len This parameter returns the length of constructed
|
|
* descriptor.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_block_descriptor_construct(
|
|
U8 * sense_data,
|
|
U32 sense_len)
|
|
{
|
|
U8 ili = 1;
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 0, SCSI_BLOCK_DESCRIPTOR_TYPE);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 1, SCSI_BLOCK_DESCRIPTOR_ADDITIONAL_LENGTH);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 2, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 3, (ili << 5));
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the command-specific descriptor for
|
|
* the descriptor sense data buffer in the user's sense data buffer
|
|
* location.
|
|
*
|
|
* @param[in] sense_data This parameter specifies the user SCSI IO request
|
|
* for which to set the sense data byte.
|
|
* @param[in] sense_len This parameter specifies length of the sense data
|
|
* to be returned by SATI.
|
|
* @param[out] descriptor_len This parameter returns the length of constructed
|
|
* descriptor.
|
|
* @param[in] information_buff This parameter specifies the address for which
|
|
* to set the command-specific information buffer.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_command_specific_descriptor_construct(
|
|
U8 * sense_data,
|
|
U32 sense_len,
|
|
U8 * information_buff)
|
|
{
|
|
U8 i;
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 0, SCSI_CMD_SPECIFIC_DESCRIPTOR_TYPE);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 1, SCSI_CMD_SPECIFIC_DESCRIPTOR_ADDITIONAL_LENGTH);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 2, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 3, 0);
|
|
|
|
// fill information buffer
|
|
// SBC 5.20.1 REASSIGN BLOCKS command overview
|
|
// If information about the first LBA not reassigned is not available
|
|
// COMMAND-SPECIFIC INFORMATION field shall be set to FFFF_FFFF_FFFF_FFFFh
|
|
for (i=0; i<8; i++)
|
|
sati_set_sense_data_byte(sense_data, sense_len, 4 + i, information_buff==NULL?0xFF:information_buff[i]);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the information descriptor for
|
|
* the descriptor sense data buffer in the user's sense data buffer
|
|
* location.
|
|
*
|
|
* @param[in] sense_data This parameter specifies the user SCSI IO request
|
|
* for which to set the sense data byte.
|
|
* @param[in] sense_len This parameter specifies length of the sense data
|
|
* to be returned by SATI.
|
|
* @param[out] descriptor_len This parameter returns the length of constructed
|
|
* descriptor.
|
|
* @param[in] information_buff This parameter specifies the address for which
|
|
* to set the information buffer.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_information_descriptor_construct(
|
|
U8 * sense_data,
|
|
U32 sense_len,
|
|
U8 * information_buff)
|
|
{
|
|
U8 i;
|
|
U8 valid = 1;
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 0, SCSI_INFORMATION_DESCRIPTOR_TYPE);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 1, SCSI_INFORMATION_DESCRIPTOR_ADDITIONAL_LENGTH);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 2, (valid << 7));
|
|
sati_set_sense_data_byte(sense_data, sense_len, 3, 0);
|
|
|
|
// fill information buffer
|
|
for (i=0; i<8; i++)
|
|
sati_set_sense_data_byte(sense_data, sense_len, 4 + i, information_buff==NULL?0:information_buff[i]);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the descriptors in the user's descriptor
|
|
* sense data buffer location.
|
|
*
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] sense_data This parameter specifies the user SCSI IO request
|
|
* for which to set the sense data byte.
|
|
* @param[in] sense_len This parameter specifies length of the sense data
|
|
* to be returned by SATI.
|
|
* @param[out] descriptor_len This parameter returns the length of constructed
|
|
* descriptor.
|
|
* @param[in] information_buff This parameter specifies the address for which
|
|
* to set the information buffer.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_common_descriptors_construct(
|
|
void * scsi_io,
|
|
U8 * sense_data,
|
|
U32 sense_len,
|
|
U8 * information_buff)
|
|
{
|
|
U8 * cdb = sati_cb_get_cdb_address(scsi_io);
|
|
U8 offset = 0;
|
|
|
|
switch (sati_get_cdb_byte(cdb, 0))
|
|
{
|
|
#if !defined(DISABLE_SATI_WRITE_LONG)
|
|
case SCSI_WRITE_LONG_10:
|
|
case SCSI_WRITE_LONG_16:
|
|
sati_scsi_block_descriptor_construct(
|
|
sense_data + offset,
|
|
sense_len - offset);
|
|
|
|
offset += SCSI_BLOCK_DESCRIPTOR_LENGTH;
|
|
sati_scsi_information_descriptor_construct(
|
|
sense_data + offset,
|
|
sense_len - offset,
|
|
information_buff);
|
|
|
|
offset += SCSI_INFORMATION_DESCRIPTOR_LENGTH;
|
|
break;
|
|
#endif // !defined(DISABLE_SATI_WRITE_LONG)
|
|
#if !defined(DISABLE_SATI_REASSIGN_BLOCKS)
|
|
case SCSI_REASSIGN_BLOCKS:
|
|
sati_scsi_command_specific_descriptor_construct(
|
|
sense_data + offset,
|
|
sense_len - offset,
|
|
NULL);
|
|
|
|
offset += SCSI_CMD_SPECIFIC_DESCRIPTOR_LENGTH;
|
|
sati_scsi_information_descriptor_construct(
|
|
sense_data + offset,
|
|
sense_len - offset,
|
|
information_buff);
|
|
|
|
offset += SCSI_INFORMATION_DESCRIPTOR_LENGTH;
|
|
break;
|
|
#endif // !defined(DISABLE_SATI_REASSIGN_BLOCKS)
|
|
case SCSI_READ_6:
|
|
case SCSI_READ_10:
|
|
case SCSI_READ_12:
|
|
case SCSI_READ_16:
|
|
case SCSI_WRITE_6:
|
|
case SCSI_WRITE_10:
|
|
case SCSI_WRITE_12:
|
|
case SCSI_WRITE_16:
|
|
#if !defined(DISABLE_SATI_VERIFY)
|
|
case SCSI_VERIFY_10:
|
|
case SCSI_VERIFY_12:
|
|
case SCSI_VERIFY_16:
|
|
#endif // !defined(DISABLE_SATI_VERIFY)
|
|
#if !defined(DISABLE_SATI_WRITE_AND_VERIFY) \
|
|
&& !defined(DISABLE_SATI_VERIFY) \
|
|
&& !defined(DISABLE_SATI_WRITE)
|
|
|
|
case SCSI_WRITE_AND_VERIFY_10:
|
|
case SCSI_WRITE_AND_VERIFY_12:
|
|
case SCSI_WRITE_AND_VERIFY_16:
|
|
#endif // !defined(DISABLE_SATI_WRITE_AND_VERIFY)
|
|
// && !defined(DISABLE_SATI_VERIFY)
|
|
// && !defined(DISABLE_SATI_WRITE)
|
|
sati_scsi_information_descriptor_construct(
|
|
sense_data + offset,
|
|
sense_len - offset,
|
|
information_buff);
|
|
|
|
offset += SCSI_INFORMATION_DESCRIPTOR_LENGTH;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the descriptor sense data buffer in
|
|
* the user's sense data buffer location. Additionally, it will set
|
|
* the user's SCSI status.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to construct the sense data.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[in] sense_key This parameter specifies the sense key to
|
|
* be set for the user's IO request.
|
|
* @param[in] additional_sense_code This parameter specifies the
|
|
* additional sense code (ASC) key to be set for the user's
|
|
* IO request.
|
|
* @param[in] additional_sense_code_qualifier This parameter specifies
|
|
* the additional sense code qualifier (ASCQ) key to be set
|
|
* for the user's IO request.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_scsi_descriptor_sense_data_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U8 scsi_status,
|
|
U8 response_code,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
U8 * sense_data;
|
|
U32 sense_len;
|
|
|
|
sati_scsi_get_sense_data_buffer(sequence, scsi_io, scsi_status, &sense_data, &sense_len);
|
|
|
|
sati_set_sense_data_byte(
|
|
sense_data,
|
|
sense_len,
|
|
0,
|
|
response_code
|
|
);
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 1, sense_key);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 2, additional_sense_code);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 3, additional_sense_code_qualifier);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 4, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 5, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 6, 0);
|
|
|
|
sati_scsi_common_descriptors_construct(scsi_io, sense_data + 8, sense_len, NULL);
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 7, sati_scsi_get_descriptor_sense_data_length(sequence, scsi_io) - 8);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the fixed format sense data buffer
|
|
* in the user's sense data buffer location. Additionally, it will
|
|
* set the user's SCSI status.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to construct the sense data.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[in] sense_key This parameter specifies the sense key to
|
|
* be set for the user's IO request.
|
|
* @param[in] additional_sense_code This parameter specifies the
|
|
* additional sense code (ASC) key to be set for the user's
|
|
* IO request.
|
|
* @param[in] additional_sense_code_qualifier This parameter specifies
|
|
* the additional sense code qualifier (ASCQ) key to be set
|
|
* for the user's IO request.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_scsi_fixed_sense_data_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U8 scsi_status,
|
|
U8 response_code,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
U8 * sense_data;
|
|
U32 sense_len;
|
|
|
|
sati_scsi_get_sense_data_buffer(sequence, scsi_io, scsi_status, &sense_data, &sense_len);
|
|
|
|
// Write out the sense data format per SPC-4.
|
|
// We utilize the fixed format sense data format.
|
|
|
|
sati_set_sense_data_byte(
|
|
sense_data,
|
|
sense_len,
|
|
0,
|
|
response_code | SCSI_FIXED_SENSE_DATA_VALID_BIT
|
|
);
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 1, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 2, sense_key);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 3, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 4, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 5, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 6, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 7, (sense_len < 18 ? sense_len - 1 : 17) - 7);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 8, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 9, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 10, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 11, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 12, additional_sense_code);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 13, additional_sense_code_qualifier);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 14, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 15, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 16, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 17, 0);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct common sense data that will be identical in
|
|
* both read error sense construct functions.
|
|
* sati_scsi_read_ncq_error_sense_construct,
|
|
* sati_scsi_read_error_sense_construct
|
|
*
|
|
* @param[in] sense_data This parameter specifies the user SCSI IO request
|
|
* for which to set the sense data byte.
|
|
* @param[in] sense_len This parameter specifies length of the sense data
|
|
* to be returned by SATI.
|
|
* @param[in] sense_key This parameter specifies the sense key to
|
|
* be set for the user's IO request.
|
|
* @param[in] additional_sense_code This parameter specifies the
|
|
* additional sense code (ASC) key to be set for the user's
|
|
* IO request.
|
|
* @param[in] additional_sense_code_qualifier This parameter specifies
|
|
* the additional sense code qualifier (ASCQ) key to be set
|
|
* for the user's IO request.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_common_fixed_sense_construct(
|
|
U8 * sense_data,
|
|
U32 sense_len,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 1, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 2, sense_key);
|
|
|
|
//Bytes 3, 4, 5, 6 are set in read_error_sense_construct functions
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 7, (sense_len < 18 ? sense_len - 1 : 17) - 7);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 8, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 9, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 10, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 11, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 12, additional_sense_code);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 13, additional_sense_code_qualifier);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 14, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 15, 0x80);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 16, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 17, 0);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the descriptor sense data buffer in
|
|
* the user's sense data buffer location. Additionally, it will set
|
|
* the user's SCSI status.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to construct the sense data.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[in] sense_key This parameter specifies the sense key to
|
|
* be set for the user's IO request.
|
|
* @param[in] additional_sense_code This parameter specifies the
|
|
* additional sense code (ASC) key to be set for the user's
|
|
* IO request.
|
|
* @param[in] additional_sense_code_qualifier This parameter specifies
|
|
* the additional sense code qualifier (ASCQ) key to be set
|
|
* for the user's IO request.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_common_descriptor_sense_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U8 * sense_data,
|
|
U32 sense_len,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier,
|
|
U8 * information_buff
|
|
)
|
|
{
|
|
sati_set_sense_data_byte(sense_data, sense_len, 1, sense_key);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 2, additional_sense_code);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 3, additional_sense_code_qualifier);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 4, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 5, 0);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 6, 0);
|
|
|
|
sati_scsi_common_descriptors_construct(scsi_io, sense_data + 8, sense_len, information_buff);
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 7, sati_scsi_get_descriptor_sense_data_length(sequence, scsi_io) - 8);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the sense data buffer in the user's
|
|
* descriptor sense data buffer location. Additionally, it will set
|
|
* the user's SCSI status. This is only used for NCQ uncorrectable
|
|
* read errors
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to construct the sense data.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] ata_input_data This parameter specifies the user's ATA IO
|
|
* response from a Read Log Ext command.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[in] sense_key This parameter specifies the sense key to
|
|
* be set for the user's IO request.
|
|
* @param[in] additional_sense_code This parameter specifies the
|
|
* additional sense code (ASC) key to be set for the user's
|
|
* IO request.
|
|
* @param[in] additional_sense_code_qualifier This parameter specifies
|
|
* the additional sense code qualifier (ASCQ) key to be set
|
|
* for the user's IO request.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_read_ncq_error_descriptor_sense_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_input_data,
|
|
U8 scsi_status,
|
|
U8 response_code,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
U8 * sense_data;
|
|
U32 sense_len;
|
|
|
|
U8 information_buff[8] = {0};
|
|
|
|
ATA_NCQ_COMMAND_ERROR_LOG_T * ncq_log = (ATA_NCQ_COMMAND_ERROR_LOG_T *) ata_input_data;
|
|
|
|
sati_scsi_get_sense_data_buffer(sequence, scsi_io, scsi_status, &sense_data, &sense_len);
|
|
|
|
sati_set_sense_data_byte(
|
|
sense_data,
|
|
sense_len,
|
|
0,
|
|
response_code
|
|
);
|
|
|
|
information_buff[2] = ncq_log->lba_47_40;
|
|
information_buff[3] = ncq_log->lba_39_32;
|
|
information_buff[4] = ncq_log->lba_31_24;
|
|
information_buff[5] = ncq_log->lba_23_16;
|
|
information_buff[6] = ncq_log->lba_15_8;
|
|
information_buff[7] = ncq_log->lba_7_0;
|
|
|
|
sati_scsi_common_descriptor_sense_construct(
|
|
sequence,
|
|
scsi_io,
|
|
sense_data,
|
|
sense_len,
|
|
sense_key,
|
|
additional_sense_code,
|
|
additional_sense_code_qualifier,
|
|
information_buff
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the sense data buffer in the user's
|
|
* sense data buffer location. Additionally, it will set the user's
|
|
* SCSI status. This is only used for NCQ uncorrectable read errors
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to construct the sense data.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] ata_input_data This parameter specifies the user's ATA IO
|
|
* response from a Read Log Ext command.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[in] sense_key This parameter specifies the sense key to
|
|
* be set for the user's IO request.
|
|
* @param[in] additional_sense_code This parameter specifies the
|
|
* additional sense code (ASC) key to be set for the user's
|
|
* IO request.
|
|
* @param[in] additional_sense_code_qualifier This parameter specifies
|
|
* the additional sense code qualifier (ASCQ) key to be set
|
|
* for the user's IO request.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_read_ncq_error_fixed_sense_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_input_data,
|
|
U8 scsi_status,
|
|
U8 response_code,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
U8 * sense_data;
|
|
U32 sense_len;
|
|
U8 valid = TRUE;
|
|
|
|
ATA_NCQ_COMMAND_ERROR_LOG_T * ncq_log = (ATA_NCQ_COMMAND_ERROR_LOG_T *) ata_input_data;
|
|
|
|
sati_scsi_get_sense_data_buffer(sequence, scsi_io, scsi_status, &sense_data, &sense_len);
|
|
|
|
if(ncq_log->lba_39_32 > 0)
|
|
{
|
|
valid = FALSE;
|
|
}
|
|
|
|
sati_set_sense_data_byte(
|
|
sense_data,
|
|
sense_len,
|
|
0,
|
|
(valid << 7) | response_code
|
|
);
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 3, ncq_log->lba_31_24);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 4, ncq_log->lba_23_16);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 5, ncq_log->lba_15_8);
|
|
sati_set_sense_data_byte(sense_data, sense_len, 6, ncq_log->lba_7_0);
|
|
|
|
sati_scsi_common_fixed_sense_construct(
|
|
sense_data,
|
|
sense_len,
|
|
sense_key,
|
|
additional_sense_code,
|
|
additional_sense_code_qualifier
|
|
);
|
|
}
|
|
|
|
void sati_scsi_read_ncq_error_sense_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_input_data,
|
|
U8 scsi_status,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
U8 response_code;
|
|
|
|
response_code = sati_scsi_get_sense_data_response_code(sequence);
|
|
|
|
switch (response_code)
|
|
{
|
|
case SCSI_FIXED_CURRENT_RESPONSE_CODE:
|
|
case SCSI_FIXED_DEFERRED_RESPONSE_CODE:
|
|
sati_scsi_read_ncq_error_fixed_sense_construct(sequence, scsi_io, ata_input_data, scsi_status,
|
|
response_code, sense_key, additional_sense_code, additional_sense_code_qualifier);
|
|
break;
|
|
case SCSI_DESCRIPTOR_CURRENT_RESPONSE_CODE:
|
|
case SCSI_DESCRIPTOR_DEFERRED_RESPONSE_CODE:
|
|
sati_scsi_read_ncq_error_descriptor_sense_construct(sequence, scsi_io, ata_input_data, scsi_status,
|
|
response_code, sense_key, additional_sense_code, additional_sense_code_qualifier);
|
|
break;
|
|
}
|
|
|
|
sequence->is_sense_response_set = TRUE;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the sense data buffer in the user's
|
|
* sense data buffer location. Additionally, it will set the user's
|
|
* SCSI status. This is used for uncorrectable read errors.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to construct the sense data.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] ata_io This parameter is a pointer to the ATA IO data used
|
|
* to get the ATA register fis.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[in] sense_key This parameter specifies the sense key to
|
|
* be set for the user's IO request.
|
|
* @param[in] additional_sense_code This parameter specifies the
|
|
* additional sense code (ASC) key to be set for the user's
|
|
* IO request.
|
|
* @param[in] additional_sense_code_qualifier This parameter specifies
|
|
* the additional sense code qualifier (ASCQ) key to be set
|
|
* for the user's IO request.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_read_error_descriptor_sense_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_io,
|
|
U8 scsi_status,
|
|
U8 response_code,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
U8 * sense_data;
|
|
U32 sense_len;
|
|
U8 information_buff[8] = {0};
|
|
|
|
U8 * register_fis = sati_cb_get_d2h_register_fis_address(ata_io);
|
|
|
|
sati_scsi_get_sense_data_buffer(sequence, scsi_io, scsi_status, &sense_data, &sense_len);
|
|
|
|
information_buff[2] = sati_get_ata_lba_high_ext(register_fis);
|
|
information_buff[3] = sati_get_ata_lba_mid_ext(register_fis);
|
|
information_buff[4] = sati_get_ata_lba_low_ext(register_fis);
|
|
information_buff[5] = sati_get_ata_lba_high(register_fis);
|
|
information_buff[6] = sati_get_ata_lba_mid(register_fis);
|
|
information_buff[7] = sati_get_ata_lba_low(register_fis);
|
|
|
|
sati_set_sense_data_byte(
|
|
sense_data,
|
|
sense_len,
|
|
0,
|
|
SCSI_DESCRIPTOR_CURRENT_RESPONSE_CODE
|
|
);
|
|
|
|
sati_scsi_common_descriptor_sense_construct(
|
|
sequence,
|
|
scsi_io,
|
|
sense_data,
|
|
sense_len,
|
|
sense_key,
|
|
additional_sense_code,
|
|
additional_sense_code_qualifier,
|
|
information_buff
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the sense data buffer in the user's
|
|
* sense data buffer location. Additionally, it will set the user's
|
|
* SCSI status. This is used for uncorrectable read errors.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to construct the sense data.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] ata_io This parameter is a pointer to the ATA IO data used
|
|
* to get the ATA register fis.
|
|
* @param[in] scsi_status This parameter specifies the SCSI status
|
|
* value for the user's IO request.
|
|
* @param[in] sense_key This parameter specifies the sense key to
|
|
* be set for the user's IO request.
|
|
* @param[in] additional_sense_code This parameter specifies the
|
|
* additional sense code (ASC) key to be set for the user's
|
|
* IO request.
|
|
* @param[in] additional_sense_code_qualifier This parameter specifies
|
|
* the additional sense code qualifier (ASCQ) key to be set
|
|
* for the user's IO request.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void sati_scsi_read_error_fixed_sense_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_io,
|
|
U8 scsi_status,
|
|
U8 response_code,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
U8 * sense_data;
|
|
U32 sense_len;
|
|
U8 valid = TRUE;
|
|
|
|
U8 * register_fis = sati_cb_get_d2h_register_fis_address(ata_io);
|
|
|
|
sati_scsi_get_sense_data_buffer(sequence, scsi_io, scsi_status, &sense_data, &sense_len);
|
|
|
|
if(sati_get_ata_lba_mid_ext(register_fis) > 0)
|
|
{
|
|
valid = FALSE;
|
|
}
|
|
|
|
sati_set_sense_data_byte(sense_data, sense_len, 3, sati_get_ata_lba_low_ext(register_fis));
|
|
sati_set_sense_data_byte(sense_data, sense_len, 4, sati_get_ata_lba_high(register_fis));
|
|
sati_set_sense_data_byte(sense_data, sense_len, 5, sati_get_ata_lba_mid(register_fis));
|
|
sati_set_sense_data_byte(sense_data, sense_len, 6, sati_get_ata_lba_low(register_fis));
|
|
|
|
|
|
sati_set_sense_data_byte(
|
|
sense_data,
|
|
sense_len,
|
|
0,
|
|
(valid << 7) | SCSI_FIXED_CURRENT_RESPONSE_CODE
|
|
);
|
|
|
|
sati_scsi_common_fixed_sense_construct(
|
|
sense_data,
|
|
sense_len,
|
|
sense_key,
|
|
additional_sense_code,
|
|
additional_sense_code_qualifier
|
|
);
|
|
}
|
|
|
|
void sati_scsi_read_error_sense_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_input_data,
|
|
U8 scsi_status,
|
|
U8 sense_key,
|
|
U8 additional_sense_code,
|
|
U8 additional_sense_code_qualifier
|
|
)
|
|
{
|
|
U8 response_code;
|
|
|
|
response_code = sati_scsi_get_sense_data_response_code(sequence);
|
|
|
|
switch (response_code)
|
|
{
|
|
case SCSI_FIXED_CURRENT_RESPONSE_CODE:
|
|
case SCSI_FIXED_DEFERRED_RESPONSE_CODE:
|
|
sati_scsi_read_error_fixed_sense_construct(sequence, scsi_io, ata_input_data, scsi_status,
|
|
response_code, sense_key, additional_sense_code, additional_sense_code_qualifier);
|
|
break;
|
|
case SCSI_DESCRIPTOR_CURRENT_RESPONSE_CODE:
|
|
case SCSI_DESCRIPTOR_DEFERRED_RESPONSE_CODE:
|
|
sati_scsi_read_error_descriptor_sense_construct(sequence, scsi_io, ata_input_data, scsi_status,
|
|
response_code, sense_key, additional_sense_code, additional_sense_code_qualifier);
|
|
break;
|
|
}
|
|
|
|
sequence->is_sense_response_set = TRUE;
|
|
}
|
|
|
|
/*
|
|
* @brief This method builds the scsi response data for a sata task management
|
|
* request.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to construct the sense data.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to construct the sense data.
|
|
* @param[in] response_data The response status for the task management
|
|
* request.
|
|
*/
|
|
void sati_scsi_response_data_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U8 response_data
|
|
)
|
|
{
|
|
#ifdef SATI_TRANSPORT_SUPPORTS_SAS
|
|
SCI_SSP_RESPONSE_IU_T * rsp_iu = (SCI_SSP_RESPONSE_IU_T*)
|
|
sati_cb_get_response_iu_address(scsi_io);
|
|
rsp_iu->data_present = 0x01;
|
|
rsp_iu->response_data_length[3] = sizeof(U32);
|
|
rsp_iu->status = 0;
|
|
((U8 *)rsp_iu->data)[3] = response_data;
|
|
#else
|
|
#endif // SATI_TRANSPORT_SUPPORTS_SAS
|
|
}
|
|
|
|
/**
|
|
* @brief This method checks to make sure that the translation isn't
|
|
* exceeding the allocation length specified in the CDB prior
|
|
* to retrieving the payload data byte from the user's buffer.
|
|
*
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to set the user payload data byte.
|
|
* @param[in] byte_offset This parameter specifies the offset into
|
|
* the user's payload buffer at which to write the supplied
|
|
* value.
|
|
* @param[in] value This parameter specifies the memory location into
|
|
* which to read the value from the user's payload buffer.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_get_data_byte(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U32 byte_offset,
|
|
U8 * value
|
|
)
|
|
{
|
|
if (byte_offset < sequence->allocation_length)
|
|
sati_cb_get_data_byte(scsi_io, byte_offset, value);
|
|
}
|
|
|
|
/**
|
|
* @brief This method checks to make sure that the translation isn't
|
|
* exceeding the allocation length specified in the CDB while
|
|
* translating payload data into the user's buffer.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to set the user payload data byte.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to set the user payload data byte.
|
|
* @param[in] byte_offset This parameter specifies the offset into
|
|
* the user's payload buffer at which to write the supplied
|
|
* value.
|
|
* @param[in] value This parameter specifies the new value to be
|
|
* written out into the user's payload buffer.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_set_data_byte(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U32 byte_offset,
|
|
U8 value
|
|
)
|
|
{
|
|
if (byte_offset < sequence->allocation_length)
|
|
{
|
|
sequence->number_data_bytes_set++;
|
|
sati_cb_set_data_byte(scsi_io, byte_offset, value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method checks to make sure that the translation isn't
|
|
* exceeding the allocation length specified in the CDB while
|
|
* translating payload data into the user's buffer.
|
|
*
|
|
* @param[in] sequence This parameter specifies the translation sequence
|
|
* for which to set the user payload data dword.
|
|
* @param[in,out] scsi_io This parameter specifies the user's IO request
|
|
* for which to set the user payload data dword.
|
|
* @param[in] byte_offset This parameter specifies the offset into
|
|
* the user's payload buffer at which to write the supplied
|
|
* value.
|
|
* @param[in] value This parameter specifies the new value to be
|
|
* written out into the user's payload buffer.
|
|
*
|
|
* @return none
|
|
*/
|
|
void sati_set_data_dword(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U32 byte_offset,
|
|
U32 value
|
|
)
|
|
{
|
|
/// @todo Check to ensure that the bytes appear correctly (SAS Address).
|
|
|
|
sati_set_data_byte(sequence, scsi_io, byte_offset, (U8)value & 0xFF);
|
|
byte_offset++;
|
|
sati_set_data_byte(sequence, scsi_io, byte_offset, (U8)(value >> 8) & 0xFF);
|
|
byte_offset++;
|
|
sati_set_data_byte(sequence, scsi_io, byte_offset, (U8)(value >> 16) & 0xFF);
|
|
byte_offset++;
|
|
sati_set_data_byte(sequence, scsi_io, byte_offset, (U8)(value >> 24) & 0xFF);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA flush cache command.
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the FLUSH CACHE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_flush_cache_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_FLUSH_CACHE);
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA standby immediate command.
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the STANDBY IMMEDIATE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @param[in] count This parameter specifies the time period programmed
|
|
* into the Standby Timer. See ATA8 spec for more details
|
|
* @return none.
|
|
*/
|
|
void sati_ata_standby_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
U16 count
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_STANDBY);
|
|
sati_set_ata_sector_count(register_fis, count);
|
|
|
|
sequence->device->ata_standby_timer = (U8) count;
|
|
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA standby immediate command.
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the STANDBY IMMEDIATE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_standby_immediate_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_STANDBY_IMMED);
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA idle immediate command.
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the IDLE IMMEDIATE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_idle_immediate_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_IDLE_IMMED);
|
|
sati_set_ata_features(register_fis, 0x00);
|
|
sati_set_ata_sector_count(register_fis, 0x00);
|
|
sati_set_ata_lba_high(register_fis, 0x00);
|
|
sati_set_ata_lba_mid(register_fis, 0x00);
|
|
sati_set_ata_lba_low(register_fis, 0x00);
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA idle immediate command
|
|
for Unload Features.
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the IDLE IMMEDIATE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_idle_immediate_unload_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_IDLE_IMMED);
|
|
sati_set_ata_features(register_fis, 0x44);
|
|
sati_set_ata_sector_count(register_fis, 0x00);
|
|
sati_set_ata_lba_high(register_fis, 0x55);
|
|
sati_set_ata_lba_mid(register_fis, 0x4E);
|
|
sati_set_ata_lba_low(register_fis, 0x4C);
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA IDLE command.\
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the ATA IDLE command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_idle_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_IDLE);
|
|
sati_set_ata_features(register_fis, 0x00);
|
|
sati_set_ata_sector_count(register_fis, 0x00);
|
|
|
|
sequence->device->ata_standby_timer = 0x00;
|
|
|
|
sati_set_ata_lba_high(register_fis, 0x00);
|
|
sati_set_ata_lba_mid(register_fis, 0x00);
|
|
sati_set_ata_lba_low(register_fis, 0x00);
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the ATA MEDIA EJECT command.
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the MEDIA EJCT command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_media_eject_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_MEDIA_EJECT);
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief This method will construct the ATA read verify sector(s) command.
|
|
*
|
|
* @pre It is expected that the user has properly set the current contents
|
|
* of the register FIS to 0.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the ATA READ VERIFY SECTOR(S) command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
*
|
|
* @return none.
|
|
*/
|
|
void sati_ata_read_verify_sectors_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_READ_VERIFY_SECTORS);
|
|
|
|
//According to SAT-2 (v7) 9.11.3
|
|
sati_set_ata_sector_count(register_fis, 1);
|
|
|
|
//According to SAT-2 (v7) 9.11.3, set LBA to a value between zero and the
|
|
//maximum LBA supported by the ATA device in its current configuration.
|
|
//From the unit test, it seems we have to set LBA to a non-zero value.
|
|
sati_set_ata_lba_low(register_fis, 1);
|
|
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct a ATA SMART Return Status command so the
|
|
* status of the ATA device can be returned. The status of the SMART
|
|
* threshold will be returned by this command.
|
|
*
|
|
* @return N/A
|
|
*
|
|
*/
|
|
void sati_ata_smart_return_status_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
U8 feature_value
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_SMART);
|
|
|
|
sati_set_ata_features(register_fis, feature_value);
|
|
|
|
sati_set_ata_lba_high(register_fis, 0xC2);
|
|
sati_set_ata_lba_mid(register_fis, 0x4F);
|
|
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct a ATA SMART Return Status command so the
|
|
* status of the ATA device can be returned. The status of the SMART
|
|
* threshold will be returned by this command.
|
|
*
|
|
* @return N/A
|
|
*
|
|
*/
|
|
void sati_ata_smart_read_log_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
U8 log_address,
|
|
U32 transfer_length
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_SMART);
|
|
sati_set_ata_features(register_fis, ATA_SMART_SUB_CMD_READ_LOG);
|
|
|
|
sati_set_ata_lba_high(register_fis, 0xC2);
|
|
sati_set_ata_lba_mid(register_fis, 0x4F);
|
|
sati_set_ata_lba_low(register_fis, log_address);
|
|
|
|
sequence->data_direction = SATI_DATA_DIRECTION_IN;
|
|
sequence->protocol = SAT_PROTOCOL_PIO_DATA_IN;
|
|
sequence->ata_transfer_length = transfer_length;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct a Write Uncorrectable ATA command that
|
|
* will write one sector with a pseudo or flagged error. The type of
|
|
* error is specified by the feature value.
|
|
*
|
|
* @return N/A
|
|
*
|
|
*/
|
|
void sati_ata_write_uncorrectable_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
U8 feature_value
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_WRITE_UNCORRECTABLE);
|
|
sati_set_ata_features(register_fis, feature_value);
|
|
sati_set_ata_sector_count(register_fis, 0x0001);
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct a Mode Select ATA SET FEATURES command
|
|
* For example, Enable/Disable Write Cache, Enable/Disable Read Ahead
|
|
*
|
|
* @return N/A
|
|
*
|
|
*/
|
|
void sati_ata_set_features_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
U8 feature
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_SET_FEATURES);
|
|
sati_set_ata_features(register_fis, feature);
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief This method will construct a Read Log ext ATA command that
|
|
* will request a log page based on the log_address.
|
|
*
|
|
* @param[in] log_address This parameter specifies the log page
|
|
* to be returned from Read Log Ext.
|
|
*
|
|
* @param[in] transfer_length This parameter specifies the size of the
|
|
* log page response returned by Read Log Ext.
|
|
*
|
|
* @return N/A
|
|
*
|
|
*/
|
|
void sati_ata_read_log_ext_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
U8 log_address,
|
|
U32 transfer_length
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_READ_LOG_EXT);
|
|
|
|
sati_set_ata_lba_low(register_fis, log_address);
|
|
sati_set_ata_lba_mid(register_fis, 0x00);
|
|
sati_set_ata_lba_mid_exp(register_fis, 0x00);
|
|
|
|
sati_set_ata_sector_count(register_fis, 0x01);
|
|
|
|
sequence->data_direction = SATI_DATA_DIRECTION_IN;
|
|
sequence->protocol = SAT_PROTOCOL_PIO_DATA_IN;
|
|
sequence->ata_transfer_length = transfer_length;
|
|
|
|
}
|
|
|
|
/**
|
|
* @brief This method will check if the ATA device is in the stopped power
|
|
* state. This is used for all medium access commands for SAT
|
|
* compliance. See SAT2r07 section 9.11.1
|
|
*
|
|
* @param[in] sequence - SATI sequence data with the device state.
|
|
*
|
|
* @return TRUE If device is stopped
|
|
*
|
|
*/
|
|
BOOL sati_device_state_stopped(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io
|
|
)
|
|
{
|
|
if(sequence->device->state == SATI_DEVICE_STATE_STOPPED)
|
|
{
|
|
sati_scsi_sense_data_construct(
|
|
sequence,
|
|
scsi_io,
|
|
SCSI_STATUS_CHECK_CONDITION,
|
|
SCSI_SENSE_NOT_READY ,
|
|
SCSI_ASC_INITIALIZING_COMMAND_REQUIRED,
|
|
SCSI_ASCQ_INITIALIZING_COMMAND_REQUIRED
|
|
);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct a ATA Read Buffer command that
|
|
* will request PIO in data containing the target device's buffer.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the ATA READ VERIFY SECTOR(S) command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
* @return N/A
|
|
*
|
|
*/
|
|
void sati_ata_read_buffer_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_READ_BUFFER);
|
|
sequence->data_direction = SATI_DATA_DIRECTION_IN;
|
|
sequence->protocol = SAT_PROTOCOL_PIO_DATA_IN;
|
|
sequence->ata_transfer_length = 512;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief This method will construct a ATA Write Buffer command that
|
|
* will send PIO out data to the target device's buffer.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the ATA READ VERIFY SECTOR(S) command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
* @return N/A
|
|
*
|
|
*/
|
|
void sati_ata_write_buffer_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
|
|
sati_set_ata_command(register_fis, ATA_WRITE_BUFFER);
|
|
|
|
sequence->data_direction = SATI_DATA_DIRECTION_OUT;
|
|
sequence->protocol = SAT_PROTOCOL_PIO_DATA_OUT;
|
|
sequence->ata_transfer_length = 512;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief This method will construct a ATA Download Microcode command that
|
|
* will send PIO out data containing new firmware for the target drive.
|
|
*
|
|
* @param[out] ata_io This parameter specifies the ATA IO request structure
|
|
* for which to build the ATA READ VERIFY SECTOR(S) command.
|
|
* @param[in] sequence This parameter specifies the translator sequence
|
|
* for which the command is being constructed.
|
|
* @param[in] mode This parameter specifies the download microcode sub-command
|
|
* code.
|
|
* @param[in] allocation_length This parameter specifies the number of bytes
|
|
* being sent to the target device.
|
|
* @param[in] buffer_offset This parameter specifies the buffer offset for the
|
|
* data sent to the target device.
|
|
*
|
|
* @return N/A
|
|
*
|
|
*/
|
|
void sati_ata_download_microcode_construct(
|
|
void * ata_io,
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
U8 mode,
|
|
U32 allocation_length,
|
|
U32 buffer_offset
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
|
|
U32 allocation_blocks = allocation_length >> 9;
|
|
U32 buffer_blkoffset = buffer_offset >> 9;
|
|
|
|
sati_set_ata_command(register_fis, ATA_DOWNLOAD_MICROCODE);
|
|
sati_set_ata_features(register_fis, mode);
|
|
|
|
if(mode == ATA_MICROCODE_DOWNLOAD_SAVE)
|
|
{
|
|
sati_set_ata_sector_count(register_fis, (U8) (allocation_length >> 9));
|
|
sati_set_ata_lba_low(register_fis, (U8) (allocation_length >> 17));
|
|
}
|
|
else //mode == 0x03
|
|
{
|
|
sati_set_ata_sector_count(register_fis, (U8) (allocation_blocks & 0xff));
|
|
sati_set_ata_lba_low(register_fis, (U8) ((allocation_blocks >> 8) & 0xff));
|
|
sati_set_ata_lba_mid(register_fis, (U8) (buffer_blkoffset & 0xff));
|
|
sati_set_ata_lba_high(register_fis, (U8) ((buffer_blkoffset >> 8) & 0xff));
|
|
}
|
|
|
|
if((allocation_length == 0) && (buffer_offset == 0))
|
|
{
|
|
sati_ata_non_data_command(ata_io, sequence);
|
|
}
|
|
else
|
|
{
|
|
sequence->data_direction = SATI_DATA_DIRECTION_OUT;
|
|
sequence->protocol = SAT_PROTOCOL_PIO_DATA_OUT;
|
|
sequence->ata_transfer_length = allocation_length;
|
|
}
|
|
}
|