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.
810 lines
24 KiB
C
810 lines
24 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 definitions to translate
|
|
* SCSI Log Sense command based of the SATv2 spec.
|
|
*/
|
|
|
|
#if !defined(DISABLE_SATI_LOG_SENSE)
|
|
|
|
#include <dev/isci/scil/sati_log_sense.h>
|
|
#include <dev/isci/scil/sati_callbacks.h>
|
|
#include <dev/isci/scil/sati_util.h>
|
|
|
|
//******************************************************************************
|
|
//* P R I V A T E M E T H O D S
|
|
//******************************************************************************
|
|
|
|
/**
|
|
* @brief This method constructs the SATI supported log page. This is a log
|
|
* containing the page codes of all the SATI supported log pages.
|
|
*
|
|
* @return n/a
|
|
*
|
|
*/
|
|
static
|
|
void sati_supported_log_page_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io
|
|
)
|
|
{
|
|
U32 next_byte;
|
|
//set SPF = 0 and PAGE_CODE = 0
|
|
sati_set_data_byte(sequence, scsi_io, 0, 0x00);
|
|
|
|
//set SUBPAGE_CODE = 0
|
|
sati_set_data_byte(sequence, scsi_io, 1, 0x00);
|
|
|
|
//set the Page Length to (n-3) or 2 because only two log pages are supported
|
|
sati_set_data_byte(sequence, scsi_io, 2, 0x00);
|
|
sati_set_data_byte(sequence, scsi_io, 3, 0x02);
|
|
|
|
//specify the next byte to be set
|
|
next_byte = 4;
|
|
|
|
if(sequence->device->capabilities & SATI_DEVICE_CAP_SMART_SUPPORT)
|
|
{
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
next_byte,
|
|
SCSI_LOG_PAGE_INFORMATION_EXCEPTION
|
|
);
|
|
next_byte = 5;
|
|
}
|
|
|
|
if(sequence->device->capabilities & SATI_DEVICE_CAP_SMART_SELF_TEST_SUPPORT)
|
|
{
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
next_byte,
|
|
SCSI_LOG_PAGE_SELF_TEST
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method sets bytes 4-19 of the self-test log parameter to zero.
|
|
*
|
|
* @return n/a
|
|
*
|
|
*/
|
|
static
|
|
void sati_set_parameters_to_zero(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io
|
|
)
|
|
{
|
|
sati_set_data_byte(sequence, scsi_io, 8, 0x00); //log_parameter byte 4
|
|
sati_set_data_byte(sequence, scsi_io, 9, 0x00); //log_parameter byte 5
|
|
sati_set_data_byte(sequence, scsi_io, 10, 0x00); //log_parameter byte 6
|
|
sati_set_data_byte(sequence, scsi_io, 11, 0x00); //log_parameter byte 7
|
|
sati_set_data_byte(sequence, scsi_io, 12, 0x00); //log_parameter byte 8
|
|
sati_set_data_byte(sequence, scsi_io, 13, 0x00); //log_parameter byte 9
|
|
sati_set_data_byte(sequence, scsi_io, 14, 0x00); //log_parameter byte 10
|
|
sati_set_data_byte(sequence, scsi_io, 15, 0x00); //log_parameter byte 11
|
|
sati_set_data_byte(sequence, scsi_io, 16, 0x00); //log_parameter byte 12
|
|
sati_set_data_byte(sequence, scsi_io, 17, 0x00); //log_parameter byte 13
|
|
sati_set_data_byte(sequence, scsi_io, 18, 0x00); //log_parameter byte 14
|
|
sati_set_data_byte(sequence, scsi_io, 19, 0x00); //log_parameter byte 15
|
|
sati_set_data_byte(sequence, scsi_io, 20, 0x00); //log_parameter byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 21, 0x00); //log_parameter byte 17
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x00); //log_parameter byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 23, 0x00); //log_parameter byte 19
|
|
}
|
|
|
|
/**
|
|
* @brief This method translates the ATA Extended SMART self-test log into
|
|
* SCSI Sense Key, Additional Sense Code, and Additional Sense code
|
|
* qualifiers based on the self test status byte in the appropriate
|
|
* descriptor entry.
|
|
*
|
|
* @return n/a
|
|
*
|
|
*/
|
|
static
|
|
void sati_translate_sense_values(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
U8 self_test_status_byte
|
|
)
|
|
{
|
|
//byte 17
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
21,
|
|
SCSI_DIAGNOSTIC_FAILURE_ON_COMPONENT
|
|
);
|
|
|
|
switch(self_test_status_byte)
|
|
{
|
|
case 1:
|
|
//byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 20, SCSI_SENSE_ABORTED_COMMAND);
|
|
|
|
//byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x81);
|
|
break;
|
|
|
|
case 2:
|
|
//byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 20, SCSI_SENSE_ABORTED_COMMAND);
|
|
|
|
//byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x82);
|
|
break;
|
|
|
|
case 3:
|
|
//byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 20, SCSI_SENSE_ABORTED_COMMAND);
|
|
|
|
//byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x83);
|
|
break;
|
|
|
|
case 4:
|
|
//byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 20, SCSI_SENSE_HARDWARE_ERROR);
|
|
|
|
//byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x84);
|
|
break;
|
|
|
|
case 5:
|
|
//byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 20, SCSI_SENSE_HARDWARE_ERROR);
|
|
|
|
//byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x85);
|
|
break;
|
|
|
|
case 6:
|
|
//byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 20, SCSI_SENSE_HARDWARE_ERROR);
|
|
|
|
//byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x86);
|
|
break;
|
|
|
|
case 7:
|
|
//byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 20, SCSI_SENSE_MEDIUM_ERROR);
|
|
|
|
//byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x87);
|
|
break;
|
|
|
|
case 8:
|
|
//byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 20, SCSI_SENSE_HARDWARE_ERROR);
|
|
|
|
//byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x88);
|
|
break;
|
|
|
|
default:
|
|
//byte 16
|
|
sati_set_data_byte(sequence, scsi_io, 20, SCSI_SENSE_NO_SENSE);
|
|
//byte 17
|
|
sati_set_data_byte(sequence, scsi_io, 21, SCSI_ASC_NO_ADDITIONAL_SENSE);
|
|
//byte 18
|
|
sati_set_data_byte(sequence, scsi_io, 22, 0x00);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* @brief This method retrieves the correct self-test results by checking the
|
|
* descriptor index in the extended SMART self-test log. The index is
|
|
* used to determine the appropriate descriptor entry.
|
|
*
|
|
* @return n/a
|
|
*
|
|
*/
|
|
static
|
|
void sati_get_self_test_results(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
ATA_EXTENDED_SMART_SELF_TEST_LOG_T * ata_log
|
|
)
|
|
{
|
|
U16 descriptor_index = *((U16 *)(&ata_log->self_test_descriptor_index[0]));
|
|
|
|
/*
|
|
* SATv2 wants data from descriptor N where N is equal to
|
|
* (descriptor_index - parameter_code) + 1. Since parameter
|
|
* code is always 0x0001 just checking descriptor_index.
|
|
*/
|
|
|
|
if(descriptor_index <= 0)
|
|
{
|
|
sati_set_parameters_to_zero(sequence, scsi_io);
|
|
}
|
|
else
|
|
{
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
8,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.status_byte
|
|
);
|
|
|
|
//Sef-test number unspecified per satv2
|
|
sati_set_data_byte(sequence, scsi_io, 9, 0x00);
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
10,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.time_stamp_high
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
11,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.time_stamp_low
|
|
);
|
|
|
|
//set to zero because it's a 48bit address
|
|
sati_set_data_byte(sequence, scsi_io, 12, 0x00);
|
|
sati_set_data_byte(sequence, scsi_io, 13, 0x00);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
14,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.failing_lba_high_ext
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
15,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.failing_lba_mid_ext
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
16,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.failing_lba_low_ext
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
17,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.failing_lba_high
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
18,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.failing_lba_mid
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
19,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.failing_lba_low
|
|
);
|
|
|
|
sati_translate_sense_values(
|
|
sequence,
|
|
scsi_io,
|
|
ata_log->descriptor_entrys[descriptor_index].DESCRIPTOR_ENTRY.status_byte
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the first eight bytes of the SCSI self test
|
|
* log page for both cases when SATI sends a ATA read log ext and a smart
|
|
* read log command.
|
|
*
|
|
* @return n/a
|
|
*
|
|
*/
|
|
static
|
|
void sati_self_test_log_header_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io
|
|
)
|
|
{
|
|
//PAGE CODE for Self-Test Log Page
|
|
sati_set_data_byte(sequence, scsi_io, 0, 0x10);
|
|
sati_set_data_byte(sequence, scsi_io, 1, 0x00);
|
|
|
|
//PAGE LENGTH is 0x14 instead of 0x190, not returning 20/0x190 log perameters
|
|
sati_set_data_byte(sequence, scsi_io, 2, 0x00);
|
|
sati_set_data_byte(sequence, scsi_io, 3, 0x14);
|
|
|
|
/*
|
|
* Log PARAMETER 0x0001
|
|
* Only sending one log parameter per self-test request.
|
|
*/
|
|
sati_set_data_byte(sequence, scsi_io, 4, 0x00); //log_parameter byte 0
|
|
sati_set_data_byte(sequence, scsi_io, 5, 0x01); //log_parameter byte 1
|
|
|
|
//Set to 0x03 per SATv2 spec
|
|
sati_set_data_byte(sequence, scsi_io, 6, 0x03); //log_parameter byte 2
|
|
|
|
//Parameter Length set to 0x10 per SATv2 spec
|
|
sati_set_data_byte(sequence, scsi_io, 7, 0x10); //log_parameter byte 3
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the SCSI self test log page from
|
|
* the Extended SMART self-test log response received from the
|
|
* ATA device. The response is from a ATA_Read_Log_EXT command
|
|
* issued by SATI.
|
|
*
|
|
* @return n/a
|
|
*
|
|
*/
|
|
static
|
|
void sati_extended_self_test_log_page_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_data
|
|
)
|
|
{
|
|
ATA_EXTENDED_SMART_SELF_TEST_LOG_T * ata_log =
|
|
(ATA_EXTENDED_SMART_SELF_TEST_LOG_T*) ata_data;
|
|
|
|
sati_self_test_log_header_construct(sequence, scsi_io);
|
|
|
|
//bytes 4-19
|
|
if( (ata_log->self_test_descriptor_index[0] == 0) &&
|
|
(ata_log->self_test_descriptor_index[1] == 0))
|
|
{
|
|
sati_set_parameters_to_zero(sequence, scsi_io);
|
|
}
|
|
else
|
|
{
|
|
sati_get_self_test_results(sequence, scsi_io, ata_log);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the SCSI self test log page from
|
|
* the SMART self-test log response received from the ATA device.
|
|
* The response is from a ATA_SMART_Read_Log command issued by SATI.
|
|
*
|
|
* @return n/a
|
|
*
|
|
*/
|
|
static
|
|
void sati_self_test_log_page_construct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_data
|
|
)
|
|
{
|
|
ATA_SMART_SELF_TEST_LOG_T * ata_log =
|
|
(ATA_SMART_SELF_TEST_LOG_T*) ata_data;
|
|
|
|
sati_self_test_log_header_construct(sequence, scsi_io);
|
|
|
|
//first descriptor entry(index == 0) is always used because scsi_parameter_code == 1
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
8,
|
|
ata_log->descriptor_entrys[0].SMART_DESCRIPTOR_ENTRY.status_byte
|
|
);
|
|
|
|
//Sef-test number unspecified per satv2
|
|
sati_set_data_byte(sequence, scsi_io, 9, 0x00);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
10,
|
|
ata_log->descriptor_entrys[0].SMART_DESCRIPTOR_ENTRY.time_stamp_high
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
11,
|
|
ata_log->descriptor_entrys[0].SMART_DESCRIPTOR_ENTRY.time_stamp_low
|
|
);
|
|
|
|
//set to zero because it's a 28bit address
|
|
sati_set_data_byte(sequence, scsi_io, 12, 0x00);
|
|
sati_set_data_byte(sequence, scsi_io, 13, 0x00);
|
|
sati_set_data_byte(sequence, scsi_io, 14, 0x00);
|
|
sati_set_data_byte(sequence, scsi_io, 15, 0x00);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
16,
|
|
ata_log->descriptor_entrys[0].SMART_DESCRIPTOR_ENTRY.failing_lba_low_ext
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
17,
|
|
ata_log->descriptor_entrys[0].SMART_DESCRIPTOR_ENTRY.failing_lba_high
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
18,
|
|
ata_log->descriptor_entrys[0].SMART_DESCRIPTOR_ENTRY.failing_lba_mid
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
19,
|
|
ata_log->descriptor_entrys[0].SMART_DESCRIPTOR_ENTRY.failing_lba_low
|
|
);
|
|
|
|
sati_translate_sense_values(
|
|
sequence,
|
|
scsi_io,
|
|
ata_log->descriptor_entrys[0].SMART_DESCRIPTOR_ENTRY.status_byte
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will construct the SCSI information exception log page from
|
|
* the ATA SMART response received from the ATA device. The response is
|
|
* from a ATA SMART return status command issued by SATI.
|
|
*
|
|
* @return n/a
|
|
*
|
|
*/
|
|
static
|
|
void sati_information_exception_log_page_contruct(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_io
|
|
)
|
|
{
|
|
U8 * register_fis = sati_cb_get_d2h_register_fis_address(ata_io);
|
|
U32 mid_register = sati_get_ata_lba_mid(register_fis);
|
|
U32 high_register = sati_get_ata_lba_high(register_fis);
|
|
|
|
//Information Exception Page code
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
0,
|
|
SCSI_LOG_PAGE_INFORMATION_EXCEPTION
|
|
);
|
|
|
|
//Sub-page code
|
|
sati_set_data_byte(sequence, scsi_io, 1, 0x00);
|
|
|
|
//Page length of log parameters
|
|
sati_set_data_byte(sequence, scsi_io, 2, 0x00);
|
|
sati_set_data_byte(sequence, scsi_io, 3, 0x08);
|
|
|
|
//parameter code
|
|
sati_set_data_byte(sequence, scsi_io, 4, 0x00);
|
|
sati_set_data_byte(sequence, scsi_io, 5, 0x00);
|
|
|
|
//Format and Linking
|
|
sati_set_data_byte(sequence, scsi_io, 6, 0x03);
|
|
//Parameter Length
|
|
sati_set_data_byte(sequence, scsi_io, 7, 0x04);
|
|
|
|
if(mid_register == ATA_MID_REGISTER_THRESHOLD_EXCEEDED
|
|
&& high_register == ATA_HIGH_REGISTER_THRESHOLD_EXCEEDED)
|
|
{
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
8,
|
|
SCSI_ASC_HARDWARE_IMPENDING_FAILURE
|
|
);
|
|
|
|
sati_set_data_byte(
|
|
sequence,
|
|
scsi_io,
|
|
9,
|
|
SCSI_ASCQ_GENERAL_HARD_DRIVE_FAILURE
|
|
);
|
|
}
|
|
else
|
|
{
|
|
sati_set_data_byte(sequence, scsi_io, 8, SCSI_ASC_NO_ADDITIONAL_SENSE);
|
|
sati_set_data_byte(sequence, scsi_io, 9, SCSI_ASCQ_NO_ADDITIONAL_SENSE);
|
|
}
|
|
//setting most recent temperature reading to 0xFF(not supported) for now.
|
|
sati_set_data_byte(sequence, scsi_io, 10, 0xFF);
|
|
}
|
|
|
|
//******************************************************************************
|
|
//* P U B L I C M E T H O D S
|
|
//******************************************************************************
|
|
|
|
/**
|
|
* @brief This method will translate the SCSI Log Sense command into ATA commands
|
|
* specified by SATv2. ATA commands Read Log EXT and SMART Read Log will
|
|
* be issued by this translation.
|
|
*
|
|
* @return SATI_STATUS Indicates if the command translation succeeded.
|
|
*
|
|
*/
|
|
SATI_STATUS sati_log_sense_translate_command(
|
|
SATI_TRANSLATOR_SEQUENCE_T * sequence,
|
|
void * scsi_io,
|
|
void * ata_io
|
|
)
|
|
{
|
|
U8 * cdb = sati_cb_get_cdb_address(scsi_io);
|
|
SATI_STATUS status = SATI_FAILURE;
|
|
|
|
if(SATI_LOG_SENSE_GET_PC_FIELD(cdb) == 1 &&
|
|
(sati_get_cdb_byte(cdb, 3) == 0))
|
|
{
|
|
sequence->allocation_length = (sati_get_cdb_byte(cdb, 7) << 8) |
|
|
(sati_get_cdb_byte(cdb, 8));
|
|
|
|
switch(SATI_LOG_SENSE_GET_PAGE_CODE(cdb))
|
|
{
|
|
//Return Supported Log Pages log page
|
|
case SCSI_LOG_PAGE_SUPPORTED_PAGES :
|
|
sati_supported_log_page_construct(sequence, scsi_io);
|
|
sequence->type = SATI_SEQUENCE_LOG_SENSE_SUPPORTED_LOG_PAGE;
|
|
status = SATI_COMPLETE;
|
|
break;
|
|
|
|
//Return Self-Test Results log page
|
|
case SCSI_LOG_PAGE_SELF_TEST :
|
|
|
|
if((sequence->device->capabilities &
|
|
SATI_DEVICE_CAP_SMART_SELF_TEST_SUPPORT) == 0)
|
|
{
|
|
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
|
|
);
|
|
status = SATI_FAILURE_CHECK_RESPONSE_DATA;
|
|
}
|
|
else
|
|
{
|
|
//check if 48-bit Address feature set is supported
|
|
if((sequence->device->capabilities &
|
|
SATI_DEVICE_CAP_48BIT_ENABLE))
|
|
{
|
|
//ATA Read Log Ext with log address set to 0x07
|
|
sati_ata_read_log_ext_construct(
|
|
ata_io,
|
|
sequence,
|
|
ATA_LOG_PAGE_EXTENDED_SMART_SELF_TEST,
|
|
sizeof(ATA_EXTENDED_SMART_SELF_TEST_LOG_T)
|
|
);
|
|
sequence->type =
|
|
SATI_SEQUENCE_LOG_SENSE_EXTENDED_SELF_TEST_LOG_PAGE;
|
|
status = SATI_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
//ATA Smart Read Log with log address set to 0x06
|
|
sati_ata_smart_read_log_construct(
|
|
ata_io,
|
|
sequence,
|
|
ATA_LOG_PAGE_SMART_SELF_TEST,
|
|
sizeof(ATA_SMART_SELF_TEST_LOG_T)
|
|
);
|
|
sequence->type = SATI_SEQUENCE_LOG_SENSE_SELF_TEST_LOG_PAGE;
|
|
status = SATI_SUCCESS;
|
|
}
|
|
}
|
|
break;
|
|
|
|
//Return Informational Exceptions log page
|
|
case SCSI_LOG_PAGE_INFORMATION_EXCEPTION :
|
|
if(sequence->device->capabilities & SATI_DEVICE_CAP_SMART_SUPPORT)
|
|
{
|
|
if(sequence->device->capabilities & SATI_DEVICE_CAP_SMART_ENABLE)
|
|
{
|
|
sati_ata_smart_return_status_construct(
|
|
ata_io,
|
|
sequence,
|
|
ATA_SMART_SUB_CMD_RETURN_STATUS
|
|
);
|
|
sequence->type =
|
|
SATI_SEQUENCE_LOG_SENSE_INFO_EXCEPTION_LOG_PAGE;
|
|
status = SATI_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
sati_scsi_sense_data_construct(
|
|
sequence,
|
|
scsi_io,
|
|
SCSI_STATUS_CHECK_CONDITION,
|
|
SCSI_SENSE_ABORTED_COMMAND,
|
|
SCSI_ASC_ATA_DEVICE_FEATURE_NOT_ENABLED,
|
|
SCSI_ASCQ_ATA_DEVICE_FEATURE_NOT_ENABLED
|
|
);
|
|
|
|
status = SATI_FAILURE_CHECK_RESPONSE_DATA;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
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
|
|
);
|
|
|
|
status = SATI_FAILURE_CHECK_RESPONSE_DATA;
|
|
}
|
|
break;
|
|
default :
|
|
//UNSPECIFIED SATv2r9
|
|
sati_scsi_sense_data_construct(
|
|
sequence,
|
|
scsi_io,
|
|
SCSI_STATUS_CHECK_CONDITION,
|
|
SCSI_SENSE_ILLEGAL_REQUEST,
|
|
SCSI_ASC_NO_ADDITIONAL_SENSE ,
|
|
SCSI_ASCQ_NO_ADDITIONAL_SENSE
|
|
);
|
|
status = SATI_FAILURE_CHECK_RESPONSE_DATA;
|
|
break;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief This method will translate the response to the SATI Log Sense
|
|
* translation. ATA command responses will be translated into the
|
|
* correct SCSI log pages to be returned by SATI.
|
|
*
|
|
* @return SATI_STATUS Indicates if the response translation succeeded.
|
|
*
|
|
*/
|
|
SATI_STATUS sati_log_sense_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_STATUS status = SATI_FAILURE;
|
|
|
|
if(sati_get_ata_status(register_fis) & ATA_STATUS_REG_ERROR_BIT)
|
|
{
|
|
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
|
|
);
|
|
status = SATI_FAILURE_CHECK_RESPONSE_DATA;
|
|
}
|
|
else
|
|
{
|
|
|
|
void * ata_data = sati_cb_get_ata_data_address(ata_io);
|
|
|
|
if(ata_data == NULL)
|
|
{
|
|
return SATI_FAILURE;
|
|
}
|
|
|
|
switch(sequence->type)
|
|
{
|
|
case SATI_SEQUENCE_LOG_SENSE_EXTENDED_SELF_TEST_LOG_PAGE:
|
|
sati_extended_self_test_log_page_construct(
|
|
sequence, scsi_io, ata_data
|
|
);
|
|
|
|
status = SATI_COMPLETE;
|
|
break;
|
|
|
|
case SATI_SEQUENCE_LOG_SENSE_SELF_TEST_LOG_PAGE:
|
|
sati_self_test_log_page_construct(sequence, scsi_io, ata_data);
|
|
status = SATI_COMPLETE;
|
|
break;
|
|
|
|
case SATI_SEQUENCE_LOG_SENSE_INFO_EXCEPTION_LOG_PAGE:
|
|
//This function needs a d->h register fis, not ata data
|
|
sati_information_exception_log_page_contruct(
|
|
sequence, scsi_io, ata_io
|
|
);
|
|
|
|
status = SATI_COMPLETE;
|
|
break;
|
|
|
|
default:
|
|
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
|
|
);
|
|
status = SATI_FAILURE_CHECK_RESPONSE_DATA;
|
|
break;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
#endif // !defined(DISABLE_SATI_LOG_SENSE)
|
|
|