diff options
Diffstat (limited to 'sys/dev/isci/scil/sati_mode_select.c')
| -rw-r--r-- | sys/dev/isci/scil/sati_mode_select.c | 1115 |
1 files changed, 1115 insertions, 0 deletions
diff --git a/sys/dev/isci/scil/sati_mode_select.c b/sys/dev/isci/scil/sati_mode_select.c new file mode 100644 index 0000000..dc83bfd --- /dev/null +++ b/sys/dev/isci/scil/sati_mode_select.c @@ -0,0 +1,1115 @@ +/*- + * This file is provided under a dual BSD/GPLv2 license. When using or + * redistributing this file, you may do so under either license. + * + * GPL LICENSE SUMMARY + * + * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. + * The full GNU General Public License is included in this distribution + * in the file called LICENSE.GPL. + * + * BSD LICENSE + * + * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +/** + * @file + * @brief This file contains the method implementations required to + * translate the SCSI mode select (6 and 10-byte) commands with 5 + * supported mode parameter pages (0x01, 0x02, 0x08, 0x0A, 0x1C). + */ + +#if !defined(DISABLE_SATI_MODE_SELECT) + +#include <dev/isci/scil/sati_mode_select.h> +#include <dev/isci/scil/sati_mode_pages.h> +#include <dev/isci/scil/sati_callbacks.h> +#include <dev/isci/scil/sci_object.h> +#include <dev/isci/scil/sati_translator_sequence.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 will get medium type parameter field per CDB size. + * + * @param[in] scsi_io This parameter specifies the user's SCSI IO object + * for which to calculate the mode page header. + * @param[in] cdb_size This parameter specifies the number of bytes + * associated with the CDB for which to calculate the header. + * + * @return This method returns the medium type for the mode page header. + */ +static +U8 sati_mode_select_get_medium_type( + U8 * mode_parameters, + U32 cdb_size +) +{ + U8 medium_type =0xFF; + SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_6_T * mode_parameters_6; + SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_10_T * mode_parameters_10; + + if(cdb_size == 6) + { + mode_parameters_6 = (SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_6_T *) mode_parameters; + medium_type = mode_parameters_6->medium_type; + } + else if(cdb_size == 10) + { + mode_parameters_10 = (SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_10_T *) mode_parameters; + medium_type = mode_parameters_10->medium_type; + } + + return medium_type; +} + +/** + * @brief This method will retrieve Block Descriptor Length. + * + * @param[in] mode_parameters This parameter contains the address to the mode parameters. + * @param[in] cdb_size This parameter specifies the number of bytes + * associated with the CDB for which to process the block descriptor. + * + * @return This method returns the size, in bytes, for the mode parameter block descriptor. + */ +static +U32 sati_mode_select_get_mode_block_descriptor_length( + U8 * mode_parameters, + U32 cdb_size +) +{ + U32 mode_block_descriptor_length = 0; + SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_6_T * mode_parameters_6; + SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_10_T * mode_parameters_10; + + if(cdb_size == 6) + { + mode_parameters_6 = (SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_6_T *) mode_parameters; + mode_block_descriptor_length = mode_parameters_6->block_descriptor_length; + } + else if(cdb_size == 10) + { + mode_parameters_10 = (SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_10_T *) mode_parameters; + //Long LBA bit is the bit0 of the byte + //Spec says another way to get the block descriptor length to multiply the block number + // with block length (8 or 16), but we can get it directly. + mode_block_descriptor_length =(((U16)mode_parameters_10->block_descriptor_length[0]) << 8) + + mode_parameters_10->block_descriptor_length[1]; + + } + + return mode_block_descriptor_length; + +} + +/** + * @brief This method will find the starting byte location for a page. + * + * @param[in] block_descriptor_length This parameter passes in the length of + * block descriptor. + * @param[in] cdb_size This parameter specifies the number of bytes + * associated with the CDB for which to calculate the header. + * + * @return This method returns the offset, for the mode page. + */ +static +U32 sati_mode_select_get_mode_page_offset( + U32 block_descriptor_length, + U32 cdb_size + ) +{ + U32 mode_page_offset; + + if(cdb_size == 6) + { + mode_page_offset = sizeof(SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_6_T) + block_descriptor_length; + } + else if(cdb_size == 10) + { + mode_page_offset = sizeof(SCSI_MODE_SELECT_MODE_PARAMETER_HEADER_10_T) + block_descriptor_length; + } + else + { + mode_page_offset = 0; + } + + return mode_page_offset; +} + +/** + * @brief This method will set the initial Mode Select processing state. + */ +static +void sati_mode_select_initialize_mode_sel_processing_state( + SATI_TRANSLATOR_SEQUENCE_T * sequence, + void * scsi_io, + void * ata_io, + U32 data_transfer_length, + U32 mode_page_offset + ) +{ + sequence->command_specific_data.process_state.ata_command_sent_for_cmp = 0; + sequence->command_specific_data.process_state.mode_page_offset=mode_page_offset; + sequence->command_specific_data.process_state.mode_pages_size = data_transfer_length - mode_page_offset; + sequence->command_specific_data.process_state.size_of_data_processed = 0; + sequence->command_specific_data.process_state.current_mode_page_processed = FALSE; +} + +/** + * @brief This method will get mode page size. + * + * @param[in] page_code This parameter contains page code for the current mode page. + * + * @return This method returns the size of current mode page. + */ +static +U32 sati_mode_select_get_mode_page_size( + U8 page_code +) +{ + U32 page_size=0; + + switch (page_code) + { + case SCSI_MODE_PAGE_READ_WRITE_ERROR: + page_size=SCSI_MODE_PAGE_01_LENGTH; + break; + + case SCSI_MODE_PAGE_DISCONNECT_RECONNECT: + page_size=SCSI_MODE_PAGE_02_LENGTH; + break; + + case SCSI_MODE_PAGE_CACHING: + page_size=SCSI_MODE_PAGE_08_LENGTH; + break; + + case SCSI_MODE_PAGE_CONTROL: + page_size=SCSI_MODE_PAGE_0A_LENGTH; + break; + + case SCSI_MODE_PAGE_INFORMATIONAL_EXCP_CONTROL: + page_size=SCSI_MODE_PAGE_1C_LENGTH; + break; + + case SCSI_MODE_PAGE_POWER_CONDITION: + page_size=SCSI_MODE_PAGE_1A_LENGTH; + break; + default: + page_size=0; + break; + } + + return page_size; +} + +/** + * @brief This method will check the validity of parameter data of Read Write Error Recovery + * page and further processing the page data if necessary. + * + * @param[in] page_size This parameter specifies page size of current mode page. + * + * @return Indicate if the translation was successful. + * @retval SATI_SUCCESS + * @retval SATI_COMPLETE + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA + */ +static +SATI_STATUS sati_mode_select_process_mode_page_read_write_error_recovery( + SATI_TRANSLATOR_SEQUENCE_T* sequence, + void * scsi_io, + U32 page_size + ) +{ + SATI_STATUS status = SATI_FAILURE_CHECK_RESPONSE_DATA; + + U8 current_mode_page[SCSI_MODE_PAGE_01_LENGTH]={0,0,0,0,0,0,0,0,0,0,0,0}; + U32 mode_page_offset; + + mode_page_offset = sequence->command_specific_data.process_state.mode_page_offset; + + //Check all the defined bits for this page + //SPF(0b); Page length 0x0A;AWRE 1; ARRE 0; Error recovery bits 0; RC 0; + //Recovery time limit last two bytes 0 + + sati_get_data_byte(sequence, scsi_io, mode_page_offset, ¤t_mode_page[0]); + sati_get_data_byte(sequence, scsi_io, mode_page_offset+1, ¤t_mode_page[1]); + sati_get_data_byte(sequence, scsi_io, mode_page_offset+2, ¤t_mode_page[2]); + sati_get_data_byte(sequence, scsi_io, mode_page_offset+10, ¤t_mode_page[10]); + sati_get_data_byte(sequence, scsi_io, mode_page_offset+11, ¤t_mode_page[11]); + + if ( ((current_mode_page[0] & SCSI_MODE_SELECT_MODE_PAGE_SPF_MASK)!= 0) || + (current_mode_page[1] != (SCSI_MODE_PAGE_01_LENGTH - 2)) || + ((current_mode_page[2] & SCSI_MODE_SELECT_MODE_PAGE_01_AWRE_MASK) == 0) || + ((current_mode_page[2] & SCSI_MODE_SELECT_MODE_PAGE_01_ARRE_MASK) != 0) || + ((current_mode_page[2] & SCSI_MODE_SELECT_MODE_PAGE_01_RC_ERBITS_MASK) != 0) || + (current_mode_page[10] != 0 ) || + (current_mode_page[11] != 0 ) ) + { + status = SATI_FAILURE_CHECK_RESPONSE_DATA; + return status; + } + + //no need to send any command + { + sequence->command_specific_data.process_state.size_of_data_processed += page_size; + sequence->command_specific_data.process_state.mode_page_offset += page_size; + sequence->command_specific_data.process_state.current_mode_page_processed = TRUE; + } + + status = SATI_COMPLETE; + + return status; +} + +/** + * @brief This method will check the validity of parameter data of Disconnect Reconnect mode + * page and further processing the page data if necessary. + * + * @param[in] page_size This parameter specifies page size of current mode page. + * + * @return Indicate if the translation was successful. + * @retval SATI_SUCCESS + * @retval SATI_COMPLETE + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA + */ +static +SATI_STATUS sati_mode_select_process_mode_page_disconnect_reconnect( + SATI_MODE_SELECT_PROCESSING_STATE_T * mode_select_process_state, + U32 page_size + ) +{ + SATI_STATUS status = SATI_FAILURE_CHECK_RESPONSE_DATA; + + // No need to check data for valid or invalid this page (undefined) + // No ata command to send + { + mode_select_process_state->size_of_data_processed += page_size; + mode_select_process_state->mode_page_offset += page_size; + mode_select_process_state->current_mode_page_processed = TRUE; + } + + // No further interaction with remote devices + status = SATI_COMPLETE; + + return status; +} + +/** + * @brief This method will check the validity of parameter data of Caching mode + * page and issue multiple ATA set feature commands to complete the translation. + * + * @param[in] page_size This parameter specifies page size of current mode page. + * + * @return Indicate if the translation was successful. + * @retval SATI_SUCCESS + * @retval SATI_COMPLETE + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA + */ +static +SATI_STATUS sati_mode_select_process_mode_page_caching( + SATI_TRANSLATOR_SEQUENCE_T * sequence, + void * scsi_io, + void * ata_io, + U32 page_size + ) +{ + SATI_STATUS status = SATI_FAILURE_CHECK_RESPONSE_DATA; + + //SCSI_MODE_PAGE_08_LENGTH 0x14= 20 + U8 current_mode_page[SCSI_MODE_PAGE_08_LENGTH] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + U32 mode_page_offset; + U32 index; + + mode_page_offset = sequence->command_specific_data.process_state.mode_page_offset; + sequence->type = SATI_SEQUENCE_MODE_SELECT_MODE_PAGE_CACHING; + + for(index = 0; index < SCSI_MODE_PAGE_08_LENGTH; index++) + { + sati_get_data_byte(sequence, scsi_io, mode_page_offset+index, ¤t_mode_page[index]); + } + + //Check for data validity + //SPF(0b); Page length 0x12;Byte2 to Byte15 all 0 with exception DRA and WCE changeable + + if (((current_mode_page[0] & SCSI_MODE_SELECT_MODE_PAGE_SPF_MASK)!= 0) || + (current_mode_page[1] != (SCSI_MODE_PAGE_08_LENGTH-2)) || + ((current_mode_page[2] | SCSI_MODE_PAGE_CACHE_PAGE_WCE_BIT)!=SCSI_MODE_PAGE_CACHE_PAGE_WCE_BIT) || + (current_mode_page[3] != 0 ) || + (current_mode_page[4] != 0 ) || + (current_mode_page[5] != 0 ) || + (current_mode_page[6] != 0 ) || + (current_mode_page[7] != 0 ) || + (current_mode_page[8] != 0 ) || + (current_mode_page[9] != 0 ) || + (current_mode_page[10] != 0 ) || + (current_mode_page[11] != 0 ) || + ((current_mode_page[12] & SCSI_MODE_SELECT_MODE_PAGE_08_FSW_LBCSS_NVDIS) != 0) || + (current_mode_page[13] != 0 ) || + (current_mode_page[14] != 0 ) || + (current_mode_page[15] != 0 )) + { + //parameter data passed in containing data that doesn't meet the SAT-2 requirement + return SATI_FAILURE_CHECK_RESPONSE_DATA; + } + + if(sequence->command_specific_data.process_state.ata_command_sent_for_cmp == 0) + { + //byte2 bit2 WCE==0 disable write cache WCE==1 enable write cache + //SCSI_MODE_PAGE_CACHE_PAGE_WCE_BIT ==0x4, + + if ( (current_mode_page[2] & SCSI_MODE_PAGE_CACHE_PAGE_WCE_BIT) == 0) + sati_ata_set_features_construct(ata_io, sequence, ATA_SET_FEATURES_SUB_CMD_DISABLE_CACHE); + else + sati_ata_set_features_construct(ata_io, sequence, ATA_SET_FEATURES_SUB_CMD_ENABLE_CACHE); + + } + else if(sequence->command_specific_data.process_state.ata_command_sent_for_cmp == 1) + { + // DRA bit is set to 0, enable Read look ahead AAh; + // DRA bit is set to 1, disable with set feature command 55h + // SCSI_MODE_PAGE_CACHE_PAGE_DRA_BIT== 0x20 + + if ( (current_mode_page[12] & SCSI_MODE_PAGE_CACHE_PAGE_DRA_BIT) == 0) + sati_ata_set_features_construct(ata_io, sequence,ATA_SET_FEATURES_SUB_CMD_ENABLE_READ_AHEAD); + else + sati_ata_set_features_construct(ata_io, sequence,ATA_SET_FEATURES_SUB_CMD_DISABLE_READ_AHEAD); + + sequence->command_specific_data.process_state.size_of_data_processed += page_size; + sequence->command_specific_data.process_state.mode_page_offset += page_size; + sequence->command_specific_data.process_state.current_mode_page_processed = TRUE; + + + } + // No more ata commands to send + + sequence->command_specific_data.process_state.ata_command_sent_for_cmp++; + + status = SATI_SUCCESS; + + return status; +} + +/** + * @brief This method will check the validity of parameter data of Control mode + * page and further processing the page data if necessary. + * + * @param[in] mode_select_process_state This parameter points to the processing state fields + * of current mode page. + * @param[in] page_size This parameter specifies page size of current mode page. + * + * @return Indicate if the translation was successful. + * @retval SATI_SUCCESS + * @retval SATI_COMPLETE + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA + */ +static +SATI_STATUS sati_mode_select_process_mode_page_control( + SATI_TRANSLATOR_SEQUENCE_T* sequence, + void * scsi_io, + void * ata_io, + U32 page_size + ) +{ + SATI_STATUS status = SATI_FAILURE_CHECK_RESPONSE_DATA; + + //SCSI_MODE_PAGE_0A_LENGTH 12 + U8 current_mode_page[SCSI_MODE_PAGE_0A_LENGTH]={0,0,0,0,0,0,0,0,0,0}; + U32 mode_page_offset; + U32 index; + + mode_page_offset = sequence->command_specific_data.process_state.mode_page_offset; + + for(index = 0; index < SCSI_MODE_PAGE_0A_LENGTH; index++) + { + sati_get_data_byte(sequence, scsi_io, mode_page_offset+index, ¤t_mode_page[index]); + } + + //bit 1 and 2 of byte3 Qerr full task management model etc. then both bits 0 + //byte 8 and 9 busy time out period variable if not ffff setable? + //check for page data validity + //Byte2: 0000???0b Byte3: Queued Algorithm Modifier should be set to 1 QErr? + //Byte4: ??000??? Byte5: ?0???000 + + if (((current_mode_page[0] & SCSI_MODE_SELECT_MODE_PAGE_SPF_MASK)!= 0) || + (current_mode_page[1] != (SCSI_MODE_PAGE_0A_LENGTH - 2)) || + ((current_mode_page[2] & SCSI_MODE_SELECT_MODE_PAGE_0A_TST_TMF_RLEC) != 0) || + ((current_mode_page[3] & SCSI_MODE_SELECT_MODE_PAGE_0A_MODIFIER) != 0) || + ((current_mode_page[4] & SCSI_MODE_SELECT_MODE_PAGE_0A_UA_SWP ) != 0) || + ((current_mode_page[5] & SCSI_MODE_SELECT_MODE_PAGE_0A_TAS_AUTO ) != 0 ) ) + { + return SATI_FAILURE_CHECK_RESPONSE_DATA; + } + + if ((current_mode_page[2] & SCSI_MODE_SELECT_MODE_PAGE_D_SENSE) != 0) + sequence->device->descriptor_sense_enable = SCSI_MODE_PAGE_CONTROL_D_SENSE_ENABLE; + else + sequence->device->descriptor_sense_enable = SCSI_MODE_PAGE_CONTROL_D_SENSE_DISABLE; + + // no ata command need to be comfirmed + { + sequence->command_specific_data.process_state.size_of_data_processed += page_size; + sequence->command_specific_data.process_state.mode_page_offset += page_size; + sequence->command_specific_data.process_state.current_mode_page_processed = TRUE; + } + + status = SATI_COMPLETE; + + return status; +} + +/** + * @brief This method will check the validity of parameter data of Information Exception Control + * mode page and further processing the page data if necessary. + * + * @param[in] page_size This parameter specifies page size of current mode page. + * + * @return Indicate if the translation was successful. + * @retval SATI_SUCCESS + * @retval SATI_COMPLETE + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA + */ +static +SATI_STATUS sati_mode_select_process_mode_page_informational_exception_control( + SATI_TRANSLATOR_SEQUENCE_T * sequence, + void * scsi_io, + void * ata_io, + U32 page_size + ) +{ + SATI_STATUS status = SATI_FAILURE_CHECK_RESPONSE_DATA; + + //SCSI_MODE_PAGE_1C_LENGTH 12 + U8 current_mode_page[SCSI_MODE_PAGE_1C_LENGTH]={0,0,0,0,0,0,0,0,0,0,0,0}; + U32 mode_page_offset; + U32 index; + + mode_page_offset = sequence->command_specific_data.process_state.mode_page_offset; + sequence->type = SATI_SEQUENCE_MODE_SELECT_MODE_INFORMATION_EXCEPT_CONTROL; + + for(index = 0; index < 4; index++) + { + sati_get_data_byte(sequence, scsi_io, mode_page_offset+index, ¤t_mode_page[index]); + } + + //Check for data validity + //SPF(0b); Page length 0x0A; Byte2 0????0?? Byte3: ????1100 + //SCSI_MODE_SELECT_MODE_PAGE_MRIE_BYTE same as REPORT_INFO_EXCEPTION_CONDITION_ON_REQUEST 0x6 + //SCSI_MODE_PAGE_DEXCPT_ENABLE + + if (((current_mode_page[0] & SCSI_MODE_SELECT_MODE_PAGE_SPF_MASK)!= 0) || + (current_mode_page[1] != (SCSI_MODE_PAGE_1C_LENGTH - 2)) || + ((current_mode_page[2] & SCSI_MODE_SELECT_MODE_PAGE_1C_PERF_TEST)!= 0 ) || + ((current_mode_page[3] & SCSI_MODE_SELECT_MODE_PAGE_MRIE_MASK) != + SCSI_MODE_SELECT_MODE_PAGE_MRIE_BYTE )) + { + return SATI_FAILURE_CHECK_RESPONSE_DATA; + } + + // DEXCPT bit is set to 0, enable SMART reporting D8h; + // DEXCPT bit is set to 1, disable SMART reporting D9h + // SCSI_MODE_PAGE_DEXCPT_ENABLE== 0x08 + + if ( (current_mode_page[2] & SCSI_MODE_PAGE_DEXCPT_ENABLE) == 0) + sati_ata_smart_return_status_construct(ata_io, sequence, ATA_SMART_SUB_CMD_ENABLE); + else + sati_ata_smart_return_status_construct(ata_io, sequence, ATA_SMART_SUB_CMD_DISABLE); + + sequence->command_specific_data.process_state.size_of_data_processed += page_size; + sequence->command_specific_data.process_state.mode_page_offset += page_size; + sequence->command_specific_data.process_state.current_mode_page_processed = TRUE; + // No more ata commands to send + + status = SATI_SUCCESS; + + return status; +} + +/** + * @brief This method will check the validity of parameter data of Power Condition mode + * page and issue multiple ATA set feature commands to complete the translation. + * + * @param[in] mode_select_process_state This parameter points to the processing state fields + * of current mode page. + * @param[in] page_size This parameter specifies page size of current mode page. + * + * @return Indicate if the translation was successful. + * @retval SATI_SUCCESS + * @retval SATI_COMPLETE + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA + */ +static +SATI_STATUS sati_mode_select_process_mode_page_power_condition( + SATI_TRANSLATOR_SEQUENCE_T * sequence, + void * scsi_io, + void * ata_io, + U32 page_size + ) +{ + SATI_STATUS status = SATI_FAILURE_CHECK_RESPONSE_DATA; + + //SCSI_MODE_PAGE_1A_LENGTH 10 + U8 current_mode_page[SCSI_MODE_PAGE_1A_LENGTH] = {0,0,0,0,0,0,0,0,0,0}; + U32 mode_page_offset; + U32 index; + + U32 timer = 0; + U16 count = 0; + + mode_page_offset = sequence->command_specific_data.process_state.mode_page_offset; + + sequence->type = SATI_SEQUENCE_MODE_SELECT_MODE_POWER_CONDITION; + + for(index = 0; index < SCSI_MODE_PAGE_1A_LENGTH; index++) + { + sati_get_data_byte(sequence, scsi_io, mode_page_offset+index, ¤t_mode_page[index]); + } + + //Check for data validity + //SPF(0b); Page length 0x0A; + + if (((current_mode_page[0] & SCSI_MODE_SELECT_MODE_PAGE_SPF_MASK)!= 0) || + (current_mode_page[1] != (SCSI_MODE_PAGE_1A_LENGTH - 2) ) || + ((current_mode_page[3] & SCSI_MODE_PAGE_POWER_CONDITION_IDLE)!= 0) + ) + { + //parameter data passed in containing data that doesn't meet the SAT-2 requirement + return SATI_FAILURE_CHECK_RESPONSE_DATA; + } + + // STANDBY bit is set to 0, do nothing since the standby timer can't be set; + // STANDBY bit is set to 1, translate the standby timer + // SCSI_MODE_PAGE_POWER_CONDITION_STANDBY== 0x01 + if (current_mode_page[3] & SCSI_MODE_PAGE_POWER_CONDITION_STANDBY) + { + timer = (current_mode_page[8]<<24) + (current_mode_page[9]<<16) + (current_mode_page[10]<<8) + current_mode_page[11]; + + //If the ATA IDENTIFY DEVICE data word 49, bit 13 is set to one, + if (sequence->device->capabilities & SATI_DEVICE_CAP_STANDBY_ENABLE) + { + if (timer == 0) + { + //TPV=0 send ATA STANDBY_IMMEDIATE + sati_ata_standby_immediate_construct(ata_io, sequence); + sequence->command_specific_data.translated_command = ATA_STANDBY_IMMED; + } + else if ((timer > 0) && (timer <= 12000)) + { + //1 to 12 000 INT((z - 1) / 50) + 1 + count = (U16)((timer -1) / 50) + 1; + sati_ata_standby_construct(ata_io, sequence, count); + } + else if ((timer > 12000) && (timer <= 12600)) + { + //12 001 to 12 600 FCh + sati_ata_standby_construct(ata_io, sequence, 0xFC); + } + else if ((timer > 12600) && (timer <= 12750)) + { + //12 601 to 12 750 FFh + sati_ata_standby_construct(ata_io, sequence, 0xFF); + } + else if ((timer > 12750) && (timer < 18000)) + { + //12 751 to 17 999 F1h + sati_ata_standby_construct(ata_io, sequence, 0xF1); + } + else if ((timer >= 18000) && (timer <= 198000)) + { + //18 000 to 198 000 INT(z / 18 000) + 240 + count = (U16)(timer / 18000) + 240; + sati_ata_standby_construct(ata_io, sequence, count); + } + else + { + //All other values FDh + sati_ata_standby_construct(ata_io, sequence, 0xFD); + } + status = SATI_SUCCESS ; + } + else + { + status = SATI_FAILURE_CHECK_RESPONSE_DATA; + //If the ATA IDENTIFY DEVICE data word 49, bit 13 is set to 0 + } + } + else + { + status = SATI_COMPLETE; + } + + sequence->command_specific_data.process_state.size_of_data_processed += page_size; + sequence->command_specific_data.process_state.mode_page_offset += page_size; + sequence->command_specific_data.process_state.current_mode_page_processed = TRUE; + + return status; +} + +/** + * @brief This method will process the mode page. + * + * + * @return Indicate if the translation was successful. + * @retval SATI_SUCCESS + * @retval SATI_COMPLETE + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA + */ +static +SATI_STATUS sati_mode_select_process_mode_page( + SATI_TRANSLATOR_SEQUENCE_T* sequence, + void * scsi_io, + void * ata_io +) +{ + SATI_STATUS status = SATI_FAILURE_CHECK_RESPONSE_DATA; + + U8 page_code; + U32 page_size = 0; // in bytes + U32 size_of_data_to_be_processed; + + U8 page_code_byte; + U32 mode_page_offset; + + mode_page_offset = sequence->command_specific_data.process_state.mode_page_offset; + + sati_get_data_byte(sequence, scsi_io, mode_page_offset, &page_code_byte); + + // No more pages. + if(sequence->command_specific_data.process_state.mode_pages_size > + sequence->command_specific_data.process_state.size_of_data_processed) + { + //SCSI_MODE_SENSE_PAGE_CODE_ENABLE==0x3f same for Mode Select + page_code = page_code_byte & SCSI_MODE_SENSE_PAGE_CODE_ENABLE; + page_size = sati_mode_select_get_mode_page_size(page_code); + size_of_data_to_be_processed = sequence->command_specific_data.process_state.mode_pages_size + - sequence->command_specific_data.process_state.size_of_data_processed; + + if( page_size == 0 ) + { + status = SATI_FAILURE_CHECK_RESPONSE_DATA; + } + else + { + // process mode page + switch(page_code) + { + case SCSI_MODE_PAGE_READ_WRITE_ERROR: + status = sati_mode_select_process_mode_page_read_write_error_recovery( + sequence, + scsi_io, + page_size + ); + break; + + case SCSI_MODE_PAGE_DISCONNECT_RECONNECT: + status = sati_mode_select_process_mode_page_disconnect_reconnect( + &sequence->command_specific_data.process_state, + page_size + ); + break; + + case SCSI_MODE_PAGE_CACHING: + status = sati_mode_select_process_mode_page_caching( + sequence, + scsi_io, + ata_io, + page_size + ); + break; + + case SCSI_MODE_PAGE_CONTROL: + status = sati_mode_select_process_mode_page_control( + sequence, + scsi_io, + ata_io, + page_size + ); + break; + + case SCSI_MODE_PAGE_INFORMATIONAL_EXCP_CONTROL: + status = sati_mode_select_process_mode_page_informational_exception_control( + sequence, + scsi_io, + ata_io, + page_size + ); + break; + + case SCSI_MODE_PAGE_POWER_CONDITION: + status = sati_mode_select_process_mode_page_power_condition( + sequence, + scsi_io, + ata_io, + page_size + ); + + break; + + default: + break; + } + + } + } + + return status; +} + +//****************************************************************************** +//* P U B L I C M E T H O D S +//****************************************************************************** + +/** + * @brief This method will translate the SCSI Mode Select 6 byte or 10 byte command + * into corresponding ATA commands. Depending upon the capabilities + * supported by the target different ATA commands can be selected. + * Additionally, in some cases more than a single ATA command may + * be required. + * + * @return Indicate if the command translation succeeded. + * @retval SCI_SUCCESS This is returned if the command translation was + * successful. + * @retval SCI_COMPLETE This is returned if the command translation was + * successful and no ATA commands need to be set. + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA This value is returned if + * sense data has been created as a result of something specified + * in the parameter data fields. + */ +static +SATI_STATUS sati_mode_select_translate_command( + SATI_TRANSLATOR_SEQUENCE_T * sequence, + void * scsi_io, + void * ata_io, + U32 cdb_size +) +{ + SATI_STATUS status = SATI_FAILURE_CHECK_RESPONSE_DATA; + U32 mode_page_offset; + U32 block_descriptor_length; + U32 index; + U16 data_transfer_length; + U8 current_mode_parameters[8]={0,0,0,0,0,0,0,0}; + U8 * cdb = sati_cb_get_cdb_address(scsi_io); + + // cdb_size must be 6 or 10 + if(FALSE == (cdb_size == 6 || cdb_size == 10)) + { + return status; + } + + if(sequence->state == SATI_SEQUENCE_STATE_INITIAL) + { + sequence->command_specific_data.process_state.ata_command_sent_for_cmp = 0; + sequence->state = SATI_SEQUENCE_STATE_TRANSLATE_DATA; + } + + //First, initializes mode_sel_processing_state + if ( sequence->command_specific_data.process_state.ata_command_sent_for_cmp == 0 ) + { + if (cdb_size == 6) + { + //CDB byte 4 is the parameter length + data_transfer_length = sati_get_cdb_byte(cdb, 4); + } + else + { + //CDB byte 7 and 8 for Mode Select 10 + data_transfer_length = (sati_get_cdb_byte(cdb, 7) << 8) + sati_get_cdb_byte(cdb, 8); + } + + sequence->allocation_length = data_transfer_length; + + //Get 8 bytes for headers (4 bytes for Mode Select 6 and 8 bytes for Mode Select 10) + for( index = 0; index < 8; index++ ) + { + sati_get_data_byte(sequence, scsi_io, index, ¤t_mode_parameters[index]); + } + + //medium type should be 0 + if ( sati_mode_select_get_medium_type(current_mode_parameters, cdb_size) != 0 ) + { + sati_scsi_sense_data_construct( + sequence, + scsi_io, + SCSI_STATUS_CHECK_CONDITION, + SCSI_SENSE_ILLEGAL_REQUEST, + SCSI_ASC_INVALID_FIELD_IN_PARM_LIST, + SCSI_ASCQ_INVALID_FIELD_IN_PARM_LIST + ); + return status; + } + + block_descriptor_length = sati_mode_select_get_mode_block_descriptor_length( + current_mode_parameters, + cdb_size + ); + + mode_page_offset = sati_mode_select_get_mode_page_offset( + block_descriptor_length, + cdb_size + ); + + if(mode_page_offset > data_transfer_length) + { + sequence->state = SATI_SEQUENCE_STATE_FINAL; + status = SATI_FAILURE_CHECK_RESPONSE_DATA; + } + else + { + sati_mode_select_initialize_mode_sel_processing_state( + sequence, + scsi_io, + ata_io, + data_transfer_length, + mode_page_offset + ); + + } + } + + // move to next mode page + if(sequence->command_specific_data.process_state.current_mode_page_processed) + { + sequence->command_specific_data.process_state.ata_command_sent_for_cmp = 0; + sequence->command_specific_data.process_state.current_mode_page_processed = FALSE; + } + + status = sati_mode_select_process_mode_page(sequence, scsi_io, ata_io); + + if(sequence->command_specific_data.process_state.current_mode_page_processed != FALSE) + { + // Done this page + sequence->state = SATI_SEQUENCE_STATE_FINAL; + } + else + { + sequence->state = SATI_SEQUENCE_STATE_INCOMPLETE; + } + + if(status == SATI_FAILURE_CHECK_RESPONSE_DATA) + { + sequence->state = SATI_SEQUENCE_STATE_FINAL; + sati_scsi_sense_data_construct( + sequence, + scsi_io, + SCSI_STATUS_CHECK_CONDITION, + SCSI_SENSE_ILLEGAL_REQUEST, + SCSI_ASC_INVALID_FIELD_IN_PARM_LIST, + SCSI_ASCQ_INVALID_FIELD_IN_PARM_LIST + ); + } + + return status; +} + +/** + * @brief This method will call Mode Select 6 Translation command + * For more information on the parameters passed to this method, + * please reference sati_translate_command(). + * + * @return Indicate if the command translation succeeded. + * @retval SCI_SUCCESS This is returned if the command translation was + * successful. + * @retval SCI_COMPLETE This is returned if the command translation was + * successful and no ATA commands need to be set. + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA This value is returned if + * sense data has been created as a result of something specified + * in the parameter data fields. + */ +SATI_STATUS sati_mode_select_6_translate_command( + SATI_TRANSLATOR_SEQUENCE_T * sequence, + void * scsi_io, + void * ata_io +) +{ + SATI_STATUS status=SATI_FAILURE; + U8 * cdb = sati_cb_get_cdb_address(scsi_io); + + //PF bit needs to be 1 byte1 bit ???1???? + if ((sati_get_cdb_byte(cdb, 1) & SCSI_MODE_SELECT_PF_MASK) == !SCSI_MODE_SELECT_PF_BIT) + { + 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; + return status; + } + + status=sati_mode_select_translate_command( + sequence, + scsi_io, + ata_io, + 6 + ); + + if(status == SATI_FAILURE_CHECK_RESPONSE_DATA) + { + sati_scsi_sense_data_construct( + sequence, + scsi_io, + SCSI_STATUS_CHECK_CONDITION, + SCSI_SENSE_ILLEGAL_REQUEST, + SCSI_ASC_INVALID_FIELD_IN_PARM_LIST, + SCSI_ASCQ_INVALID_FIELD_IN_PARM_LIST + ); + } + return status; + +} + +/** + * @brief This method will call Mode Select 10 translation command + * For more information on the parameters passed to this method, + * please reference sati_translate_command(). + * + * @return Indicate if the command translation succeeded. + * @retval SCI_SUCCESS This is returned if the command translation was + * successful. + * @retval SCI_COMPLETE This is returned if the command translation was + * successful and no ATA commands need to be set. + * @retval SATI_FAILURE_CHECK_RESPONSE_DATA This value is returned if + * sense data has been created as a result of something specified + * in the parameter data fields. + */ +SATI_STATUS sati_mode_select_10_translate_command( + SATI_TRANSLATOR_SEQUENCE_T * sequence, + void * scsi_io, + void * ata_io +) +{ + SATI_STATUS status=SATI_FAILURE; + U8 * cdb = sati_cb_get_cdb_address(scsi_io); + + //PF bit needs to be 1 byte1 bit ???1???? + if ((sati_get_cdb_byte(cdb, 1) & SCSI_MODE_SELECT_PF_MASK) == !SCSI_MODE_SELECT_PF_BIT) + { + 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; + return status; + } + + status=sati_mode_select_translate_command( + sequence, + scsi_io, + ata_io, + 10 + ); + + if(status == SATI_FAILURE_CHECK_RESPONSE_DATA) + { + sati_scsi_sense_data_construct( + sequence, + scsi_io, + SCSI_STATUS_CHECK_CONDITION, + SCSI_SENSE_ILLEGAL_REQUEST, + SCSI_ASC_INVALID_FIELD_IN_PARM_LIST, + SCSI_ASCQ_INVALID_FIELD_IN_PARM_LIST + ); + } + return status; +} + +/** +* @brief This method will conduct error handling for the ATA Set Features command +* that is issued during a Mode Select translation for the Caching Mode +* page. +* +* +* @return Indicate if the command translation succeeded. +* +* @retval SCI_COMPLETE This is returned if the command translation was +* successful and no additional ATA commands need to be set. +* @retval SATI_FAILURE_CHECK_RESPONSE_DATA This value is returned if +* sense data has been created as a result of an error returned +*/ +SATI_STATUS sati_mode_select_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 + { + if (sequence->state == SATI_SEQUENCE_STATE_INCOMPLETE) + { + status = SATI_SEQUENCE_INCOMPLETE; + } + else + { + status = SATI_COMPLETE; + } + } + return status; +} + +#endif // !defined(DISABLE_SATI_MODE_SELECT) |
