d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
4f3addd94b
freebsd-skq/sys/dev/isci/scil/scif_sas_domain_state_handlers.c
Pedro F. Giffuni 718cf2ccb9 sys/dev: further adoption of SPDX licensing ID tags. 
Mainly focus on files that use BSD 2-Clause license, however the tool I
was using misidentified many licenses so this was mostly a manual - error
prone - task.

The Software Package Data Exchange (SPDX) group provides a specification
to make it easier for automated tools to detect and summarize well known
opensource licenses. We are gradually adopting the specification, noting
that the tags are considered only advisory and do not, in any way,
superceed or replace the license texts.
2017-11-27 14:52:40 +00:00

1633 lines
58 KiB
C
Raw Blame History

/*-
* SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
*
* This file is provided under a dual BSD/GPLv2 license. When using or
* redistributing this file, you may do so under either license.
*
* GPL LICENSE SUMMARY
*
* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
* The full GNU General Public License is included in this distribution
* in the file called LICENSE.GPL.
*
* BSD LICENSE
*
* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
/**
* @file
*
* @brief This file contains all of the state handler routines for each
* of the domain states defined by the SCI_BASE_DOMAIN state
* machine.
* @note
* - The discover method must be synchronized with the
* controller's completion handler. The OS specific driver
* component is responsible for ensuring this occurs. If the
* discovery method is called from within the call
* tree of the completion routine, then no action is necessary.
*/
#include <dev/isci/scil/scic_port.h>
#include <dev/isci/scil/scic_io_request.h>
#include <dev/isci/scil/scif_sas_logger.h>
#include <dev/isci/scil/scif_sas_domain.h>
//******************************************************************************
//* P R O T E C T E D M E T H O D S
//******************************************************************************
//******************************************************************************
//* S T A R T I N G H A N D L E R S
//******************************************************************************
static
SCI_STATUS scif_sas_domain_starting_port_ready_handler(
SCI_BASE_DOMAIN_T * domain
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_domain_starting_port_ready_handler(0x%x) enter\n",
domain
));
// The domain was previously completely stopped. Now that the port is
// ready we can transition the domain to the ready state.
sci_base_state_machine_change_state(
&domain->state_machine, SCI_BASE_DOMAIN_STATE_READY
);
return SCI_SUCCESS;
}
//******************************************************************************
//* R E A D Y H A N D L E R S
//******************************************************************************
/**
* @brief This method provides READY state specific handling for
* when a user attempts to discover a domain.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a discover
* operation.
*
* @return This method returns an indication of whether the discover operation
* succeeded.
* @retval SCI_SUCCESSS This value is returned when the discover operation
* begins successfully.
*/
static
SCI_STATUS scif_sas_domain_ready_discover_handler(
SCI_BASE_DOMAIN_T * domain,
U32 op_timeout,
U32 device_timeout
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T *)domain;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_domain_ready_discover_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, op_timeout, device_timeout
));
fw_domain->operation.timeout = op_timeout;
fw_domain->operation.device_timeout = device_timeout;
fw_domain->operation.status = SCI_SUCCESS;
scif_cb_timer_start(
fw_domain->controller,
fw_domain->operation.timer,
fw_domain->operation.timeout
);
scif_sas_domain_transition_to_discovering_state(fw_domain);
return fw_domain->operation.status;
}
/**
* @brief This method provides READY state processing for reception of a
* port NOT ready notification from the core.
*
* @param[in] domain This parameter specifies the domain object
* on which the core port has just come ready.
*
* @return
*/
static
SCI_STATUS scif_sas_domain_ready_port_not_ready_handler(
SCI_BASE_DOMAIN_T * domain,
U32 reason_code
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_domain_ready_port_not_ready_handler(0x%x, 0x%x) enter\n",
domain,
reason_code
));
if (reason_code != SCIC_PORT_NOT_READY_HARD_RESET_REQUESTED)
{
// Change to the STOPPING state to cause existing request
// completions to be terminated and devices removed.
sci_base_state_machine_change_state(
&domain->state_machine, SCI_BASE_DOMAIN_STATE_STOPPING
);
}
return SCI_SUCCESS;
}
/**
* @brief This method provides READY state specific handling for
* when a user attempts to start an IO request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a start IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] io_request This parameter specifies the io request that is
* being started.
*
* @return This method returns an indication of whether the start IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the start IO operation
* begins successfully.
*/
static
SCI_STATUS scif_sas_domain_ready_start_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T*) domain;
SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
remote_device;
SCIF_SAS_REQUEST_T * fw_request = (SCIF_SAS_REQUEST_T*) io_request;
SCI_STATUS status;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_ready_start_io_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request
));
status = fw_device->state_handlers->parent.start_io_handler(
&fw_device->parent, &fw_request->parent
);
if (status == SCI_SUCCESS)
{
// Add the IO to the list of outstanding requests on the domain.
sci_fast_list_insert_tail(
&fw_domain->request_list, &fw_request->list_element
);
}
return status;
}
/**
* @brief This method provides READY state specific handling for
* when a user attempts to complete an IO request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a complete
* IO operation.
* @param[in] io_request This parameter specifies the io request that is
* being completed.
*
* @return This method returns an indication of whether the complete IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the complete IO operation
* is successful.
*/
static
SCI_STATUS scif_sas_domain_ready_complete_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
remote_device;
SCIF_SAS_REQUEST_T * fw_request= (SCIF_SAS_REQUEST_T*) io_request;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_ready_complete_io_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request
));
// Remove the IO from the list of outstanding requests on the domain.
sci_fast_list_remove_element(&fw_request->list_element);
return fw_device->state_handlers->parent.complete_io_handler(
&fw_device->parent, &fw_request->parent
);
}
/**
* @brief This method provides READY state specific handling for
* when a user attempts to continue an IO request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a continue IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] io_request This parameter specifies the io request that is
* being started.
*
* @return This method returns an indication of whether the continue IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the continue IO operation
* begins successfully.
*/
static
SCI_STATUS scif_sas_domain_ready_continue_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_ready_continue_io_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request
));
/// @todo fix return code handling.
return SCI_FAILURE;
}
/**
* @brief This method provides READY state specific handling for
* when a user attempts to start a task request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a start task
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] task_request This parameter specifies the task request that
* is being started.
*
* @return This method returns an indication of whether the start task
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the start task operation
* begins successfully.
*/
static
SCI_STATUS scif_sas_domain_ready_start_task_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * task_request
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T*) domain;
SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
remote_device;
SCIF_SAS_REQUEST_T * fw_request = (SCIF_SAS_REQUEST_T*) task_request;
SCI_STATUS status;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_TASK_MANAGEMENT,
"scif_sas_domain_ready_start_task_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, task_request
));
status = fw_device->state_handlers->parent.start_task_handler(
&fw_device->parent, &fw_request->parent
);
if (status == SCI_SUCCESS)
{
// Add the task to the list of outstanding requests on the domain.
sci_fast_list_insert_tail(
&fw_domain->request_list, &fw_request->list_element
);
}
return status;
}
/**
* @brief This method provides READY state specific handling for
* when a user attempts to complete a task request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete task
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] task_request This parameter specifies the task request that
* is being started.
*
* @return This method returns an indication of whether the complete task
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the complete task operation
* begins successfully.
*/
static
SCI_STATUS scif_sas_domain_ready_complete_task_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * task_request
)
{
SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
remote_device;
SCIF_SAS_REQUEST_T * fw_request = (SCIF_SAS_REQUEST_T*) task_request;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_TASK_MANAGEMENT,
"scif_sas_domain_ready_complete_task_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, task_request
));
// Remove the IO from the list of outstanding requests on the domain.
sci_fast_list_remove_element(&fw_request->list_element);
return fw_device->state_handlers->parent.complete_task_handler(
&fw_device->parent, &fw_request->parent
);
}
/**
* @brief This method provides READY state specific handling for when a user
* attempts to start a high priority IO request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a start high priority
* IO operation (which is exclusively for Phy Control hard reset).
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start
* high priority IO operation.
* @param[in] io_request This parameter specifies the io request that is
* being started.
*
* @return This method returns an indication of whether the start IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the start IO operation
* begins successfully.
*/
static
SCI_STATUS scif_sas_domain_ready_start_high_priority_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T*) domain;
SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
remote_device;
SCIF_SAS_REQUEST_T * fw_request = (SCIF_SAS_REQUEST_T*) io_request;
SCI_STATUS status;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_ready_start_high_priority_request_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request
));
status = fw_device->state_handlers->start_high_priority_io_handler(
&fw_device->parent, &fw_request->parent
);
if (status == SCI_SUCCESS)
{
// Add the IO to the list of outstanding requests on the domain.
// When domain is in READY state, this high priority io is likely
// a smp Phy Control or Discover request sent to parent device of
// a target device, which is to be Target Reset. This high priority
// IO's probably has already been added to the domain's list as a
// SCIF_SAS_TASK_REQUEST. We need to check if it is already on the
// list.
if ( ! sci_fast_list_is_on_this_list(
&fw_domain->request_list, &fw_request->list_element))
sci_fast_list_insert_tail(
&fw_domain->request_list, &fw_request->list_element
);
}
return status;
}
/**
* @brief This method provides READY state specific handling for
* when a user attempts to complete an high priroity IO request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete high
* priority IO operation (which is exclusively for Phy Control
* hard reset).
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a complete
* IO operation.
* @param[in] io_request This parameter specifies the io request that is
* being completed.
*
* @return This method returns an indication of whether the complete IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the complete IO operation
* is successful.
*/
static
SCI_STATUS scif_sas_domain_ready_complete_high_priority_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request,
void * response_data,
SCI_IO_STATUS completion_status
)
{
SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
remote_device;
SCIF_SAS_REQUEST_T * fw_request= (SCIF_SAS_REQUEST_T*) io_request;
SCIC_TRANSPORT_PROTOCOL protocol;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_ready_complete_high_priority_io_handler(0x%x, 0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request, response_data
));
protocol = scic_io_request_get_protocol(fw_request->core_object);
// If the request is an SMP HARD/LINK RESET request, then the request
// came through the task management path (partially). As a result,
// the accounting for the request is managed in the task request
// completion path. Thus, only change the domain request counter if
// the request is not an SMP target reset of some sort.
if (
(protocol != SCIC_SMP_PROTOCOL)
|| (fw_device->protocol_device.smp_device.current_activity !=
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET)
)
{
sci_fast_list_remove_element(&fw_request->list_element);
}
return fw_device->state_handlers->complete_high_priority_io_handler(
&fw_device->parent, &fw_request->parent, response_data, completion_status
);
}
//******************************************************************************
//* S T O P P I N G H A N D L E R S
//******************************************************************************
static
SCI_STATUS scif_sas_domain_stopping_device_stop_complete_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T *) domain;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"scif_sas_domain_stopping_device_stop_complete_handler(0x%x, 0x%x) enter\n",
domain, remote_device
));
// Attempt to transition to the stopped state.
scif_sas_domain_transition_to_stopped_state(fw_domain);
return SCI_SUCCESS;
}
/**
* @brief This method provides STOPPING state specific handling for
* when a user attempts to complete an IO request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a complete
* IO operation.
* @param[in] io_request This parameter specifies the io request that is
* being completed.
*
* @return This method returns an indication of whether the complete IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the complete IO operation
* is successful.
*/
static
SCI_STATUS scif_sas_domain_stopping_complete_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T *) domain;
SCI_STATUS status;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_stopping_complete_io_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request
));
status = scif_sas_domain_ready_complete_io_handler(
domain, remote_device, io_request
);
// Attempt to transition to the stopped state.
scif_sas_domain_transition_to_stopped_state(fw_domain);
return status;
}
/**
* @brief This method provides STOPPING state specific handling for
* when a user attempts to complete an IO request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a complete
* IO operation.
* @param[in] io_request This parameter specifies the io request that is
* being completed.
*
* @return This method returns an indication of whether the complete IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the complete IO operation
* is successful.
*/
static
SCI_STATUS scif_sas_domain_stopping_complete_high_priority_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request,
void * response_data,
SCI_IO_STATUS completion_status
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T *) domain;
SCI_STATUS status;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_stopping_complete_io_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request
));
status = scif_sas_domain_ready_complete_high_priority_io_handler(
domain, remote_device, io_request, response_data, completion_status
);
// Attempt to transition to the stopped state.
scif_sas_domain_transition_to_stopped_state(fw_domain);
return status;
}
/**
* @brief This method provides STOPPING state specific handling for
* when a user attempts to complete a task request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete task
* operation.
*
* @return This method returns an indication of whether the complete task
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the complete task operation
* begins successfully.
*/
static
SCI_STATUS scif_sas_domain_stopping_complete_task_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * task_request
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T *) domain;
SCI_STATUS status;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_TASK_MANAGEMENT,
"scif_sas_domain_stopping_complete_task_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, task_request
));
status = scif_sas_domain_ready_complete_task_handler(
domain, remote_device, task_request
);
// Attempt to transition to the stopped state.
scif_sas_domain_transition_to_stopped_state(fw_domain);
return SCI_SUCCESS;
}
//******************************************************************************
//* D I S C O V E R I N G H A N D L E R S
//******************************************************************************
/**
* @brief This method provides DISCOVERING state specific processing for
* reception of a port NOT ready notification from the core. A port
* NOT ready notification forces the discovery operation to complete
* in error. Additionally, all IOs are aborted and devices removed.
*
* @param[in] domain This parameter specifies the domain object
* for which the core port is no longer ready.
*
* @return
*/
static
SCI_STATUS scif_sas_domain_discovering_port_not_ready_handler(
SCI_BASE_DOMAIN_T * domain,
U32 reason_code
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_domain_discovering_port_not_ready_handler(0x%x, 0x%x) enter\n",
domain,
reason_code
));
// Change to the STOPPING state to cause existing request
// completions to be terminated and devices removed.
sci_base_state_machine_change_state(
&domain->state_machine, SCI_BASE_DOMAIN_STATE_STOPPING
);
return SCI_SUCCESS;
}
static
SCI_STATUS scif_sas_domain_discovering_device_start_complete_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T *)domain;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_domain_discovering_device_start_complete_handler(0x%x) enter\n",
domain, remote_device
));
//domain will decide what's next step.
scif_sas_domain_continue_discover(fw_domain);
return SCI_SUCCESS;
}
// ---------------------------------------------------------------------------
static
SCI_STATUS scif_sas_domain_discovering_device_stop_complete_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_domain_discovering_device_stop_complete_handler(0x%x) enter\n",
domain, remote_device
));
return SCI_FAILURE;
}
/**
* @brief This method provides DISCOVERING state specific handling for when a user
* attempts to start a high priority IO request.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a start IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] io_request This parameter specifies the io request that is
* being started.
*
* @return This method returns an indication of whether the start IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the start IO operation
* begins successfully.
*/
static
SCI_STATUS scif_sas_domain_discovering_start_high_priority_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T*) domain;
SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
remote_device;
SCIF_SAS_REQUEST_T * fw_request = (SCIF_SAS_REQUEST_T*) io_request;
SCI_STATUS status;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_discovery_start_high_priority_request_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request
));
status = fw_device->state_handlers->start_high_priority_io_handler(
&fw_device->parent, &fw_request->parent
);
if (status == SCI_SUCCESS)
{
// Add the IO to the list of outstanding requests on the domain.
// It is possible this high priority IO's has already been added to
// the domain's list as a SCIF_SAS_TASK_REQUEST. We need to check
// if it is already on the list.
if ( ! sci_fast_list_is_on_this_list(
&fw_domain->request_list, &fw_request->list_element))
sci_fast_list_insert_tail(
&fw_domain->request_list, &fw_request->list_element
);
}
return status;
}
/**
* @brief This method provides DISCOVERING state specific handling for
* when a user attempts to complete an IO request. User IOs are
* allowed to be completed during discovery.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a complete
* IO operation.
* @param[in] io_request This parameter specifies the io request that is
* being completed.
*
* @return This method returns an indication of whether the complete IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the complete IO operation
* is successful.
*/
static
SCI_STATUS scif_sas_domain_discovering_complete_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_discovering_complete_io_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request
));
return scif_sas_domain_ready_complete_io_handler(
domain, remote_device, io_request
);
}
/**
* @brief This method provides DISCOVERING state specific handling for
* when a user attempts to complete an high priroity IO request. User
* IOs are allowed to be completed during discovery.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a complete
* IO operation.
* @param[in] io_request This parameter specifies the io request that is
* being completed.
*
* @return This method returns an indication of whether the complete IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the complete IO operation
* is successful.
*/
static
SCI_STATUS scif_sas_domain_discovering_complete_high_priority_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request,
void * response_data,
SCI_IO_STATUS completion_status
)
{
SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
remote_device;
SCIF_SAS_REQUEST_T * fw_request= (SCIF_SAS_REQUEST_T*) io_request;
SCIC_TRANSPORT_PROTOCOL protocol;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_discovering_complete_high_priority_io_handler(0x%x, 0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request, response_data
));
protocol = scic_io_request_get_protocol(fw_request->core_object);
// Remove the IO from the list of outstanding requests on the domain.
// If the request is an SMP HARD/LINK RESET request, then the request
// came through the task management path (partially). As a result,
// the accounting for the request is managed in the task request
// completion path. Thus, only change the domain request counter if
// the request is not an SMP target reset of some sort.
if (
(protocol != SCIC_SMP_PROTOCOL)
|| (fw_device->protocol_device.smp_device.current_activity !=
SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET)
)
{
sci_fast_list_remove_element(&fw_request->list_element);
}
return fw_device->state_handlers->complete_high_priority_io_handler(
&fw_device->parent, &fw_request->parent, response_data, completion_status
);
}
/**
* @brief This method provides DISCOVERING state specific handling for
* when the framework attempts to complete an IO request. Internal
* Framework IOs allowed to be continued during discovery.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a continue IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a continue
* IO operation.
* @param[in] io_request This parameter specifies the io request that is
* being continued.
*
* @return This method returns an indication of whether the continue IO
* operation succeeded.
* @retval SCI_SUCCESS This value is returned when the continue IO operation
* is successful.
*/
static
SCI_STATUS scif_sas_domain_discovering_continue_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_domain_discovering_continue_io_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, io_request
));
/// @todo fix return code handling.
return SCI_FAILURE;
}
/**
* @brief This method provides handling when a user attempts to start
* a task on a domain in DISCOVER state, only hard reset is allowed.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a start task
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] task_request This parameter specifies the task request that
* is being started.
*
* @return This method returns a status of start task operations
* @retval SCI_FAILURE_INVALID_STATE This value is returned for any tasks,
* except for HARD RESET.
*/
static
SCI_STATUS scif_sas_domain_discovering_start_task_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * task_request
)
{
SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
remote_device;
SCIF_SAS_TASK_REQUEST_T * fw_task = (SCIF_SAS_TASK_REQUEST_T*)task_request;
//Only let target reset go through.
if (scif_sas_task_request_get_function(fw_task)
== SCI_SAS_HARD_RESET)
{
//If the domain is in the middle of smp DISCOVER process,
//interrupt it. After target reset is done, resume the smp DISCOVERY.
scif_sas_domain_cancel_smp_activities(fw_device->domain);
return scif_sas_domain_ready_start_task_handler(domain, remote_device, task_request);
}
else{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x start task message invalid\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
}
/**
* @brief This method provides DISCOVERING state specific handling for
* when a user attempts to complete a task request. User task
* management requests are allowed to be completed during discovery.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a complete
* IO operation.
* @param[in] task_request This parameter specifies the task request that
* is being completed.
*
* @return This method returns an indication of whether the complete task
* management operation succeeded.
* @retval SCI_SUCCESS This value is returned when the complete task request
* is successful.
*/
static
SCI_STATUS scif_sas_domain_discovering_complete_task_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * task_request
)
{
SCI_STATUS status;
SCIF_LOG_TRACE((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_TASK_MANAGEMENT,
"scif_sas_domain_discovering_complete_task_handler(0x%x, 0x%x, 0x%x) enter\n",
domain, remote_device, task_request
));
status = scif_sas_domain_ready_complete_task_handler(
domain, remote_device, task_request
);
return status;
}
//******************************************************************************
//* D E F A U L T H A N D L E R S
//******************************************************************************
/**
* @brief This method provides default handling (i.e. returns an error)
* when a user attempts to discover a domain and a discovery
* operation is not allowed.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform an discover
* operation.
* @param[in] op_timeout This parameter specifies the timeout
* (in milliseconds) for the entire discovery operation.
* This timeout value should be some multiple of the
* individual device_timeout value.
* @param[in] device_timeout This parameter specifies the timeout
* (in milliseconds) for an individual device being discovered
* and configured during this operation.
*
* @return This method returns an indication that discovery operations
* are not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_discover_handler(
SCI_BASE_DOMAIN_T * domain,
U32 op_timeout,
U32 device_timeout
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger((SCIF_SAS_DOMAIN_T *)domain),
SCIF_LOG_OBJECT_DOMAIN | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"Domain:0x%x State:0x%x requested to discover in invalid state\n",
domain,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default processing for reception of a port
* ready notification from the core.
*
* @param[in] domain This parameter specifies the domain object
* on which the core port has just come ready.
*
* @return
*/
static
SCI_STATUS scif_sas_domain_default_port_ready_handler(
SCI_BASE_DOMAIN_T * domain
)
{
SCIF_LOG_INFO((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x State:0x%x port now ready\n",
domain,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_SUCCESS;
}
/**
* @brief This method provides default processing for reception of a port
* NOT ready notification from the core.
*
* @param[in] domain This parameter specifies the domain object
* on which the core port has just come ready.
*
* @return
*/
static
SCI_STATUS scif_sas_domain_default_port_not_ready_handler(
SCI_BASE_DOMAIN_T * domain,
U32 reason_code
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x State:0x%x Port Not Ready 0x%x in invalid state\n",
domain,
sci_base_state_machine_get_state(&domain->state_machine),
reason_code
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default handling (i.e. returns an error)
* when a user attempts to start an IO on a domain and a start
* IO operation is not allowed.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a start IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] io_request This parameter specifies the io request that is
* being started.
*
* @return This method returns an indication that start IO operations
* are not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_start_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x start IO message invalid\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default handling (i.e. returns an error)
* when a user attempts to complete an IO on a domain and a
* complete IO operation is not allowed.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a complete IO
* operation.
* @param[in] io_request This parameter specifies the io request that is
* being completed.
*
* @return This method returns an indication that complete IO operations
* are not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_complete_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x complete IO message invalid\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default handling (i.e. returns an error)
* when a user attempts to complete an IO on a domain and a
* complete IO operation is not allowed.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a complete IO
* operation.
* @param[in] io_request This parameter specifies the io request that is
* being completed.
*
* @return This method returns an indication that complete IO operations
* are not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_complete_high_priority_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request,
void * response_data,
SCI_IO_STATUS completion_status
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x complete IO message invalid\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default handling (i.e. returns an error)
* when a user attempts to continue an IO on a domain and a
* continue IO operation is not allowed.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a continue IO
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] io_request This parameter specifies the io request that is
* being started.
*
* @return This method returns an indication that continue IO operations
* are not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_continue_io_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * io_request
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x contineu IO message invalid\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default handling (i.e. returns an error)
* when a user attempts to start a task on a domain and a start
* task operation is not allowed.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a start task
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] task_request This parameter specifies the task request that
* is being started.
*
* @return This method returns an indication that start task operations
* are not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_start_task_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * task_request
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x start task message invalid\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default handling (i.e. returns an error)
* when a user attempts to complete a task on a domain and a
* complete task operation is not allowed.
*
* @param[in] domain This parameter specifies the domain object
* on which the user is attempting to perform a complete task
* operation.
* @param[in] remote_device This parameter specifies the remote device
* object on which the user is attempting to perform a start IO
* operation.
* @param[in] task_request This parameter specifies the task request that
* is being started.
*
* @return This method returns an indication that complete task operations
* are not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_complete_task_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device,
SCI_BASE_REQUEST_T * task_request
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x complete task message invalid\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default handling (i.e. returns an error)
* when a remote device start operation completes in a state.
*
* @param[in] domain This parameter specifies the domain object
* on which the remote device start operation is completing.
* @param[in] remote_device This parameter specifies the remote device
* for which the start operation is completing.
*
* @return This method returns an indication that start operation
* completion is not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_device_start_complete_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x device stop complete message invalid\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default handling (i.e. returns an error)
* when a remote device stop operation completes in a state.
*
* @param[in] domain This parameter specifies the domain object
* on which the remote device stop operation is completing.
* @param[in] remote_device This parameter specifies the remote device
* for which the stop operation is completing.
*
* @return This method returns an indication that stop operation
* completion is not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_device_stop_complete_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x device stop complete message invalid\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides default handling (i.e. returns an error)
* when sci user try to destruct a remote device of this domain.
*
* @param[in] domain This parameter specifies the domain object
* on which the remote device is to be destructed.
* @param[in] remote_device This parameter specifies the remote device
* to be destructed.
*
* @return This method returns an indication that device destruction
* is not allowed.
* @retval SCI_FAILURE_INVALID_STATE This value is always returned.
*/
static
SCI_STATUS scif_sas_domain_default_device_destruct_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device
)
{
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x device destruct in invalid state\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
return SCI_FAILURE_INVALID_STATE;
}
/**
* @brief This method provides handling when sci user destruct a remote
* device of this domain in discovering state. Mainly the device
* is removed from domain's remote_device_list.
*
* @param[in] domain This parameter specifies the domain object
* on which the remote device is to be destructed.
* @param[in] remote_device This parameter specifies the remote device
* to be destructed.
*
* @return This method returns a status of the device destruction.
* @retval SCI_SUCCESS This value is returned when a remote device is
* successfully removed from domain.
*/
static
SCI_STATUS scif_sas_domain_discovering_device_destruct_handler(
SCI_BASE_DOMAIN_T * domain,
SCI_BASE_REMOTE_DEVICE_T * remote_device
)
{
SCIF_SAS_DOMAIN_T * fw_domain = (SCIF_SAS_DOMAIN_T *)domain;
SCIF_LOG_WARNING((
sci_base_object_get_logger(domain),
SCIF_LOG_OBJECT_DOMAIN,
"Domain:0x%x Device:0x%x State:0x%x device destruct in domain DISCOVERING state\n",
domain, remote_device,
sci_base_state_machine_get_state(&domain->state_machine)
));
//remove the remote device from domain's remote_device_list
sci_abstract_list_erase(
&(fw_domain->remote_device_list),
remote_device
);
return SCI_SUCCESS;
}
#define scif_sas_domain_stopped_discover_handler \
scif_sas_domain_ready_discover_handler
#define scif_sas_domain_default_start_high_priority_io_handler \
scif_sas_domain_default_start_io_handler
SCI_BASE_DOMAIN_STATE_HANDLER_T
scif_sas_domain_state_handler_table[SCI_BASE_DOMAIN_MAX_STATES] =
{
// SCI_BASE_DOMAIN_STATE_INITIAL
{
scif_sas_domain_default_discover_handler,
scif_sas_domain_default_port_ready_handler,
scif_sas_domain_default_port_not_ready_handler,
scif_sas_domain_default_device_start_complete_handler,
scif_sas_domain_default_device_stop_complete_handler,
scif_sas_domain_default_device_destruct_handler,
scif_sas_domain_default_start_io_handler,
scif_sas_domain_default_start_high_priority_io_handler,
scif_sas_domain_default_complete_io_handler,
scif_sas_domain_default_complete_high_priority_io_handler,
scif_sas_domain_default_continue_io_handler,
scif_sas_domain_default_start_task_handler,
scif_sas_domain_default_complete_task_handler
},
// SCI_BASE_DOMAIN_STATE_STARTING
{
scif_sas_domain_default_discover_handler,
scif_sas_domain_starting_port_ready_handler,
scif_sas_domain_default_port_not_ready_handler,
scif_sas_domain_default_device_start_complete_handler,
scif_sas_domain_default_device_stop_complete_handler,
scif_sas_domain_default_device_destruct_handler,
scif_sas_domain_default_start_io_handler,
scif_sas_domain_default_start_high_priority_io_handler,
scif_sas_domain_default_complete_io_handler,
scif_sas_domain_default_complete_high_priority_io_handler,
scif_sas_domain_default_continue_io_handler,
scif_sas_domain_default_start_task_handler,
scif_sas_domain_default_complete_task_handler
},
// SCI_BASE_DOMAIN_STATE_READY
{
scif_sas_domain_ready_discover_handler,
scif_sas_domain_default_port_ready_handler,
scif_sas_domain_ready_port_not_ready_handler,
scif_sas_domain_default_device_start_complete_handler,
scif_sas_domain_default_device_stop_complete_handler,
scif_sas_domain_default_device_destruct_handler,
scif_sas_domain_ready_start_io_handler,
scif_sas_domain_ready_start_high_priority_io_handler,
scif_sas_domain_ready_complete_io_handler,
scif_sas_domain_ready_complete_high_priority_io_handler,
scif_sas_domain_ready_continue_io_handler,
scif_sas_domain_ready_start_task_handler,
scif_sas_domain_ready_complete_task_handler
},
// SCI_BASE_DOMAIN_STATE_STOPPING
{
scif_sas_domain_default_discover_handler,
scif_sas_domain_default_port_ready_handler,
scif_sas_domain_default_port_not_ready_handler,
scif_sas_domain_default_device_start_complete_handler,
scif_sas_domain_stopping_device_stop_complete_handler,
scif_sas_domain_default_device_destruct_handler,
scif_sas_domain_default_start_io_handler,
scif_sas_domain_default_start_high_priority_io_handler,
scif_sas_domain_stopping_complete_io_handler,
scif_sas_domain_stopping_complete_high_priority_io_handler,
scif_sas_domain_default_continue_io_handler,
scif_sas_domain_default_start_task_handler,
scif_sas_domain_stopping_complete_task_handler
},
// SCI_BASE_DOMAIN_STATE_STOPPED
{
scif_sas_domain_stopped_discover_handler,
scif_sas_domain_default_port_ready_handler,
scif_sas_domain_default_port_not_ready_handler,
scif_sas_domain_default_device_start_complete_handler,
scif_sas_domain_default_device_stop_complete_handler,
scif_sas_domain_default_device_destruct_handler,
scif_sas_domain_default_start_io_handler,
scif_sas_domain_default_start_high_priority_io_handler,
scif_sas_domain_default_complete_io_handler,
scif_sas_domain_default_complete_high_priority_io_handler,
scif_sas_domain_default_continue_io_handler,
scif_sas_domain_default_start_task_handler,
scif_sas_domain_default_complete_task_handler
},
// SCI_BASE_DOMAIN_STATE_DISCOVERING
{
scif_sas_domain_default_discover_handler,
scif_sas_domain_default_port_ready_handler,
scif_sas_domain_discovering_port_not_ready_handler,
scif_sas_domain_discovering_device_start_complete_handler,
scif_sas_domain_discovering_device_stop_complete_handler,
scif_sas_domain_discovering_device_destruct_handler, //
scif_sas_domain_default_start_io_handler,
scif_sas_domain_discovering_start_high_priority_io_handler,
scif_sas_domain_discovering_complete_io_handler,
scif_sas_domain_discovering_complete_high_priority_io_handler, //
scif_sas_domain_discovering_continue_io_handler,
scif_sas_domain_discovering_start_task_handler,
scif_sas_domain_discovering_complete_task_handler
}
};
Reference in New Issue View Git Blame Copy Permalink