/*-
* 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 methods for the SCIF_SAS_SMP_REMOTE_DEVICE object.
*/
#include <dev/isci/scil/sci_controller.h>
#include <dev/isci/scil/scif_sas_controller.h>
#include <dev/isci/scil/scif_sas_remote_device.h>
#include <dev/isci/scil/scif_sas_logger.h>
#include <dev/isci/scil/scif_sas_smp_remote_device.h>
#include <dev/isci/scil/scif_sas_smp_io_request.h>
#include <dev/isci/scil/intel_sas.h>
#include <dev/isci/scil/scic_io_request.h>
#include <dev/isci/scil/scic_remote_device.h>
#include <dev/isci/scil/scif_sas_smp_phy.h>
/**
* @brief This method resets all fields for a smp remote device. This is a
* private method.
*
* @param[in] fw_device the framework SMP device that is being
* constructed.
*
* @return none
*/
void scif_sas_smp_remote_device_clear(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
//reset all fields in smp_device, indicate that the smp device is not
//in discovery process.
fw_device->protocol_device.smp_device.current_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
fw_device->protocol_device.smp_device.current_smp_request =
NOT_IN_SMP_ACTIVITY;
fw_device->protocol_device.smp_device.current_activity_phy_index = 0;
fw_device->protocol_device.smp_device.curr_config_route_index = 0;
fw_device->protocol_device.smp_device.config_route_smp_phy_anchor = NULL;
fw_device->protocol_device.smp_device.is_route_table_cleaned = FALSE;
fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy = NULL;
fw_device->protocol_device.smp_device.scheduled_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
fw_device->protocol_device.smp_device.io_retry_count = 0;
fw_device->protocol_device.smp_device.curr_clear_affiliation_phy = NULL;
if (fw_device->protocol_device.smp_device.smp_activity_timer != NULL)
{
//stop the timer
scif_cb_timer_stop(
fw_device->domain->controller,
fw_device->protocol_device.smp_device.smp_activity_timer
);
//destroy the timer
scif_cb_timer_destroy(
fw_device->domain->controller,
fw_device->protocol_device.smp_device.smp_activity_timer
);
fw_device->protocol_device.smp_device.smp_activity_timer = NULL;
}
}
/**
* @brief This method intializes a smp remote device.
*
* @param[in] fw_device the framework SMP device that is being
* constructed.
*
* @return none
*/
void scif_sas_smp_remote_device_construct(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE,
"scif_sas_smp_remote_device_construct(0x%x) enter\n",
fw_device
));
fw_device->protocol_device.smp_device.number_of_phys = 0;
fw_device->protocol_device.smp_device.expander_route_indexes = 0;
fw_device->protocol_device.smp_device.is_table_to_table_supported = FALSE;
fw_device->protocol_device.smp_device.is_externally_configurable = FALSE;
fw_device->protocol_device.smp_device.is_able_to_config_others = FALSE;
sci_fast_list_init(&fw_device->protocol_device.smp_device.smp_phy_list);
scif_sas_smp_remote_device_clear(fw_device);
}
/**
* @brief This method decodes a smp response to this smp device and then
* continue the smp discover process.
*
* @param[in] fw_device The framework device that a SMP response targets to.
* @param[in] fw_request The pointer to an smp request whose response
* is to be decoded.
* @param[in] response_data The response data passed in.
*
* @return none
*/
SCI_STATUS scif_sas_smp_remote_device_decode_smp_response(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SCIF_SAS_REQUEST_T * fw_request,
void * response_data,
SCI_IO_STATUS completion_status
)
{
SMP_RESPONSE_T * smp_response = (SMP_RESPONSE_T *)response_data;
SCI_STATUS status = SCI_FAILURE_UNSUPPORTED_INFORMATION_TYPE;
if (fw_device->protocol_device.smp_device.smp_activity_timer != NULL)
{
//if there is a timer being used, recycle it now. Since we may
//use the timer for other purpose next.
scif_cb_timer_destroy(
fw_device->domain->controller,
fw_device->protocol_device.smp_device.smp_activity_timer
);
fw_device->protocol_device.smp_device.smp_activity_timer = NULL;
}
//if Core set the status of this io to be RETRY_REQUIRED, we should
//retry the IO without even decode the response.
if (completion_status == SCI_FAILURE_RETRY_REQUIRED)
{
scif_sas_smp_remote_device_continue_current_activity(
fw_device, fw_request, SCI_FAILURE_RETRY_REQUIRED
);
return SCI_FAILURE_RETRY_REQUIRED;
}
//check the current smp request, decide what's next smp request to issue.
switch (fw_device->protocol_device.smp_device.current_smp_request)
{
case SMP_FUNCTION_REPORT_GENERAL:
{
//interpret REPORT GENERAL response.
status = scif_sas_smp_remote_device_decode_report_general_response(
fw_device, smp_response
);
break;
}
case SMP_FUNCTION_REPORT_MANUFACTURER_INFORMATION:
{
// No need to perform any parsing. Just want to see
// the information in a trace if necessary.
status = SCI_SUCCESS;
break;
}
case SMP_FUNCTION_DISCOVER:
{
if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER)
{
//decode discover response
status = scif_sas_smp_remote_device_decode_initial_discover_response(
fw_device, smp_response
);
}
else if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET)
{
//decode discover response as a polling result for a remote device
//target reset.
status =
scif_sas_smp_remote_device_decode_target_reset_discover_response(
fw_device, smp_response
);
}
else if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_SATA_SPINUP_HOLD_RELEASE)
{
//decode discover response
status =
scif_sas_smp_remote_device_decode_spinup_hold_release_discover_response(
fw_device, smp_response
);
}
else
ASSERT(0);
break;
}
case SMP_FUNCTION_REPORT_PHY_SATA:
{
//decode the report phy sata response.
status = scif_sas_smp_remote_device_decode_report_phy_sata_response(
fw_device, smp_response
);
break;
}
case SMP_FUNCTION_PHY_CONTROL:
{
if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER)
{
//decode the phy control response.
status = scif_sas_smp_remote_device_decode_discover_phy_control_response(
fw_device, smp_response
);
}
else if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET)
{
//decode discover response as a polling result for a remote device
//target reset.
status = scif_sas_smp_remote_device_decode_target_reset_phy_control_response(
fw_device, smp_response
);
}
else if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CLEAR_AFFILIATION)
{
//currently don't care about the status.
status = SCI_SUCCESS;
}
else
ASSERT(0);
break;
}
case SMP_FUNCTION_CONFIGURE_ROUTE_INFORMATION:
{
//Note, currently we don't expect any abnormal status from config route info response,
//but there is a possibility that we exceed the maximum route index. We will take care
//of errors later.
status = scif_sas_smp_remote_device_decode_config_route_info_response(
fw_device, smp_response
);
break;
}
default:
//unsupported case, TBD
status = SCI_FAILURE_UNSUPPORTED_INFORMATION_TYPE;
break;
} //end of switch
//Continue current activity based on response's decoding status.
scif_sas_smp_remote_device_continue_current_activity(
fw_device, fw_request, status
);
return status;
}
/**
* @brief This method decodes a smp Report Genernal response to this smp device
* and then continue the smp discover process.
*
* @param[in] fw_device The framework device that the REPORT GENERAL command
* targets to.
* @param[in] report_general_response The pointer to a report general response
*
* @return none
*/
SCI_STATUS scif_sas_smp_remote_device_decode_report_general_response(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SMP_RESPONSE_T * smp_response
)
{
SMP_RESPONSE_REPORT_GENERAL_T * report_general_response =
&smp_response->response.report_general;
SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_decode_report_general_response(0x%x, 0x%x) enter\n",
fw_device, smp_response
));
if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
{
/// @todo: more decoding work needed when the function_result is not
/// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
/// function result.
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"Report General function result(0x%x)\n",
response_header->function_result
));
return SCI_FAILURE;
}
//get info from report general response.
fw_device->protocol_device.smp_device.number_of_phys =
(U8)report_general_response->number_of_phys;
//currently there is byte swap issue in U16 data.
fw_device->protocol_device.smp_device.expander_route_indexes =
((report_general_response->expander_route_indexes & 0xff) << 8) |
((report_general_response->expander_route_indexes & 0xff00) >> 8);
fw_device->protocol_device.smp_device.is_table_to_table_supported =
(BOOL)report_general_response->table_to_table_supported;
fw_device->protocol_device.smp_device.is_externally_configurable =
(BOOL)report_general_response->configurable_route_table;
fw_device->protocol_device.smp_device.is_able_to_config_others =
(BOOL)report_general_response->configures_others;
//If the top level expander of a domain is able to configure others,
//no config route table is needed in the domain. Or else,
//we'll let all the externally configurable expanders in the damain
//configure route table.
if (fw_device->containing_device == NULL
&& ! fw_device->protocol_device.smp_device.is_able_to_config_others)
fw_device->domain->is_config_route_table_needed = TRUE;
//knowing number of phys this expander has, we can allocate all the smp phys for
//this expander now if it is not done already.
if (fw_device->protocol_device.smp_device.smp_phy_list.element_count == 0)
scif_sas_smp_remote_device_populate_smp_phy_list(fw_device);
if (report_general_response->configuring)
return SCI_FAILURE_RETRY_REQUIRED;
return SCI_SUCCESS;
}
/**
* @brief This method decodes a smp Discover response to this smp device
* and then continue the smp discover process. This is only ever
* called for the very first discover stage during a given domain
* discovery process.
*
* @param[in] fw_device The framework device that the DISCOVER command
* targets to.
* @param[in] discover_response The pointer to a DISCOVER response
*
* @return none
*/
SCI_STATUS scif_sas_smp_remote_device_decode_initial_discover_response(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SMP_RESPONSE_T * smp_response
)
{
SCIF_SAS_DOMAIN_T * fw_domain = fw_device->domain;
SCI_SAS_ADDRESS_T attached_device_address;
SCIF_SAS_REMOTE_DEVICE_T * attached_remote_device;
SMP_RESPONSE_DISCOVER_T * discover_response =
&smp_response->response.discover;
SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_decode_initial_discover_response(0x%x, 0x%x) enter\n",
fw_device, smp_response
));
if (response_header->function_result == SMP_RESULT_PHY_VACANT)
{
return SCI_SUCCESS;
}
else if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
{
/// @todo: more decoding work needed when the function_result is not
/// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
/// function result.
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"Discover function result(0x%x)\n",
response_header->function_result
));
return SCI_FAILURE;
}
//only if there is target device attached. We don't add device that is
//initiator only.
if ( ( discover_response->u2.sas1_1.attached_device_type
!= SMP_NO_DEVICE_ATTACHED )
&& ( discover_response->protocols.u.bits.attached_ssp_target
|| discover_response->protocols.u.bits.attached_stp_target
|| discover_response->protocols.u.bits.attached_smp_target
|| discover_response->protocols.u.bits.attached_sata_device ) )
{
attached_device_address = discover_response->attached_sas_address;
attached_remote_device = (SCIF_SAS_REMOTE_DEVICE_T *)
scif_domain_get_device_by_sas_address(
fw_domain, &attached_device_address
);
//need to check if the device already existed in the domian.
if (attached_remote_device != SCI_INVALID_HANDLE)
{
#if !defined(DISABLE_WIDE_PORTED_TARGETS)
if ( attached_remote_device->is_currently_discovered == TRUE
&& attached_remote_device != fw_device->containing_device )
{
//a downstream wide port target is found.
attached_remote_device->device_port_width++;
}
else
#endif //#if !defined(DISABLE_WIDE_PORTED_TARGETS)
{
//The device already existed. Mark the device as discovered.
attached_remote_device->is_currently_discovered = TRUE;
}
#if !defined(DISABLE_WIDE_PORTED_TARGETS)
if (attached_remote_device->device_port_width !=
scic_remote_device_get_port_width(attached_remote_device->core_object)
&& discover_response->protocols.u.bits.attached_ssp_target
)
{
scif_sas_remote_device_update_port_width(
attached_remote_device, attached_remote_device->device_port_width);
}
#endif //#if !defined(DISABLE_WIDE_PORTED_TARGETS)
if ( discover_response->protocols.u.bits.attached_smp_target
&& attached_remote_device != fw_device->containing_device)
{
//another expander device is discovered. Its own smp discover will starts after
//this discover finishes.
attached_remote_device->protocol_device.smp_device.scheduled_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER;
}
}
else
{
//report the discovery of a disk for all types of end device.
scif_cb_domain_ea_device_added(
fw_domain->controller, fw_domain, fw_device, discover_response
);
//get info from discover response to see what we found. And do
//extra work according to end device's protocol type.
if ( discover_response->protocols.u.bits.attached_ssp_target
|| discover_response->protocols.u.bits.attached_smp_target)
{
//for SSP or SMP target, no extra work.
;
}
else if ( (discover_response->protocols.u.bits.attached_stp_target)
|| (discover_response->protocols.u.bits.attached_sata_device) )
{
// We treat a SATA Device bit the same as an attached STP
// target.
discover_response->protocols.u.bits.attached_stp_target = 1;
//kick off REPORT PHY SATA to the same phy.
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_REPORT_PHY_SATA;
}
}
}
else if( (discover_response->u2.sas1_1.negotiated_physical_link_rate == SCI_SATA_SPINUP_HOLD
|| discover_response->u4.sas2.negotiated_physical_link_rate == SCI_SATA_SPINUP_HOLD)
&&(discover_response->protocols.u.bits.attached_stp_target
|| discover_response->protocols.u.bits.attached_sata_device)
)
{
attached_remote_device = scif_sas_domain_get_device_by_containing_device(
fw_domain,
fw_device,
discover_response->phy_identifier
);
if (attached_remote_device != SCI_INVALID_HANDLE)
{
//Here, the only reason a device already existed in domain but
//the initial discover rersponse shows it in SPINUP_HOLD, is that
//a device has been removed and coming back in SPINUP_HOLD before
//we detected. The possibility of this situation is very very rare.
//we need to remove the device then add it back using the new
//discover response.
scif_cb_domain_device_removed(
fw_domain->controller, fw_domain, attached_remote_device
);
}
discover_response->protocols.u.bits.attached_stp_target = 1;
//still report ea_device_added(). But this device will not be
//started during scif_remote_device_ea_construct().
scif_cb_domain_ea_device_added(
fw_domain->controller, fw_domain, fw_device, discover_response
);
//need to send Phy Control (RESET) to release the phy from spinup hold
//condition.
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_PHY_CONTROL;
}
//update the smp phy info based on this DISCOVER response.
return scif_sas_smp_remote_device_save_smp_phy_info(
fw_device, discover_response);
}
/**
* @brief This method decodes a smp Report Phy Sata response to this
* smp device and then continue the smp discover process.
*
* @param[in] fw_device The framework device that the REPORT PHY SATA
* command targets to.
* @param[in] report_phy_sata_response The pointer to a REPORT PHY
* SATA response
*
* @return none
*/
SCI_STATUS scif_sas_smp_remote_device_decode_report_phy_sata_response(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SMP_RESPONSE_T * smp_response
)
{
SMP_RESPONSE_REPORT_PHY_SATA_T * report_phy_sata_response =
&smp_response->response.report_phy_sata;
SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_decode_report_phy_sata_response(0x%x, 0x%x) enter\n",
fw_device, smp_response
));
if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
{
/// @todo: more decoding work needed when the function_result is not
/// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
/// function result.
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"Report Phy Sata function result(0x%x)\n",
response_header->function_result
));
return SCI_FAILURE;
}
scif_sas_remote_device_save_report_phy_sata_information(
report_phy_sata_response
);
// continue the discover process.
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_DISCOVER;
return SCI_SUCCESS;
}
/**
* @brief This method decodes a smp Phy Control response to this smp device and
* then continue the smp TARGET RESET process.
*
* @param[in] fw_device The framework device that the Phy Control command
* targets to.
* @param[in] smp_response The pointer to a Phy Control response
* @param[in] fw_io The scif IO request that associates to this smp response.
*
* @return none
*/
SCI_STATUS scif_sas_smp_remote_device_decode_target_reset_phy_control_response(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SMP_RESPONSE_T * smp_response
)
{
SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
SCI_STATUS status = SCI_SUCCESS;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_decode_target_reset_phy_control_response(0x%x, 0x%x) enter\n",
fw_device, smp_response
));
if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
{
/// @todo: more decoding work needed when the function_result is not
/// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
/// function result.
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"Phy Control function unaccepted result(0x%x)\n",
response_header->function_result
));
status = SCI_FAILURE_RETRY_REQUIRED;
}
// phy Control succeeded.
return status;
}
/**
* @brief This method decodes a smp Phy Control response to this smp device and
* then continue the smp DISCOVER process.
*
* @param[in] fw_device The framework device that the Phy Control command
* targets to.
* @param[in] smp_response The pointer to a Phy Control response
*
* @return Almost always SCI_SUCCESS
*/
SCI_STATUS scif_sas_smp_remote_device_decode_discover_phy_control_response(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SMP_RESPONSE_T * smp_response
)
{
SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
SCI_STATUS status = SCI_SUCCESS;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_decode_discover_phy_control_response(0x%x, 0x%x) enter\n",
fw_device, smp_response
));
if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
{
/// @todo: more decoding work needed when the function_result is not
/// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
/// function result.
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"Phy Control function unaccepted result(0x%x)\n",
response_header->function_result
));
return SCI_FAILURE_RETRY_REQUIRED;
}
// continue the discover process.
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_DISCOVER;
// phy Control succeeded.
return status;
}
/**
* @brief This method decodes a smp Discover response to this smp device
* and then continue the smp discover process.
*
* @param[in] fw_device The framework device that the DISCOVER command
* targets to.
* @param[in] discover_response The pointer to a DISCOVER response
*
* @return none
*/
SCI_STATUS scif_sas_smp_remote_device_decode_target_reset_discover_response(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SMP_RESPONSE_T * smp_response
)
{
SCIF_SAS_DOMAIN_T * fw_domain;
SCI_SAS_ADDRESS_T attached_device_address;
SMP_RESPONSE_DISCOVER_T * discover_response =
&smp_response->response.discover;
SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_decode_target_reset_discover_response(0x%x, 0x%x) enter\n",
fw_device, smp_response
));
if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
{
/// @todo: more decoding work needed when the function_result is not
/// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
/// function result.
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"Discover function result(0x%x)\n",
response_header->function_result
));
return SCI_FAILURE_RETRY_REQUIRED;
}
//only if there is device attached.
if ( discover_response->u2.sas1_1.attached_device_type != SMP_NO_DEVICE_ATTACHED )
{
fw_domain = fw_device->domain;
attached_device_address = discover_response->attached_sas_address;
// the device should have already existed in the domian.
ASSERT(scif_domain_get_device_by_sas_address(
fw_domain,
&attached_device_address
) != SCI_INVALID_HANDLE);
return SCI_SUCCESS;
}
else
return SCI_FAILURE_RETRY_REQUIRED;
}
/**
* @brief This method decodes a smp Discover response to this smp device
* for SPINUP_HOLD_RELEASE activity. If a DISCOVER response says
* SATA DEVICE ATTACHED and has a valid NPL value, we call fw_device's
* start_handler(). But if a DISCOVER response still shows SPINUP
* in NPL state, we need to return retry_required status
*
* @param[in] fw_device The framework device that the DISCOVER command
* targets to.
* @param[in] discover_response The pointer to a DISCOVER response
*
* @return SCI_SUCCESS
* SCI_FAILURE_RETRY_REQUIRED
*/
SCI_STATUS scif_sas_smp_remote_device_decode_spinup_hold_release_discover_response(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SMP_RESPONSE_T * smp_response
)
{
SMP_RESPONSE_DISCOVER_T * discover_response = &smp_response->response.discover;
SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_decode_spinup_hold_release_discover_response(0x%x, 0x%x) enter\n",
fw_device, smp_response
));
if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
{
/// @todo: more decoding work needed when the function_result is not
/// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
/// function result.
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"Discover function result(0x%x)\n",
response_header->function_result
));
return SCI_FAILURE;
}
if ( discover_response->u2.sas1_1.attached_device_type != SMP_NO_DEVICE_ATTACHED )
{
if (discover_response->u2.sas1_1.negotiated_physical_link_rate != SCI_SATA_SPINUP_HOLD
&& discover_response->u4.sas2.negotiated_physical_link_rate != SCI_SATA_SPINUP_HOLD
&& ( discover_response->protocols.u.bits.attached_stp_target
||discover_response->protocols.u.bits.attached_sata_device )
)
{
SCIF_SAS_REMOTE_DEVICE_T * target_device =
scif_sas_domain_get_device_by_containing_device(
fw_device->domain,
fw_device,
fw_device->protocol_device.smp_device.current_activity_phy_index
);
//Need to update the device's connection rate. Its connection rate was SPINIP_HOLD.
scic_remote_device_set_max_connection_rate(
target_device->core_object,
discover_response->u2.sas1_1.negotiated_physical_link_rate
);
//Need to update the smp phy info too.
scif_sas_smp_remote_device_save_smp_phy_info(
fw_device, discover_response);
//This device has already constructed, only need to call start_handler
//of this device here.
return target_device->state_handlers->parent.start_handler(
&target_device->parent );
}
else
return SCI_FAILURE_RETRY_REQUIRED;
}
else
return SCI_FAILURE_RETRY_REQUIRED;
}
/**
* @brief This method decodes a smp CONFIG ROUTE INFO response to this smp
* device and then continue to config route table.
*
* @param[in] fw_device The framework device that the CONFIG ROUTE INFO command
* targets to.
* @param[in] smp_response The pointer to a CONFIG ROUTE INFO response
*
* @return none
*/
SCI_STATUS scif_sas_smp_remote_device_decode_config_route_info_response(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SMP_RESPONSE_T * smp_response
)
{
SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_decode_config_route_info_response(0x%x, 0x%x) enter\n",
fw_device, smp_response
));
if (response_header->function_result == SMP_RESULT_INDEX_DOES_NOT_EXIST)
{
//case of exceeding max route index. We need to remove the devices that are not
//able to be edit to route table. The destination config route smp phy
//is used to remove devices.
scif_sas_smp_remote_device_cancel_config_route_table_activity(fw_device);
return SCI_FAILURE_EXCEED_MAX_ROUTE_INDEX;
}
else if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
{
/// @todo: more decoding work needed when the function_result is not
/// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
/// function result.
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"Discover function result(0x%x)\n",
response_header->function_result
));
return SCI_FAILURE;
}
return SCI_SUCCESS;
}
/**
* @brief This method starts the smp Discover process for an expander by
* sending Report General request.
*
* @param[in] fw_device The framework smp device that a command
* targets to.
*
* @return none
*/
void scif_sas_smp_remote_device_start_discover(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_SAS_CONTROLLER_T * fw_controller = fw_device->domain->controller;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_start_discover(0x%x) enter\n",
fw_device
));
//For safety, clear the device again, there may be some config route table
//related info are not cleared yet.
scif_sas_smp_remote_device_clear(fw_device);
//set current activity
fw_device->protocol_device.smp_device.current_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER;
//Set current_smp_request to REPORT GENERAL.
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_REPORT_GENERAL;
//reset discover_to_start flag.
fw_device->protocol_device.smp_device.scheduled_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
//build the first smp request Report Genernal.
scif_sas_smp_request_construct_report_general(fw_controller, fw_device);
//issue DPC to start this request.
scif_cb_start_internal_io_task_schedule(
fw_controller,
scif_sas_controller_start_high_priority_io,
fw_controller
);
}
/**
* @brief This method continues the smp Discover process.
*
* @param[in] fw_device The framework smp device that a DISCOVER command
* targets to.
* @param[in] fw_request The pointer to an smp request whose response
* has been decoded.
* @param[in] status The decoding status of the smp request's response
*
* @return none
*/
void scif_sas_smp_remote_device_continue_current_activity(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SCIF_SAS_REQUEST_T * fw_request,
SCI_STATUS status
)
{
SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T *)fw_request;
// save the retry count.
U8 io_retry_count = fw_io->retry_count;
if (fw_request->is_internal)
{
// Complete this internal io request now. We want to free this io before
// we create another SMP request, which is going to happen soon.
scif_sas_internal_io_request_complete(
fw_device->domain->controller,
(SCIF_SAS_INTERNAL_IO_REQUEST_T *)fw_request,
SCI_SUCCESS
);
}
if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER)
{
if (status == SCI_SUCCESS)
{ //continue the discover process.
scif_sas_smp_remote_device_continue_discover(fw_device);
}
else if (status == SCI_FAILURE_RETRY_REQUIRED)
{
//Retry the smp request. Since we are in the middle of Discover
//process, all the smp requests are internal. A new smp request
//will be created for retry.
U32 retry_wait_duration = (SCIF_DOMAIN_DISCOVER_TIMEOUT / 2) / SCIF_SAS_IO_RETRY_LIMIT;
if (io_retry_count < SCIF_SAS_IO_RETRY_LIMIT)
scif_sas_smp_remote_device_retry_internal_io (
fw_device, io_retry_count, retry_wait_duration);
else
scif_sas_smp_remote_device_fail_discover(fw_device);
}
else if (status == SCI_FAILURE_ILLEGAL_ROUTING_ATTRIBUTE_CONFIGURATION)
{
//remove this expander device and its child devices. No need to
//continue the discover on this device.
scif_sas_domain_remove_expander_device(fw_device->domain, fw_device);
//continue the domain's smp discover.
scif_sas_domain_continue_discover(fw_device->domain);
}
else
{ //terminate the discover process.
scif_sas_smp_remote_device_fail_discover(fw_device);
}
}
else if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET)
{
if (status == SCI_SUCCESS)
{ //continue the target reset process.
scif_sas_smp_remote_device_continue_target_reset(
fw_device, fw_request);
}
else if (status == SCI_FAILURE_RETRY_REQUIRED)
{
//Retry the same smp request. Since we are in the middle of Target
//reset process, all the smp requests are using external resource.
//We will use the exactly same memory to retry.
if (io_retry_count < SCIF_SAS_IO_RETRY_LIMIT)
{
if (fw_device->protocol_device.smp_device.smp_activity_timer == NULL)
{
//create the timer to wait before retry.
fw_device->protocol_device.smp_device.smp_activity_timer =
scif_cb_timer_create(
(SCI_CONTROLLER_HANDLE_T *)fw_device->domain->controller,
(SCI_TIMER_CALLBACK_T)scif_sas_smp_external_request_retry,
(void*)fw_request
);
}
else
{
ASSERT(0);
}
//start the timer to wait
scif_cb_timer_start(
(SCI_CONTROLLER_HANDLE_T)fw_device->domain->controller,
fw_device->protocol_device.smp_device.smp_activity_timer,
SMP_REQUEST_RETRY_WAIT_DURATION //20 miliseconds
);
}
else
scif_sas_smp_remote_device_fail_target_reset(fw_device, fw_request);
}
else
//terminate the discover process.
scif_sas_smp_remote_device_fail_target_reset(fw_device, fw_request);
}
else if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_SATA_SPINUP_HOLD_RELEASE)
{
SCIF_SAS_REMOTE_DEVICE_T * target_device =
scif_sas_domain_get_device_by_containing_device(
fw_device->domain,
fw_device,
fw_device->protocol_device.smp_device.current_activity_phy_index
);
if (status == SCI_SUCCESS)
{
//move on to next round of SPINUP_HOLD_REALSE activity.
scif_sas_smp_remote_device_sata_spinup_hold_release(fw_device);
}
else if (status == SCI_FAILURE_RETRY_REQUIRED)
{
U32 delay =
(scic_remote_device_get_suggested_reset_timeout(target_device->core_object) /
SCIF_SAS_IO_RETRY_LIMIT);
//Retry the smp request. Since we are in the middle of Discover
//process, all the smp requests are internal. A new smp request
//will be created for retry.
if (io_retry_count < SCIF_SAS_IO_RETRY_LIMIT)
{
scif_sas_smp_remote_device_retry_internal_io(
fw_device, io_retry_count, delay);
}
else //give up on this target device.
{
scif_sas_smp_remote_device_fail_target_spinup_hold_release(
fw_device , target_device);
}
}
else //give up on this target device.
scif_sas_smp_remote_device_fail_target_spinup_hold_release(
fw_device, target_device);
}
else if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CONFIG_ROUTE_TABLE)
{
SCI_FAST_LIST_ELEMENT_T * next_phy_element = sci_fast_list_get_next(
&(fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy->list_element) );
SCI_FAST_LIST_T * destination_smp_phy_list =
fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy->list_element.owning_list;
SCIF_SAS_SMP_PHY_T * next_phy_in_wide_port = NULL;
if (next_phy_element != NULL
&& status != SCI_FAILURE_EXCEED_MAX_ROUTE_INDEX)
{
fw_device->protocol_device.smp_device.curr_config_route_index++;
fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy =
(SCIF_SAS_SMP_PHY_T *)sci_fast_list_get_object(next_phy_element);
// Update the anchor for config route index.
fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->config_route_table_index_anchor =
fw_device->protocol_device.smp_device.curr_config_route_index;
scif_sas_smp_remote_device_configure_route_table(fw_device);
}
else if ( scif_sas_smp_remote_device_get_config_route_table_method(fw_device)
== SCIF_SAS_CONFIG_ROUTE_TABLE_ALL_PHYS
&& (next_phy_in_wide_port = scif_sas_smp_phy_find_next_phy_in_wide_port(
fw_device->protocol_device.smp_device.config_route_smp_phy_anchor)
)!= NULL
)
{
//config the other phy in the same wide port
fw_device->protocol_device.smp_device.config_route_smp_phy_anchor =
next_phy_in_wide_port;
fw_device->protocol_device.smp_device.current_activity_phy_index =
fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->phy_identifier;
fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy =
sci_fast_list_get_head(destination_smp_phy_list);
if (fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->config_route_table_index_anchor != 0)
fw_device->protocol_device.smp_device.curr_config_route_index =
fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->config_route_table_index_anchor + 1;
else
fw_device->protocol_device.smp_device.curr_config_route_index = 0;
scif_sas_smp_remote_device_configure_route_table(fw_device);
}
else if ( fw_device->protocol_device.smp_device.is_route_table_cleaned == FALSE)
{
fw_device->protocol_device.smp_device.current_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CLEAN_ROUTE_TABLE;
scif_sas_smp_remote_device_clean_route_table(fw_device);
}
else
{
//set this device's activity to NON.
fw_device->protocol_device.smp_device.current_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
//we need to notify domain that this device finished config route table, domain
//may pick up other activities (i.e. Discover) for other expanders.
scif_sas_domain_continue_discover(fw_device->domain);
}
}
else if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CLEAN_ROUTE_TABLE)
{
scif_sas_smp_remote_device_clean_route_table(fw_device);
}
else if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CLEAR_AFFILIATION)
{
scif_sas_smp_remote_device_continue_clear_affiliation(fw_device);
}
}
/**
* @brief This method continues the smp Discover process.
*
* @param[in] fw_device The framework smp device that a DISCOVER command
* targets to.
*
* @return none
*/
void scif_sas_smp_remote_device_continue_discover(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_SAS_DOMAIN_T * fw_domain = fw_device->domain;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_continue_discover(0x%x) enter\n",
fw_device
));
switch (fw_device->protocol_device.smp_device.current_smp_request)
{
case SMP_FUNCTION_REPORT_GENERAL:
// send the REPORT MANUFACTURER_INFO request
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_REPORT_MANUFACTURER_INFORMATION;
scif_sas_smp_request_construct_report_manufacturer_info(
fw_domain->controller, fw_device
);
break;
case SMP_FUNCTION_REPORT_MANUFACTURER_INFORMATION:
//send the first SMP DISCOVER request.
fw_device->protocol_device.smp_device.current_activity_phy_index = 0;
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_DISCOVER;
scif_sas_smp_request_construct_discover(
fw_domain->controller,
fw_device,
fw_device->protocol_device.smp_device.current_activity_phy_index,
NULL, NULL
);
break;
case SMP_FUNCTION_DISCOVER:
fw_device->protocol_device.smp_device.current_activity_phy_index++;
if ( (fw_device->protocol_device.smp_device.current_activity_phy_index <
fw_device->protocol_device.smp_device.number_of_phys) )
{
scif_sas_smp_request_construct_discover(
fw_domain->controller,
fw_device,
fw_device->protocol_device.smp_device.current_activity_phy_index,
NULL, NULL
);
}
else
scif_sas_smp_remote_device_finish_initial_discover(fw_device);
break;
case SMP_FUNCTION_REPORT_PHY_SATA:
scif_sas_smp_request_construct_report_phy_sata(
fw_device->domain->controller,
fw_device,
fw_device->protocol_device.smp_device.current_activity_phy_index
);
break;
case SMP_FUNCTION_PHY_CONTROL:
scif_sas_smp_request_construct_phy_control(
fw_device->domain->controller,
fw_device,
PHY_OPERATION_HARD_RESET,
fw_device->protocol_device.smp_device.current_activity_phy_index,
NULL,
NULL
);
break;
default:
break;
}
}
/**
* @brief This method finishes the initial smp DISCOVER process. There
* may be a spinup_hold release phase following of initial discover,
* depending on whether there are SATA device in the domain
* in SATA_SPINUP_HOLD condition.
*
* @param[in] fw_device The framework smp device that finishes all the
* DISCOVER requests.
*
* @return none
*/
void scif_sas_smp_remote_device_finish_initial_discover(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_SAS_REMOTE_DEVICE_T * device_in_sata_spinup_hold =
scif_sas_domain_find_device_in_spinup_hold(fw_device->domain);
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_finish_initial_discover(0x%x) enter\n",
fw_device
));
if ( device_in_sata_spinup_hold != NULL )
{
//call the common private routine to reset all fields of this smp device.
scif_sas_smp_remote_device_clear(fw_device);
//Move on to next activity SPINUP_HOLD_RELEASE
fw_device->protocol_device.smp_device.current_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_SATA_SPINUP_HOLD_RELEASE;
//create the timer to delay a little bit before going to
//sata spinup hold release activity.
if (fw_device->protocol_device.smp_device.smp_activity_timer == NULL)
{
fw_device->protocol_device.smp_device.smp_activity_timer =
scif_cb_timer_create(
(SCI_CONTROLLER_HANDLE_T *)fw_device->domain->controller,
(SCI_TIMER_CALLBACK_T)scif_sas_smp_remote_device_sata_spinup_hold_release,
(void*)fw_device
);
}
else
{
ASSERT (0);
}
scif_cb_timer_start(
(SCI_CONTROLLER_HANDLE_T)fw_device->domain->controller,
fw_device->protocol_device.smp_device.smp_activity_timer,
SMP_SPINUP_HOLD_RELEASE_WAIT_DURATION
);
}
else
scif_sas_smp_remote_device_finish_discover(fw_device);
}
/**
* @brief This method finishes the smp DISCOVER process.
*
* @param[in] fw_device The framework smp device that finishes all the
* DISCOVER requests.
*
* @return none
*/
void scif_sas_smp_remote_device_finish_discover(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_SAS_DOMAIN_T * fw_domain = fw_device->domain;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_finish_discover(0x%x) enter\n",
fw_device
));
if ( fw_domain->is_config_route_table_needed
&& fw_device->protocol_device.smp_device.smp_phy_list.list_head != NULL)
scif_sas_smp_remote_device_configure_upstream_expander_route_info(fw_device);
//call the common private routine to reset all fields of this smp device.
scif_sas_smp_remote_device_clear(fw_device);
#ifdef SCI_SMP_PHY_LIST_DEBUG_PRINT
scif_sas_smp_remote_device_print_smp_phy_list(fw_device);
#endif
//notify domain this smp device's discover finishes, it's up to domain
//to continue the discover process in a bigger scope.
scif_sas_domain_continue_discover(fw_domain);
}
/**
* @brief This method continues the smp Target Reset (Phy Control) process.
*
* @param[in] fw_device The framework smp device that a smp reset targets to.
*
* @return none
*/
void scif_sas_smp_remote_device_continue_target_reset(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SCIF_SAS_REQUEST_T * fw_request
)
{
SCIF_SAS_CONTROLLER_T * fw_controller = fw_device->domain->controller;
SCIF_SAS_REMOTE_DEVICE_T * target_device =
scif_sas_domain_get_device_by_containing_device(
fw_device->domain,
fw_device,
fw_device->protocol_device.smp_device.current_activity_phy_index
);
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_continue_target_reset(0x%x, 0x%x) enter\n",
fw_device, fw_request
));
if (fw_device->protocol_device.smp_device.current_smp_request ==
SMP_FUNCTION_PHY_CONTROL)
{
//query the core remote device to get suggested reset timeout value
//then scale down by factor of 8 to get the duration of the pause
//before sending out Discover command to poll.
U32 delay =
(scic_remote_device_get_suggested_reset_timeout(target_device->core_object)/8);
//create the timer to send Discover command polling target device's
//coming back.
if (fw_device->protocol_device.smp_device.smp_activity_timer == NULL)
{
fw_device->protocol_device.smp_device.smp_activity_timer =
scif_cb_timer_create(
(SCI_CONTROLLER_HANDLE_T *)fw_controller,
(SCI_TIMER_CALLBACK_T)scif_sas_smp_remote_device_target_reset_poll,
(void*)fw_request
);
}
else
{
ASSERT(0);
}
//start the timer
scif_cb_timer_start(
(SCI_CONTROLLER_HANDLE_T)fw_controller,
fw_device->protocol_device.smp_device.smp_activity_timer,
delay
);
}
else if (fw_device->protocol_device.smp_device.current_smp_request ==
SMP_FUNCTION_DISCOVER)
{
//tell target reset successful
scif_sas_remote_device_target_reset_complete(
target_device, fw_request, SCI_SUCCESS);
}
}
/**
* @brief This routine is invoked by timer or when 2 BCN are received
* after Phy Control command. This routine will construct a
* Discover command to the same expander phy to poll the target
* device's coming back. This new request is then put into
* high priority queue and will be started by a DPC soon.
*
* @param[in] fw_request The scif request for smp activities.
*/
void scif_sas_smp_remote_device_target_reset_poll(
SCIF_SAS_REQUEST_T * fw_request
)
{
SCIF_SAS_REMOTE_DEVICE_T * fw_device = fw_request->device;
SCIF_SAS_CONTROLLER_T * fw_controller = fw_device->domain->controller;
void * new_command_handle;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_target_reset_poll(0x%x) enter\n",
fw_request
));
// Before we construct new io using the same memory, we need to
// remove the IO from the list of outstanding requests on the domain
// so that we don't damage the domain's fast list of request.
sci_fast_list_remove_element(&fw_request->list_element);
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_DISCOVER;
//sent smp discover request to poll on remote device's coming back.
//construct Discover command using the same memory as fw_request.
new_command_handle = scif_sas_smp_request_construct_discover(
fw_device->domain->controller,
fw_device,
fw_device->protocol_device.smp_device.current_activity_phy_index,
(void *)sci_object_get_association(fw_request),
(void *)fw_request
);
//put into the high priority queue.
sci_pool_put(fw_controller->hprq.pool, (POINTER_UINT) new_command_handle);
//schedule the DPC to start new Discover command.
scif_cb_start_internal_io_task_schedule(
fw_controller, scif_sas_controller_start_high_priority_io, fw_controller
);
}
/**
* @brief This method fails discover process.
*
* @param[in] fw_device The framework smp device that failed at current
* activity.
*
* @return none
*/
void scif_sas_smp_remote_device_fail_discover(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_fail_discover(0x%x) enter\n",
fw_device
));
switch (fw_device->protocol_device.smp_device.current_smp_request)
{
case SMP_FUNCTION_REPORT_GENERAL:
case SMP_FUNCTION_REPORT_MANUFACTURER_INFORMATION:
scif_sas_smp_remote_device_finish_discover(fw_device);
break;
case SMP_FUNCTION_DISCOVER:
case SMP_FUNCTION_REPORT_PHY_SATA:
//Retry limit reached, we will continue to send DISCOVER to next phy.
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_DISCOVER;
scif_sas_smp_remote_device_continue_discover(fw_device);
break;
default:
break;
}
}
/**
* @brief This method fails Target Reset.
*
* @param[in] fw_device The framework smp device that failed at current
* activity.
* @param[in] fw_request The smp request created for target reset
* using external resource.
*
* @return none
*/
void scif_sas_smp_remote_device_fail_target_reset(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SCIF_SAS_REQUEST_T * fw_request
)
{
SCIF_SAS_REMOTE_DEVICE_T * target_device =
scif_sas_domain_get_device_by_containing_device(
fw_device->domain,
fw_device,
fw_device->protocol_device.smp_device.current_activity_phy_index
);
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_fail_target_reset(0x%x, 0x%x, 0x%x) enter\n",
fw_device, target_device, fw_request
));
//tell target reset failed
scif_sas_remote_device_target_reset_complete(
target_device, fw_request, SCI_FAILURE);
}
/**
* @brief This method init or continue the SATA SPINUP_HOLD RELEASE activity.
* This function searches domain's device list, find a device in STOPPED STATE
* and its connection_rate is SPINIP, then send DISCOVER command to its expander
* phy id to poll. But if searching the domain's device list for SATA devices on
* SPINUP_HOLD finds no device, the activity SPINUP_HOLD_RELEASE is finished.
* We then call fw_domain->device_start_complete_handler() for this smp-device.
*
* @param[in] fw_device The framework smp device that is on SATA SPINUP_HOLD_RELEASE
* activity.
*
* @return none
*/
void scif_sas_smp_remote_device_sata_spinup_hold_release(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_SAS_DOMAIN_T * fw_domain = fw_device->domain;
SCIF_SAS_CONTROLLER_T * fw_controller = fw_domain->controller;
SCIF_SAS_REMOTE_DEVICE_T * device_to_poll = NULL;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_sata_spinup_hold_release(0x%x) enter\n",
fw_device
));
//search throught domain's device list to find a sata device on spinup_hold
//state to poll.
device_to_poll = scif_sas_domain_find_device_in_spinup_hold(fw_domain);
if (device_to_poll != NULL)
{
//send DISCOVER command to this device's expaner phy.
fw_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_DISCOVER;
fw_device->protocol_device.smp_device.current_activity_phy_index =
device_to_poll->expander_phy_identifier;
scif_sas_smp_request_construct_discover(
fw_domain->controller,
fw_device,
fw_device->protocol_device.smp_device.current_activity_phy_index,
NULL, NULL
);
//schedule the DPC to start new Discover command.
scif_cb_start_internal_io_task_schedule(
fw_controller, scif_sas_controller_start_high_priority_io, fw_controller
);
}
else //SATA SPINUP HOLD RELEASE activity is done.
scif_sas_smp_remote_device_finish_discover (fw_device);
}
/**
* @brief This method fail an action of SATA SPINUP_HOLD RELEASE on a single EA
* SATA device. It will remove a remote_device object for a sata device
* that fails to come out of spinup_hold.
*
* @param[in] fw_device The framework smp device that is on SATA SPINUP_HOLD_RELEASE
* activity.
* @param[in] target_device The expander attached device failed being brought out
* of SPINUP_HOLD state.
*
* @return none
*/
void scif_sas_smp_remote_device_fail_target_spinup_hold_release(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SCIF_SAS_REMOTE_DEVICE_T * target_device
)
{
SCIF_SAS_DOMAIN_T * fw_domain = fw_device->domain;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_fail_target_spinup_hold_release(0x%x, 0x%x) enter\n",
fw_device, target_device
));
//need to remove the device, since we have to give up on spinup_hold_release
//activity on this device.
scif_cb_domain_device_removed(
fw_domain->controller, fw_domain, target_device
);
//move on to next round of SPINUP_HOLD_REALSE activity.
scif_sas_smp_remote_device_sata_spinup_hold_release(fw_device);
}
/**
* @brief This method retry only internal IO for the smp device.
*
* @param[in] fw_device The framework smp device that has an smp request to retry.
* @param[in] io_retry_count current count for times the IO being retried.
* @param[in] delay The time delay before the io gets retried.
*
* @return none
*/
void scif_sas_smp_remote_device_retry_internal_io(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
U8 io_retry_count,
U32 delay
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_retry_internal_io(0x%x, 0x%x, 0x%x) enter\n",
fw_device, io_retry_count, delay
));
fw_device->protocol_device.smp_device.io_retry_count =
io_retry_count;
//create the timer for poll target device's coming back.
if (fw_device->protocol_device.smp_device.smp_activity_timer == NULL)
{
fw_device->protocol_device.smp_device.smp_activity_timer =
scif_cb_timer_create(
(SCI_CONTROLLER_HANDLE_T *)fw_device->domain->controller,
(SCI_TIMER_CALLBACK_T)scif_sas_smp_internal_request_retry,
(void*)fw_device
);
}
else
{
ASSERT(0);
}
//start the timer for a purpose of waiting.
scif_cb_timer_start(
(SCI_CONTROLLER_HANDLE_T)fw_device->domain->controller,
fw_device->protocol_device.smp_device.smp_activity_timer,
delay
);
}
/**
* @brief This method indicates whether an expander device is in Discover
* process.
*
* @param[in] fw_device The framework smp device.
*
* @return Whether an expander device is in the middle of discovery process.
*/
BOOL scif_sas_smp_remote_device_is_in_activity(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
return(fw_device->protocol_device.smp_device.current_activity
!= SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE);
}
/**
* @brief This method search through the smp phy list of an expander to
* find a smp phy by its phy id of the expander.
*
* @param[in] phy_identifier The search criteria.
* @param[in] smp_remote_device The expander that owns the smp phy list.
*
* @return The found smp phy or a NULL pointer to indicate no smp phy is found.
*/
SCIF_SAS_SMP_PHY_T * scif_sas_smp_remote_device_find_smp_phy_by_id(
U8 phy_identifier,
SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device
)
{
SCI_FAST_LIST_ELEMENT_T * element = smp_remote_device->smp_phy_list.list_head;
SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
ASSERT(phy_identifier < smp_remote_device->smp_phy_list.number_of_phys);
while (element != NULL)
{
curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
element = sci_fast_list_get_next(element);
if (curr_smp_phy->phy_identifier == phy_identifier)
return curr_smp_phy;
}
return NULL;
}
/**
* @brief This method takes care of removing smp phy list of a smp devcie, which is
* about to be removed.
*
* @param[in] fw_device The expander device that is about to be removed.
*
* @return none.
*/
void scif_sas_smp_remote_device_removed(
SCIF_SAS_REMOTE_DEVICE_T * this_device
)
{
SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device =
&this_device->protocol_device.smp_device;
SCI_FAST_LIST_ELEMENT_T * element = smp_remote_device->smp_phy_list.list_head;
SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
SCIF_LOG_TRACE((
sci_base_object_get_logger(this_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_removed(0x%x) enter\n",
this_device
));
//remove all the smp phys in this device's smp_phy_list, and the conterpart smp phys
//in phy connections.
while (element != NULL)
{
curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
element = sci_fast_list_get_next(element);
scif_sas_smp_phy_destruct(curr_smp_phy);
}
this_device->protocol_device.smp_device.number_of_phys = 0;
this_device->protocol_device.smp_device.expander_route_indexes = 0;
this_device->protocol_device.smp_device.is_table_to_table_supported = FALSE;
this_device->protocol_device.smp_device.is_externally_configurable = FALSE;
this_device->protocol_device.smp_device.is_able_to_config_others = FALSE;
scif_sas_smp_remote_device_clear(this_device);
}
/**
* @brief This method takes care of terminated smp request to a smp device. The
* terminated smp request is most likely timeout and being aborted. A timeout
* maybe due to OPEN REJECT (NO DESTINATION).
*
* @param[in] fw_device The expander device that a timed out smp request towards to.
* @param[in] fw_request A failed smp request that is terminated by scic.
*
* @return none.
*/
void scif_sas_smp_remote_device_terminated_request_handler(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SCIF_SAS_REQUEST_T * fw_request
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_terminated_request_handler(0x%x, 0x%x) enter\n",
fw_device, fw_request
));
scif_sas_smp_remote_device_decode_smp_response(
fw_device, fw_request, NULL, SCI_IO_FAILURE_RETRY_REQUIRED
);
}
/**
* @brief This method allocates and populates the smp phy list of a expander device.
*
* @param[in] fw_device The expander device, whose smp phy list is to be populated after
* getting REPORT GENERAL response.
*
* @return none.
*/
void scif_sas_smp_remote_device_populate_smp_phy_list(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_SAS_SMP_PHY_T * this_smp_phy = NULL;
U8 expander_phy_id = 0;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_populate_smp_phy_list(0x%x) enter\n",
fw_device
));
for ( expander_phy_id = 0;
expander_phy_id < fw_device->protocol_device.smp_device.number_of_phys;
expander_phy_id++ )
{
this_smp_phy =
scif_sas_controller_allocate_smp_phy(fw_device->domain->controller);
ASSERT( this_smp_phy != NULL );
if ( this_smp_phy != NULL )
scif_sas_smp_phy_construct(this_smp_phy, fw_device, expander_phy_id);
}
}
/**
* @brief This method updates a smp phy of a expander device based on DISCOVER response.
*
* @param[in] fw_device The expander device, one of whose smp phys is to be updated.
* @param[in] discover_response The smp DISCOVER response.
*
* @return SCI_STATUS If a smp phy pair between expanders has invalid routing attribute,
* return SCI_FAILURE_ILLEGAL_ROUTING_ATTRIBUTE_CONFIGURATION, otherwise,
* return SCI_SUCCESS
*/
SCI_STATUS scif_sas_smp_remote_device_save_smp_phy_info(
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
SMP_RESPONSE_DISCOVER_T * discover_response
)
{
SCI_STATUS status = SCI_SUCCESS;
SCIF_SAS_SMP_PHY_T * smp_phy = NULL;
SCIF_SAS_REMOTE_DEVICE_T * attached_device = NULL;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_save_smp_phy_info(0x%x, 0x%x) enter\n",
fw_device, discover_response
));
smp_phy = scif_sas_smp_remote_device_find_smp_phy_by_id(
discover_response->phy_identifier,
&fw_device->protocol_device.smp_device
);
ASSERT( smp_phy != NULL );
//Note, attached_device could be NULL, not all the smp phy have to connected to a device.
attached_device = (SCIF_SAS_REMOTE_DEVICE_T *)
scif_domain_get_device_by_sas_address(
fw_device->domain, &discover_response->attached_sas_address);
scif_sas_smp_phy_save_information(
smp_phy, attached_device, discover_response);
//handle the special case of smp phys between expanders.
if ( discover_response->protocols.u.bits.attached_smp_target )
{
//this fw_device is a child expander, just found its parent expander.
//And there is no smp_phy constructed yet, record this phy connection.
if ( attached_device != NULL
&& attached_device == fw_device->containing_device )
{
//record the smp phy info, for this phy connects to a upstream smp device.
//the connection of a pair of smp phys are completed.
status = scif_sas_smp_phy_set_attached_phy(
smp_phy,
discover_response->attached_phy_identifier,
attached_device
);
if (status == SCI_SUCCESS)
{
//check the routing attribute for this phy and its containing device's
//expander_phy_routing_attribute.
if ( scif_sas_smp_phy_verify_routing_attribute(
smp_phy, smp_phy->u.attached_phy) != SCI_SUCCESS )
return SCI_FAILURE_ILLEGAL_ROUTING_ATTRIBUTE_CONFIGURATION;
}
}
}
return status;
}
#ifdef SCI_SMP_PHY_LIST_DEBUG_PRINT
void scif_sas_smp_remote_device_print_smp_phy_list(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device = &fw_device->protocol_device.smp_device;
SCI_FAST_LIST_ELEMENT_T * element = smp_remote_device->smp_phy_list.list_head;
SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE,
"==========EXPANDER DEVICE (0x%x) smp phy list========== \n",
fw_device
));
while (element != NULL)
{
curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
element = sci_fast_list_get_next(element);
//print every thing about a smp phy
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE,
"SMP_PHY_%d (0x%x), attached device(0x%x), attached_sas_address(%x%x) attached_device_type(%d), routing_attribute(%d)\n",
curr_smp_phy->phy_identifier, curr_smp_phy,
curr_smp_phy->u.end_device,
curr_smp_phy->attached_sas_address.high, curr_smp_phy->attached_sas_address.low,
curr_smp_phy->attached_device_type,
curr_smp_phy->routing_attribute
));
}
}
#endif
/**
* @brief This method configure upstream expander(s)' (if there is any) route info.
*
* @param[in] this_device The expander device that is currently in discover process.
*
* @return none.
*/
void scif_sas_smp_remote_device_configure_upstream_expander_route_info(
SCIF_SAS_REMOTE_DEVICE_T * this_device
)
{
SCIF_SAS_REMOTE_DEVICE_T * curr_child_expander = this_device;
SCIF_SAS_REMOTE_DEVICE_T * curr_parent_expander =
scif_sas_remote_device_find_upstream_expander(this_device);
SCIF_SAS_REMOTE_DEVICE_T * curr_config_route_info_expander = NULL;
SCIF_LOG_TRACE((
sci_base_object_get_logger(this_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_configure_upstream_expander_route_info(0x%x) enter\n",
this_device
));
//traverse back to find root device.
while(curr_parent_expander != NULL )
{
//must set destination_smp_phy outside of find_upstream_expander() using the device
//that is just about to finish the discovery.
curr_parent_expander->protocol_device.smp_device.curr_config_route_destination_smp_phy =
(SCIF_SAS_SMP_PHY_T*)sci_fast_list_get_object(
this_device->protocol_device.smp_device.smp_phy_list.list_head);
curr_child_expander = curr_parent_expander;
curr_parent_expander = scif_sas_remote_device_find_upstream_expander(curr_child_expander);
}
//found the root device: curr_child_expander. configure it and its downstream expander(s) till
//this_device or a self-configuring expander that configures others;
curr_config_route_info_expander = curr_child_expander;
while ( curr_config_route_info_expander != NULL
&& curr_config_route_info_expander != this_device
&& curr_config_route_info_expander->protocol_device.smp_device.scheduled_activity
== SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE
)
{
if (curr_config_route_info_expander->protocol_device.smp_device.is_externally_configurable)
{
SCIF_SAS_SMP_PHY_T * phy_being_config =
curr_config_route_info_expander->protocol_device.smp_device.config_route_smp_phy_anchor;
curr_config_route_info_expander->protocol_device.smp_device.curr_config_route_index =
phy_being_config->config_route_table_index_anchor;
if (curr_config_route_info_expander->protocol_device.smp_device.curr_config_route_index != 0)
curr_config_route_info_expander->protocol_device.smp_device.curr_config_route_index++;
curr_config_route_info_expander->protocol_device.smp_device.scheduled_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CONFIG_ROUTE_TABLE;
//Find a downstream expander that has curr_config_route_destination_smp_phy.owning device
//same as curr_config_route_info_expander.
curr_config_route_info_expander = scif_sas_remote_device_find_downstream_expander(
curr_config_route_info_expander);
}
else if (curr_config_route_info_expander->protocol_device.smp_device.is_able_to_config_others)
{
//no need to config route table to this expander and its children.
//find its downstream expander and clear the planned config route table activity.
SCIF_SAS_REMOTE_DEVICE_T * curr_downstream_expander =
scif_sas_remote_device_find_downstream_expander(
curr_config_route_info_expander);
scif_sas_smp_remote_device_clear(curr_config_route_info_expander);
while ( curr_downstream_expander != NULL
&& curr_downstream_expander != this_device )
{
scif_sas_smp_remote_device_clear(curr_downstream_expander);
curr_downstream_expander =
scif_sas_remote_device_find_downstream_expander(
curr_config_route_info_expander);
}
break;
}
else
{
// current expander is a self-configuring expander, which is not externally
// configurable, and doesn't config others. we need to simply skip this expander.
curr_config_route_info_expander = scif_sas_remote_device_find_downstream_expander(
curr_config_route_info_expander);
}
}
}
/**
* @brief This method finds the immediate upstream expander of a given expander device.
*
* @param[in] this_device The given expander device, whose upstream expander is to be found.
*
* @return The immediate upstream expander. Or a NULL pointer if this_device is root already.
*/
SCIF_SAS_REMOTE_DEVICE_T * scif_sas_remote_device_find_upstream_expander(
SCIF_SAS_REMOTE_DEVICE_T * this_device
)
{
SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device =
&this_device->protocol_device.smp_device;
SCIF_SAS_REMOTE_DEVICE_T * upstream_expander = NULL;
SCI_FAST_LIST_ELEMENT_T * element = smp_remote_device->smp_phy_list.list_head;
SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
SCIF_LOG_TRACE((
sci_base_object_get_logger(this_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_configure_upstream_expander_route_info(0x%x) enter\n",
this_device
));
while (element != NULL)
{
curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
element = sci_fast_list_get_next(element);
if ( curr_smp_phy->routing_attribute == SUBTRACTIVE_ROUTING_ATTRIBUTE
&& ( curr_smp_phy->attached_device_type == SMP_EDGE_EXPANDER_DEVICE
|| curr_smp_phy->attached_device_type == SMP_FANOUT_EXPANDER_DEVICE)
&& curr_smp_phy->u.attached_phy != NULL
&& curr_smp_phy->u.attached_phy->routing_attribute == TABLE_ROUTING_ATTRIBUTE )
{
//set the current_activity and current_config_route_index for that
//upstream expander.
upstream_expander = curr_smp_phy->u.attached_phy->owning_device;
upstream_expander->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_CONFIGURE_ROUTE_INFORMATION;
//if the upstream_expander's config route table method is config phy0 only or
//config all phys, the current activity phy is found.
upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor =
scif_sas_smp_remote_device_find_smp_phy_by_id(
curr_smp_phy->u.attached_phy->phy_identifier,
&(curr_smp_phy->u.attached_phy->owning_device->protocol_device.smp_device)
);
//if the upstream_expander's config route table method is config middle phy only
//config highest phy only, the current activity phy needs a update.
if ( scif_sas_smp_remote_device_get_config_route_table_method(upstream_expander)
== SCIF_SAS_CONFIG_ROUTE_TABLE_MIDDLE_PHY_ONLY )
{
upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor =
scif_sas_smp_phy_find_middle_phy_in_wide_port (
upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor
);
}
else if ( scif_sas_smp_remote_device_get_config_route_table_method(upstream_expander)
== SCIF_SAS_CONFIG_ROUTE_TABLE_HIGHEST_PHY_ONLY )
{
upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor =
scif_sas_smp_phy_find_highest_phy_in_wide_port (
upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor
);
}
upstream_expander->protocol_device.smp_device.current_activity_phy_index =
upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor->phy_identifier;
return upstream_expander;
}
}
return NULL;
}
/**
* @brief This method finds the immediate downstream expander of a given expander device.
*
* @param[in] this_device The given expander device, whose downstream expander is to be found.
*
* @return The immediate downstream expander. Or a NULL pointer if there is none.
*/
SCIF_SAS_REMOTE_DEVICE_T * scif_sas_remote_device_find_downstream_expander(
SCIF_SAS_REMOTE_DEVICE_T * this_device
)
{
SCIF_SAS_SMP_REMOTE_DEVICE_T * this_smp_remote_device =
&this_device->protocol_device.smp_device;
SCIF_SAS_REMOTE_DEVICE_T * downstream_expander = NULL;
SCI_FAST_LIST_ELEMENT_T * element = this_smp_remote_device->smp_phy_list.list_head;
SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
SCIF_LOG_TRACE((
sci_base_object_get_logger(this_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_remote_device_find_downstream_expander(0x%x) enter\n",
this_device
));
while (element != NULL)
{
curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
element = sci_fast_list_get_next(element);
if ( curr_smp_phy->routing_attribute == TABLE_ROUTING_ATTRIBUTE
&& curr_smp_phy->attached_device_type == SMP_EDGE_EXPANDER_DEVICE
&& curr_smp_phy->u.attached_phy != NULL)
{
//set the current_activity and current_config_route_index for that
//upstream expander.
downstream_expander = curr_smp_phy->u.attached_phy->owning_device;
if ( downstream_expander->protocol_device.smp_device.curr_config_route_destination_smp_phy != NULL
&& downstream_expander->protocol_device.smp_device.curr_config_route_destination_smp_phy->owning_device ==
this_smp_remote_device->curr_config_route_destination_smp_phy->owning_device )
return downstream_expander;
}
}
return NULL;
}
/**
* @brief This method follows route table optimization rule to check if a destination_device
* should be recorded in the device_being_config's route table
*
* @param[in] device_being_config The upstream expander device, whose route table is being configured.
* @param[in] destination_smp_phy A smp phy whose attached device is potentially to be
* recorded in route table.
*
* @return BOOL This method returns TRUE if a destination_device should be recorded in route table.
* This method returns FALSE if a destination_device need not to be recorded
* in route table.
*/
BOOL scif_sas_smp_remote_device_do_config_route_info(
SCIF_SAS_REMOTE_DEVICE_T * device_being_config,
SCIF_SAS_SMP_PHY_T * destination_smp_phy
)
{
SCI_SAS_ADDRESS_T device_being_config_sas_address;
SCIF_LOG_TRACE((
sci_base_object_get_logger(device_being_config),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_do_config_route_info(0x%x, 0x%x) enter\n",
device_being_config, destination_smp_phy
));
scic_remote_device_get_sas_address(
device_being_config->core_object, &device_being_config_sas_address
);
//refer to SAS-2 spec 4.8.3, rule (b)
if ((destination_smp_phy->attached_sas_address.low == 0
&& destination_smp_phy->attached_sas_address.high == 0)
&& (destination_smp_phy->attached_device_type == SMP_NO_DEVICE_ATTACHED))
{
return FALSE;
}
//refer to SAS-2 spec 4.8.3, rule (c), self-referencing.
if (destination_smp_phy->attached_sas_address.high ==
device_being_config_sas_address.high
&& destination_smp_phy->attached_sas_address.low ==
device_being_config_sas_address.low)
{
return FALSE;
}
//There will be no cases that falling into rule (a), (d), (e) to be excluded,
//based on our current mechanism of cofig route table.
return TRUE;
}
/**
* @brief This method configures device_being_config's route table for all the enclosed devices in
* a downstream smp device, destination_device.
*
* @param[in] device_being_config The upstream expander device, whose route table is being configured.
*
* @return None
*/
void scif_sas_smp_remote_device_configure_route_table(
SCIF_SAS_REMOTE_DEVICE_T * device_being_config
)
{
//go through the smp phy list of this_device.
SCI_FAST_LIST_ELEMENT_T * element =
&(device_being_config->protocol_device.smp_device.curr_config_route_destination_smp_phy->list_element);
SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
SCIF_LOG_TRACE((
sci_base_object_get_logger(device_being_config),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_configure_route_table(0x%x) enter\n",
device_being_config
));
device_being_config->protocol_device.smp_device.current_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CONFIG_ROUTE_TABLE;
while (element != NULL)
{
curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
element = sci_fast_list_get_next(element);
//check if this phy needs to be added to the expander's route table.
if (scif_sas_smp_remote_device_do_config_route_info(
device_being_config, curr_smp_phy) == TRUE )
{
SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device =
&device_being_config->protocol_device.smp_device;
smp_remote_device->curr_config_route_destination_smp_phy =
curr_smp_phy;
//Then config this_device's route table entry at the phy and next route_index.
//send config_route_info using curr_smp_phy.phy_identifier and sas_address.
scif_sas_smp_request_construct_config_route_info(
device_being_config->domain->controller,
device_being_config,
smp_remote_device->current_activity_phy_index,
smp_remote_device->curr_config_route_index,
curr_smp_phy->attached_sas_address,
FALSE
);
//schedule the DPC.
scif_cb_start_internal_io_task_schedule(
device_being_config->domain->controller,
scif_sas_controller_start_high_priority_io,
device_being_config->domain->controller
);
//stop here, we need to wait for config route info's response then send
//the next one.
break;
}
}
}
/**
* @brief This method walks through an expander's route table to clean table
* attribute phys' route entries. This routine finds one table entry
* to clean and will be called repeatly till it finishes cleanning the
* whole table.
*
* @param[in] fw_device The expander device, whose route table entry is to be cleaned.
*
* @return None.
*/
void scif_sas_smp_remote_device_clean_route_table(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_SAS_SMP_PHY_T * smp_phy_being_config;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_clean_route_table(0x%x) enter\n",
fw_device
));
//from anchors, start to clean all the other route table entries.
fw_device->protocol_device.smp_device.curr_config_route_index++;
if ( fw_device->protocol_device.smp_device.curr_config_route_index >=
fw_device->protocol_device.smp_device.expander_route_indexes )
{
fw_device->protocol_device.smp_device.curr_config_route_index = 0;
do //find next table attribute PHY.
{
fw_device->protocol_device.smp_device.current_activity_phy_index++;
if (fw_device->protocol_device.smp_device.current_activity_phy_index ==
fw_device->protocol_device.smp_device.number_of_phys)
fw_device->protocol_device.smp_device.current_activity_phy_index=0;
//phy_index changed, so update the smp_phy_being_config.
smp_phy_being_config =
scif_sas_smp_remote_device_find_smp_phy_by_id(
fw_device->protocol_device.smp_device.current_activity_phy_index,
&(fw_device->protocol_device.smp_device)
);
} while( smp_phy_being_config->routing_attribute != TABLE_ROUTING_ATTRIBUTE );
if ( smp_phy_being_config->phy_identifier !=
fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->phy_identifier)
{
if (smp_phy_being_config->config_route_table_index_anchor != 0)
fw_device->protocol_device.smp_device.curr_config_route_index =
smp_phy_being_config->config_route_table_index_anchor + 1;
else
fw_device->protocol_device.smp_device.curr_config_route_index = 0;
}
}
if ( !(fw_device->protocol_device.smp_device.current_activity_phy_index ==
fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->phy_identifier
&& fw_device->protocol_device.smp_device.curr_config_route_index == 0)
)
{
//clean this route entry.
scif_sas_smp_remote_device_clean_route_table_entry(fw_device);
}
else
{
fw_device->protocol_device.smp_device.is_route_table_cleaned = TRUE;
//set this device's activity to NON.
fw_device->protocol_device.smp_device.current_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
//we need to notify domain that this device finished config route table, domain
//may pick up other activities (i.e. Discover) for other expanders.
scif_sas_domain_continue_discover(fw_device->domain);
}
}
/**
* @brief This method cleans a device's route table antry.
*
* @param[in] fw_device The expander device, whose route table entry is to be cleaned.
*
* @return None.
*/
void scif_sas_smp_remote_device_clean_route_table_entry(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCI_SAS_ADDRESS_T empty_sas_address;
SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device =
&(fw_device->protocol_device.smp_device);
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_clean_route_table(0x%x) enter\n",
fw_device
));
empty_sas_address.high = 0;
empty_sas_address.low = 0;
scif_sas_smp_request_construct_config_route_info(
fw_device->domain->controller,
fw_device,
smp_remote_device->current_activity_phy_index,
smp_remote_device->curr_config_route_index,
empty_sas_address,
TRUE
);
//schedule the DPC.
scif_cb_start_internal_io_task_schedule(
fw_device->domain->controller,
scif_sas_controller_start_high_priority_io,
fw_device->domain->controller
);
}
/**
* @brief This method handles the case of exceeding route index when config route table
* for a device, by removing the attached device of current config route
* destination smp phy and the rest of smp phys in the same smp phy list.
*
* @param[in] fw_device The expander device, whose route table to be edited but failed
* with a SMP function result of INDEX DOES NOT EXIST.
*
* @return None.
*/
void scif_sas_smp_remote_device_cancel_config_route_table_activity(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
//go through the rest of the smp phy list of destination device.
SCI_FAST_LIST_ELEMENT_T * element =
&(fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy->list_element);
SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
SCIF_SAS_REMOTE_DEVICE_T * curr_attached_device = NULL;
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_cancel_config_route_table_activity(0x%x) enter\n",
fw_device
));
while (element != NULL)
{
curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
element = sci_fast_list_get_next(element);
//check if this phy needs to be added to the expander's route table but can't due to
//exceeding max route index.
if (scif_sas_smp_remote_device_do_config_route_info(
fw_device, curr_smp_phy) == TRUE )
{
//set the is_currently_discovered to FALSE for attached device. Then when
//domain finish discover, domain will remove this device.
curr_attached_device = (SCIF_SAS_REMOTE_DEVICE_T *)
scif_domain_get_device_by_sas_address(
fw_device->domain, &(curr_smp_phy->attached_sas_address));
if (curr_attached_device != NULL)
curr_attached_device->is_currently_discovered = FALSE;
}
}
}
/**
* @brief This method cancel current activity and terminate the outstanding internal IO
* if there is one.
*
* @param[in] fw_device The expander device, whose smp activity is to be canceled.
*
* @return None.
*/
void scif_sas_smp_remote_device_cancel_smp_activity(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_device),
SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_smp_remote_device_cancel_smp_activity(0x%x) enter\n",
fw_device
));
//Terminate all of the requests in the silicon for this device.
scif_sas_domain_terminate_requests(
fw_device->domain, fw_device, NULL, NULL
);
if (fw_device->protocol_device.smp_device.current_activity ==
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CONFIG_ROUTE_TABLE)
scif_sas_smp_remote_device_cancel_config_route_table_activity(fw_device);
//Clear the device to stop the smp sctivity.
scif_sas_smp_remote_device_clear(fw_device);
}
/**
* @brief This method tells the way to configure route table for a expander. The
* possible ways are: configure phy 0's route table, configure middle
* phy's route table, configure highest order phy's route table,
* configure all phys.
*
* @param[in] fw_device The expander device, whose config route table method is
* to be chosen.
*
* @return one in 4 possible options.
*/
U8 scif_sas_smp_remote_device_get_config_route_table_method(
SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
U8 config_route_table_method;
//config_route_table_method = SCIF_SAS_CONFIG_ROUTE_TABLE_MIDDLE_PHY_ONLY;
config_route_table_method = SCIF_SAS_CONFIG_ROUTE_TABLE_ALL_PHYS;
return config_route_table_method;
}
/**
* @brief This method starts the EA target reset process by constructing
* and starting a PHY CONTROL (hard reset) smp request.
*
* @param[in] expander_device The expander device, to which a PHY Control smp command is
* sent.
* @param[in] target_device The expander attahced target device, to which the target reset
* request is sent.
* @param[in] fw_request The target reset task request.
*
* @return none
*/
void scif_sas_smp_remote_device_start_target_reset(
SCIF_SAS_REMOTE_DEVICE_T * expander_device,
SCIF_SAS_REMOTE_DEVICE_T * target_device,
SCIF_SAS_REQUEST_T * fw_request
)
{
SCIF_SAS_CONTROLLER_T * fw_controller = expander_device->domain->controller;
//set current_activity and current_smp_request to expander device.
expander_device->protocol_device.smp_device.current_activity =
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET;
expander_device->protocol_device.smp_device.current_smp_request =
SMP_FUNCTION_PHY_CONTROL;
expander_device->protocol_device.smp_device.current_activity_phy_index =
target_device->expander_phy_identifier;
//A Phy Control smp request has been constructed towards parent device.
//Walk the high priority io path.
fw_controller->state_handlers->start_high_priority_io_handler(
(SCI_BASE_CONTROLLER_T*) fw_controller,
(SCI_BASE_REMOTE_DEVICE_T*) expander_device,
(SCI_BASE_REQUEST_T*) fw_request,
SCI_CONTROLLER_INVALID_IO_TAG
);
}