7043 lines
220 KiB
C
7043 lines
220 KiB
C
/*-
|
|
* 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 implementation of the SCIC_SDS_CONTROLLER
|
|
* public, protected, and private methods.
|
|
*/
|
|
|
|
#include <dev/isci/types.h>
|
|
#include <dev/isci/scil/sci_util.h>
|
|
#include <dev/isci/scil/scic_controller.h>
|
|
#include <dev/isci/scil/scic_port.h>
|
|
#include <dev/isci/scil/scic_phy.h>
|
|
#include <dev/isci/scil/scic_remote_device.h>
|
|
#include <dev/isci/scil/scic_user_callback.h>
|
|
#include <dev/isci/scil/scic_sds_pci.h>
|
|
#include <dev/isci/scil/scic_sds_library.h>
|
|
#include <dev/isci/scil/scic_sds_controller.h>
|
|
#include <dev/isci/scil/scic_sds_controller_registers.h>
|
|
#include <dev/isci/scil/scic_sds_port.h>
|
|
#include <dev/isci/scil/scic_sds_phy.h>
|
|
#include <dev/isci/scil/scic_sds_remote_device.h>
|
|
#include <dev/isci/scil/scic_sds_request.h>
|
|
#include <dev/isci/scil/scic_sds_logger.h>
|
|
#include <dev/isci/scil/scic_sds_port_configuration_agent.h>
|
|
#include <dev/isci/scil/scu_constants.h>
|
|
#include <dev/isci/scil/scu_event_codes.h>
|
|
#include <dev/isci/scil/scu_completion_codes.h>
|
|
#include <dev/isci/scil/scu_task_context.h>
|
|
#include <dev/isci/scil/scu_remote_node_context.h>
|
|
#include <dev/isci/scil/scu_unsolicited_frame.h>
|
|
#include <dev/isci/scil/intel_pci.h>
|
|
#include <dev/isci/scil/scic_sgpio.h>
|
|
#include <dev/isci/scil/scic_sds_phy_registers.h>
|
|
|
|
#define SCU_CONTEXT_RAM_INIT_STALL_TIME 200
|
|
#define SCIC_SDS_CONTROLLER_MIN_TIMER_COUNT 3
|
|
#define SCIC_SDS_CONTROLLER_MAX_TIMER_COUNT 3
|
|
|
|
#define SCU_MAX_ZPT_DWORD_INDEX 131
|
|
|
|
/**
|
|
* The number of milliseconds to wait for a phy to start.
|
|
*/
|
|
#define SCIC_SDS_CONTROLLER_PHY_START_TIMEOUT 100
|
|
|
|
/**
|
|
* The number of milliseconds to wait while a given phy is consuming
|
|
* power before allowing another set of phys to consume power.
|
|
* Ultimately, this will be specified by OEM parameter.
|
|
*/
|
|
#define SCIC_SDS_CONTROLLER_POWER_CONTROL_INTERVAL 500
|
|
|
|
/**
|
|
* This macro will return the cycle bit of the completion queue entry
|
|
*/
|
|
#define COMPLETION_QUEUE_CYCLE_BIT(x) ((x) & 0x80000000)
|
|
|
|
/**
|
|
* This macro will normalize the completion queue get pointer so its value
|
|
* can be used as an index into an array
|
|
*/
|
|
#define NORMALIZE_GET_POINTER(x) \
|
|
((x) & SMU_COMPLETION_QUEUE_GET_POINTER_MASK)
|
|
|
|
/**
|
|
* This macro will normalize the completion queue put pointer so its value
|
|
* can be used as an array inde
|
|
*/
|
|
#define NORMALIZE_PUT_POINTER(x) \
|
|
((x) & SMU_COMPLETION_QUEUE_PUT_POINTER_MASK)
|
|
|
|
|
|
/**
|
|
* This macro will normalize the completion queue cycle pointer so it
|
|
* matches the completion queue cycle bit
|
|
*/
|
|
#define NORMALIZE_GET_POINTER_CYCLE_BIT(x) \
|
|
(((U32)(SMU_CQGR_CYCLE_BIT & (x))) << (31 - SMU_COMPLETION_QUEUE_GET_CYCLE_BIT_SHIFT))
|
|
|
|
/**
|
|
* This macro will normalize the completion queue event entry so its value
|
|
* can be used as an index.
|
|
*/
|
|
#define NORMALIZE_EVENT_POINTER(x) \
|
|
( \
|
|
((U32)((x) & SMU_COMPLETION_QUEUE_GET_EVENT_POINTER_MASK)) \
|
|
>> SMU_COMPLETION_QUEUE_GET_EVENT_POINTER_SHIFT \
|
|
)
|
|
|
|
/**
|
|
* This macro will increment the controllers completion queue index value
|
|
* and possibly toggle the cycle bit if the completion queue index wraps
|
|
* back to 0.
|
|
*/
|
|
#define INCREMENT_COMPLETION_QUEUE_GET(controller, index, cycle) \
|
|
INCREMENT_QUEUE_GET( \
|
|
(index), \
|
|
(cycle), \
|
|
(controller)->completion_queue_entries, \
|
|
SMU_CQGR_CYCLE_BIT \
|
|
)
|
|
|
|
/**
|
|
* This macro will increment the controllers event queue index value and
|
|
* possibly toggle the event cycle bit if the event queue index wraps back
|
|
* to 0.
|
|
*/
|
|
#define INCREMENT_EVENT_QUEUE_GET(controller, index, cycle) \
|
|
INCREMENT_QUEUE_GET( \
|
|
(index), \
|
|
(cycle), \
|
|
(controller)->completion_event_entries, \
|
|
SMU_CQGR_EVENT_CYCLE_BIT \
|
|
)
|
|
|
|
//****************************************************************************-
|
|
//* SCIC SDS Controller Initialization Methods
|
|
//****************************************************************************-
|
|
|
|
/**
|
|
* @brief This timer is used to start another phy after we have given up on
|
|
* the previous phy to transition to the ready state.
|
|
*
|
|
* @param[in] controller
|
|
*/
|
|
static
|
|
void scic_sds_controller_phy_startup_timeout_handler(
|
|
void *controller
|
|
)
|
|
{
|
|
SCI_STATUS status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
this_controller->phy_startup_timer_pending = FALSE;
|
|
|
|
status = SCI_FAILURE;
|
|
|
|
while (status != SCI_SUCCESS)
|
|
{
|
|
status = scic_sds_controller_start_next_phy(this_controller);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method initializes the phy startup operations for controller start.
|
|
*
|
|
* @param this_controller
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_initialize_phy_startup(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
this_controller->phy_startup_timer = scic_cb_timer_create(
|
|
this_controller,
|
|
scic_sds_controller_phy_startup_timeout_handler,
|
|
this_controller
|
|
);
|
|
|
|
if (this_controller->phy_startup_timer == NULL)
|
|
{
|
|
return SCI_FAILURE_INSUFFICIENT_RESOURCES;
|
|
}
|
|
else
|
|
{
|
|
this_controller->next_phy_to_start = 0;
|
|
this_controller->phy_startup_timer_pending = FALSE;
|
|
}
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* This method initializes the power control operations for the controller
|
|
* object.
|
|
*
|
|
* @param this_controller
|
|
*/
|
|
void scic_sds_controller_initialize_power_control(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
this_controller->power_control.timer = scic_cb_timer_create(
|
|
this_controller,
|
|
scic_sds_controller_power_control_timer_handler,
|
|
this_controller
|
|
);
|
|
|
|
memset(
|
|
this_controller->power_control.requesters,
|
|
0,
|
|
sizeof(this_controller->power_control.requesters)
|
|
);
|
|
|
|
this_controller->power_control.phys_waiting = 0;
|
|
this_controller->power_control.remote_devices_granted_power = 0;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#define SCU_REMOTE_NODE_CONTEXT_ALIGNMENT (32)
|
|
#define SCU_TASK_CONTEXT_ALIGNMENT (256)
|
|
#define SCU_UNSOLICITED_FRAME_ADDRESS_ALIGNMENT (64)
|
|
#define SCU_UNSOLICITED_FRAME_BUFFER_ALIGNMENT (1024)
|
|
#define SCU_UNSOLICITED_FRAME_HEADER_ALIGNMENT (64)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* @brief This method builds the memory descriptor table for this
|
|
* controller.
|
|
*
|
|
* @param[in] this_controller This parameter specifies the controller
|
|
* object for which to build the memory table.
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_controller_build_memory_descriptor_table(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
sci_base_mde_construct(
|
|
&this_controller->memory_descriptors[SCU_MDE_COMPLETION_QUEUE],
|
|
SCU_COMPLETION_RAM_ALIGNMENT,
|
|
(sizeof(U32) * this_controller->completion_queue_entries),
|
|
(SCI_MDE_ATTRIBUTE_CACHEABLE | SCI_MDE_ATTRIBUTE_PHYSICALLY_CONTIGUOUS)
|
|
);
|
|
|
|
sci_base_mde_construct(
|
|
&this_controller->memory_descriptors[SCU_MDE_REMOTE_NODE_CONTEXT],
|
|
SCU_REMOTE_NODE_CONTEXT_ALIGNMENT,
|
|
this_controller->remote_node_entries * sizeof(SCU_REMOTE_NODE_CONTEXT_T),
|
|
SCI_MDE_ATTRIBUTE_PHYSICALLY_CONTIGUOUS
|
|
);
|
|
|
|
sci_base_mde_construct(
|
|
&this_controller->memory_descriptors[SCU_MDE_TASK_CONTEXT],
|
|
SCU_TASK_CONTEXT_ALIGNMENT,
|
|
this_controller->task_context_entries * sizeof(SCU_TASK_CONTEXT_T),
|
|
SCI_MDE_ATTRIBUTE_PHYSICALLY_CONTIGUOUS
|
|
);
|
|
|
|
// The UF buffer address table size must be programmed to a power
|
|
// of 2. Find the first power of 2 that is equal to or greater then
|
|
// the number of unsolicited frame buffers to be utilized.
|
|
scic_sds_unsolicited_frame_control_set_address_table_count(
|
|
&this_controller->uf_control
|
|
);
|
|
|
|
sci_base_mde_construct(
|
|
&this_controller->memory_descriptors[SCU_MDE_UF_BUFFER],
|
|
SCU_UNSOLICITED_FRAME_BUFFER_ALIGNMENT,
|
|
scic_sds_unsolicited_frame_control_get_mde_size(this_controller->uf_control),
|
|
SCI_MDE_ATTRIBUTE_PHYSICALLY_CONTIGUOUS
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief This method validates the driver supplied memory descriptor
|
|
* table.
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return SCI_STATUS
|
|
*/
|
|
SCI_STATUS scic_sds_controller_validate_memory_descriptor_table(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
BOOL mde_list_valid;
|
|
|
|
mde_list_valid = sci_base_mde_is_valid(
|
|
&this_controller->memory_descriptors[SCU_MDE_COMPLETION_QUEUE],
|
|
SCU_COMPLETION_RAM_ALIGNMENT,
|
|
(sizeof(U32) * this_controller->completion_queue_entries),
|
|
(SCI_MDE_ATTRIBUTE_CACHEABLE | SCI_MDE_ATTRIBUTE_PHYSICALLY_CONTIGUOUS)
|
|
);
|
|
|
|
if (mde_list_valid == FALSE)
|
|
return SCI_FAILURE_UNSUPPORTED_INFORMATION_FIELD;
|
|
|
|
mde_list_valid = sci_base_mde_is_valid(
|
|
&this_controller->memory_descriptors[SCU_MDE_REMOTE_NODE_CONTEXT],
|
|
SCU_REMOTE_NODE_CONTEXT_ALIGNMENT,
|
|
this_controller->remote_node_entries * sizeof(SCU_REMOTE_NODE_CONTEXT_T),
|
|
SCI_MDE_ATTRIBUTE_PHYSICALLY_CONTIGUOUS
|
|
);
|
|
|
|
if (mde_list_valid == FALSE)
|
|
return SCI_FAILURE_UNSUPPORTED_INFORMATION_FIELD;
|
|
|
|
mde_list_valid = sci_base_mde_is_valid(
|
|
&this_controller->memory_descriptors[SCU_MDE_TASK_CONTEXT],
|
|
SCU_TASK_CONTEXT_ALIGNMENT,
|
|
this_controller->task_context_entries * sizeof(SCU_TASK_CONTEXT_T),
|
|
SCI_MDE_ATTRIBUTE_PHYSICALLY_CONTIGUOUS
|
|
);
|
|
|
|
if (mde_list_valid == FALSE)
|
|
return SCI_FAILURE_UNSUPPORTED_INFORMATION_FIELD;
|
|
|
|
mde_list_valid = sci_base_mde_is_valid(
|
|
&this_controller->memory_descriptors[SCU_MDE_UF_BUFFER],
|
|
SCU_UNSOLICITED_FRAME_BUFFER_ALIGNMENT,
|
|
scic_sds_unsolicited_frame_control_get_mde_size(this_controller->uf_control),
|
|
SCI_MDE_ATTRIBUTE_PHYSICALLY_CONTIGUOUS
|
|
);
|
|
|
|
if (mde_list_valid == FALSE)
|
|
return SCI_FAILURE_UNSUPPORTED_INFORMATION_FIELD;
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* @brief This method initializes the controller with the physical memory
|
|
* addresses that are used to communicate with the driver.
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_controller_ram_initialization(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
SCI_PHYSICAL_MEMORY_DESCRIPTOR_T *mde;
|
|
|
|
// The completion queue is actually placed in cacheable memory
|
|
// Therefore it no longer comes out of memory in the MDL.
|
|
mde = &this_controller->memory_descriptors[SCU_MDE_COMPLETION_QUEUE];
|
|
this_controller->completion_queue = (U32*) mde->virtual_address;
|
|
SMU_CQBAR_WRITE(this_controller, mde->physical_address);
|
|
|
|
// Program the location of the Remote Node Context table
|
|
// into the SCU.
|
|
mde = &this_controller->memory_descriptors[SCU_MDE_REMOTE_NODE_CONTEXT];
|
|
this_controller->remote_node_context_table = (SCU_REMOTE_NODE_CONTEXT_T *)
|
|
mde->virtual_address;
|
|
SMU_RNCBAR_WRITE(this_controller, mde->physical_address);
|
|
|
|
// Program the location of the Task Context table into the SCU.
|
|
mde = &this_controller->memory_descriptors[SCU_MDE_TASK_CONTEXT];
|
|
this_controller->task_context_table = (SCU_TASK_CONTEXT_T *)
|
|
mde->virtual_address;
|
|
SMU_HTTBAR_WRITE(this_controller, mde->physical_address);
|
|
|
|
mde = &this_controller->memory_descriptors[SCU_MDE_UF_BUFFER];
|
|
scic_sds_unsolicited_frame_control_construct(
|
|
&this_controller->uf_control, mde, this_controller
|
|
);
|
|
|
|
// Inform the silicon as to the location of the UF headers and
|
|
// address table.
|
|
SCU_UFHBAR_WRITE(
|
|
this_controller,
|
|
this_controller->uf_control.headers.physical_address);
|
|
SCU_PUFATHAR_WRITE(
|
|
this_controller,
|
|
this_controller->uf_control.address_table.physical_address);
|
|
|
|
//enable the ECC correction and detection.
|
|
SCU_SECR0_WRITE(
|
|
this_controller,
|
|
(SIGNLE_BIT_ERROR_CORRECTION_ENABLE
|
|
| MULTI_BIT_ERROR_REPORTING_ENABLE
|
|
| SINGLE_BIT_ERROR_REPORTING_ENABLE) );
|
|
SCU_SECR1_WRITE(
|
|
this_controller,
|
|
(SIGNLE_BIT_ERROR_CORRECTION_ENABLE
|
|
| MULTI_BIT_ERROR_REPORTING_ENABLE
|
|
| SINGLE_BIT_ERROR_REPORTING_ENABLE) );
|
|
}
|
|
|
|
/**
|
|
* @brief This method initializes the task context data for the controller.
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_controller_assign_task_entries(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 task_assignment;
|
|
|
|
// Assign all the TCs to function 0
|
|
// TODO: Do we actually need to read this register to write it back?
|
|
task_assignment = SMU_TCA_READ(this_controller, 0);
|
|
|
|
task_assignment =
|
|
(
|
|
task_assignment
|
|
| (SMU_TCA_GEN_VAL(STARTING, 0))
|
|
| (SMU_TCA_GEN_VAL(ENDING, this_controller->task_context_entries - 1))
|
|
| (SMU_TCA_GEN_BIT(RANGE_CHECK_ENABLE))
|
|
);
|
|
|
|
SMU_TCA_WRITE(this_controller, 0, task_assignment);
|
|
}
|
|
|
|
/**
|
|
* @brief This method initializes the hardware completion queue.
|
|
*
|
|
* @param[in] this_controller
|
|
*/
|
|
void scic_sds_controller_initialize_completion_queue(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 index;
|
|
U32 completion_queue_control_value;
|
|
U32 completion_queue_get_value;
|
|
U32 completion_queue_put_value;
|
|
|
|
this_controller->completion_queue_get = 0;
|
|
|
|
completion_queue_control_value = (
|
|
SMU_CQC_QUEUE_LIMIT_SET(this_controller->completion_queue_entries - 1)
|
|
| SMU_CQC_EVENT_LIMIT_SET(this_controller->completion_event_entries - 1)
|
|
);
|
|
|
|
SMU_CQC_WRITE(this_controller, completion_queue_control_value);
|
|
|
|
// Set the completion queue get pointer and enable the queue
|
|
completion_queue_get_value = (
|
|
(SMU_CQGR_GEN_VAL(POINTER, 0))
|
|
| (SMU_CQGR_GEN_VAL(EVENT_POINTER, 0))
|
|
| (SMU_CQGR_GEN_BIT(ENABLE))
|
|
| (SMU_CQGR_GEN_BIT(EVENT_ENABLE))
|
|
);
|
|
|
|
SMU_CQGR_WRITE(this_controller, completion_queue_get_value);
|
|
|
|
this_controller->completion_queue_get = completion_queue_get_value;
|
|
|
|
// Set the completion queue put pointer
|
|
completion_queue_put_value = (
|
|
(SMU_CQPR_GEN_VAL(POINTER, 0))
|
|
| (SMU_CQPR_GEN_VAL(EVENT_POINTER, 0))
|
|
);
|
|
|
|
SMU_CQPR_WRITE(this_controller, completion_queue_put_value);
|
|
|
|
// Initialize the cycle bit of the completion queue entries
|
|
for (index = 0; index < this_controller->completion_queue_entries; index++)
|
|
{
|
|
// If get.cycle_bit != completion_queue.cycle_bit
|
|
// its not a valid completion queue entry
|
|
// so at system start all entries are invalid
|
|
this_controller->completion_queue[index] = 0x80000000;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method initializes the hardware unsolicited frame queue.
|
|
*
|
|
* @param[in] this_controller
|
|
*/
|
|
void scic_sds_controller_initialize_unsolicited_frame_queue(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 frame_queue_control_value;
|
|
U32 frame_queue_get_value;
|
|
U32 frame_queue_put_value;
|
|
|
|
// Write the queue size
|
|
frame_queue_control_value =
|
|
SCU_UFQC_GEN_VAL(QUEUE_SIZE, this_controller->uf_control.address_table.count);
|
|
|
|
SCU_UFQC_WRITE(this_controller, frame_queue_control_value);
|
|
|
|
// Setup the get pointer for the unsolicited frame queue
|
|
frame_queue_get_value = (
|
|
SCU_UFQGP_GEN_VAL(POINTER, 0)
|
|
| SCU_UFQGP_GEN_BIT(ENABLE_BIT)
|
|
);
|
|
|
|
SCU_UFQGP_WRITE(this_controller, frame_queue_get_value);
|
|
|
|
// Setup the put pointer for the unsolicited frame queue
|
|
frame_queue_put_value = SCU_UFQPP_GEN_VAL(POINTER, 0);
|
|
|
|
SCU_UFQPP_WRITE(this_controller, frame_queue_put_value);
|
|
}
|
|
|
|
/**
|
|
* @brief This method enables the hardware port task scheduler.
|
|
*
|
|
* @param[in] this_controller
|
|
*/
|
|
void scic_sds_controller_enable_port_task_scheduler(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 port_task_scheduler_value;
|
|
|
|
port_task_scheduler_value = SCU_PTSGCR_READ(this_controller);
|
|
|
|
port_task_scheduler_value |=
|
|
(SCU_PTSGCR_GEN_BIT(ETM_ENABLE) | SCU_PTSGCR_GEN_BIT(PTSG_ENABLE));
|
|
|
|
SCU_PTSGCR_WRITE(this_controller, port_task_scheduler_value);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#ifdef ARLINGTON_BUILD
|
|
/**
|
|
* This method will read from the lexington status register. This is required
|
|
* as a read fence to the lexington register writes.
|
|
*
|
|
* @param this_controller
|
|
*/
|
|
void scic_sds_controller_lex_status_read_fence(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 lex_status;
|
|
|
|
// Read Fence
|
|
lex_status = lex_register_read(
|
|
this_controller, this_controller->lex_registers + 0xC4);
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"Controller 0x%x lex_status = 0x%08x\n",
|
|
this_controller, lex_status
|
|
));
|
|
}
|
|
|
|
/**
|
|
* This method will initialize the arlington through the LEX_BAR.
|
|
*
|
|
* @param this_controller
|
|
*/
|
|
void scic_sds_controller_lex_atux_initialization(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
// 1. Reset all SCU PHY
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0020FFFF) ;
|
|
|
|
// 2. Write to LEX_CTRL
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0xC0, 0x00000700);
|
|
|
|
scic_sds_controller_lex_status_read_fence(this_controller);
|
|
|
|
// 3. Enable PCI Master
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x70, 0x00000002);
|
|
|
|
// 4. Enable SCU Register Clock Domain
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0xC0, 0x00000300);
|
|
|
|
scic_sds_controller_lex_status_read_fence(this_controller);
|
|
|
|
// 5.1 Release PHY-A Reg Reset
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0000FFFF);
|
|
|
|
// 5.2 Initialize the AFE for PHY-A
|
|
scic_sds_controller_afe_initialization(this_controller);
|
|
|
|
scic_sds_controller_lex_status_read_fence(this_controller);
|
|
|
|
#if 0
|
|
// 5.3 Release PHY Reg Reset
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0000FFFF);
|
|
#endif
|
|
|
|
// 6.1 Release PHY-B Reg Reset
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0040FFFF) ;
|
|
|
|
// 6.2 Initialize the AFE for PHY-B
|
|
scic_sds_controller_afe_initialization(this_controller);
|
|
|
|
scic_sds_controller_lex_status_read_fence(this_controller);
|
|
|
|
#if 0
|
|
// 6.3 Release PHY-B Reg Reset
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0040FFFF) ;
|
|
#endif
|
|
|
|
// 7. Enable SCU clock domaion
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0xC0, 0x00000100);
|
|
|
|
scic_sds_controller_lex_status_read_fence(this_controller);
|
|
|
|
// 8. Release LEX SCU Reset
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0xC0, 0x00000000);
|
|
|
|
scic_sds_controller_lex_status_read_fence(this_controller);
|
|
|
|
#if !defined(DISABLE_INTERRUPTS)
|
|
// 8a. Set legacy interrupts (SCU INTx to PCI-x INTA)
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0xC0, 0x00000800);
|
|
|
|
scic_sds_controller_lex_status_read_fence(this_controller);
|
|
#endif
|
|
|
|
#if 0
|
|
// 9. Override TXOLVL
|
|
//write to lex_ctrl
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0xC0, 0x27800000);
|
|
#endif
|
|
|
|
// 10. Release PHY-A & PHY-B Resets
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0000FF77);
|
|
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0000FF55);
|
|
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0000FF11);
|
|
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0000FF00);
|
|
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x28, 0x0003FF00);
|
|
}
|
|
#endif // ARLINGTON_BUILD
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#ifdef ARLINGTON_BUILD
|
|
/**
|
|
* This method enables chipwatch on the arlington board
|
|
*
|
|
* @param[in] this_controller
|
|
*/
|
|
void scic_sds_controller_enable_chipwatch(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x88, 0x09090909);
|
|
|
|
lex_register_write(
|
|
this_controller, this_controller->lex_registers + 0x8C, 0xcac9c862);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* This macro is used to delay between writes to the AFE registers
|
|
* during AFE initialization.
|
|
*/
|
|
#define AFE_REGISTER_WRITE_DELAY 10
|
|
|
|
/**
|
|
* Initialize the AFE for this phy index.
|
|
*
|
|
* @todo We need to read the AFE setup from the OEM parameters
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return none
|
|
*/
|
|
#if defined(ARLINGTON_BUILD)
|
|
void scic_sds_controller_afe_initialization(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
// 1. Establish Power
|
|
// Hold Bias, PLL, and RX TX in reset and powerdown
|
|
// pe_afe0_rst_n = 0
|
|
// pe_afe0_txpdn0,1,2,3 = 1
|
|
// pe_afe0_rxpdn0,1,2,3 = 1
|
|
// pe_afe0_txrst0,1,2,3_n = 0
|
|
// pe_afe0_rxrst0,1,2,3_n = 0
|
|
// wait 1us
|
|
// pe_afe0_rst_n = 1
|
|
// wait 1us
|
|
scu_afe_register_write(
|
|
this_controller, afe_pll_control, 0x00247506);
|
|
|
|
// 2. Write 0x00000000 to AFE XCVR Ctrl2
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_transceiver_status_clear, 0x00000000);
|
|
|
|
// 3. afe0_override_en = 0
|
|
// afe0_pll_dis_override = 0
|
|
// afe0_tx_rst_override = 0
|
|
// afe0_pll_dis = 1
|
|
// pe_afe0_txrate = 01
|
|
// pe_afe0_rxrate = 01
|
|
// pe_afe0_txdis = 11
|
|
// pe_afe0_txoob = 1
|
|
// pe_afe0_txovlv = 9'b001110000
|
|
scu_afe_register_write(
|
|
this_controller, afe_transceiver_control0[0], 0x0700141e);
|
|
|
|
// 4. Configure PLL Unit
|
|
// Write 0x00200506 to AFE PLL Ctrl Register 0
|
|
scu_afe_register_write(this_controller, afe_pll_control, 0x00200506);
|
|
scu_afe_register_write(this_controller, afe_pll_dfx_control, 0x10000080);
|
|
|
|
// 5. Configure Bias Unit
|
|
scu_afe_register_write(this_controller, afe_bias_control[0], 0x00124814);
|
|
scu_afe_register_write(this_controller, afe_bias_control[1], 0x24900000);
|
|
|
|
// 6. Configure Transceiver Units
|
|
scu_afe_register_write(
|
|
this_controller, afe_transceiver_control0[0], 0x0702941e);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, afe_transceiver_control1[0], 0x0000000a);
|
|
|
|
// 7. Configure RX Units
|
|
scu_afe_register_write(
|
|
this_controller, afe_transceiver_equalization_control[0], 0x00ba2223);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, reserved_0028_003c[2], 0x00000000);
|
|
|
|
// 8. Configure TX Units
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_transmit_control_register[0], 0x03815428);
|
|
|
|
// 9. Transfer control to PE signals
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_transceiver_status_clear, 0x00000010);
|
|
|
|
// 10. Release PLL Powerdown
|
|
scu_afe_register_write(this_controller, afe_pll_control, 0x00200504);
|
|
|
|
// 11. Release PLL Reset
|
|
scu_afe_register_write(this_controller, afe_pll_control, 0x00200505);
|
|
|
|
// 12. Wait for PLL to Lock
|
|
// (afe0_comm_sta [1:0] should go to 1'b11, and
|
|
// [5:2] is 0x5, 0x6, 0x7, 0x8, or 0x9
|
|
scu_afe_register_write(this_controller, afe_pll_control, 0x00200501);
|
|
|
|
while ((scu_afe_register_read(this_controller, afe_common_status) & 0x03) != 0x03)
|
|
{
|
|
// Give time for the PLLs to lock
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
|
|
// 13. pe_afe0_rxpdn0 = 0
|
|
// pe_afe0_rxrst0 = 1
|
|
// pe_afe0_txrst0_n = 1
|
|
// pe_afe_txoob0_n = 0
|
|
scu_afe_register_write(
|
|
this_controller, afe_transceiver_control0[0], 0x07028c11);
|
|
}
|
|
|
|
#elif defined(PLEASANT_RIDGE_BUILD)
|
|
|
|
void scic_sds_controller_afe_initialization(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 afe_status;
|
|
U32 phy_id;
|
|
|
|
#if defined(SPREADSHEET_AFE_SETTINGS)
|
|
// Clear DFX Status registers
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_master_control0, 0x0000000f);
|
|
// Configure bias currents to normal
|
|
scu_afe_register_write(
|
|
this_controller, afe_bias_control, 0x0000aa00);
|
|
// Enable PLL
|
|
scu_afe_register_write(
|
|
this_controller, afe_pll_control0, 0x80000908);
|
|
|
|
// Wait for the PLL to lock
|
|
do
|
|
{
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
afe_status = scu_afe_register_read(
|
|
this_controller, afe_common_block_status);
|
|
}
|
|
while((afe_status & 0x00001000) == 0);
|
|
|
|
for (phy_id = 0; phy_id < SCI_MAX_PHYS; phy_id++)
|
|
{
|
|
// Initialize transceiver channels
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_channel_control, 0x00000157);
|
|
// Configure transceiver modes
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x38016d1a);
|
|
// Configure receiver parameters
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control1, 0x01501014);
|
|
// Configure transmitter parameters
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_control, 0x00000000);
|
|
// Configure transmitter equalization
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control0, 0x000bdd08);
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control1, 0x000ffc00);
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control2, 0x000b7c09);
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control3, 0x000afc6e);
|
|
// Configure transmitter SSC parameters
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_ssc_control, 0x00000000);
|
|
// Configure receiver parameters
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_rx_ssc_control0, 0x3208903f);
|
|
|
|
// Start power on sequence
|
|
// Enable bias currents to transceivers and wait 200ns
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_channel_control, 0x00000154);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
// Take receiver out of power down and wait 200ns
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x3801611a);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
// Take receiver out of reset and wait 200ns
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x3801631a);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
// Take transmitter out of power down and wait 200ns
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x38016318);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
// Take transmitter out of reset and wait 200ns
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x38016319);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
// Take transmitter out of DC idle
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x38016319);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
|
|
// Transfer control to the PEs
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_master_control0, 0x00010f00);
|
|
#else // !defined(SPREADSHEET_AFE_SETTINGS)
|
|
// These are the AFEE settings used by the SV group
|
|
// Clear DFX Status registers
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_master_control0, 0x0081000f);
|
|
// Configure bias currents to normal
|
|
scu_afe_register_write(
|
|
this_controller, afe_bias_control, 0x0000aa00);
|
|
// Enable PLL
|
|
scu_afe_register_write(
|
|
this_controller, afe_pll_control0, 0x80000908);
|
|
|
|
// Wait for the PLL to lock
|
|
// Note: this is done later in the SV shell script however this looks
|
|
// like the location to do this since we have enabled the PLL.
|
|
do
|
|
{
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
afe_status = scu_afe_register_read(
|
|
this_controller, afe_common_block_status);
|
|
}
|
|
while((afe_status & 0x00001000) == 0);
|
|
|
|
// Make sure BIST is disabled
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_master_control1, 0x00000000);
|
|
// Shorten SAS SNW lock time
|
|
scu_afe_register_write(
|
|
this_controller, afe_pmsn_master_control0, 0x7bd316ad);
|
|
|
|
for (phy_id = 0; phy_id < SCI_MAX_PHYS; phy_id++)
|
|
{
|
|
// Initialize transceiver channels
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_channel_control, 0x00000174);
|
|
// Configure SSC control
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_ssc_control, 0x00030000);
|
|
// Configure transceiver modes
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x0000651a);
|
|
// Power up TX RX and RX OOB
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00006518);
|
|
// Enable RX OOB Detect
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00006518);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
#if 0
|
|
// Configure transmitter parameters
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_control, 0x00000000);
|
|
// Configure transmitter equalization
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control0, 0x000bdd08);
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control1, 0x000ffc00);
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control2, 0x000b7c09);
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control3, 0x000afc6e);
|
|
// Configure transmitter SSC parameters
|
|
// Power up TX RX
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_channel_control, 0x00000154);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// FFE = Max
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_dfx_rx_control1, 0x00000080);
|
|
// DFE1-5 = small
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_dfx_rx_control1, 0x01041042);
|
|
// Enable DFE/FFE and freeze
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_rx_ssc_control0, 0x320891bf);
|
|
#endif
|
|
// Take receiver out of power down and wait 200ns
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00006118);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
// TX Electrical Idle
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00006108);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// Leave DFE/FFE on
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_rx_ssc_control0, 0x0317108f);
|
|
|
|
// Configure receiver parameters
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control1, 0x01e00021);
|
|
|
|
// Bring RX out of reset
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00006109);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00006009);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00006209);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
|
|
// Transfer control to the PEs
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_master_control0, 0x00010f00);
|
|
#endif
|
|
}
|
|
|
|
#elif defined(PBG_HBA_A0_BUILD) || defined(PBG_HBA_A2_BUILD) || defined(PBG_HBA_BETA_BUILD) || defined(PBG_BUILD)
|
|
|
|
void scic_sds_controller_afe_initialization(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 afe_status;
|
|
U32 phy_id;
|
|
U8 cable_selection_mask;
|
|
|
|
if (
|
|
(this_controller->pci_revision != SCIC_SDS_PCI_REVISION_A0)
|
|
&& (this_controller->pci_revision != SCIC_SDS_PCI_REVISION_A2)
|
|
&& (this_controller->pci_revision != SCIC_SDS_PCI_REVISION_B0)
|
|
&& (this_controller->pci_revision != SCIC_SDS_PCI_REVISION_C0)
|
|
&& (this_controller->pci_revision != SCIC_SDS_PCI_REVISION_C1)
|
|
)
|
|
{
|
|
// A programming bug has occurred if we are attempting to
|
|
// support a PCI revision other than those listed. Default
|
|
// to B0, and attempt to limp along if it isn't B0.
|
|
ASSERT(FALSE);
|
|
this_controller->pci_revision = SCIC_SDS_PCI_REVISION_C1;
|
|
}
|
|
|
|
cable_selection_mask =
|
|
this_controller->oem_parameters.sds1.controller.cable_selection_mask;
|
|
|
|
// These are the AFEE settings used by the SV group
|
|
// Clear DFX Status registers
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_master_control0, 0x0081000f);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
if (
|
|
(this_controller->pci_revision == SCIC_SDS_PCI_REVISION_B0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C1)
|
|
)
|
|
{
|
|
// PM Rx Equalization Save, PM SPhy Rx Acknowledgement Timer, PM Stagger Timer
|
|
scu_afe_register_write(
|
|
this_controller, afe_pmsn_master_control2, 0x0007FFFF);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
|
|
// Configure bias currents to normal
|
|
if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A0)
|
|
scu_afe_register_write(this_controller, afe_bias_control, 0x00005500);
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A2)
|
|
scu_afe_register_write(this_controller, afe_bias_control, 0x00005A00);
|
|
else if ( (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_B0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C0) )
|
|
scu_afe_register_write(this_controller, afe_bias_control, 0x00005F00);
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C1)
|
|
scu_afe_register_write(this_controller, afe_bias_control, 0x00005500);
|
|
// For C0 the AFE BIAS Control is unchanged
|
|
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// Enable PLL
|
|
if ( (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A2) )
|
|
{
|
|
scu_afe_register_write(this_controller, afe_pll_control0, 0x80040908);
|
|
}
|
|
else if ( (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_B0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C0) )
|
|
{
|
|
scu_afe_register_write(this_controller, afe_pll_control0, 0x80040A08);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C1)
|
|
{
|
|
scu_afe_register_write(this_controller, afe_pll_control0, 0x80000b08);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
scu_afe_register_write(this_controller, afe_pll_control0, 0x00000b08);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
scu_afe_register_write(this_controller, afe_pll_control0, 0x80000b08);
|
|
}
|
|
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// Wait for the PLL to lock
|
|
// Note: this is done later in the SV shell script however this looks
|
|
// like the location to do this since we have enabled the PLL.
|
|
do
|
|
{
|
|
afe_status = scu_afe_register_read(
|
|
this_controller, afe_common_block_status);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
while((afe_status & 0x00001000) == 0);
|
|
|
|
if ( (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A2) )
|
|
{
|
|
// Shorten SAS SNW lock time (RxLock timer value from 76 us to 50 us)
|
|
scu_afe_register_write(
|
|
this_controller, afe_pmsn_master_control0, 0x7bcc96ad);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
|
|
for (phy_id = 0; phy_id < SCI_MAX_PHYS; phy_id++)
|
|
{
|
|
U8 cable_length_long = (cable_selection_mask >> phy_id) & 1;
|
|
U8 cable_length_medium = (cable_selection_mask >> (phy_id + 4)) & 1;
|
|
|
|
if ( (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A2) )
|
|
{
|
|
// All defaults, except the Receive Word Alignament/Comma Detect
|
|
// Enable....(0xe800)
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00004512
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control1, 0x0050100F
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_B0)
|
|
{
|
|
// Configure transmitter SSC parameters
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_ssc_control, 0x00030000
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C0)
|
|
{
|
|
// Configure transmitter SSC parameters
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_ssc_control, 0x00010202
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// All defaults, except the Receive Word Alignament/Comma Detect
|
|
// Enable....(0xe800)
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00014500
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C1)
|
|
{
|
|
// Configure transmitter SSC parameters
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_ssc_control, 0x00010202
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// All defaults, except the Receive Word Alignament/Comma Detect
|
|
// Enable....(0xe800)
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x0001C500
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
// Power up TX and RX out from power down (PWRDNTX and PWRDNRX)
|
|
// & increase TX int & ext bias 20%....(0xe85c)
|
|
if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A0)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_channel_control,
|
|
0x000003D4
|
|
);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A2)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_channel_control,
|
|
0x000003F0
|
|
);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_B0)
|
|
{
|
|
// Power down TX and RX (PWRDNTX and PWRDNRX)
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_channel_control,
|
|
0x000003d7
|
|
);
|
|
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// Power up TX and RX out from power down (PWRDNTX and PWRDNRX)
|
|
// & increase TX int & ext bias 20%....(0xe85c)
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_channel_control,
|
|
0x000003d4
|
|
);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C0)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_channel_control,
|
|
0x000001e7
|
|
);
|
|
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// Power up TX and RX out from power down (PWRDNTX and PWRDNRX)
|
|
// & increase TX int & ext bias 20%....(0xe85c)
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_channel_control,
|
|
0x000001e4
|
|
);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C1)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_channel_control,
|
|
cable_length_long ? 0x000002F7 :
|
|
cable_length_medium ? 0x000001F7 : 0x000001F7
|
|
);
|
|
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// Power up TX and RX out from power down (PWRDNTX and PWRDNRX)
|
|
// & increase TX int & ext bias 20%....(0xe85c)
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_channel_control,
|
|
cable_length_long ? 0x000002F4 :
|
|
cable_length_medium ? 0x000001F4 : 0x000001F4
|
|
);
|
|
}
|
|
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
if ( (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A2) )
|
|
{
|
|
// Enable TX equalization (0xe824)
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_tx_control,
|
|
0x00040000
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
|
|
if ( (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A2)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_B0) )
|
|
{
|
|
// RDPI=0x0(RX Power On), RXOOBDETPDNC=0x0, TPD=0x0(TX Power On),
|
|
// RDD=0x0(RX Detect Enabled) ....(0xe800)
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00004100);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C0)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x00014100);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C1)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control0, 0x0001c100);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
|
|
// Leave DFE/FFE on
|
|
if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A0)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_rx_ssc_control0,
|
|
0x3F09983F
|
|
);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A2)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_rx_ssc_control0,
|
|
0x3F11103F
|
|
);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_B0)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller,
|
|
scu_afe_xcvr[phy_id].afe_rx_ssc_control0,
|
|
0x3F11103F
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// Enable TX equalization (0xe824)
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_control, 0x00040000);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C0)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control1, 0x01400c0f);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_rx_ssc_control0, 0x3f6f103f);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// Enable TX equalization (0xe824)
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_control, 0x00040000);
|
|
}
|
|
else if (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_C1)
|
|
{
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_xcvr_control1,
|
|
cable_length_long ? 0x01500C0C :
|
|
cable_length_medium ? 0x01400C0D : 0x02400C0D
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_dfx_rx_control1, 0x000003e0);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_rx_ssc_control0,
|
|
cable_length_long ? 0x33091C1F :
|
|
cable_length_medium ? 0x3315181F : 0x2B17161F
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
// Enable TX equalization (0xe824)
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_control, 0x00040000);
|
|
}
|
|
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control0,
|
|
this_controller->oem_parameters.sds1.phys[phy_id].afe_tx_amp_control0
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control1,
|
|
this_controller->oem_parameters.sds1.phys[phy_id].afe_tx_amp_control1
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control2,
|
|
this_controller->oem_parameters.sds1.phys[phy_id].afe_tx_amp_control2
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
|
|
scu_afe_register_write(
|
|
this_controller, scu_afe_xcvr[phy_id].afe_tx_amp_control3,
|
|
this_controller->oem_parameters.sds1.phys[phy_id].afe_tx_amp_control3
|
|
);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
|
|
// Transfer control to the PEs
|
|
scu_afe_register_write(
|
|
this_controller, afe_dfx_master_control0, 0x00010f00);
|
|
scic_cb_stall_execution(AFE_REGISTER_WRITE_DELAY);
|
|
}
|
|
#else
|
|
#error "Unsupported board type"
|
|
#endif
|
|
|
|
//****************************************************************************-
|
|
//* SCIC SDS Controller Internal Start/Stop Routines
|
|
//****************************************************************************-
|
|
|
|
|
|
/**
|
|
* @brief This method will attempt to transition into the ready state
|
|
* for the controller and indicate that the controller start
|
|
* operation has completed if all criteria are met.
|
|
*
|
|
* @param[in,out] this_controller This parameter indicates the controller
|
|
* object for which to transition to ready.
|
|
* @param[in] status This parameter indicates the status value to be
|
|
* pass into the call to scic_cb_controller_start_complete().
|
|
*
|
|
* @return none.
|
|
*/
|
|
static
|
|
void scic_sds_controller_transition_to_ready(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCI_STATUS status
|
|
)
|
|
{
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_transition_to_ready(0x%x, 0x%x) enter\n",
|
|
this_controller, status
|
|
));
|
|
|
|
if (this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_STARTING)
|
|
{
|
|
// We move into the ready state, because some of the phys/ports
|
|
// may be up and operational.
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_READY
|
|
);
|
|
|
|
scic_cb_controller_start_complete(this_controller, status);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method is the general timeout handler for the controller.
|
|
* It will take the correct timetout action based on the current
|
|
* controller state
|
|
*
|
|
* @param[in] controller This parameter indicates the controller on which
|
|
* a timeout occurred.
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_controller_timeout_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCI_BASE_CONTROLLER_STATES current_state;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
current_state = sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller)
|
|
);
|
|
|
|
if (current_state == SCI_BASE_CONTROLLER_STATE_STARTING)
|
|
{
|
|
scic_sds_controller_transition_to_ready(
|
|
this_controller, SCI_FAILURE_TIMEOUT
|
|
);
|
|
}
|
|
else if (current_state == SCI_BASE_CONTROLLER_STATE_STOPPING)
|
|
{
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_FAILED
|
|
);
|
|
|
|
scic_cb_controller_stop_complete(controller, SCI_FAILURE_TIMEOUT);
|
|
}
|
|
else
|
|
{
|
|
/// @todo Now what do we want to do in this case?
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"Controller timer fired when controller was not in a state being timed.\n"
|
|
));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return SCI_STATUS
|
|
*/
|
|
SCI_STATUS scic_sds_controller_stop_ports(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 index;
|
|
SCI_STATUS status;
|
|
SCI_STATUS port_status;
|
|
|
|
status = SCI_SUCCESS;
|
|
|
|
for (index = 0; index < this_controller->logical_port_entries; index++)
|
|
{
|
|
port_status = this_controller->port_table[index].
|
|
state_handlers->parent.stop_handler(&this_controller->port_table[index].parent);
|
|
if (
|
|
(port_status != SCI_SUCCESS)
|
|
&& (port_status != SCI_FAILURE_INVALID_STATE)
|
|
)
|
|
{
|
|
status = SCI_FAILURE;
|
|
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER | SCIC_LOG_OBJECT_PORT,
|
|
"Controller stop operation failed to stop port %d because of status %d.\n",
|
|
this_controller->port_table[index].logical_port_index, port_status
|
|
));
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @param[in] this_controller
|
|
*/
|
|
static
|
|
void scic_sds_controller_phy_timer_start(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
scic_cb_timer_start(
|
|
this_controller,
|
|
this_controller->phy_startup_timer,
|
|
SCIC_SDS_CONTROLLER_PHY_START_TIMEOUT
|
|
);
|
|
|
|
this_controller->phy_startup_timer_pending = TRUE;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @param[in] this_controller
|
|
*/
|
|
void scic_sds_controller_phy_timer_stop(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
scic_cb_timer_stop(
|
|
this_controller,
|
|
this_controller->phy_startup_timer
|
|
);
|
|
|
|
this_controller->phy_startup_timer_pending = FALSE;
|
|
}
|
|
|
|
/**
|
|
* @brief This method is called internally to determine whether the
|
|
* controller start process is complete. This is only true when:
|
|
* - all links have been given an opportunity to start
|
|
* - have no indication of a connected device
|
|
* - have an indication of a connected device and it has
|
|
* finished the link training process.
|
|
*
|
|
* @param[in] this_controller This parameter specifies the controller
|
|
* object for which to start the next phy.
|
|
*
|
|
* @return BOOL
|
|
*/
|
|
BOOL scic_sds_controller_is_start_complete(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U8 index;
|
|
|
|
for (index = 0; index < SCI_MAX_PHYS; index++)
|
|
{
|
|
SCIC_SDS_PHY_T *the_phy = & this_controller->phy_table[index];
|
|
|
|
if (
|
|
(
|
|
this_controller->oem_parameters.sds1.controller.mode_type
|
|
== SCIC_PORT_AUTOMATIC_CONFIGURATION_MODE
|
|
)
|
|
|| (
|
|
(
|
|
this_controller->oem_parameters.sds1.controller.mode_type
|
|
== SCIC_PORT_MANUAL_CONFIGURATION_MODE
|
|
)
|
|
&& (scic_sds_phy_get_port(the_phy) != SCI_INVALID_HANDLE)
|
|
)
|
|
)
|
|
{
|
|
/**
|
|
* The controller start operation is complete if and only
|
|
* if:
|
|
* - all links have been given an opportunity to start
|
|
* - have no indication of a connected device
|
|
* - have an indication of a connected device and it has
|
|
* finished the link training process.
|
|
*/
|
|
if (
|
|
(
|
|
(the_phy->is_in_link_training == FALSE)
|
|
&& (the_phy->parent.state_machine.current_state_id
|
|
== SCI_BASE_PHY_STATE_INITIAL)
|
|
)
|
|
|| (
|
|
(the_phy->is_in_link_training == FALSE)
|
|
&& (the_phy->parent.state_machine.current_state_id
|
|
== SCI_BASE_PHY_STATE_STOPPED)
|
|
)
|
|
|| (
|
|
(the_phy->is_in_link_training == TRUE)
|
|
&& (the_phy->parent.state_machine.current_state_id
|
|
== SCI_BASE_PHY_STATE_STARTING)
|
|
)
|
|
|| (
|
|
this_controller->port_agent.phy_ready_mask
|
|
!= this_controller->port_agent.phy_configured_mask
|
|
)
|
|
)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* @brief This method is called internally by the controller object to
|
|
* start the next phy on the controller. If all the phys have
|
|
* been starte, then this method will attempt to transition the
|
|
* controller to the READY state and inform the user
|
|
* (scic_cb_controller_start_complete()).
|
|
*
|
|
* @param[in] this_controller This parameter specifies the controller
|
|
* object for which to start the next phy.
|
|
*
|
|
* @return SCI_STATUS
|
|
*/
|
|
SCI_STATUS scic_sds_controller_start_next_phy(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
SCI_STATUS status;
|
|
|
|
status = SCI_SUCCESS;
|
|
|
|
if (this_controller->phy_startup_timer_pending == FALSE)
|
|
{
|
|
if (this_controller->next_phy_to_start == SCI_MAX_PHYS)
|
|
{
|
|
// The controller has successfully finished the start process.
|
|
// Inform the SCI Core user and transition to the READY state.
|
|
if (scic_sds_controller_is_start_complete(this_controller) == TRUE)
|
|
{
|
|
scic_sds_controller_transition_to_ready(
|
|
this_controller, SCI_SUCCESS
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SCIC_SDS_PHY_T * the_phy;
|
|
|
|
the_phy = &this_controller->phy_table[this_controller->next_phy_to_start];
|
|
|
|
if (
|
|
this_controller->oem_parameters.sds1.controller.mode_type
|
|
== SCIC_PORT_MANUAL_CONFIGURATION_MODE
|
|
)
|
|
{
|
|
if (scic_sds_phy_get_port(the_phy) == SCI_INVALID_HANDLE)
|
|
{
|
|
this_controller->next_phy_to_start++;
|
|
|
|
// Caution recursion ahead be forwarned
|
|
//
|
|
// The PHY was never added to a PORT in MPC mode so start the next phy in sequence
|
|
// This phy will never go link up and will not draw power the OEM parameters either
|
|
// configured the phy incorrectly for the PORT or it was never assigned to a PORT
|
|
return scic_sds_controller_start_next_phy(this_controller);
|
|
}
|
|
}
|
|
|
|
status = scic_phy_start(the_phy);
|
|
|
|
if (status == SCI_SUCCESS)
|
|
{
|
|
scic_sds_controller_phy_timer_start(this_controller);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER | SCIC_LOG_OBJECT_PHY,
|
|
"Controller stop operation failed to stop phy %d because of status %d.\n",
|
|
this_controller->phy_table[this_controller->next_phy_to_start].phy_index,
|
|
status
|
|
));
|
|
}
|
|
|
|
this_controller->next_phy_to_start++;
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return SCI_STATUS
|
|
*/
|
|
SCI_STATUS scic_sds_controller_stop_phys(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 index;
|
|
SCI_STATUS status;
|
|
SCI_STATUS phy_status;
|
|
|
|
status = SCI_SUCCESS;
|
|
|
|
for (index = 0; index < SCI_MAX_PHYS; index++)
|
|
{
|
|
phy_status = scic_phy_stop(&this_controller->phy_table[index]);
|
|
|
|
if (
|
|
(phy_status != SCI_SUCCESS)
|
|
&& (phy_status != SCI_FAILURE_INVALID_STATE)
|
|
)
|
|
{
|
|
status = SCI_FAILURE;
|
|
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER | SCIC_LOG_OBJECT_PHY,
|
|
"Controller stop operation failed to stop phy %d because of status %d.\n",
|
|
this_controller->phy_table[index].phy_index, phy_status
|
|
));
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return SCI_STATUS
|
|
*/
|
|
SCI_STATUS scic_sds_controller_stop_devices(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 index;
|
|
SCI_STATUS status;
|
|
SCI_STATUS device_status;
|
|
|
|
status = SCI_SUCCESS;
|
|
|
|
for (index = 0; index < this_controller->remote_node_entries; index++)
|
|
{
|
|
if (this_controller->device_table[index] != SCI_INVALID_HANDLE)
|
|
{
|
|
/// @todo What timeout value do we want to provide to this request?
|
|
device_status = scic_remote_device_stop(this_controller->device_table[index], 0);
|
|
|
|
if (
|
|
(device_status != SCI_SUCCESS)
|
|
&& (device_status != SCI_FAILURE_INVALID_STATE)
|
|
)
|
|
{
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER | SCIC_LOG_OBJECT_SSP_REMOTE_TARGET,
|
|
"Controller stop operation failed to stop device 0x%x because of status %d.\n",
|
|
this_controller->device_table[index], device_status
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
//****************************************************************************-
|
|
//* SCIC SDS Controller Power Control (Staggered Spinup)
|
|
//****************************************************************************-
|
|
|
|
/**
|
|
* This method starts the power control timer for this controller object.
|
|
*
|
|
* @param this_controller
|
|
*/
|
|
static
|
|
void scic_sds_controller_power_control_timer_start(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
scic_cb_timer_start(
|
|
this_controller, this_controller->power_control.timer,
|
|
SCIC_SDS_CONTROLLER_POWER_CONTROL_INTERVAL
|
|
);
|
|
|
|
this_controller->power_control.timer_started = TRUE;
|
|
}
|
|
|
|
/**
|
|
* This method stops the power control timer for this controller object.
|
|
*
|
|
* @param this_controller
|
|
*/
|
|
static
|
|
void scic_sds_controller_power_control_timer_stop(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
if (this_controller->power_control.timer_started)
|
|
{
|
|
scic_cb_timer_stop(
|
|
this_controller, this_controller->power_control.timer
|
|
);
|
|
|
|
this_controller->power_control.timer_started = FALSE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method stops and starts the power control timer for this controller object.
|
|
*
|
|
* @param this_controller
|
|
*/
|
|
static
|
|
void scic_sds_controller_power_control_timer_restart(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
scic_sds_controller_power_control_timer_stop(this_controller);
|
|
scic_sds_controller_power_control_timer_start(this_controller);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @param[in] controller
|
|
*/
|
|
void scic_sds_controller_power_control_timer_handler(
|
|
void *controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
this_controller->power_control.remote_devices_granted_power = 0;
|
|
|
|
if (this_controller->power_control.phys_waiting == 0)
|
|
{
|
|
this_controller->power_control.timer_started = FALSE;
|
|
}
|
|
else
|
|
{
|
|
SCIC_SDS_PHY_T *the_phy = NULL;
|
|
U8 i;
|
|
|
|
for (i=0;
|
|
(i < SCI_MAX_PHYS)
|
|
&& (this_controller->power_control.phys_waiting != 0);
|
|
i++)
|
|
{
|
|
if (this_controller->power_control.requesters[i] != NULL)
|
|
{
|
|
if ( this_controller->power_control.remote_devices_granted_power <
|
|
this_controller->oem_parameters.sds1.controller.max_number_concurrent_device_spin_up
|
|
)
|
|
{
|
|
the_phy = this_controller->power_control.requesters[i];
|
|
this_controller->power_control.requesters[i] = NULL;
|
|
this_controller->power_control.phys_waiting--;
|
|
this_controller->power_control.remote_devices_granted_power ++;
|
|
scic_sds_phy_consume_power_handler(the_phy);
|
|
|
|
if (the_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS)
|
|
{
|
|
U8 j;
|
|
SCIC_SDS_PHY_T * current_requester_phy;
|
|
|
|
for (j = 0; j < SCI_MAX_PHYS; j++)
|
|
{
|
|
current_requester_phy = this_controller->power_control.requesters[j];
|
|
|
|
//Search the power_control queue to see if there are other phys attached to
|
|
//the same remote device. If found, take all of them out of await_sas_power state.
|
|
if (current_requester_phy != NULL &&
|
|
current_requester_phy != the_phy &&
|
|
current_requester_phy->phy_type.sas.identify_address_frame_buffer.sas_address.high
|
|
== the_phy->phy_type.sas.identify_address_frame_buffer.sas_address.high &&
|
|
current_requester_phy->phy_type.sas.identify_address_frame_buffer.sas_address.low
|
|
== the_phy->phy_type.sas.identify_address_frame_buffer.sas_address.low)
|
|
{
|
|
this_controller->power_control.requesters[j] = NULL;
|
|
this_controller->power_control.phys_waiting--;
|
|
scic_sds_phy_consume_power_handler(current_requester_phy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// It doesn't matter if the power list is empty, we need to start the
|
|
// timer in case another phy becomes ready.
|
|
scic_sds_controller_power_control_timer_start(this_controller);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method inserts the phy in the stagger spinup control queue.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] the_phy
|
|
*/
|
|
void scic_sds_controller_power_control_queue_insert(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_PHY_T *the_phy
|
|
)
|
|
{
|
|
ASSERT (the_phy != NULL);
|
|
|
|
if( this_controller->power_control.remote_devices_granted_power <
|
|
this_controller->oem_parameters.sds1.controller.max_number_concurrent_device_spin_up
|
|
)
|
|
{
|
|
this_controller->power_control.remote_devices_granted_power ++;
|
|
scic_sds_phy_consume_power_handler(the_phy);
|
|
|
|
//stop and start the power_control timer. When the timer fires, the
|
|
//no_of_devices_granted_power will be set to 0
|
|
scic_sds_controller_power_control_timer_restart (this_controller);
|
|
}
|
|
else
|
|
{
|
|
//there are phys, attached to the same sas address as this phy, are already
|
|
//in READY state, this phy don't need wait.
|
|
U8 i;
|
|
SCIC_SDS_PHY_T * current_phy;
|
|
for(i = 0; i < SCI_MAX_PHYS; i++)
|
|
{
|
|
current_phy = &this_controller->phy_table[i];
|
|
|
|
if (current_phy->parent.state_machine.current_state_id == SCI_BASE_PHY_STATE_READY &&
|
|
current_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS &&
|
|
current_phy->phy_type.sas.identify_address_frame_buffer.sas_address.high
|
|
== the_phy->phy_type.sas.identify_address_frame_buffer.sas_address.high &&
|
|
current_phy->phy_type.sas.identify_address_frame_buffer.sas_address.low
|
|
== the_phy->phy_type.sas.identify_address_frame_buffer.sas_address.low)
|
|
{
|
|
scic_sds_phy_consume_power_handler(the_phy);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == SCI_MAX_PHYS)
|
|
{
|
|
//Add the phy in the waiting list
|
|
this_controller->power_control.requesters[the_phy->phy_index] = the_phy;
|
|
this_controller->power_control.phys_waiting++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method removes the phy from the stagger spinup control
|
|
* queue.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] the_phy
|
|
*/
|
|
void scic_sds_controller_power_control_queue_remove(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_PHY_T *the_phy
|
|
)
|
|
{
|
|
ASSERT (the_phy != NULL);
|
|
|
|
if (this_controller->power_control.requesters[the_phy->phy_index] != NULL)
|
|
{
|
|
this_controller->power_control.phys_waiting--;
|
|
}
|
|
|
|
this_controller->power_control.requesters[the_phy->phy_index] = NULL;
|
|
}
|
|
|
|
//****************************************************************************-
|
|
//* SCIC SDS Controller Completion Routines
|
|
//****************************************************************************-
|
|
|
|
/**
|
|
* @brief This method returns a TRUE value if the completion queue has
|
|
* entries that can be processed
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return BOOL
|
|
* @retval TRUE if the completion queue has entries to process
|
|
* FALSE if the completion queue has no entries to process
|
|
*/
|
|
static
|
|
BOOL scic_sds_controller_completion_queue_has_entries(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 get_value = this_controller->completion_queue_get;
|
|
U32 get_index = get_value & SMU_COMPLETION_QUEUE_GET_POINTER_MASK;
|
|
if (
|
|
NORMALIZE_GET_POINTER_CYCLE_BIT(get_value)
|
|
== COMPLETION_QUEUE_CYCLE_BIT(this_controller->completion_queue[get_index])
|
|
)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* @brief This method processes a task completion notification. This is
|
|
* called from within the controller completion handler.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] completion_entry
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_task_completion(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U32 completion_entry
|
|
)
|
|
{
|
|
U32 index;
|
|
SCIC_SDS_REQUEST_T *io_request;
|
|
|
|
index = SCU_GET_COMPLETION_INDEX(completion_entry);
|
|
io_request = this_controller->io_request_table[index];
|
|
|
|
// Make sure that we really want to process this IO request
|
|
if (
|
|
(io_request != SCI_INVALID_HANDLE)
|
|
&& (io_request->io_tag != SCI_CONTROLLER_INVALID_IO_TAG)
|
|
&& (
|
|
scic_sds_io_tag_get_sequence(io_request->io_tag)
|
|
== this_controller->io_request_sequence[index]
|
|
)
|
|
)
|
|
{
|
|
// Yep this is a valid io request pass it along to the io request handler
|
|
scic_sds_io_request_tc_completion(io_request, completion_entry);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method processes an SDMA completion event. This is called
|
|
* from within the controller completion handler.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] completion_entry
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_sdma_completion(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U32 completion_entry
|
|
)
|
|
{
|
|
U32 index;
|
|
SCIC_SDS_REQUEST_T *io_request;
|
|
SCIC_SDS_REMOTE_DEVICE_T *device;
|
|
|
|
index = SCU_GET_COMPLETION_INDEX(completion_entry);
|
|
|
|
switch (scu_get_command_request_type(completion_entry))
|
|
{
|
|
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC:
|
|
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_TC:
|
|
io_request = this_controller->io_request_table[index];
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER
|
|
| SCIC_LOG_OBJECT_SMP_IO_REQUEST
|
|
| SCIC_LOG_OBJECT_SSP_IO_REQUEST
|
|
| SCIC_LOG_OBJECT_STP_IO_REQUEST,
|
|
"SCIC SDS Completion type SDMA %x for io request %x\n",
|
|
completion_entry,
|
|
io_request
|
|
));
|
|
/// @todo For a post TC operation we need to fail the IO request
|
|
break;
|
|
|
|
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_RNC:
|
|
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC:
|
|
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_RNC:
|
|
device = this_controller->device_table[index];
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER
|
|
| SCIC_LOG_OBJECT_SSP_REMOTE_TARGET
|
|
| SCIC_LOG_OBJECT_SMP_REMOTE_TARGET
|
|
| SCIC_LOG_OBJECT_STP_REMOTE_TARGET,
|
|
"SCIC SDS Completion type SDMA %x for remote device %x\n",
|
|
completion_entry,
|
|
device
|
|
));
|
|
/// @todo For a port RNC operation we need to fail the device
|
|
break;
|
|
|
|
default:
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC SDS Completion unknown SDMA completion type %x\n",
|
|
completion_entry
|
|
));
|
|
break;
|
|
}
|
|
|
|
/// This is an unexpected completion type and is un-recoverable
|
|
/// Transition to the failed state and wait for a controller reset
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_FAILED
|
|
);
|
|
}
|
|
|
|
/**
|
|
* This method processes an unsolicited frame message. This is called from
|
|
* within the controller completion handler.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] completion_entry
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_unsolicited_frame(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U32 completion_entry
|
|
)
|
|
{
|
|
U32 index;
|
|
U32 frame_index;
|
|
|
|
SCU_UNSOLICITED_FRAME_HEADER_T * frame_header;
|
|
SCIC_SDS_PHY_T * phy;
|
|
SCIC_SDS_REMOTE_DEVICE_T * device;
|
|
|
|
SCI_STATUS result = SCI_FAILURE;
|
|
|
|
frame_index = SCU_GET_FRAME_INDEX(completion_entry);
|
|
|
|
frame_header
|
|
= this_controller->uf_control.buffers.array[frame_index].header;
|
|
this_controller->uf_control.buffers.array[frame_index].state
|
|
= UNSOLICITED_FRAME_IN_USE;
|
|
|
|
if (SCU_GET_FRAME_ERROR(completion_entry))
|
|
{
|
|
/// @todo If the IAF frame or SIGNATURE FIS frame has an error will
|
|
/// this cause a problem? We expect the phy initialization will
|
|
/// fail if there is an error in the frame.
|
|
scic_sds_controller_release_frame(this_controller, frame_index);
|
|
return;
|
|
}
|
|
|
|
if (frame_header->is_address_frame)
|
|
{
|
|
index = SCU_GET_PROTOCOL_ENGINE_INDEX(completion_entry);
|
|
phy = &this_controller->phy_table[index];
|
|
if (phy != NULL)
|
|
{
|
|
result = scic_sds_phy_frame_handler(phy, frame_index);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
index = SCU_GET_COMPLETION_INDEX(completion_entry);
|
|
|
|
if (index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
|
|
{
|
|
// This is a signature fis or a frame from a direct attached SATA
|
|
// device that has not yet been created. In either case forwared
|
|
// the frame to the PE and let it take care of the frame data.
|
|
index = SCU_GET_PROTOCOL_ENGINE_INDEX(completion_entry);
|
|
phy = &this_controller->phy_table[index];
|
|
result = scic_sds_phy_frame_handler(phy, frame_index);
|
|
}
|
|
else
|
|
{
|
|
if (index < this_controller->remote_node_entries)
|
|
device = this_controller->device_table[index];
|
|
else
|
|
device = NULL;
|
|
|
|
if (device != NULL)
|
|
result = scic_sds_remote_device_frame_handler(device, frame_index);
|
|
else
|
|
scic_sds_controller_release_frame(this_controller, frame_index);
|
|
}
|
|
}
|
|
|
|
if (result != SCI_SUCCESS)
|
|
{
|
|
/// @todo Is there any reason to report some additional error message
|
|
/// when we get this failure notifiction?
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method processes an event completion entry. This is called
|
|
* from within the controller completion handler.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] completion_entry
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_event_completion(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U32 completion_entry
|
|
)
|
|
{
|
|
U32 index;
|
|
SCIC_SDS_REQUEST_T *io_request;
|
|
SCIC_SDS_REMOTE_DEVICE_T *device;
|
|
SCIC_SDS_PHY_T *phy;
|
|
|
|
index = SCU_GET_COMPLETION_INDEX(completion_entry);
|
|
|
|
switch (scu_get_event_type(completion_entry))
|
|
{
|
|
case SCU_EVENT_TYPE_SMU_COMMAND_ERROR:
|
|
/// @todo The driver did something wrong and we need to fix the condtion.
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller 0x%x received SMU command error 0x%x\n",
|
|
this_controller, completion_entry
|
|
));
|
|
break;
|
|
|
|
case SCU_EVENT_TYPE_FATAL_MEMORY_ERROR:
|
|
// report fatal memory error
|
|
this_controller->parent.error = SCI_CONTROLLER_FATAL_MEMORY_ERROR;
|
|
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_FAILED
|
|
);
|
|
|
|
//continue as in following events
|
|
case SCU_EVENT_TYPE_SMU_PCQ_ERROR:
|
|
case SCU_EVENT_TYPE_SMU_ERROR:
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller 0x%x received fatal controller event 0x%x\n",
|
|
this_controller, completion_entry
|
|
));
|
|
break;
|
|
|
|
case SCU_EVENT_TYPE_TRANSPORT_ERROR:
|
|
io_request = this_controller->io_request_table[index];
|
|
scic_sds_io_request_event_handler(io_request, completion_entry);
|
|
break;
|
|
|
|
case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
|
|
switch (scu_get_event_specifier(completion_entry))
|
|
{
|
|
case SCU_EVENT_SPECIFIC_SMP_RESPONSE_NO_PE:
|
|
case SCU_EVENT_SPECIFIC_TASK_TIMEOUT:
|
|
io_request = this_controller->io_request_table[index];
|
|
if (io_request != SCI_INVALID_HANDLE)
|
|
{
|
|
scic_sds_io_request_event_handler(io_request, completion_entry);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER |
|
|
SCIC_LOG_OBJECT_SMP_IO_REQUEST |
|
|
SCIC_LOG_OBJECT_SSP_IO_REQUEST |
|
|
SCIC_LOG_OBJECT_STP_IO_REQUEST,
|
|
"SCIC Controller 0x%x received event 0x%x for io request object that doesnt exist.\n",
|
|
this_controller, completion_entry
|
|
));
|
|
}
|
|
break;
|
|
|
|
case SCU_EVENT_SPECIFIC_IT_NEXUS_TIMEOUT:
|
|
device = this_controller->device_table[index];
|
|
if (device != SCI_INVALID_HANDLE)
|
|
{
|
|
scic_sds_remote_device_event_handler(device, completion_entry);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER |
|
|
SCIC_LOG_OBJECT_SMP_REMOTE_TARGET |
|
|
SCIC_LOG_OBJECT_SSP_REMOTE_TARGET |
|
|
SCIC_LOG_OBJECT_STP_REMOTE_TARGET,
|
|
"SCIC Controller 0x%x received event 0x%x for remote device object that doesnt exist.\n",
|
|
this_controller, completion_entry
|
|
));
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SCU_EVENT_TYPE_BROADCAST_CHANGE:
|
|
// direct the broadcast change event to the phy first and then let
|
|
// the phy redirect the broadcast change to the port object
|
|
case SCU_EVENT_TYPE_ERR_CNT_EVENT:
|
|
// direct error counter event to the phy object since that is where
|
|
// we get the event notification. This is a type 4 event.
|
|
case SCU_EVENT_TYPE_OSSP_EVENT:
|
|
index = SCU_GET_PROTOCOL_ENGINE_INDEX(completion_entry);
|
|
phy = &this_controller->phy_table[index];
|
|
scic_sds_phy_event_handler(phy, completion_entry);
|
|
break;
|
|
|
|
case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
|
|
case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
|
|
case SCU_EVENT_TYPE_RNC_OPS_MISC:
|
|
if (index < this_controller->remote_node_entries)
|
|
{
|
|
device = this_controller->device_table[index];
|
|
|
|
if (device != NULL)
|
|
{
|
|
scic_sds_remote_device_event_handler(device, completion_entry);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER |
|
|
SCIC_LOG_OBJECT_SMP_REMOTE_TARGET |
|
|
SCIC_LOG_OBJECT_SSP_REMOTE_TARGET |
|
|
SCIC_LOG_OBJECT_STP_REMOTE_TARGET,
|
|
"SCIC Controller 0x%x received event 0x%x for remote device object 0x%0x that doesnt exist.\n",
|
|
this_controller, completion_entry, index
|
|
));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller received unknown event code %x\n",
|
|
completion_entry
|
|
));
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method is a private routine for processing the completion
|
|
* queue entries.
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_process_completions(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U32 completion_count = 0;
|
|
U32 completion_entry;
|
|
U32 get_index;
|
|
U32 get_cycle;
|
|
U32 event_index;
|
|
U32 event_cycle;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_process_completions(0x%x) enter\n",
|
|
this_controller
|
|
));
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_COMPLETION_QUEUE,
|
|
"completion queue beginning get : 0x%08x\n",
|
|
this_controller->completion_queue_get
|
|
));
|
|
|
|
// Get the component parts of the completion queue
|
|
get_index = NORMALIZE_GET_POINTER(this_controller->completion_queue_get);
|
|
get_cycle = SMU_CQGR_CYCLE_BIT & this_controller->completion_queue_get;
|
|
|
|
event_index = NORMALIZE_EVENT_POINTER(this_controller->completion_queue_get);
|
|
event_cycle = SMU_CQGR_EVENT_CYCLE_BIT & this_controller->completion_queue_get;
|
|
|
|
while (
|
|
NORMALIZE_GET_POINTER_CYCLE_BIT(get_cycle)
|
|
== COMPLETION_QUEUE_CYCLE_BIT(this_controller->completion_queue[get_index])
|
|
)
|
|
{
|
|
completion_count++;
|
|
|
|
completion_entry = this_controller->completion_queue[get_index];
|
|
INCREMENT_COMPLETION_QUEUE_GET(this_controller, get_index, get_cycle);
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_COMPLETION_QUEUE,
|
|
"completion queue entry : 0x%08x\n",
|
|
completion_entry
|
|
));
|
|
|
|
switch (SCU_GET_COMPLETION_TYPE(completion_entry))
|
|
{
|
|
case SCU_COMPLETION_TYPE_TASK:
|
|
scic_sds_controller_task_completion(this_controller, completion_entry);
|
|
break;
|
|
|
|
case SCU_COMPLETION_TYPE_SDMA:
|
|
scic_sds_controller_sdma_completion(this_controller, completion_entry);
|
|
break;
|
|
|
|
case SCU_COMPLETION_TYPE_UFI:
|
|
scic_sds_controller_unsolicited_frame(this_controller, completion_entry);
|
|
break;
|
|
|
|
case SCU_COMPLETION_TYPE_EVENT:
|
|
scic_sds_controller_event_completion(this_controller, completion_entry);
|
|
break;
|
|
|
|
case SCU_COMPLETION_TYPE_NOTIFY:
|
|
// Presently we do the same thing with a notify event that we do with the
|
|
// other event codes.
|
|
INCREMENT_EVENT_QUEUE_GET(this_controller, event_index, event_cycle);
|
|
scic_sds_controller_event_completion(this_controller, completion_entry);
|
|
break;
|
|
|
|
default:
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller received unknown completion type %x\n",
|
|
completion_entry
|
|
));
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Update the get register if we completed one or more entries
|
|
if (completion_count > 0)
|
|
{
|
|
this_controller->completion_queue_get =
|
|
SMU_CQGR_GEN_BIT(ENABLE)
|
|
| SMU_CQGR_GEN_BIT(EVENT_ENABLE)
|
|
| event_cycle | SMU_CQGR_GEN_VAL(EVENT_POINTER, event_index)
|
|
| get_cycle | SMU_CQGR_GEN_VAL(POINTER, get_index) ;
|
|
|
|
SMU_CQGR_WRITE(this_controller, this_controller->completion_queue_get);
|
|
}
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_COMPLETION_QUEUE,
|
|
"completion queue ending get : 0x%08x\n",
|
|
this_controller->completion_queue_get
|
|
));
|
|
|
|
}
|
|
|
|
/**
|
|
* @brief This method is a private routine for processing the completion
|
|
* queue entries.
|
|
*
|
|
* @param[in] this_controller
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_transitioned_process_completions(
|
|
SCIC_SDS_CONTROLLER_T * this_controller
|
|
)
|
|
{
|
|
U32 completion_count = 0;
|
|
U32 completion_entry;
|
|
U32 get_index;
|
|
U32 get_cycle;
|
|
U32 event_index;
|
|
U32 event_cycle;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_transitioned_process_completions(0x%x) enter\n",
|
|
this_controller
|
|
));
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_COMPLETION_QUEUE,
|
|
"completion queue beginning get : 0x%08x\n",
|
|
this_controller->completion_queue_get
|
|
));
|
|
|
|
// Get the component parts of the completion queue
|
|
get_index = NORMALIZE_GET_POINTER(this_controller->completion_queue_get);
|
|
get_cycle = SMU_CQGR_CYCLE_BIT & this_controller->completion_queue_get;
|
|
|
|
event_index = NORMALIZE_EVENT_POINTER(this_controller->completion_queue_get);
|
|
event_cycle = SMU_CQGR_EVENT_CYCLE_BIT & this_controller->completion_queue_get;
|
|
|
|
while (
|
|
NORMALIZE_GET_POINTER_CYCLE_BIT(get_cycle)
|
|
== COMPLETION_QUEUE_CYCLE_BIT(
|
|
this_controller->completion_queue[get_index])
|
|
)
|
|
{
|
|
completion_count++;
|
|
|
|
completion_entry = this_controller->completion_queue[get_index];
|
|
INCREMENT_COMPLETION_QUEUE_GET(this_controller, get_index, get_cycle);
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_COMPLETION_QUEUE,
|
|
"completion queue entry : 0x%08x\n",
|
|
completion_entry
|
|
));
|
|
|
|
switch (SCU_GET_COMPLETION_TYPE(completion_entry))
|
|
{
|
|
case SCU_COMPLETION_TYPE_TASK:
|
|
scic_sds_controller_task_completion(this_controller, completion_entry);
|
|
break;
|
|
|
|
case SCU_COMPLETION_TYPE_NOTIFY:
|
|
INCREMENT_EVENT_QUEUE_GET(this_controller, event_index, event_cycle);
|
|
// Fall-through
|
|
|
|
case SCU_COMPLETION_TYPE_EVENT:
|
|
case SCU_COMPLETION_TYPE_SDMA:
|
|
case SCU_COMPLETION_TYPE_UFI:
|
|
default:
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller ignoring completion type %x\n",
|
|
completion_entry
|
|
));
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Update the get register if we completed one or more entries
|
|
if (completion_count > 0)
|
|
{
|
|
this_controller->completion_queue_get =
|
|
SMU_CQGR_GEN_BIT(ENABLE)
|
|
| SMU_CQGR_GEN_BIT(EVENT_ENABLE)
|
|
| event_cycle | SMU_CQGR_GEN_VAL(EVENT_POINTER, event_index)
|
|
| get_cycle | SMU_CQGR_GEN_VAL(POINTER, get_index) ;
|
|
|
|
SMU_CQGR_WRITE(this_controller, this_controller->completion_queue_get);
|
|
}
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_COMPLETION_QUEUE,
|
|
"completion queue ending get : 0x%08x\n",
|
|
this_controller->completion_queue_get
|
|
));
|
|
}
|
|
|
|
//****************************************************************************-
|
|
//* SCIC SDS Controller Interrupt and Completion functions
|
|
//****************************************************************************-
|
|
|
|
/**
|
|
* @brief This method provides standard (common) processing of interrupts
|
|
* for polling and legacy based interrupts.
|
|
*
|
|
* @param[in] controller
|
|
* @param[in] interrupt_status
|
|
*
|
|
* @return This method returns a boolean (BOOL) indication as to
|
|
* whether an completions are pending to be processed.
|
|
* @retval TRUE if an interrupt is to be processed
|
|
* @retval FALSE if no interrupt was pending
|
|
*/
|
|
static
|
|
BOOL scic_sds_controller_standard_interrupt_handler(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U32 interrupt_status
|
|
)
|
|
{
|
|
BOOL is_completion_needed = FALSE;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_standard_interrupt_handler(0x%d,0x%d) enter\n",
|
|
this_controller, interrupt_status
|
|
));
|
|
|
|
if (
|
|
(interrupt_status & SMU_ISR_QUEUE_ERROR)
|
|
|| (
|
|
(interrupt_status & SMU_ISR_QUEUE_SUSPEND)
|
|
&& (!scic_sds_controller_completion_queue_has_entries(this_controller))
|
|
)
|
|
)
|
|
{
|
|
// We have a fatal error on the read of the completion queue bar
|
|
// OR
|
|
// We have a fatal error there is nothing in the completion queue
|
|
// but we have a report from the hardware that the queue is full
|
|
/// @todo how do we request the a controller reset
|
|
is_completion_needed = TRUE;
|
|
this_controller->encountered_fatal_error = TRUE;
|
|
}
|
|
|
|
if (scic_sds_controller_completion_queue_has_entries(this_controller))
|
|
{
|
|
is_completion_needed = TRUE;
|
|
}
|
|
|
|
return is_completion_needed;
|
|
}
|
|
|
|
/**
|
|
* @brief This is the method provided to handle polling for interrupts
|
|
* for the controller object.
|
|
*
|
|
* @param[in] controller
|
|
*
|
|
* @return BOOL
|
|
* @retval TRUE if an interrupt is to be processed
|
|
* @retval FALSE if no interrupt was pending
|
|
*/
|
|
static
|
|
BOOL scic_sds_controller_polling_interrupt_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
U32 interrupt_status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_polling_interrupt_handler(0x%d) enter\n",
|
|
controller
|
|
));
|
|
|
|
/*
|
|
* In INTERRUPT_POLLING_MODE we exit the interrupt handler if the hardware
|
|
* indicates nothing is pending. Since we are not being called from a real
|
|
* interrupt, we don't want to confuse the hardware by servicing the
|
|
* completion queue before the hardware indicates it is ready. We'll
|
|
* simply wait for another polling interval and check again.
|
|
*/
|
|
interrupt_status = SMU_ISR_READ(this_controller);
|
|
if ((interrupt_status &
|
|
(SMU_ISR_COMPLETION |
|
|
SMU_ISR_QUEUE_ERROR |
|
|
SMU_ISR_QUEUE_SUSPEND)) == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return scic_sds_controller_standard_interrupt_handler(
|
|
controller, interrupt_status
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief This is the method provided to handle completions when interrupt
|
|
* polling is in use.
|
|
*
|
|
* @param[in] controller
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_polling_completion_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_polling_completion_handler(0x%d) enter\n",
|
|
controller
|
|
));
|
|
|
|
if (this_controller->encountered_fatal_error == TRUE)
|
|
{
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller has encountered a fatal error.\n"
|
|
));
|
|
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_FAILED
|
|
);
|
|
}
|
|
else if (scic_sds_controller_completion_queue_has_entries(this_controller))
|
|
{
|
|
if (this_controller->restrict_completions == FALSE)
|
|
scic_sds_controller_process_completions(this_controller);
|
|
else
|
|
scic_sds_controller_transitioned_process_completions(this_controller);
|
|
}
|
|
|
|
/*
|
|
* The interrupt handler does not adjust the CQ's
|
|
* get pointer. So, SCU's INTx pin stays asserted during the
|
|
* interrupt handler even though it tries to clear the interrupt
|
|
* source. Therefore, the completion handler must ensure that the
|
|
* interrupt source is cleared. Otherwise, we get a spurious
|
|
* interrupt for which the interrupt handler will not issue a
|
|
* corresponding completion event. Also, we unmask interrupts.
|
|
*/
|
|
SMU_ISR_WRITE(
|
|
this_controller,
|
|
(U32)(SMU_ISR_COMPLETION | SMU_ISR_QUEUE_ERROR | SMU_ISR_QUEUE_SUSPEND)
|
|
);
|
|
}
|
|
|
|
#if !defined(DISABLE_INTERRUPTS)
|
|
/**
|
|
* @brief This is the method provided to handle legacy interrupts for the
|
|
* controller object.
|
|
*
|
|
* @param[in] controller
|
|
*
|
|
* @return BOOL
|
|
* @retval TRUE if an interrupt is processed
|
|
* FALSE if no interrupt was processed
|
|
*/
|
|
static
|
|
BOOL scic_sds_controller_legacy_interrupt_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
U32 interrupt_status;
|
|
BOOL is_completion_needed;
|
|
SCIC_SDS_CONTROLLER_T *this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
|
|
interrupt_status = SMU_ISR_READ(this_controller);
|
|
is_completion_needed = scic_sds_controller_standard_interrupt_handler(
|
|
this_controller, interrupt_status
|
|
);
|
|
|
|
return is_completion_needed;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief This is the method provided to handle legacy completions it is
|
|
* expected that the SCI User will call this completion handler
|
|
* anytime the interrupt handler reports that it has handled an
|
|
* interrupt.
|
|
*
|
|
* @param[in] controller
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_legacy_completion_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_legacy_completion_handler(0x%d) enter\n",
|
|
controller
|
|
));
|
|
|
|
scic_sds_controller_polling_completion_handler(controller);
|
|
|
|
SMU_IMR_WRITE(this_controller, 0x00000000);
|
|
|
|
#ifdef IMR_READ_FENCE
|
|
{
|
|
volatile U32 int_mask_value = 0;
|
|
ULONG count = 0;
|
|
|
|
/*
|
|
* Temporary code since we have seen with legacy interrupts
|
|
* that interrupts are still masked after clearing the mask
|
|
* above. This may be an Arlington problem or it may be an
|
|
* old driver problem. Presently this code is turned off
|
|
* since we have not seen this problem recently.
|
|
*/
|
|
do
|
|
{
|
|
int_mask_value = SMU_IMR_READ(this_controler);
|
|
|
|
if (count++ > 10)
|
|
{
|
|
#ifdef ALLOW_ENTER_DEBUGGER
|
|
__debugbreak();
|
|
#endif
|
|
break;
|
|
}
|
|
} while (int_mask_value != 0);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* @brief This is the method provided to handle an MSIX interrupt message
|
|
* when there is just a single MSIX message being provided by the
|
|
* hardware. This mode of operation is single vector mode.
|
|
*
|
|
* @param[in] controller
|
|
*
|
|
* @return BOOL
|
|
* @retval TRUE if an interrupt is processed
|
|
* FALSE if no interrupt was processed
|
|
*/
|
|
static
|
|
BOOL scic_sds_controller_single_vector_interrupt_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
U32 interrupt_status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
// Mask the interrupts
|
|
// There is a race in the hardware that could cause us not to be notified
|
|
// of an interrupt completion if we do not take this step. We will unmask
|
|
// the interrupts in the completion routine.
|
|
SMU_IMR_WRITE(this_controller, 0xFFFFFFFF);
|
|
|
|
interrupt_status = SMU_ISR_READ(this_controller);
|
|
interrupt_status &= (SMU_ISR_QUEUE_ERROR | SMU_ISR_QUEUE_SUSPEND);
|
|
|
|
if (
|
|
(interrupt_status == 0)
|
|
&& scic_sds_controller_completion_queue_has_entries(this_controller)
|
|
)
|
|
{
|
|
// There is at least one completion queue entry to process so we can
|
|
// return a success and ignore for now the case of an error interrupt
|
|
SMU_ISR_WRITE(this_controller, SMU_ISR_COMPLETION);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
if (interrupt_status != 0)
|
|
{
|
|
// There is an error interrupt pending so let it through and handle
|
|
// in the callback
|
|
return TRUE;
|
|
}
|
|
|
|
// Clear any offending interrupts since we could not find any to handle
|
|
// and unmask them all
|
|
SMU_ISR_WRITE(this_controller, 0x00000000);
|
|
SMU_IMR_WRITE(this_controller, 0x00000000);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* @brief This is the method provided to handle completions for a single
|
|
* MSIX message.
|
|
*
|
|
* @param[in] controller
|
|
*/
|
|
static
|
|
void scic_sds_controller_single_vector_completion_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
U32 interrupt_status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_single_vector_completion_handler(0x%d) enter\n",
|
|
controller
|
|
));
|
|
|
|
interrupt_status = SMU_ISR_READ(this_controller);
|
|
interrupt_status &= (SMU_ISR_QUEUE_ERROR | SMU_ISR_QUEUE_SUSPEND);
|
|
|
|
if (interrupt_status & SMU_ISR_QUEUE_ERROR)
|
|
{
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller has encountered a fatal error.\n"
|
|
));
|
|
|
|
// We have a fatal condition and must reset the controller
|
|
// Leave the interrupt mask in place and get the controller reset
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_FAILED
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (
|
|
(interrupt_status & SMU_ISR_QUEUE_SUSPEND)
|
|
&& !scic_sds_controller_completion_queue_has_entries(this_controller)
|
|
)
|
|
{
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller has encountered a fatal error.\n"
|
|
));
|
|
|
|
// We have a fatal condtion and must reset the controller
|
|
// Leave the interrupt mask in place and get the controller reset
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_FAILED
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (scic_sds_controller_completion_queue_has_entries(this_controller))
|
|
{
|
|
scic_sds_controller_process_completions(this_controller);
|
|
|
|
// We dont care which interrupt got us to processing the completion queu
|
|
// so clear them both.
|
|
SMU_ISR_WRITE(
|
|
this_controller,
|
|
(SMU_ISR_COMPLETION | SMU_ISR_QUEUE_SUSPEND)
|
|
);
|
|
}
|
|
|
|
SMU_IMR_WRITE(this_controller, 0x00000000);
|
|
}
|
|
|
|
/**
|
|
* @brief This is the method provided to handle a MSIX message for a normal
|
|
* completion.
|
|
*
|
|
* @param[in] controller
|
|
*
|
|
* @return BOOL
|
|
* @retval TRUE if an interrupt is processed
|
|
* FALSE if no interrupt was processed
|
|
*/
|
|
static
|
|
BOOL scic_sds_controller_normal_vector_interrupt_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
if (scic_sds_controller_completion_queue_has_entries(this_controller))
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
// we have a spurious interrupt it could be that we have already
|
|
// emptied the completion queue from a previous interrupt
|
|
SMU_ISR_WRITE(this_controller, SMU_ISR_COMPLETION);
|
|
|
|
// There is a race in the hardware that could cause us not to be notified
|
|
// of an interrupt completion if we do not take this step. We will mask
|
|
// then unmask the interrupts so if there is another interrupt pending
|
|
// the clearing of the interrupt source we get the next interrupt message.
|
|
SMU_IMR_WRITE(this_controller, 0xFF000000);
|
|
SMU_IMR_WRITE(this_controller, 0x00000000);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* @brief This is the method provided to handle the completions for a
|
|
* normal MSIX message.
|
|
*
|
|
* @param[in] controller
|
|
*/
|
|
static
|
|
void scic_sds_controller_normal_vector_completion_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_normal_vector_completion_handler(0x%d) enter\n",
|
|
controller
|
|
));
|
|
|
|
// Empty out the completion queue
|
|
if (scic_sds_controller_completion_queue_has_entries(this_controller))
|
|
{
|
|
scic_sds_controller_process_completions(this_controller);
|
|
}
|
|
|
|
// Clear the interrupt and enable all interrupts again
|
|
SMU_ISR_WRITE(this_controller, SMU_ISR_COMPLETION);
|
|
// Could we write the value of SMU_ISR_COMPLETION?
|
|
SMU_IMR_WRITE(this_controller, 0xFF000000);
|
|
SMU_IMR_WRITE(this_controller, 0x00000000);
|
|
}
|
|
|
|
/**
|
|
* @brief This is the method provided to handle the error MSIX message
|
|
* interrupt. This is the normal operating mode for the hardware if
|
|
* MSIX is enabled.
|
|
*
|
|
* @param[in] controller
|
|
*
|
|
* @return BOOL
|
|
* @retval TRUE if an interrupt is processed
|
|
* FALSE if no interrupt was processed
|
|
*/
|
|
static
|
|
BOOL scic_sds_controller_error_vector_interrupt_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
U32 interrupt_status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
|
|
interrupt_status = SMU_ISR_READ(this_controller);
|
|
interrupt_status &= (SMU_ISR_QUEUE_ERROR | SMU_ISR_QUEUE_SUSPEND);
|
|
|
|
if (interrupt_status != 0)
|
|
{
|
|
// There is an error interrupt pending so let it through and handle
|
|
// in the callback
|
|
return TRUE;
|
|
}
|
|
|
|
// There is a race in the hardware that could cause us not to be notified
|
|
// of an interrupt completion if we do not take this step. We will mask
|
|
// then unmask the error interrupts so if there was another interrupt
|
|
// pending we will be notified.
|
|
// Could we write the value of (SMU_ISR_QUEUE_ERROR | SMU_ISR_QUEUE_SUSPEND)?
|
|
SMU_IMR_WRITE(this_controller, 0x000000FF);
|
|
SMU_IMR_WRITE(this_controller, 0x00000000);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* @brief This is the method provided to handle the error completions when
|
|
* the hardware is using two MSIX messages.
|
|
*
|
|
* @param[in] controller
|
|
*/
|
|
static
|
|
void scic_sds_controller_error_vector_completion_handler(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
U32 interrupt_status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_error_vector_completion_handler(0x%d) enter\n",
|
|
controller
|
|
));
|
|
|
|
interrupt_status = SMU_ISR_READ(this_controller);
|
|
|
|
if (
|
|
(interrupt_status & SMU_ISR_QUEUE_SUSPEND)
|
|
&& scic_sds_controller_completion_queue_has_entries(this_controller)
|
|
)
|
|
{
|
|
scic_sds_controller_process_completions(this_controller);
|
|
|
|
SMU_ISR_WRITE(this_controller, SMU_ISR_QUEUE_SUSPEND);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller reports CRC error on completion ISR %x\n",
|
|
interrupt_status
|
|
));
|
|
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_FAILED
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
// If we dont process any completions I am not sure that we want to do this.
|
|
// We are in the middle of a hardware fault and should probably be reset.
|
|
SMU_IMR_WRITE(this_controller, 0x00000000);
|
|
}
|
|
|
|
#endif // !defined(DISABLE_INTERRUPTS)
|
|
|
|
//****************************************************************************-
|
|
//* SCIC SDS Controller External Methods
|
|
//****************************************************************************-
|
|
|
|
/**
|
|
* @brief This method returns the sizeof the SCIC SDS Controller Object
|
|
*
|
|
* @return U32
|
|
*/
|
|
U32 scic_sds_controller_get_object_size(void)
|
|
{
|
|
return sizeof(SCIC_SDS_CONTROLLER_T);
|
|
}
|
|
|
|
/**
|
|
* This method returns the minimum number of timers that are required by the
|
|
* controller object. This will include required timers for phys and ports.
|
|
*
|
|
* @return U32
|
|
* @retval The minimum number of timers that are required to make this
|
|
* controller operational.
|
|
*/
|
|
U32 scic_sds_controller_get_min_timer_count(void)
|
|
{
|
|
return SCIC_SDS_CONTROLLER_MIN_TIMER_COUNT
|
|
+ scic_sds_port_get_min_timer_count()
|
|
+ scic_sds_phy_get_min_timer_count();
|
|
}
|
|
|
|
/**
|
|
* This method returns the maximum number of timers that are required by the
|
|
* controller object. This will include required timers for phys and ports.
|
|
*
|
|
* @return U32
|
|
* @retval The maximum number of timers that will be used by the controller
|
|
* object
|
|
*/
|
|
U32 scic_sds_controller_get_max_timer_count(void)
|
|
{
|
|
return SCIC_SDS_CONTROLLER_MAX_TIMER_COUNT
|
|
+ scic_sds_port_get_max_timer_count()
|
|
+ scic_sds_phy_get_max_timer_count();
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] the_port
|
|
* @param[in] the_phy
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_controller_link_up(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_PORT_T *the_port,
|
|
SCIC_SDS_PHY_T *the_phy
|
|
)
|
|
{
|
|
if (this_controller->state_handlers->link_up_handler != NULL)
|
|
{
|
|
this_controller->state_handlers->link_up_handler(
|
|
this_controller, the_port, the_phy);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_INFO((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller linkup event from phy %d in unexpected state %d\n",
|
|
the_phy->phy_index,
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] the_port
|
|
* @param[in] the_phy
|
|
*/
|
|
void scic_sds_controller_link_down(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_PORT_T *the_port,
|
|
SCIC_SDS_PHY_T *the_phy
|
|
)
|
|
{
|
|
if (this_controller->state_handlers->link_down_handler != NULL)
|
|
{
|
|
this_controller->state_handlers->link_down_handler(
|
|
this_controller, the_port, the_phy);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_INFO((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller linkdown event from phy %d in unexpected state %d\n",
|
|
the_phy->phy_index,
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method is called by the remote device to inform the controller
|
|
* that this remote device has started.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] the_device
|
|
*/
|
|
void scic_sds_controller_remote_device_started(
|
|
SCIC_SDS_CONTROLLER_T * this_controller,
|
|
SCIC_SDS_REMOTE_DEVICE_T * the_device
|
|
)
|
|
{
|
|
if (this_controller->state_handlers->remote_device_started_handler != NULL)
|
|
{
|
|
this_controller->state_handlers->remote_device_started_handler(
|
|
this_controller, the_device
|
|
);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_INFO((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller 0x%x remote device started event from device 0x%x in unexpected state %d\n",
|
|
this_controller,
|
|
the_device,
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This is a helper method to determine if any remote devices on this
|
|
* controller are still in the stopping state.
|
|
*
|
|
* @param[in] this_controller
|
|
*/
|
|
BOOL scic_sds_controller_has_remote_devices_stopping(
|
|
SCIC_SDS_CONTROLLER_T * this_controller
|
|
)
|
|
{
|
|
U32 index;
|
|
|
|
for (index = 0; index < this_controller->remote_node_entries; index++)
|
|
{
|
|
if (
|
|
(this_controller->device_table[index] != NULL)
|
|
&& (
|
|
this_controller->device_table[index]->parent.state_machine.current_state_id
|
|
== SCI_BASE_REMOTE_DEVICE_STATE_STOPPING
|
|
)
|
|
)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* @brief This method is called by the remote device to inform the controller
|
|
* object that the remote device has stopped.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] the_device
|
|
*/
|
|
void scic_sds_controller_remote_device_stopped(
|
|
SCIC_SDS_CONTROLLER_T * this_controller,
|
|
SCIC_SDS_REMOTE_DEVICE_T * the_device
|
|
)
|
|
{
|
|
if (this_controller->state_handlers->remote_device_stopped_handler != NULL)
|
|
{
|
|
this_controller->state_handlers->remote_device_stopped_handler(
|
|
this_controller, the_device
|
|
);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_INFO((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller 0x%x remote device stopped event from device 0x%x in unexpected state %d\n",
|
|
this_controller,
|
|
the_device,
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method will write to the SCU PCP register the request value.
|
|
* The method is used to suspend/resume ports, devices, and phys.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] request
|
|
*/
|
|
void scic_sds_controller_post_request(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U32 request
|
|
)
|
|
{
|
|
SCIC_LOG_INFO((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER | SCIC_LOG_OBJECT_COMPLETION_QUEUE,
|
|
"SCIC Controller 0x%08x post request 0x%08x\n",
|
|
this_controller, request
|
|
));
|
|
|
|
SMU_PCP_WRITE(this_controller, request);
|
|
}
|
|
|
|
/**
|
|
* @brief This method will copy the soft copy of the task context into
|
|
* the physical memory accessible by the controller.
|
|
*
|
|
* @note After this call is made the SCIC_SDS_IO_REQUEST object will
|
|
* always point to the physical memory version of the task context.
|
|
* Thus, all subsequent updates to the task context are performed in
|
|
* the TC table (i.e. DMAable memory).
|
|
*
|
|
* @param[in] this_controller This parameter specifies the controller for
|
|
* which to copy the task context.
|
|
* @param[in] this_request This parameter specifies the request for which
|
|
* the task context is being copied.
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_controller_copy_task_context(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_REQUEST_T *this_request
|
|
)
|
|
{
|
|
SCU_TASK_CONTEXT_T *task_context_buffer;
|
|
|
|
task_context_buffer = scic_sds_controller_get_task_context_buffer(
|
|
this_controller, this_request->io_tag
|
|
);
|
|
|
|
memcpy(
|
|
task_context_buffer,
|
|
this_request->task_context_buffer,
|
|
SCI_FIELD_OFFSET(SCU_TASK_CONTEXT_T, sgl_snapshot_ac)
|
|
);
|
|
|
|
// Now that the soft copy of the TC has been copied into the TC
|
|
// table accessible by the silicon. Thus, any further changes to
|
|
// the TC (e.g. TC termination) occur in the appropriate location.
|
|
this_request->task_context_buffer = task_context_buffer;
|
|
}
|
|
|
|
/**
|
|
* @brief This method returns the task context buffer for the given io tag.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] io_tag
|
|
*
|
|
* @return struct SCU_TASK_CONTEXT*
|
|
*/
|
|
SCU_TASK_CONTEXT_T * scic_sds_controller_get_task_context_buffer(
|
|
SCIC_SDS_CONTROLLER_T * this_controller,
|
|
U16 io_tag
|
|
)
|
|
{
|
|
U16 task_index = scic_sds_io_tag_get_index(io_tag);
|
|
|
|
if (task_index < this_controller->task_context_entries)
|
|
{
|
|
return &this_controller->task_context_table[task_index];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* @brief This method returnst the sequence value from the io tag value
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] io_tag
|
|
*
|
|
* @return U16
|
|
*/
|
|
U16 scic_sds_controller_get_io_sequence_from_tag(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U16 io_tag
|
|
)
|
|
{
|
|
return scic_sds_io_tag_get_sequence(io_tag);
|
|
}
|
|
|
|
/**
|
|
* @brief This method returns the IO request associated with the tag value
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] io_tag
|
|
*
|
|
* @return SCIC_SDS_IO_REQUEST_T*
|
|
* @retval NULL if there is no valid IO request at the tag value
|
|
*/
|
|
SCIC_SDS_REQUEST_T *scic_sds_controller_get_io_request_from_tag(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U16 io_tag
|
|
)
|
|
{
|
|
U16 task_index;
|
|
U16 task_sequence;
|
|
|
|
task_index = scic_sds_io_tag_get_index(io_tag);
|
|
|
|
if (task_index < this_controller->task_context_entries)
|
|
{
|
|
if (this_controller->io_request_table[task_index] != SCI_INVALID_HANDLE)
|
|
{
|
|
task_sequence = scic_sds_io_tag_get_sequence(io_tag);
|
|
|
|
if (task_sequence == this_controller->io_request_sequence[task_index])
|
|
{
|
|
return this_controller->io_request_table[task_index];
|
|
}
|
|
}
|
|
}
|
|
|
|
return SCI_INVALID_HANDLE;
|
|
}
|
|
|
|
/**
|
|
* @brief This method allocates remote node index and the reserves the
|
|
* remote node context space for use. This method can fail if there
|
|
* are no more remote node index available.
|
|
*
|
|
* @param[in] this_controller This is the controller object which contains
|
|
* the set of free remote node ids
|
|
* @param[in] the_devce This is the device object which is requesting the a
|
|
* remote node id
|
|
* @param[out] node_id This is the remote node id that is assinged to the
|
|
* device if one is available
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_FAILURE_OUT_OF_RESOURCES if there are no available remote
|
|
* node index available.
|
|
*/
|
|
SCI_STATUS scic_sds_controller_allocate_remote_node_context(
|
|
SCIC_SDS_CONTROLLER_T * this_controller,
|
|
SCIC_SDS_REMOTE_DEVICE_T * the_device,
|
|
U16 * node_id
|
|
)
|
|
{
|
|
U16 node_index;
|
|
U32 remote_node_count = scic_sds_remote_device_node_count(the_device);
|
|
|
|
node_index = scic_sds_remote_node_table_allocate_remote_node(
|
|
&this_controller->available_remote_nodes, remote_node_count
|
|
);
|
|
|
|
if (node_index != SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
|
|
{
|
|
this_controller->device_table[node_index] = the_device;
|
|
|
|
*node_id = node_index;
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
return SCI_FAILURE_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
/**
|
|
* @brief This method frees the remote node index back to the available
|
|
* pool. Once this is done the remote node context buffer is no
|
|
* longer valid and can not be used.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] the_device
|
|
* @param[in] node_id
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_controller_free_remote_node_context(
|
|
SCIC_SDS_CONTROLLER_T * this_controller,
|
|
SCIC_SDS_REMOTE_DEVICE_T * the_device,
|
|
U16 node_id
|
|
)
|
|
{
|
|
U32 remote_node_count = scic_sds_remote_device_node_count(the_device);
|
|
|
|
if (this_controller->device_table[node_id] == the_device)
|
|
{
|
|
this_controller->device_table[node_id] = SCI_INVALID_HANDLE;
|
|
|
|
scic_sds_remote_node_table_release_remote_node_index(
|
|
&this_controller->available_remote_nodes, remote_node_count, node_id
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method returns the SCU_REMOTE_NODE_CONTEXT for the specified
|
|
* remote node id.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] node_id
|
|
*
|
|
* @return SCU_REMOTE_NODE_CONTEXT_T*
|
|
*/
|
|
SCU_REMOTE_NODE_CONTEXT_T *scic_sds_controller_get_remote_node_context_buffer(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U16 node_id
|
|
)
|
|
{
|
|
if (
|
|
(node_id < this_controller->remote_node_entries)
|
|
&& (this_controller->device_table[node_id] != SCI_INVALID_HANDLE)
|
|
)
|
|
{
|
|
return &this_controller->remote_node_context_table[node_id];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* This method will combind the frame header and frame buffer to create
|
|
* a SATA D2H register FIS
|
|
*
|
|
* @param[out] resposne_buffer This is the buffer into which the D2H register
|
|
* FIS will be constructed.
|
|
* @param[in] frame_header This is the frame header returned by the hardware.
|
|
* @param[in] frame_buffer This is the frame buffer returned by the hardware.
|
|
*
|
|
* @erturn none
|
|
*/
|
|
void scic_sds_controller_copy_sata_response(
|
|
void * response_buffer,
|
|
void * frame_header,
|
|
void * frame_buffer
|
|
)
|
|
{
|
|
memcpy(
|
|
response_buffer,
|
|
frame_header,
|
|
sizeof(U32)
|
|
);
|
|
|
|
memcpy(
|
|
(char *)((char *)response_buffer + sizeof(U32)),
|
|
frame_buffer,
|
|
sizeof(SATA_FIS_REG_D2H_T) - sizeof(U32)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief This method releases the frame once this is done the frame is
|
|
* available for re-use by the hardware. The data contained in the
|
|
* frame header and frame buffer is no longer valid.
|
|
* The UF queue get pointer is only updated if UF control indicates
|
|
* this is appropriate.
|
|
*
|
|
* @param[in] this_controller
|
|
* @param[in] frame_index
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_controller_release_frame(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
U32 frame_index
|
|
)
|
|
{
|
|
if (scic_sds_unsolicited_frame_control_release_frame(
|
|
&this_controller->uf_control, frame_index) == TRUE)
|
|
SCU_UFQGP_WRITE(this_controller, this_controller->uf_control.get);
|
|
}
|
|
|
|
#ifdef SCI_LOGGING
|
|
void scic_sds_controller_initialize_state_logging(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
sci_base_state_machine_logger_initialize(
|
|
&this_controller->parent.state_machine_logger,
|
|
&this_controller->parent.state_machine,
|
|
&this_controller->parent.parent,
|
|
scic_cb_logger_log_states,
|
|
"SCIC_SDS_CONTROLLER_T", "base state machine",
|
|
SCIC_LOG_OBJECT_CONTROLLER
|
|
);
|
|
}
|
|
|
|
void scic_sds_controller_deinitialize_state_logging(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
sci_base_state_machine_logger_deinitialize(
|
|
&this_controller->parent.state_machine_logger,
|
|
&this_controller->parent.state_machine
|
|
);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief This method sets user parameters and OEM parameters to
|
|
* default values. Users can override these values utilizing
|
|
* the scic_user_parameters_set() and scic_oem_parameters_set()
|
|
* methods.
|
|
*
|
|
* @param[in] controller This parameter specifies the controller for
|
|
* which to set the configuration parameters to their
|
|
* default values.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_set_default_config_parameters(
|
|
SCIC_SDS_CONTROLLER_T *this_controller
|
|
)
|
|
{
|
|
U16 index;
|
|
|
|
// Default to APC mode.
|
|
this_controller->oem_parameters.sds1.controller.mode_type = SCIC_PORT_AUTOMATIC_CONFIGURATION_MODE;
|
|
|
|
// Default to 1
|
|
this_controller->oem_parameters.sds1.controller.max_number_concurrent_device_spin_up = 1;
|
|
|
|
// Default to no SSC operation.
|
|
this_controller->oem_parameters.sds1.controller.ssc_sata_tx_spread_level = 0;
|
|
this_controller->oem_parameters.sds1.controller.ssc_sas_tx_spread_level = 0;
|
|
this_controller->oem_parameters.sds1.controller.ssc_sas_tx_type = 0;
|
|
|
|
// Default to all phys to using short cables
|
|
this_controller->oem_parameters.sds1.controller.cable_selection_mask = 0;
|
|
|
|
// Initialize all of the port parameter information to narrow ports.
|
|
for (index = 0; index < SCI_MAX_PORTS; index++)
|
|
{
|
|
this_controller->oem_parameters.sds1.ports[index].phy_mask = 0;
|
|
}
|
|
|
|
// Initialize all of the phy parameter information.
|
|
for (index = 0; index < SCI_MAX_PHYS; index++)
|
|
{
|
|
// Default to 6G (i.e. Gen 3) for now. User can override if
|
|
// they choose.
|
|
this_controller->user_parameters.sds1.phys[index].max_speed_generation = 2;
|
|
|
|
//the frequencies cannot be 0
|
|
this_controller->user_parameters.sds1.phys[index].align_insertion_frequency = 0x7f;
|
|
this_controller->user_parameters.sds1.phys[index].in_connection_align_insertion_frequency = 0xff;
|
|
this_controller->user_parameters.sds1.phys[index].notify_enable_spin_up_insertion_frequency = 0x33;
|
|
|
|
// Previous Vitesse based expanders had a arbitration issue that
|
|
// is worked around by having the upper 32-bits of SAS address
|
|
// with a value greater then the Vitesse company identifier.
|
|
// Hence, usage of 0x5FCFFFFF.
|
|
this_controller->oem_parameters.sds1.phys[index].sas_address.sci_format.high
|
|
= 0x5FCFFFFF;
|
|
|
|
// Add in controller index to ensure each controller will have unique SAS addresses by default.
|
|
this_controller->oem_parameters.sds1.phys[index].sas_address.sci_format.low
|
|
= 0x00000001 + this_controller->controller_index;
|
|
|
|
if ( (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A0)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_A2)
|
|
|| (this_controller->pci_revision == SCIC_SDS_PCI_REVISION_B0) )
|
|
{
|
|
this_controller->oem_parameters.sds1.phys[index].afe_tx_amp_control0 = 0x000E7C03;
|
|
this_controller->oem_parameters.sds1.phys[index].afe_tx_amp_control1 = 0x000E7C03;
|
|
this_controller->oem_parameters.sds1.phys[index].afe_tx_amp_control2 = 0x000E7C03;
|
|
this_controller->oem_parameters.sds1.phys[index].afe_tx_amp_control3 = 0x000E7C03;
|
|
}
|
|
else // This must be SCIC_SDS_PCI_REVISION_C0
|
|
{
|
|
this_controller->oem_parameters.sds1.phys[index].afe_tx_amp_control0 = 0x000BDD08;
|
|
this_controller->oem_parameters.sds1.phys[index].afe_tx_amp_control1 = 0x000B7069;
|
|
this_controller->oem_parameters.sds1.phys[index].afe_tx_amp_control2 = 0x000B7C09;
|
|
this_controller->oem_parameters.sds1.phys[index].afe_tx_amp_control3 = 0x000AFC6E;
|
|
}
|
|
}
|
|
|
|
this_controller->user_parameters.sds1.stp_inactivity_timeout = 5;
|
|
this_controller->user_parameters.sds1.ssp_inactivity_timeout = 5;
|
|
this_controller->user_parameters.sds1.stp_max_occupancy_timeout = 5;
|
|
this_controller->user_parameters.sds1.ssp_max_occupancy_timeout = 20;
|
|
this_controller->user_parameters.sds1.no_outbound_task_timeout = 20;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief This method release resources in SCI controller.
|
|
*
|
|
* @param[in] this_controller This parameter specifies the core
|
|
* controller and associated objects whose resources are to be
|
|
* released.
|
|
*
|
|
* @return This method returns a value indicating if the operation succeeded.
|
|
* @retval SCI_SUCCESS This value indicates that all the timers are destroyed.
|
|
* @retval SCI_FAILURE This value indicates certain failure during the process
|
|
* of cleaning timer resource.
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_release_resource(
|
|
SCIC_SDS_CONTROLLER_T * this_controller
|
|
)
|
|
{
|
|
SCIC_SDS_PORT_T * port;
|
|
SCIC_SDS_PHY_T * phy;
|
|
U8 index;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER | SCIC_LOG_OBJECT_INITIALIZATION,
|
|
"scic_sds_controller_release_resource(0x%x) enter\n",
|
|
this_controller
|
|
));
|
|
|
|
if(this_controller->phy_startup_timer != NULL)
|
|
{
|
|
scic_cb_timer_destroy(this_controller, this_controller->phy_startup_timer);
|
|
this_controller->phy_startup_timer = NULL;
|
|
}
|
|
|
|
if(this_controller->power_control.timer != NULL)
|
|
{
|
|
scic_cb_timer_destroy(this_controller, this_controller->power_control.timer);
|
|
this_controller->power_control.timer = NULL;
|
|
}
|
|
|
|
if(this_controller->timeout_timer != NULL)
|
|
{
|
|
scic_cb_timer_destroy(this_controller, this_controller->timeout_timer);
|
|
this_controller->timeout_timer = NULL;
|
|
}
|
|
|
|
scic_sds_port_configuration_agent_release_resource(
|
|
this_controller,
|
|
&this_controller->port_agent);
|
|
|
|
for(index = 0; index < SCI_MAX_PORTS+1; index++)
|
|
{
|
|
port = &this_controller->port_table[index];
|
|
scic_sds_port_release_resource(this_controller, port);
|
|
}
|
|
|
|
for(index = 0; index < SCI_MAX_PHYS; index++)
|
|
{
|
|
phy = &this_controller->phy_table[index];
|
|
scic_sds_phy_release_resource(this_controller, phy);
|
|
}
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief This method process the ports configured message from port configuration
|
|
* agent.
|
|
*
|
|
* @param[in] this_controller This parameter specifies the core
|
|
* controller that its ports are configured.
|
|
*
|
|
* @return None.
|
|
*/
|
|
void scic_sds_controller_port_agent_configured_ports(
|
|
SCIC_SDS_CONTROLLER_T * this_controller
|
|
)
|
|
{
|
|
//simply transit to ready. The function below checks the controller state
|
|
scic_sds_controller_transition_to_ready(
|
|
this_controller, SCI_SUCCESS
|
|
);
|
|
}
|
|
|
|
|
|
//****************************************************************************-
|
|
//* SCIC Controller Public Methods
|
|
//****************************************************************************-
|
|
|
|
SCI_STATUS scic_controller_construct(
|
|
SCI_LIBRARY_HANDLE_T library,
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
void * user_object
|
|
)
|
|
{
|
|
SCIC_SDS_LIBRARY_T *my_library;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
|
|
my_library = (SCIC_SDS_LIBRARY_T *)library;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(library),
|
|
SCIC_LOG_OBJECT_CONTROLLER | SCIC_LOG_OBJECT_INITIALIZATION,
|
|
"scic_controller_construct(0x%x, 0x%x) enter\n",
|
|
library, controller
|
|
));
|
|
|
|
// Just clear out the memory of the structure to be safe.
|
|
memset(this_controller, 0, sizeof(SCIC_SDS_CONTROLLER_T));
|
|
|
|
// Make sure that the static data is assigned before moving onto the
|
|
// base constroller construct as this will cause the controller to
|
|
// enter its initial state and the controller_index and pci_revision
|
|
// will be required to complete those operations correctly
|
|
this_controller->controller_index =
|
|
scic_sds_library_get_controller_index(my_library, this_controller);
|
|
|
|
this_controller->pci_revision = my_library->pci_revision;
|
|
|
|
sci_base_controller_construct(
|
|
&this_controller->parent,
|
|
sci_base_object_get_logger(my_library),
|
|
scic_sds_controller_state_table,
|
|
this_controller->memory_descriptors,
|
|
ARRAY_SIZE(this_controller->memory_descriptors),
|
|
NULL
|
|
);
|
|
|
|
sci_object_set_association(controller, user_object);
|
|
|
|
scic_sds_controller_initialize_state_logging(this_controller);
|
|
|
|
scic_sds_pci_bar_initialization(this_controller);
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_initialize(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCI_STATUS status = SCI_FAILURE_INVALID_STATE;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_initialize(0x%x, 0x%d) enter\n",
|
|
controller
|
|
));
|
|
|
|
if (this_controller->state_handlers->parent.initialize_handler != NULL)
|
|
{
|
|
status = this_controller->state_handlers->parent.initialize_handler(
|
|
(SCI_BASE_CONTROLLER_T *)controller
|
|
);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller initialize operation requested in invalid state %d\n",
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
U32 scic_controller_get_suggested_start_timeout(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
// Validate the user supplied parameters.
|
|
if (controller == SCI_INVALID_HANDLE)
|
|
return 0;
|
|
|
|
// The suggested minimum timeout value for a controller start operation:
|
|
//
|
|
// Signature FIS Timeout
|
|
// + Phy Start Timeout
|
|
// + Number of Phy Spin Up Intervals
|
|
// ---------------------------------
|
|
// Number of milliseconds for the controller start operation.
|
|
//
|
|
// NOTE: The number of phy spin up intervals will be equivalent
|
|
// to the number of phys divided by the number phys allowed
|
|
// per interval - 1 (once OEM parameters are supported).
|
|
// Currently we assume only 1 phy per interval.
|
|
|
|
return (SCIC_SDS_SIGNATURE_FIS_TIMEOUT
|
|
+ SCIC_SDS_CONTROLLER_PHY_START_TIMEOUT
|
|
+ ((SCI_MAX_PHYS-1) * SCIC_SDS_CONTROLLER_POWER_CONTROL_INTERVAL));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_start(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U32 timeout
|
|
)
|
|
{
|
|
SCI_STATUS status = SCI_FAILURE_INVALID_STATE;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_start(0x%x, 0x%d) enter\n",
|
|
controller, timeout
|
|
));
|
|
|
|
if (this_controller->state_handlers->parent.start_handler != NULL)
|
|
{
|
|
status = this_controller->state_handlers->parent.start_handler(
|
|
(SCI_BASE_CONTROLLER_T *)controller, timeout
|
|
);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller start operation requested in invalid state %d\n",
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_stop(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U32 timeout
|
|
)
|
|
{
|
|
SCI_STATUS status = SCI_FAILURE_INVALID_STATE;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_stop(0x%x, 0x%d) enter\n",
|
|
controller, timeout
|
|
));
|
|
|
|
if (this_controller->state_handlers->parent.stop_handler != NULL)
|
|
{
|
|
status = this_controller->state_handlers->parent.stop_handler(
|
|
(SCI_BASE_CONTROLLER_T *)controller, timeout
|
|
);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller stop operation requested in invalid state %d\n",
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_reset(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCI_STATUS status = SCI_FAILURE_INVALID_STATE;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_reset(0x%x) enter\n",
|
|
controller
|
|
));
|
|
|
|
if (this_controller->state_handlers->parent.reset_handler != NULL)
|
|
{
|
|
status = this_controller->state_handlers->parent.reset_handler(
|
|
(SCI_BASE_CONTROLLER_T *)controller
|
|
);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller reset operation requested in invalid state %d\n",
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_get_handler_methods(
|
|
SCIC_INTERRUPT_TYPE interrupt_type,
|
|
U16 message_count,
|
|
SCIC_CONTROLLER_HANDLER_METHODS_T *handler_methods
|
|
)
|
|
{
|
|
SCI_STATUS status = SCI_FAILURE_UNSUPPORTED_MESSAGE_COUNT;
|
|
|
|
switch (interrupt_type)
|
|
{
|
|
#if !defined(DISABLE_INTERRUPTS)
|
|
case SCIC_LEGACY_LINE_INTERRUPT_TYPE:
|
|
if (message_count == 0)
|
|
{
|
|
handler_methods[0].interrupt_handler
|
|
= scic_sds_controller_legacy_interrupt_handler;
|
|
handler_methods[0].completion_handler
|
|
= scic_sds_controller_legacy_completion_handler;
|
|
|
|
status = SCI_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case SCIC_MSIX_INTERRUPT_TYPE:
|
|
if (message_count == 1)
|
|
{
|
|
handler_methods[0].interrupt_handler
|
|
= scic_sds_controller_single_vector_interrupt_handler;
|
|
handler_methods[0].completion_handler
|
|
= scic_sds_controller_single_vector_completion_handler;
|
|
|
|
status = SCI_SUCCESS;
|
|
}
|
|
else if (message_count == 2)
|
|
{
|
|
handler_methods[0].interrupt_handler
|
|
= scic_sds_controller_normal_vector_interrupt_handler;
|
|
handler_methods[0].completion_handler
|
|
= scic_sds_controller_normal_vector_completion_handler;
|
|
|
|
handler_methods[1].interrupt_handler
|
|
= scic_sds_controller_error_vector_interrupt_handler;
|
|
handler_methods[1].completion_handler
|
|
= scic_sds_controller_error_vector_completion_handler;
|
|
|
|
status = SCI_SUCCESS;
|
|
}
|
|
break;
|
|
#endif // !defined(DISABLE_INTERRUPTS)
|
|
|
|
case SCIC_NO_INTERRUPTS:
|
|
if (message_count == 0)
|
|
{
|
|
|
|
handler_methods[0].interrupt_handler
|
|
= scic_sds_controller_polling_interrupt_handler;
|
|
handler_methods[0].completion_handler
|
|
= scic_sds_controller_polling_completion_handler;
|
|
|
|
status = SCI_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
status = SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_IO_STATUS scic_controller_start_io(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCI_REMOTE_DEVICE_HANDLE_T remote_device,
|
|
SCI_IO_REQUEST_HANDLE_T io_request,
|
|
U16 io_tag
|
|
)
|
|
{
|
|
SCI_STATUS status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_start_io(0x%x, 0x%x, 0x%x, 0x%x) enter\n",
|
|
controller, remote_device, io_request, io_tag
|
|
));
|
|
|
|
status = this_controller->state_handlers->parent.start_io_handler(
|
|
&this_controller->parent,
|
|
(SCI_BASE_REMOTE_DEVICE_T *)remote_device,
|
|
(SCI_BASE_REQUEST_T *)io_request,
|
|
io_tag
|
|
);
|
|
|
|
return (SCI_IO_STATUS)status;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_terminate_request(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCI_REMOTE_DEVICE_HANDLE_T remote_device,
|
|
SCI_IO_REQUEST_HANDLE_T request
|
|
)
|
|
{
|
|
SCI_STATUS status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_terminate_request(0x%x, 0x%x, 0x%x) enter\n",
|
|
controller, remote_device, request
|
|
));
|
|
|
|
status = this_controller->state_handlers->terminate_request_handler(
|
|
&this_controller->parent,
|
|
(SCI_BASE_REMOTE_DEVICE_T *)remote_device,
|
|
(SCI_BASE_REQUEST_T *)request
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_complete_io(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCI_REMOTE_DEVICE_HANDLE_T remote_device,
|
|
SCI_IO_REQUEST_HANDLE_T io_request
|
|
)
|
|
{
|
|
SCI_STATUS status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_complete_io(0x%x, 0x%x, 0x%x) enter\n",
|
|
controller, remote_device, io_request
|
|
));
|
|
|
|
status = this_controller->state_handlers->parent.complete_io_handler(
|
|
&this_controller->parent,
|
|
(SCI_BASE_REMOTE_DEVICE_T *)remote_device,
|
|
(SCI_BASE_REQUEST_T *)io_request
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#if !defined(DISABLE_TASK_MANAGEMENT)
|
|
|
|
SCI_TASK_STATUS scic_controller_start_task(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCI_REMOTE_DEVICE_HANDLE_T remote_device,
|
|
SCI_TASK_REQUEST_HANDLE_T task_request,
|
|
U16 task_tag
|
|
)
|
|
{
|
|
SCI_STATUS status = SCI_FAILURE_INVALID_STATE;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_start_task(0x%x, 0x%x, 0x%x, 0x%x) enter\n",
|
|
controller, remote_device, task_request, task_tag
|
|
));
|
|
|
|
if (this_controller->state_handlers->parent.start_task_handler != NULL)
|
|
{
|
|
status = this_controller->state_handlers->parent.start_task_handler(
|
|
&this_controller->parent,
|
|
(SCI_BASE_REMOTE_DEVICE_T *)remote_device,
|
|
(SCI_BASE_REQUEST_T *)task_request,
|
|
task_tag
|
|
);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_INFO((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller starting task from invalid state\n"
|
|
));
|
|
}
|
|
|
|
return (SCI_TASK_STATUS)status;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_complete_task(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCI_REMOTE_DEVICE_HANDLE_T remote_device,
|
|
SCI_TASK_REQUEST_HANDLE_T task_request
|
|
)
|
|
{
|
|
SCI_STATUS status = SCI_FAILURE_INVALID_STATE;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_complete_task(0x%x, 0x%x, 0x%x) enter\n",
|
|
controller, remote_device, task_request
|
|
));
|
|
|
|
if (this_controller->state_handlers->parent.complete_task_handler != NULL)
|
|
{
|
|
status = this_controller->state_handlers->parent.complete_task_handler(
|
|
&this_controller->parent,
|
|
(SCI_BASE_REMOTE_DEVICE_T *)remote_device,
|
|
(SCI_BASE_REQUEST_T *)task_request
|
|
);
|
|
}
|
|
else
|
|
{
|
|
SCIC_LOG_INFO((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller completing task from invalid state\n"
|
|
));
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
#endif // !defined(DISABLE_TASK_MANAGEMENT)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_get_port_handle(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U8 port_index,
|
|
SCI_PORT_HANDLE_T * port_handle
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_get_port_handle(0x%x, 0x%x, 0x%x) enter\n",
|
|
controller, port_index, port_handle
|
|
));
|
|
|
|
if (port_index < this_controller->logical_port_entries)
|
|
{
|
|
*port_handle = &this_controller->port_table[port_index];
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
return SCI_FAILURE_INVALID_PORT;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_get_phy_handle(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U8 phy_index,
|
|
SCI_PHY_HANDLE_T * phy_handle
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_get_phy_handle(0x%x, 0x%x, 0x%x) enter\n",
|
|
controller, phy_index, phy_handle
|
|
));
|
|
|
|
if (phy_index < ARRAY_SIZE(this_controller->phy_table))
|
|
{
|
|
*phy_handle = &this_controller->phy_table[phy_index];
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
SCIC_LOG_ERROR((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_PORT | SCIC_LOG_OBJECT_CONTROLLER,
|
|
"Controller:0x%x PhyId:0x%x invalid phy index\n",
|
|
this_controller, phy_index
|
|
));
|
|
|
|
return SCI_FAILURE_INVALID_PHY;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
U16 scic_controller_allocate_io_tag(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
U16 task_context;
|
|
U16 sequence_count;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_allocate_io_tag(0x%x) enter\n",
|
|
controller
|
|
));
|
|
|
|
if (!sci_pool_empty(this_controller->tci_pool))
|
|
{
|
|
sci_pool_get(this_controller->tci_pool, task_context);
|
|
|
|
sequence_count = this_controller->io_request_sequence[task_context];
|
|
|
|
return scic_sds_io_tag_construct(sequence_count, task_context);
|
|
}
|
|
|
|
return SCI_CONTROLLER_INVALID_IO_TAG;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_free_io_tag(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U16 io_tag
|
|
)
|
|
{
|
|
U16 sequence;
|
|
U16 index;
|
|
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
ASSERT(io_tag != SCI_CONTROLLER_INVALID_IO_TAG);
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_free_io_tag(0x%x, 0x%x) enter\n",
|
|
controller, io_tag
|
|
));
|
|
|
|
sequence = scic_sds_io_tag_get_sequence(io_tag);
|
|
index = scic_sds_io_tag_get_index(io_tag);
|
|
|
|
if (!sci_pool_full(this_controller->tci_pool))
|
|
{
|
|
if (sequence == this_controller->io_request_sequence[index])
|
|
{
|
|
scic_sds_io_sequence_increment(
|
|
this_controller->io_request_sequence[index]);
|
|
|
|
sci_pool_put(this_controller->tci_pool, index);
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
}
|
|
|
|
return SCI_FAILURE_INVALID_IO_TAG;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void scic_controller_enable_interrupts(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
ASSERT(this_controller->smu_registers != NULL);
|
|
|
|
SMU_IMR_WRITE(this_controller, 0x00000000);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void scic_controller_disable_interrupts(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
ASSERT(this_controller->smu_registers != NULL);
|
|
|
|
SMU_IMR_WRITE(this_controller, 0xffffffff);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_set_mode(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCI_CONTROLLER_MODE operating_mode
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
SCI_STATUS status = SCI_SUCCESS;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_set_mode(0x%x, 0x%x) enter\n",
|
|
controller, operating_mode
|
|
));
|
|
|
|
if (
|
|
(this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_INITIALIZING)
|
|
|| (this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_INITIALIZED)
|
|
)
|
|
{
|
|
switch (operating_mode)
|
|
{
|
|
case SCI_MODE_SPEED:
|
|
this_controller->remote_node_entries =
|
|
MIN(this_controller->remote_node_entries, SCI_MAX_REMOTE_DEVICES);
|
|
this_controller->task_context_entries =
|
|
MIN(this_controller->task_context_entries, SCU_IO_REQUEST_COUNT);
|
|
this_controller->uf_control.buffers.count =
|
|
MIN(this_controller->uf_control.buffers.count, SCU_UNSOLICITED_FRAME_COUNT);
|
|
this_controller->completion_event_entries =
|
|
MIN(this_controller->completion_event_entries, SCU_EVENT_COUNT);
|
|
this_controller->completion_queue_entries =
|
|
MIN(this_controller->completion_queue_entries, SCU_COMPLETION_QUEUE_COUNT);
|
|
|
|
scic_sds_controller_build_memory_descriptor_table(this_controller);
|
|
break;
|
|
|
|
case SCI_MODE_SIZE:
|
|
this_controller->remote_node_entries =
|
|
MIN(this_controller->remote_node_entries, SCI_MIN_REMOTE_DEVICES);
|
|
this_controller->task_context_entries =
|
|
MIN(this_controller->task_context_entries, SCI_MIN_IO_REQUESTS);
|
|
this_controller->uf_control.buffers.count =
|
|
MIN(this_controller->uf_control.buffers.count, SCU_MIN_UNSOLICITED_FRAMES);
|
|
this_controller->completion_event_entries =
|
|
MIN(this_controller->completion_event_entries, SCU_MIN_EVENTS);
|
|
this_controller->completion_queue_entries =
|
|
MIN(this_controller->completion_queue_entries, SCU_MIN_COMPLETION_QUEUE_ENTRIES);
|
|
|
|
scic_sds_controller_build_memory_descriptor_table(this_controller);
|
|
break;
|
|
|
|
default:
|
|
status = SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
status = SCI_FAILURE_INVALID_STATE;
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* This method will reset the controller hardware.
|
|
*
|
|
* @param[in] this_controller The controller that is to be reset.
|
|
*/
|
|
void scic_sds_controller_reset_hardware(
|
|
SCIC_SDS_CONTROLLER_T * this_controller
|
|
)
|
|
{
|
|
// Disable interrupts so we dont take any spurious interrupts
|
|
scic_controller_disable_interrupts(this_controller);
|
|
|
|
// Reset the SCU
|
|
SMU_SMUSRCR_WRITE(this_controller, 0xFFFFFFFF);
|
|
|
|
// Delay for 1ms to before clearing the CQP and UFQPR.
|
|
scic_cb_stall_execution(1000);
|
|
|
|
// The write to the CQGR clears the CQP
|
|
SMU_CQGR_WRITE(this_controller, 0x00000000);
|
|
|
|
// The write to the UFQGP clears the UFQPR
|
|
SCU_UFQGP_WRITE(this_controller, 0x00000000);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_user_parameters_set(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCIC_USER_PARAMETERS_T * scic_parms
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T * this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
|
|
if (
|
|
(this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_RESET)
|
|
|| (this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_INITIALIZING)
|
|
|| (this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_INITIALIZED)
|
|
)
|
|
{
|
|
U16 index;
|
|
|
|
// Validate the user parameters. If they are not legal, then
|
|
// return a failure.
|
|
for (index = 0; index < SCI_MAX_PHYS; index++)
|
|
{
|
|
if (!
|
|
( scic_parms->sds1.phys[index].max_speed_generation
|
|
<= SCIC_SDS_PARM_MAX_SPEED
|
|
&& scic_parms->sds1.phys[index].max_speed_generation
|
|
> SCIC_SDS_PARM_NO_SPEED
|
|
)
|
|
)
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
|
|
if (
|
|
(scic_parms->sds1.phys[index].in_connection_align_insertion_frequency < 3) ||
|
|
(scic_parms->sds1.phys[index].align_insertion_frequency == 0) ||
|
|
(scic_parms->sds1.phys[index].notify_enable_spin_up_insertion_frequency == 0)
|
|
)
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
}
|
|
|
|
if (
|
|
(scic_parms->sds1.stp_inactivity_timeout == 0) ||
|
|
(scic_parms->sds1.ssp_inactivity_timeout == 0) ||
|
|
(scic_parms->sds1.stp_max_occupancy_timeout == 0) ||
|
|
(scic_parms->sds1.ssp_max_occupancy_timeout == 0) ||
|
|
(scic_parms->sds1.no_outbound_task_timeout == 0)
|
|
)
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
|
|
memcpy(
|
|
(&this_controller->user_parameters), scic_parms, sizeof(*scic_parms));
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
return SCI_FAILURE_INVALID_STATE;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void scic_user_parameters_get(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCIC_USER_PARAMETERS_T * scic_parms
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T * this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
|
|
memcpy(scic_parms, (&this_controller->user_parameters), sizeof(*scic_parms));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
SCI_STATUS scic_oem_parameters_set(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCIC_OEM_PARAMETERS_T * scic_parms,
|
|
U8 scic_parms_version
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T * this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
SCI_BIOS_OEM_PARAM_ELEMENT_T *old_oem_params =
|
|
(SCI_BIOS_OEM_PARAM_ELEMENT_T *)(&(scic_parms->sds1));
|
|
|
|
|
|
if (
|
|
(this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_RESET)
|
|
|| (this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_INITIALIZING)
|
|
|| (this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_INITIALIZED)
|
|
)
|
|
{
|
|
U16 index;
|
|
U8 combined_phy_mask = 0;
|
|
|
|
/*
|
|
* Set the OEM parameter version for the controller. This comes
|
|
* from the OEM parameter block header or the registry depending
|
|
* on what WCDL is set to retrieve.
|
|
*/
|
|
this_controller->oem_parameters_version = scic_parms_version;
|
|
|
|
// Validate the oem parameters. If they are not legal, then
|
|
// return a failure.
|
|
for(index=0; index<SCI_MAX_PORTS; index++)
|
|
{
|
|
if (scic_parms->sds1.ports[index].phy_mask > SCIC_SDS_PARM_PHY_MASK_MAX)
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
}
|
|
|
|
for(index=0; index<SCI_MAX_PHYS; index++)
|
|
{
|
|
if (
|
|
scic_parms->sds1.phys[index].sas_address.sci_format.high == 0
|
|
&& scic_parms->sds1.phys[index].sas_address.sci_format.low == 0
|
|
)
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
|
|
#if defined(PBG_HBA_A0_BUILD) || defined(PBG_HBA_A2_BUILD) || defined(PBG_HBA_BETA_BUILD) || defined(PBG_BUILD)
|
|
if (
|
|
(scic_parms->sds1.phys[index].afe_tx_amp_control0 == 0) ||
|
|
(scic_parms->sds1.phys[index].afe_tx_amp_control1 == 0) ||
|
|
(scic_parms->sds1.phys[index].afe_tx_amp_control2 == 0) ||
|
|
(scic_parms->sds1.phys[index].afe_tx_amp_control3 == 0)
|
|
)
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (scic_parms->sds1.controller.mode_type == SCIC_PORT_AUTOMATIC_CONFIGURATION_MODE)
|
|
{
|
|
for(index=0; index<SCI_MAX_PHYS; index++)
|
|
{
|
|
if (scic_parms->sds1.ports[index].phy_mask != 0)
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
}
|
|
}
|
|
else if (scic_parms->sds1.controller.mode_type == SCIC_PORT_MANUAL_CONFIGURATION_MODE)
|
|
{
|
|
for(index=0; index<SCI_MAX_PHYS; index++)
|
|
{
|
|
combined_phy_mask |= scic_parms->sds1.ports[index].phy_mask;
|
|
}
|
|
|
|
if (combined_phy_mask == 0)
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
|
|
if (scic_parms->sds1.controller.max_number_concurrent_device_spin_up > MAX_CONCURRENT_DEVICE_SPIN_UP_COUNT)
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
|
|
if (old_oem_params->controller.do_enable_ssc != 0)
|
|
{
|
|
if ( (scic_parms_version == SCI_OEM_PARAM_VER_1_0)
|
|
&& (old_oem_params->controller.do_enable_ssc != 0x01))
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
|
|
if (scic_parms_version >= SCI_OEM_PARAM_VER_1_1)
|
|
{
|
|
SCI_BIOS_OEM_PARAM_ELEMENT_v_1_1_T *oem_params =
|
|
(SCI_BIOS_OEM_PARAM_ELEMENT_v_1_1_T*)(&(scic_parms->sds1));
|
|
|
|
U8 test = oem_params->controller.ssc_sata_tx_spread_level;
|
|
if ( !((test == 0x0) || (test == 0x2) || (test == 0x3) ||
|
|
(test == 0x6) || (test == 0x7)) )
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
|
|
test = oem_params->controller.ssc_sas_tx_spread_level;
|
|
if (oem_params->controller.ssc_sas_tx_type == 0)
|
|
{
|
|
if ( !((test == 0x0) || (test == 0x2) || (test == 0x3)) )
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
else
|
|
if (oem_params->controller.ssc_sas_tx_type == 1)
|
|
{
|
|
if ( !((test == 0x0) || (test == 0x3) || (test == 0x6)) )
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
memcpy(
|
|
(&this_controller->oem_parameters), scic_parms, sizeof(*scic_parms));
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
return SCI_FAILURE_INVALID_STATE;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void scic_oem_parameters_get(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
SCIC_OEM_PARAMETERS_T * scic_parms
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T * this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
|
|
memcpy(scic_parms, (&this_controller->oem_parameters), sizeof(*scic_parms));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#if !defined(DISABLE_INTERRUPTS)
|
|
|
|
#define INTERRUPT_COALESCE_TIMEOUT_BASE_RANGE_LOWER_BOUND_NS 853
|
|
#define INTERRUPT_COALESCE_TIMEOUT_BASE_RANGE_UPPER_BOUND_NS 1280
|
|
#define INTERRUPT_COALESCE_TIMEOUT_MAX_US 2700000
|
|
#define INTERRUPT_COALESCE_NUMBER_MAX 256
|
|
#define INTERRUPT_COALESCE_TIMEOUT_ENCODE_MIN 7
|
|
#define INTERRUPT_COALESCE_TIMEOUT_ENCODE_MAX 28
|
|
|
|
SCI_STATUS scic_controller_set_interrupt_coalescence(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U32 coalesce_number,
|
|
U32 coalesce_timeout
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T * scic_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
U8 timeout_encode = 0;
|
|
U32 min = 0;
|
|
U32 max = 0;
|
|
|
|
//Check if the input parameters fall in the range.
|
|
if (coalesce_number > INTERRUPT_COALESCE_NUMBER_MAX)
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
|
|
// Defined encoding for interrupt coalescing timeout:
|
|
// Value Min Max Units
|
|
// ----- --- --- -----
|
|
// 0 - - Disabled
|
|
// 1 13.3 20.0 ns
|
|
// 2 26.7 40.0
|
|
// 3 53.3 80.0
|
|
// 4 106.7 160.0
|
|
// 5 213.3 320.0
|
|
// 6 426.7 640.0
|
|
// 7 853.3 1280.0
|
|
// 8 1.7 2.6 us
|
|
// 9 3.4 5.1
|
|
// 10 6.8 10.2
|
|
// 11 13.7 20.5
|
|
// 12 27.3 41.0
|
|
// 13 54.6 81.9
|
|
// 14 109.2 163.8
|
|
// 15 218.5 327.7
|
|
// 16 436.9 655.4
|
|
// 17 873.8 1310.7
|
|
// 18 1.7 2.6 ms
|
|
// 19 3.5 5.2
|
|
// 20 7.0 10.5
|
|
// 21 14.0 21.0
|
|
// 22 28.0 41.9
|
|
// 23 55.9 83.9
|
|
// 24 111.8 167.8
|
|
// 25 223.7 335.5
|
|
// 26 447.4 671.1
|
|
// 27 894.8 1342.2
|
|
// 28 1.8 2.7 s
|
|
// Others Undefined
|
|
|
|
//Use the table above to decide the encode of interrupt coalescing timeout
|
|
//value for register writing.
|
|
if (coalesce_timeout == 0)
|
|
timeout_encode = 0;
|
|
else
|
|
{
|
|
//make the timeout value in unit of (10 ns).
|
|
coalesce_timeout = coalesce_timeout * 100;
|
|
min = INTERRUPT_COALESCE_TIMEOUT_BASE_RANGE_LOWER_BOUND_NS / 10;
|
|
max = INTERRUPT_COALESCE_TIMEOUT_BASE_RANGE_UPPER_BOUND_NS / 10;
|
|
|
|
//get the encode of timeout for register writing.
|
|
for ( timeout_encode = INTERRUPT_COALESCE_TIMEOUT_ENCODE_MIN;
|
|
timeout_encode <= INTERRUPT_COALESCE_TIMEOUT_ENCODE_MAX;
|
|
timeout_encode++ )
|
|
{
|
|
if (min <= coalesce_timeout && max > coalesce_timeout)
|
|
break;
|
|
else if (coalesce_timeout >= max && coalesce_timeout < min*2
|
|
&& coalesce_timeout <= INTERRUPT_COALESCE_TIMEOUT_MAX_US*100)
|
|
{
|
|
if ( (coalesce_timeout-max) < (2*min - coalesce_timeout) )
|
|
break;
|
|
else
|
|
{
|
|
timeout_encode++;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
max = max*2;
|
|
min = min*2;
|
|
}
|
|
}
|
|
|
|
if ( timeout_encode == INTERRUPT_COALESCE_TIMEOUT_ENCODE_MAX+1 )
|
|
//the value is out of range.
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
|
|
SMU_ICC_WRITE(
|
|
scic_controller,
|
|
(SMU_ICC_GEN_VAL(NUMBER, coalesce_number)|
|
|
SMU_ICC_GEN_VAL(TIMER, timeout_encode))
|
|
);
|
|
|
|
scic_controller->interrupt_coalesce_number = (U16)coalesce_number;
|
|
scic_controller->interrupt_coalesce_timeout = coalesce_timeout/100;
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void scic_controller_get_interrupt_coalescence(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U32 * coalesce_number,
|
|
U32 * coalesce_timeout
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T * scic_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
*coalesce_number = scic_controller->interrupt_coalesce_number;
|
|
*coalesce_timeout = scic_controller->interrupt_coalesce_timeout;
|
|
}
|
|
|
|
#endif // !defined(DISABLE_INTERRUPTS)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
U32 scic_controller_get_scratch_ram_size(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
return SCU_SCRATCH_RAM_SIZE_IN_DWORDS;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_read_scratch_ram_dword(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U32 offset,
|
|
U32 * value
|
|
)
|
|
{
|
|
U32 zpt_index;
|
|
SCIC_SDS_CONTROLLER_T * scic_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
U32 status = SMU_SMUCSR_READ(scic_controller);
|
|
|
|
//Check if the SCU Scratch RAM been initialized, if not return zeros
|
|
if ((status & SCU_RAM_INIT_COMPLETED) != SCU_RAM_INIT_COMPLETED)
|
|
{
|
|
*value = 0x00000000;
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
if (offset < scic_controller_get_scratch_ram_size(controller))
|
|
{
|
|
if(offset <= SCU_MAX_ZPT_DWORD_INDEX)
|
|
{
|
|
zpt_index = offset + (offset - (offset % 4)) + 4;
|
|
|
|
*value = scu_controller_scratch_ram_register_read(scic_controller,zpt_index);
|
|
}
|
|
else //offset > SCU_MAX_ZPT_DWORD_INDEX
|
|
{
|
|
offset = offset - 132;
|
|
|
|
zpt_index = offset + (offset - (offset % 4)) + 4;
|
|
|
|
*value = scu_controller_scratch_ram_register_read_ext(scic_controller,zpt_index);
|
|
}
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_write_scratch_ram_dword(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U32 offset,
|
|
U32 value
|
|
)
|
|
{
|
|
U32 zpt_index;
|
|
|
|
if (offset < scic_controller_get_scratch_ram_size(controller))
|
|
{
|
|
SCIC_SDS_CONTROLLER_T * scic_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
if(offset <= SCU_MAX_ZPT_DWORD_INDEX)
|
|
{
|
|
zpt_index = offset + (offset - (offset % 4)) + 4;
|
|
|
|
scu_controller_scratch_ram_register_write(scic_controller,zpt_index,value);
|
|
}
|
|
else //offset > SCU_MAX_ZPT_DWORD_INDEX
|
|
{
|
|
offset = offset - 132;
|
|
|
|
zpt_index = offset + (offset - (offset % 4)) + 4;
|
|
|
|
scu_controller_scratch_ram_register_write_ext(scic_controller,zpt_index,value);
|
|
|
|
}
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_suspend(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T * this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
U8 index;
|
|
|
|
// As a precaution, disable interrupts. The user is required
|
|
// to re-enable interrupts if so desired after the call.
|
|
scic_controller_disable_interrupts(controller);
|
|
|
|
// Stop all the timers
|
|
// Maybe change the states of the objects to avoid processing stuff.
|
|
|
|
|
|
// Suspend the Ports in order to ensure no unexpected
|
|
// frame reception occurs on the links from the target
|
|
for (index = 0; index < SCI_MAX_PORTS; index++)
|
|
scic_sds_port_suspend_port_task_scheduler(
|
|
&(this_controller->port_table[index]));
|
|
|
|
// Disable/Reset the completion queue and unsolicited frame
|
|
// queue.
|
|
SMU_CQGR_WRITE(this_controller, 0x00000000);
|
|
SCU_UFQGP_WRITE(this_controller, 0x00000000);
|
|
|
|
// Clear any interrupts that may be pending or may have been generated
|
|
// by setting CQGR and CQPR back to 0
|
|
SMU_ISR_WRITE(this_controller, 0xFFFFFFFF);
|
|
|
|
//reset the software get pointer to completion queue.
|
|
this_controller->completion_queue_get = 0;
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_resume(
|
|
SCI_CONTROLLER_HANDLE_T controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T * this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
U8 index;
|
|
|
|
// Initialize the completion queue and unsolicited frame queue.
|
|
scic_sds_controller_initialize_completion_queue(this_controller);
|
|
scic_sds_controller_initialize_unsolicited_frame_queue(this_controller);
|
|
|
|
this_controller->restrict_completions = FALSE;
|
|
|
|
// Release the port suspensions to allow for further successful
|
|
// operation.
|
|
for (index = 0; index < SCI_MAX_PORTS; index++)
|
|
scic_sds_port_resume_port_task_scheduler(
|
|
&(this_controller->port_table[index]));
|
|
|
|
//check the link layer status register DWORD sync acquired bit to detect
|
|
//link down event. If there is any link down event happened during controller
|
|
//suspension, restart phy state machine.
|
|
for (index = 0; index < SCI_MAX_PHYS; index ++)
|
|
{
|
|
SCIC_SDS_PHY_T * curr_phy = &this_controller->phy_table[index];
|
|
U32 link_layer_status = SCU_SAS_LLSTA_READ(curr_phy);
|
|
|
|
if ((link_layer_status & SCU_SAS_LLSTA_DWORD_SYNCA_BIT) == 0)
|
|
{
|
|
//Need to put the phy back to start OOB. Then an appropriate link event
|
|
//message will be send to scic user.
|
|
scic_sds_phy_restart_starting_state(curr_phy);
|
|
}
|
|
}
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_transition(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
BOOL restrict_completions
|
|
)
|
|
{
|
|
SCI_STATUS result = SCI_FAILURE_INVALID_STATE;
|
|
SCIC_SDS_CONTROLLER_T * this_controller = (SCIC_SDS_CONTROLLER_T*)controller;
|
|
U8 index;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_controller_transition(0x%x) enter\n",
|
|
controller
|
|
));
|
|
|
|
if (this_controller->parent.state_machine.current_state_id
|
|
== SCI_BASE_CONTROLLER_STATE_READY)
|
|
{
|
|
// Ensure that there are no outstanding IO operations at this
|
|
// time.
|
|
for (index = 0; index < SCI_MAX_PORTS; index++)
|
|
{
|
|
if (this_controller->port_table[index].started_request_count != 0)
|
|
return result;
|
|
}
|
|
|
|
scic_controller_suspend(controller);
|
|
|
|
// Loop through the memory descriptor list and reprogram
|
|
// the silicon memory registers accordingly.
|
|
result = scic_sds_controller_validate_memory_descriptor_table(
|
|
this_controller);
|
|
if (result == SCI_SUCCESS)
|
|
{
|
|
scic_sds_controller_ram_initialization(this_controller);
|
|
this_controller->restrict_completions = restrict_completions;
|
|
}
|
|
|
|
scic_controller_resume(controller);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_get_max_ports(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U8 * count
|
|
)
|
|
{
|
|
*count = SCI_MAX_PORTS;
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_STATUS scic_controller_get_max_phys(
|
|
SCI_CONTROLLER_HANDLE_T controller,
|
|
U8 * count
|
|
)
|
|
{
|
|
*count = SCI_MAX_PHYS;
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
|
|
//******************************************************************************
|
|
//* CONTROLLER STATE MACHINE
|
|
//******************************************************************************
|
|
|
|
/**
|
|
* This macro returns the maximum number of logical ports supported by the
|
|
* hardware. The caller passes in the value read from the device context
|
|
* capacity register and this macro will mash and shift the value
|
|
* appropriately.
|
|
*/
|
|
#define smu_dcc_get_max_ports(dcc_value) \
|
|
( \
|
|
( ((U32)((dcc_value) & SMU_DEVICE_CONTEXT_CAPACITY_MAX_LP_MASK)) \
|
|
>> SMU_DEVICE_CONTEXT_CAPACITY_MAX_LP_SHIFT ) + 1\
|
|
)
|
|
|
|
/**
|
|
* This macro returns the maximum number of task contexts supported by the
|
|
* hardware. The caller passes in the value read from the device context
|
|
* capacity register and this macro will mash and shift the value
|
|
* appropriately.
|
|
*/
|
|
#define smu_dcc_get_max_task_context(dcc_value) \
|
|
( \
|
|
( ((U32)((dcc_value) & SMU_DEVICE_CONTEXT_CAPACITY_MAX_TC_MASK)) \
|
|
>> SMU_DEVICE_CONTEXT_CAPACITY_MAX_TC_SHIFT ) + 1\
|
|
)
|
|
|
|
/**
|
|
* This macro returns the maximum number of remote node contexts supported
|
|
* by the hardware. The caller passes in the value read from the device
|
|
* context capacity register and this macro will mash and shift the value
|
|
* appropriately.
|
|
*/
|
|
#define smu_dcc_get_max_remote_node_context(dcc_value) \
|
|
( \
|
|
( ( (U32)((dcc_value) & SMU_DEVICE_CONTEXT_CAPACITY_MAX_RNC_MASK) )\
|
|
>> SMU_DEVICE_CONTEXT_CAPACITY_MAX_RNC_SHIFT ) + 1\
|
|
)
|
|
|
|
//*****************************************************************************
|
|
//* DEFAULT STATE HANDLERS
|
|
//*****************************************************************************
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER default start
|
|
* io/task handler is in place.
|
|
* - Issue a warning message
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which, if it was
|
|
* used, would be cast to a SCIC_SDS_REMOTE_DEVICE.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which, if it was used,
|
|
* would be cast to a SCIC_SDS_IO_REQUEST.
|
|
* @param[in] io_tag This is the IO tag to be assigned to the IO request or
|
|
* SCI_CONTROLLER_INVALID_IO_TAG.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_FAILURE_INVALID_STATE
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_default_start_operation_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request,
|
|
U16 io_tag
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller requested to start an io/task from invalid state %d\n",
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
|
|
return SCI_FAILURE_INVALID_STATE;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER default
|
|
* request handler is in place.
|
|
* - Issue a warning message
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which, if it was
|
|
* used, would be cast to a SCIC_SDS_REMOTE_DEVICE.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which, if it was used,
|
|
* would be cast to a SCIC_SDS_IO_REQUEST.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_FAILURE_INVALID_STATE
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_default_request_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller request operation from invalid state %d\n",
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
|
|
return SCI_FAILURE_INVALID_STATE;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//* GENERAL (COMMON) STATE HANDLERS
|
|
//*****************************************************************************
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the ready state
|
|
* reset handler is in place.
|
|
* - Transition to SCI_BASE_CONTROLLER_STATE_RESETTING
|
|
*
|
|
* @param[in] controller The SCI_BASE_CONTROLLER object which is cast into a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_SUCCESS
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_general_reset_handler(
|
|
SCI_BASE_CONTROLLER_T *controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_resetting_state_enter(0x%x) enter\n",
|
|
controller
|
|
));
|
|
|
|
//Release resource. So far only resource to be released are timers.
|
|
scic_sds_controller_release_resource(this_controller);
|
|
|
|
// The reset operation is not a graceful cleanup just perform the state
|
|
// transition.
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_RESETTING
|
|
);
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//* RESET STATE HANDLERS
|
|
//*****************************************************************************
|
|
|
|
/**
|
|
* This method is the SCIC_SDS_CONTROLLER initialize handler for the reset
|
|
* state.
|
|
* - Currently this function does nothing
|
|
*
|
|
* @param[in] controller This is the SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_FAILURE
|
|
*
|
|
* @todo This function is not yet implemented and is a valid request from the
|
|
* reset state.
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_reset_state_initialize_handler(
|
|
SCI_BASE_CONTROLLER_T *controller
|
|
)
|
|
{
|
|
U32 index;
|
|
SCI_STATUS result = SCI_SUCCESS;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER | SCIC_LOG_OBJECT_INITIALIZATION,
|
|
"scic_sds_controller_reset_state_initialize_handler(0x%x) enter\n",
|
|
controller
|
|
));
|
|
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_INITIALIZING
|
|
);
|
|
|
|
this_controller->timeout_timer = scic_cb_timer_create(
|
|
controller,
|
|
scic_sds_controller_timeout_handler,
|
|
controller
|
|
);
|
|
|
|
scic_sds_controller_initialize_power_control(this_controller);
|
|
|
|
/// todo: This should really be done in the reset state enter but
|
|
/// the controller has not yet been initialized before getting
|
|
/// to the reset enter state so the PCI BAR is not yet assigned
|
|
scic_sds_controller_reset_hardware(this_controller);
|
|
|
|
#if defined(ARLINGTON_BUILD)
|
|
scic_sds_controller_lex_atux_initialization(this_controller);
|
|
#elif defined(PLEASANT_RIDGE_BUILD) \
|
|
|| defined(PBG_HBA_A0_BUILD) \
|
|
|| defined(PBG_HBA_A2_BUILD)
|
|
scic_sds_controller_afe_initialization(this_controller);
|
|
#elif defined(PBG_HBA_BETA_BUILD) || defined(PBG_BUILD)
|
|
// There is nothing to do here for B0 since we do not have to
|
|
// program the AFE registers.
|
|
/// @todo The AFE settings are supposed to be correct for the B0 but
|
|
/// presently they seem to be wrong.
|
|
scic_sds_controller_afe_initialization(this_controller);
|
|
#else // !defined(ARLINGTON_BUILD) && !defined(PLEASANT_RIDGE_BUILD)
|
|
// What other systems do we want to add here?
|
|
#endif // !defined(ARLINGTON_BUILD) && !defined(PLEASANT_RIDGE_BUILD)
|
|
|
|
if (SCI_SUCCESS == result)
|
|
{
|
|
U32 status;
|
|
U32 terminate_loop;
|
|
|
|
// Take the hardware out of reset
|
|
SMU_SMUSRCR_WRITE(this_controller, 0x00000000);
|
|
|
|
/// @todo Provide meaningfull error code for hardware failure
|
|
//result = SCI_FAILURE_CONTROLLER_HARDWARE;
|
|
result = SCI_FAILURE;
|
|
terminate_loop = 100;
|
|
|
|
while (terminate_loop-- && (result != SCI_SUCCESS))
|
|
{
|
|
// Loop until the hardware reports success
|
|
scic_cb_stall_execution(SCU_CONTEXT_RAM_INIT_STALL_TIME);
|
|
status = SMU_SMUCSR_READ(this_controller);
|
|
|
|
if ((status & SCU_RAM_INIT_COMPLETED) == SCU_RAM_INIT_COMPLETED)
|
|
{
|
|
result = SCI_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef ARLINGTON_BUILD
|
|
scic_sds_controller_enable_chipwatch(this_controller);
|
|
#endif
|
|
|
|
if (result == SCI_SUCCESS)
|
|
{
|
|
U32 max_supported_ports;
|
|
U32 max_supported_devices;
|
|
U32 max_supported_io_requests;
|
|
U32 device_context_capacity;
|
|
|
|
// Determine what are the actaul device capacities that the
|
|
// hardware will support
|
|
device_context_capacity = SMU_DCC_READ(this_controller);
|
|
|
|
max_supported_ports =
|
|
smu_dcc_get_max_ports(device_context_capacity);
|
|
max_supported_devices =
|
|
smu_dcc_get_max_remote_node_context(device_context_capacity);
|
|
max_supported_io_requests =
|
|
smu_dcc_get_max_task_context(device_context_capacity);
|
|
|
|
// Make all PEs that are unassigned match up with the logical ports
|
|
for (index = 0; index < max_supported_ports; index++)
|
|
{
|
|
scu_register_write(
|
|
this_controller,
|
|
this_controller->scu_registers->peg0.ptsg.protocol_engine[index],
|
|
index
|
|
);
|
|
}
|
|
|
|
// Now that we have the correct hardware reported minimum values
|
|
// build the MDL for the controller. Default to a performance
|
|
// configuration.
|
|
scic_controller_set_mode(this_controller, SCI_MODE_SPEED);
|
|
|
|
// Record the smaller of the two capacity values
|
|
this_controller->logical_port_entries =
|
|
MIN(max_supported_ports, this_controller->logical_port_entries);
|
|
|
|
this_controller->task_context_entries =
|
|
MIN(max_supported_io_requests, this_controller->task_context_entries);
|
|
|
|
this_controller->remote_node_entries =
|
|
MIN(max_supported_devices, this_controller->remote_node_entries);
|
|
}
|
|
|
|
// Initialize hardware PCI Relaxed ordering in DMA engines
|
|
if (result == SCI_SUCCESS)
|
|
{
|
|
U32 dma_configuration;
|
|
|
|
// Configure the payload DMA
|
|
dma_configuration = SCU_PDMACR_READ(this_controller);
|
|
dma_configuration |= SCU_PDMACR_GEN_BIT(PCI_RELAXED_ORDERING_ENABLE);
|
|
SCU_PDMACR_WRITE(this_controller, dma_configuration);
|
|
|
|
// Configure the control DMA
|
|
dma_configuration = SCU_CDMACR_READ(this_controller);
|
|
dma_configuration |= SCU_CDMACR_GEN_BIT(PCI_RELAXED_ORDERING_ENABLE);
|
|
SCU_CDMACR_WRITE(this_controller, dma_configuration);
|
|
}
|
|
|
|
// Initialize the PHYs before the PORTs because the PHY registers
|
|
// are accessed during the port initialization.
|
|
if (result == SCI_SUCCESS)
|
|
{
|
|
// Initialize the phys
|
|
for (index = 0;
|
|
(result == SCI_SUCCESS) && (index < SCI_MAX_PHYS);
|
|
index++)
|
|
{
|
|
result = scic_sds_phy_initialize(
|
|
&this_controller->phy_table[index],
|
|
&this_controller->scu_registers->peg0.pe[index].tl,
|
|
&this_controller->scu_registers->peg0.pe[index].ll
|
|
);
|
|
}
|
|
}
|
|
|
|
//Initialize the SGPIO Unit for HARDWARE controlled SGPIO
|
|
if(result == SCI_SUCCESS)
|
|
{
|
|
scic_sgpio_hardware_initialize(this_controller);
|
|
}
|
|
|
|
if (result == SCI_SUCCESS)
|
|
{
|
|
// Initialize the logical ports
|
|
for (index = 0;
|
|
(index < this_controller->logical_port_entries)
|
|
&& (result == SCI_SUCCESS);
|
|
index++)
|
|
{
|
|
result = scic_sds_port_initialize(
|
|
&this_controller->port_table[index],
|
|
&this_controller->scu_registers->peg0.ptsg.port[index],
|
|
&this_controller->scu_registers->peg0.ptsg.protocol_engine,
|
|
&this_controller->scu_registers->peg0.viit[index]
|
|
);
|
|
}
|
|
}
|
|
|
|
if (SCI_SUCCESS == result)
|
|
{
|
|
result = scic_sds_port_configuration_agent_initialize(
|
|
this_controller,
|
|
&this_controller->port_agent
|
|
);
|
|
}
|
|
|
|
// Advance the controller state machine
|
|
if (result == SCI_SUCCESS)
|
|
{
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_INITIALIZED
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//stay in the same state and release the resource
|
|
scic_sds_controller_release_resource(this_controller);
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER | SCIC_LOG_OBJECT_INITIALIZATION,
|
|
"Invalid Port Configuration from scic_sds_controller_reset_state_initialize_handler(0x%x) \n",
|
|
controller
|
|
));
|
|
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//* INITIALIZED STATE HANDLERS
|
|
//*****************************************************************************
|
|
|
|
/**
|
|
* This method is the SCIC_SDS_CONTROLLER start handler for the initialized
|
|
* state.
|
|
* - Validate we have a good memory descriptor table
|
|
* - Initialze the physical memory before programming the hardware
|
|
* - Program the SCU hardware with the physical memory addresses passed in
|
|
* the memory descriptor table.
|
|
* - Initialzie the TCi pool
|
|
* - Initialize the RNi pool
|
|
* - Initialize the completion queue
|
|
* - Initialize the unsolicited frame data
|
|
* - Take the SCU port task scheduler out of reset
|
|
* - Start the first phy object.
|
|
* - Transition to SCI_BASE_CONTROLLER_STATE_STARTING.
|
|
*
|
|
* @param[in] controller This is the SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] timeout This is the allowed time for the controller object to
|
|
* reach the started state.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_SUCCESS if all of the controller start operations complete
|
|
* @retval SCI_FAILURE_UNSUPPORTED_INFORMATION_FIELD if one or more of the
|
|
* memory descriptor fields is invalid.
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_initialized_state_start_handler(
|
|
SCI_BASE_CONTROLLER_T * controller,
|
|
U32 timeout
|
|
)
|
|
{
|
|
U16 index;
|
|
SCI_STATUS result;
|
|
SCIC_SDS_CONTROLLER_T * this_controller;
|
|
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
// Make sure that the SCI User filled in the memory descriptor table correctly
|
|
result = scic_sds_controller_validate_memory_descriptor_table(this_controller);
|
|
|
|
if (result == SCI_SUCCESS)
|
|
{
|
|
// The memory descriptor list looks good so program the hardware
|
|
scic_sds_controller_ram_initialization(this_controller);
|
|
}
|
|
|
|
if (SCI_SUCCESS == result)
|
|
{
|
|
// Build the TCi free pool
|
|
sci_pool_initialize(this_controller->tci_pool);
|
|
for (index = 0; index < this_controller->task_context_entries; index++)
|
|
{
|
|
sci_pool_put(this_controller->tci_pool, index);
|
|
}
|
|
|
|
// Build the RNi free pool
|
|
scic_sds_remote_node_table_initialize(
|
|
&this_controller->available_remote_nodes,
|
|
this_controller->remote_node_entries
|
|
);
|
|
}
|
|
|
|
if (SCI_SUCCESS == result)
|
|
{
|
|
// Before anything else lets make sure we will not be interrupted
|
|
// by the hardware.
|
|
scic_controller_disable_interrupts(controller);
|
|
|
|
// Enable the port task scheduler
|
|
scic_sds_controller_enable_port_task_scheduler(this_controller);
|
|
|
|
// Assign all the task entries to this controller physical function
|
|
scic_sds_controller_assign_task_entries(this_controller);
|
|
|
|
// Now initialze the completion queue
|
|
scic_sds_controller_initialize_completion_queue(this_controller);
|
|
|
|
// Initialize the unsolicited frame queue for use
|
|
scic_sds_controller_initialize_unsolicited_frame_queue(this_controller);
|
|
|
|
// Setup the phy start timer
|
|
result = scic_sds_controller_initialize_phy_startup(this_controller);
|
|
}
|
|
|
|
// Start all of the ports on this controller
|
|
for (
|
|
index = 0;
|
|
(index < this_controller->logical_port_entries) && (result == SCI_SUCCESS);
|
|
index++
|
|
)
|
|
{
|
|
result = this_controller->port_table[index].
|
|
state_handlers->parent.start_handler(&this_controller->port_table[index].parent);
|
|
}
|
|
|
|
if (SCI_SUCCESS == result)
|
|
{
|
|
scic_sds_controller_start_next_phy(this_controller);
|
|
|
|
// See if the user requested to timeout this operation.
|
|
if (timeout != 0)
|
|
scic_cb_timer_start(controller, this_controller->timeout_timer, timeout);
|
|
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_STARTING
|
|
);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//* STARTING STATE HANDLERS
|
|
//*****************************************************************************
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the starting state
|
|
* link up handler is called. This method will perform the following:
|
|
* - Stop the phy timer
|
|
* - Start the next phy
|
|
* - Report the link up condition to the port object
|
|
*
|
|
* @param[in] controller This is SCIC_SDS_CONTROLLER which receives the link up
|
|
* notification.
|
|
* @param[in] port This is SCIC_SDS_PORT with which the phy is associated.
|
|
* @param[in] phy This is the SCIC_SDS_PHY which has gone link up.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_starting_state_link_up_handler(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_PORT_T *port,
|
|
SCIC_SDS_PHY_T *phy
|
|
)
|
|
{
|
|
scic_sds_controller_phy_timer_stop(this_controller);
|
|
|
|
this_controller->port_agent.link_up_handler(
|
|
this_controller, &this_controller->port_agent, port, phy
|
|
);
|
|
//scic_sds_port_link_up(port, phy);
|
|
|
|
scic_sds_controller_start_next_phy(this_controller);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the starting state
|
|
* link down handler is called.
|
|
* - Report the link down condition to the port object
|
|
*
|
|
* @param[in] controller This is SCIC_SDS_CONTROLLER which receives the
|
|
* link down notification.
|
|
* @param[in] port This is SCIC_SDS_PORT with which the phy is associated.
|
|
* @param[in] phy This is the SCIC_SDS_PHY which has gone link down.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_starting_state_link_down_handler(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_PORT_T *port,
|
|
SCIC_SDS_PHY_T *phy
|
|
)
|
|
{
|
|
this_controller->port_agent.link_down_handler(
|
|
this_controller, &this_controller->port_agent, port, phy
|
|
);
|
|
//scic_sds_port_link_down(port, phy);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//* READY STATE HANDLERS
|
|
//*****************************************************************************
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the ready state
|
|
* stop handler is called.
|
|
* - Start the timeout timer
|
|
* - Transition to SCI_BASE_CONTROLLER_STATE_STOPPING.
|
|
*
|
|
* @param[in] controller The SCI_BASE_CONTROLLER object which is cast into a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
* @param[in] timeout The timeout for when the stop operation should report a
|
|
* failure.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_SUCCESS
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_ready_state_stop_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
U32 timeout
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
// See if the user requested to timeout this operation
|
|
if (timeout != 0)
|
|
scic_cb_timer_start(controller, this_controller->timeout_timer, timeout);
|
|
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_STOPPING
|
|
);
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the ready state
|
|
* and the start io handler is called.
|
|
* - Start the io request on the remote device
|
|
* - if successful
|
|
* - assign the io_request to the io_request_table
|
|
* - post the request to the hardware
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which is cast to a
|
|
* SCIC_SDS_REMOTE_DEVICE object.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which is cast to a
|
|
* SCIC_SDS_IO_REQUEST object.
|
|
* @param[in] io_tag This is the IO tag to be assigned to the IO request or
|
|
* SCI_CONTROLLER_INVALID_IO_TAG.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_SUCCESS if the start io operation succeeds
|
|
* @retval SCI_FAILURE_INSUFFICIENT_RESOURCES if the IO tag could not be
|
|
* allocated for the io request.
|
|
* @retval SCI_FAILURE_INVALID_STATE if one or more objects are not in a valid
|
|
* state to accept io requests.
|
|
*
|
|
* @todo How does the io_tag parameter get assigned to the io request?
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_ready_state_start_io_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request,
|
|
U16 io_tag
|
|
)
|
|
{
|
|
SCI_STATUS status;
|
|
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
SCIC_SDS_REQUEST_T *the_request;
|
|
SCIC_SDS_REMOTE_DEVICE_T *the_device;
|
|
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
the_request = (SCIC_SDS_REQUEST_T *)io_request;
|
|
the_device = (SCIC_SDS_REMOTE_DEVICE_T *)remote_device;
|
|
|
|
status = scic_sds_remote_device_start_io(this_controller, the_device, the_request);
|
|
|
|
if (status == SCI_SUCCESS)
|
|
{
|
|
this_controller->io_request_table[
|
|
scic_sds_io_tag_get_index(the_request->io_tag)] = the_request;
|
|
|
|
scic_sds_controller_post_request(
|
|
this_controller,
|
|
scic_sds_request_get_post_context(the_request)
|
|
);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the ready state
|
|
* and the complete io handler is called.
|
|
* - Complete the io request on the remote device
|
|
* - if successful
|
|
* - remove the io_request to the io_request_table
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which is cast to a
|
|
* SCIC_SDS_REMOTE_DEVICE object.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which is cast to a
|
|
* SCIC_SDS_IO_REQUEST object.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_SUCCESS if the start io operation succeeds
|
|
* @retval SCI_FAILURE_INVALID_STATE if one or more objects are not in a valid
|
|
* state to accept io requests.
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_ready_state_complete_io_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request
|
|
)
|
|
{
|
|
U16 index;
|
|
SCI_STATUS status;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
SCIC_SDS_REQUEST_T *the_request;
|
|
SCIC_SDS_REMOTE_DEVICE_T *the_device;
|
|
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
the_request = (SCIC_SDS_REQUEST_T *)io_request;
|
|
the_device = (SCIC_SDS_REMOTE_DEVICE_T *)remote_device;
|
|
|
|
status = scic_sds_remote_device_complete_io(
|
|
this_controller, the_device, the_request);
|
|
|
|
if (status == SCI_SUCCESS)
|
|
{
|
|
index = scic_sds_io_tag_get_index(the_request->io_tag);
|
|
this_controller->io_request_table[index] = SCI_INVALID_HANDLE;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the ready state
|
|
* and the continue io handler is called.
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which is cast to a
|
|
* SCIC_SDS_REMOTE_DEVICE object.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which is cast to a
|
|
* SCIC_SDS_IO_REQUEST object.
|
|
*
|
|
* @return SCI_STATUS
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_ready_state_continue_io_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
SCIC_SDS_REQUEST_T *the_request;
|
|
|
|
the_request = (SCIC_SDS_REQUEST_T *)io_request;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
this_controller->io_request_table[
|
|
scic_sds_io_tag_get_index(the_request->io_tag)] = the_request;
|
|
|
|
scic_sds_controller_post_request(
|
|
this_controller,
|
|
scic_sds_request_get_post_context(the_request)
|
|
);
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the ready state
|
|
* and the start task handler is called.
|
|
* - The remote device is requested to start the task request
|
|
* - if successful
|
|
* - assign the task to the io_request_table
|
|
* - post the request to the SCU hardware
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which is cast to a
|
|
* SCIC_SDS_REMOTE_DEVICE object.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which is cast to a
|
|
* SCIC_SDS_IO_REQUEST object.
|
|
* @param[in] task_tag This is the task tag to be assigned to the task request
|
|
* or SCI_CONTROLLER_INVALID_IO_TAG.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_SUCCESS if the start io operation succeeds
|
|
* @retval SCI_FAILURE_INSUFFICIENT_RESOURCES if the IO tag could not be
|
|
* allocated for the io request.
|
|
* @retval SCI_FAILURE_INVALID_STATE if one or more objects are not in a valid
|
|
* state to accept io requests.
|
|
*
|
|
* @todo How does the io tag get assigned in this code path?
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_ready_state_start_task_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request,
|
|
U16 task_tag
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller = (SCIC_SDS_CONTROLLER_T *)
|
|
controller;
|
|
SCIC_SDS_REQUEST_T *the_request = (SCIC_SDS_REQUEST_T *)
|
|
io_request;
|
|
SCIC_SDS_REMOTE_DEVICE_T *the_device = (SCIC_SDS_REMOTE_DEVICE_T *)
|
|
remote_device;
|
|
SCI_STATUS status;
|
|
|
|
status = scic_sds_remote_device_start_task(
|
|
this_controller, the_device, the_request
|
|
);
|
|
|
|
if (status == SCI_SUCCESS)
|
|
{
|
|
this_controller->io_request_table[
|
|
scic_sds_io_tag_get_index(the_request->io_tag)] = the_request;
|
|
|
|
scic_sds_controller_post_request(
|
|
this_controller,
|
|
scic_sds_request_get_post_context(the_request)
|
|
);
|
|
}
|
|
else if (status == SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS)
|
|
{
|
|
this_controller->io_request_table[
|
|
scic_sds_io_tag_get_index(the_request->io_tag)] = the_request;
|
|
|
|
//We will let framework know this task request started successfully,
|
|
//although core is still woring on starting the request (to post tc when
|
|
//RNC is resumed.)
|
|
status = SCI_SUCCESS;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the ready state
|
|
* and the terminate request handler is called.
|
|
* - call the io request terminate function
|
|
* - if successful
|
|
* - post the terminate request to the SCU hardware
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which is cast to a
|
|
* SCIC_SDS_REMOTE_DEVICE object.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which is cast to a
|
|
* SCIC_SDS_IO_REQUEST object.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_SUCCESS if the start io operation succeeds
|
|
* @retval SCI_FAILURE_INVALID_STATE if one or more objects are not in a valid
|
|
* state to accept io requests.
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_ready_state_terminate_request_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller = (SCIC_SDS_CONTROLLER_T *)
|
|
controller;
|
|
SCIC_SDS_REQUEST_T *the_request = (SCIC_SDS_REQUEST_T *)
|
|
io_request;
|
|
SCI_STATUS status;
|
|
|
|
status = scic_sds_io_request_terminate(the_request);
|
|
if (status == SCI_SUCCESS)
|
|
{
|
|
// Utilize the original post context command and or in the POST_TC_ABORT
|
|
// request sub-type.
|
|
scic_sds_controller_post_request(
|
|
this_controller,
|
|
scic_sds_request_get_post_context(the_request)
|
|
| SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT
|
|
);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the starting state
|
|
* link up handler is called. This method will perform the following:
|
|
* - Stop the phy timer
|
|
* - Start the next phy
|
|
* - Report the link up condition to the port object
|
|
*
|
|
* @param[in] controller This is SCIC_SDS_CONTROLLER which receives the link up
|
|
* notification.
|
|
* @param[in] port This is SCIC_SDS_PORT with which the phy is associated.
|
|
* @param[in] phy This is the SCIC_SDS_PHY which has gone link up.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_ready_state_link_up_handler(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_PORT_T *port,
|
|
SCIC_SDS_PHY_T *phy
|
|
)
|
|
{
|
|
this_controller->port_agent.link_up_handler(
|
|
this_controller, &this_controller->port_agent, port, phy
|
|
);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the starting state
|
|
* link down handler is called.
|
|
* - Report the link down condition to the port object
|
|
*
|
|
* @param[in] controller This is SCIC_SDS_CONTROLLER which receives the
|
|
* link down notification.
|
|
* @param[in] port This is SCIC_SDS_PORT with which the phy is associated.
|
|
* @param[in] phy This is the SCIC_SDS_PHY which has gone link down.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_ready_state_link_down_handler(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_PORT_T *port,
|
|
SCIC_SDS_PHY_T *phy
|
|
)
|
|
{
|
|
this_controller->port_agent.link_down_handler(
|
|
this_controller, &this_controller->port_agent, port, phy
|
|
);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//* STOPPING STATE HANDLERS
|
|
//*****************************************************************************
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in a stopping state
|
|
* and the complete io handler is called.
|
|
* - This function is not yet implemented
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which is cast to a
|
|
* SCIC_SDS_REMOTE_DEVICE object.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which is cast to a
|
|
* SCIC_SDS_IO_REQUEST object.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_FAILURE
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_stopping_state_complete_io_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
/// @todo Implement this function
|
|
return SCI_FAILURE;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in a stopping state
|
|
* and the a remote device has stopped.
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which is cast to a
|
|
* SCIC_SDS_REMOTE_DEVICE object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_stopping_state_device_stopped_handler(
|
|
SCIC_SDS_CONTROLLER_T * controller,
|
|
SCIC_SDS_REMOTE_DEVICE_T * remote_device
|
|
)
|
|
{
|
|
if (!scic_sds_controller_has_remote_devices_stopping(controller))
|
|
{
|
|
sci_base_state_machine_change_state(
|
|
&controller->parent.state_machine,
|
|
SCI_BASE_CONTROLLER_STATE_STOPPED
|
|
);
|
|
}
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//* STOPPED STATE HANDLERS
|
|
//*****************************************************************************
|
|
|
|
//*****************************************************************************
|
|
//* FAILED STATE HANDLERS
|
|
//*****************************************************************************
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER failed state start
|
|
* io/task handler is in place.
|
|
* - Issue a warning message
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which, if it was
|
|
* used, would be cast to a SCIC_SDS_REMOTE_DEVICE.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which, if it was used,
|
|
* would be cast to a SCIC_SDS_IO_REQUEST.
|
|
* @param[in] io_tag This is the IO tag to be assigned to the IO request or
|
|
* SCI_CONTROLLER_INVALID_IO_TAG.
|
|
*
|
|
* @return SCI_FAILURE
|
|
* @retval SCI_FAILURE
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_failed_state_start_operation_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request,
|
|
U16 io_tag
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
SCIC_LOG_WARNING((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"SCIC Controller requested to start an io/task from failed state %d\n",
|
|
sci_base_state_machine_get_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller))
|
|
));
|
|
|
|
return SCI_FAILURE;
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the failed state
|
|
* reset handler is in place.
|
|
* - Transition to SCI_BASE_CONTROLLER_STATE_RESETTING
|
|
*
|
|
* @param[in] controller The SCI_BASE_CONTROLLER object which is cast into a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_FAILURE if fatal memory error occurred
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_failed_state_reset_handler(
|
|
SCI_BASE_CONTROLLER_T *controller
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller = (SCIC_SDS_CONTROLLER_T *)controller;
|
|
|
|
if (this_controller->parent.error == SCI_CONTROLLER_FATAL_MEMORY_ERROR) {
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_resetting_state_enter(0x%x) enter\n not allowed with fatal memory error",
|
|
controller
|
|
));
|
|
|
|
return SCI_FAILURE;
|
|
} else {
|
|
return scic_sds_controller_general_reset_handler(controller);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method is called when the SCIC_SDS_CONTROLLER is in the failed state
|
|
* and the terminate request handler is called.
|
|
* - call the io request terminate function
|
|
* - if successful
|
|
* - post the terminate request to the SCU hardware
|
|
*
|
|
* @param[in] controller This is SCI_BASE_CONTROLLER object which is cast
|
|
* into a SCIC_SDS_CONTROLLER object.
|
|
* @param[in] remote_device This is SCI_BASE_REMOTE_DEVICE which is cast to a
|
|
* SCIC_SDS_REMOTE_DEVICE object.
|
|
* @param[in] io_request This is the SCI_BASE_REQUEST which is cast to a
|
|
* SCIC_SDS_IO_REQUEST object.
|
|
*
|
|
* @return SCI_STATUS
|
|
* @retval SCI_SUCCESS if the start io operation succeeds
|
|
* @retval SCI_FAILURE_INVALID_STATE if one or more objects are not in a valid
|
|
* state to accept io requests.
|
|
*/
|
|
static
|
|
SCI_STATUS scic_sds_controller_failed_state_terminate_request_handler(
|
|
SCI_BASE_CONTROLLER_T *controller,
|
|
SCI_BASE_REMOTE_DEVICE_T *remote_device,
|
|
SCI_BASE_REQUEST_T *io_request
|
|
)
|
|
{
|
|
SCIC_SDS_REQUEST_T *the_request = (SCIC_SDS_REQUEST_T *)
|
|
io_request;
|
|
|
|
return scic_sds_io_request_terminate(the_request);
|
|
}
|
|
|
|
SCIC_SDS_CONTROLLER_STATE_HANDLER_T
|
|
scic_sds_controller_state_handler_table[SCI_BASE_CONTROLLER_MAX_STATES] =
|
|
{
|
|
// SCI_BASE_CONTROLLER_STATE_INITIAL
|
|
{
|
|
{
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
},
|
|
// SCI_BASE_CONTROLLER_STATE_RESET
|
|
{
|
|
{
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_reset_state_initialize_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
},
|
|
// SCI_BASE_CONTROLLER_STATE_INITIALIZING
|
|
{
|
|
{
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
},
|
|
// SCI_BASE_CONTROLLER_STATE_INITIALIZED
|
|
{
|
|
{
|
|
scic_sds_controller_initialized_state_start_handler,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
},
|
|
// SCI_BASE_CONTROLLER_STATE_STARTING
|
|
{
|
|
{
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_starting_state_link_up_handler,
|
|
scic_sds_controller_starting_state_link_down_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
// SCI_BASE_CONTROLLER_STATE_READY
|
|
{
|
|
{
|
|
NULL,
|
|
scic_sds_controller_ready_state_stop_handler,
|
|
scic_sds_controller_general_reset_handler,
|
|
NULL,
|
|
scic_sds_controller_ready_state_start_io_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_ready_state_complete_io_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_ready_state_continue_io_handler,
|
|
scic_sds_controller_ready_state_start_task_handler,
|
|
scic_sds_controller_ready_state_complete_io_handler
|
|
},
|
|
scic_sds_controller_ready_state_terminate_request_handler,
|
|
scic_sds_controller_ready_state_link_up_handler,
|
|
scic_sds_controller_ready_state_link_down_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
// SCI_BASE_CONTROLLER_STATE_RESETTING
|
|
{
|
|
{
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
},
|
|
// SCI_BASE_CONTROLLER_STATE_STOPPING
|
|
{
|
|
{
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_stopping_state_complete_io_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_stopping_state_device_stopped_handler
|
|
},
|
|
// SCI_BASE_CONTROLLER_STATE_STOPPED
|
|
{
|
|
{
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_failed_state_reset_handler,
|
|
NULL,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_start_operation_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
},
|
|
// SCI_BASE_CONTROLLER_STATE_FAILED
|
|
{
|
|
{
|
|
NULL,
|
|
NULL,
|
|
scic_sds_controller_general_reset_handler,
|
|
NULL,
|
|
scic_sds_controller_failed_state_start_operation_handler,
|
|
scic_sds_controller_failed_state_start_operation_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
scic_sds_controller_default_request_handler,
|
|
NULL,
|
|
NULL
|
|
},
|
|
scic_sds_controller_failed_state_terminate_request_handler,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_INITIAL.
|
|
* - Set the state handlers to the controllers initial state.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*
|
|
* @todo This function should initialze the controller object.
|
|
*/
|
|
static
|
|
void scic_sds_controller_initial_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_INITIAL);
|
|
|
|
sci_base_state_machine_change_state(
|
|
&this_controller->parent.state_machine, SCI_BASE_CONTROLLER_STATE_RESET);
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_RESET.
|
|
* - Set the state handlers to the controllers reset state.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_reset_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
U8 index;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_RESET);
|
|
|
|
scic_sds_port_configuration_agent_construct(&this_controller->port_agent);
|
|
|
|
// Construct the ports for this controller
|
|
for (index = 0; index < (SCI_MAX_PORTS + 1); index++)
|
|
{
|
|
scic_sds_port_construct(
|
|
&this_controller->port_table[index],
|
|
(index == SCI_MAX_PORTS) ? SCIC_SDS_DUMMY_PORT : index,
|
|
this_controller
|
|
);
|
|
}
|
|
|
|
// Construct the phys for this controller
|
|
for (index = 0; index < SCI_MAX_PHYS; index++)
|
|
{
|
|
// Add all the PHYs to the dummy port
|
|
scic_sds_phy_construct(
|
|
&this_controller->phy_table[index],
|
|
&this_controller->port_table[SCI_MAX_PORTS],
|
|
index
|
|
);
|
|
}
|
|
|
|
this_controller->invalid_phy_mask = 0;
|
|
|
|
// Set the default maximum values
|
|
this_controller->completion_event_entries = SCU_EVENT_COUNT;
|
|
this_controller->completion_queue_entries = SCU_COMPLETION_QUEUE_COUNT;
|
|
this_controller->remote_node_entries = SCI_MAX_REMOTE_DEVICES;
|
|
this_controller->logical_port_entries = SCI_MAX_PORTS;
|
|
this_controller->task_context_entries = SCU_IO_REQUEST_COUNT;
|
|
this_controller->uf_control.buffers.count = SCU_UNSOLICITED_FRAME_COUNT;
|
|
this_controller->uf_control.address_table.count= SCU_UNSOLICITED_FRAME_COUNT;
|
|
|
|
// Initialize the User and OEM parameters to default values.
|
|
scic_sds_controller_set_default_config_parameters(this_controller);
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_INITIALIZING.
|
|
* - Set the state handlers to the controllers initializing state.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_initializing_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_INITIALIZING);
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_INITIALIZED.
|
|
* - Set the state handlers to the controllers initialized state.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_initialized_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_INITIALIZED);
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_STARTING.
|
|
* - Set the state handlers to the controllers starting state.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_starting_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_STARTING);
|
|
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on exit
|
|
* from the SCI_BASE_CONTROLLER_STATE_STARTING.
|
|
* - This function stops the controller starting timeout timer.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_starting_state_exit(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_cb_timer_stop(object, this_controller->timeout_timer);
|
|
|
|
// We are done with this timer since we are exiting the starting
|
|
// state so remove it
|
|
scic_cb_timer_destroy(
|
|
this_controller,
|
|
this_controller->phy_startup_timer
|
|
);
|
|
|
|
this_controller->phy_startup_timer = NULL;
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_READY.
|
|
* - Set the state handlers to the controllers ready state.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_ready_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
U32 clock_gating_unit_value;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_READY);
|
|
|
|
/**
|
|
* enable clock gating for power control of the scu unit
|
|
*/
|
|
clock_gating_unit_value = SMU_CGUCR_READ(this_controller);
|
|
|
|
clock_gating_unit_value &= ~( SMU_CGUCR_GEN_BIT(REGCLK_ENABLE)
|
|
| SMU_CGUCR_GEN_BIT(TXCLK_ENABLE)
|
|
| SMU_CGUCR_GEN_BIT(XCLK_ENABLE) );
|
|
clock_gating_unit_value |= SMU_CGUCR_GEN_BIT(IDLE_ENABLE);
|
|
|
|
SMU_CGUCR_WRITE(this_controller, clock_gating_unit_value);
|
|
|
|
//set the default interrupt coalescence number and timeout value.
|
|
scic_controller_set_interrupt_coalescence(
|
|
this_controller, 0x10, 250);
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on exit
|
|
* from the SCI_BASE_CONTROLLER_STATE_READY.
|
|
* - This function does nothing.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_ready_state_exit(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
U32 clock_gating_unit_value;
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
/**
|
|
* restore clock gating for power control of the scu unit
|
|
*/
|
|
clock_gating_unit_value = SMU_CGUCR_READ(this_controller);
|
|
|
|
clock_gating_unit_value &= ~SMU_CGUCR_GEN_BIT(IDLE_ENABLE);
|
|
clock_gating_unit_value |= ( SMU_CGUCR_GEN_BIT(REGCLK_ENABLE)
|
|
| SMU_CGUCR_GEN_BIT(TXCLK_ENABLE)
|
|
| SMU_CGUCR_GEN_BIT(XCLK_ENABLE) );
|
|
|
|
SMU_CGUCR_WRITE(this_controller, clock_gating_unit_value);
|
|
|
|
//disable interrupt coalescence.
|
|
scic_controller_set_interrupt_coalescence(this_controller, 0, 0);
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_READY.
|
|
* - Set the state handlers to the controllers ready state.
|
|
* - Stop all of the remote devices on this controller
|
|
* - Stop the ports on this controller
|
|
* - Stop the phys on this controller
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_stopping_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_STOPPING);
|
|
|
|
// Stop all of the components for this controller in the reverse order
|
|
// from which they are initialized.
|
|
scic_sds_controller_stop_devices(this_controller);
|
|
scic_sds_controller_stop_ports(this_controller);
|
|
|
|
if (!scic_sds_controller_has_remote_devices_stopping(this_controller))
|
|
{
|
|
sci_base_state_machine_change_state(
|
|
&this_controller->parent.state_machine,
|
|
SCI_BASE_CONTROLLER_STATE_STOPPED
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on exit
|
|
* from the SCI_BASE_CONTROLLER_STATE_STOPPING.
|
|
* - This function stops the controller stopping timeout timer.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_stopping_state_exit(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_cb_timer_stop(this_controller, this_controller->timeout_timer);
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_STOPPED.
|
|
* - Set the state handlers to the controllers stopped state.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_stopped_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_STOPPED);
|
|
|
|
// We are done with this timer until the next timer we initialize
|
|
scic_cb_timer_destroy(
|
|
this_controller,
|
|
this_controller->timeout_timer
|
|
);
|
|
this_controller->timeout_timer = NULL;
|
|
|
|
// Controller has stopped so disable all the phys on this controller
|
|
scic_sds_controller_stop_phys(this_controller);
|
|
|
|
scic_sds_port_configuration_agent_destroy(
|
|
this_controller,
|
|
&this_controller->port_agent
|
|
);
|
|
|
|
scic_cb_controller_stop_complete(this_controller, SCI_SUCCESS);
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_RESETTING.
|
|
* - Set the state handlers to the controllers resetting state.
|
|
* - Write to the SCU hardware reset register to force a reset
|
|
* - Transition to the SCI_BASE_CONTROLLER_STATE_RESET
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_resetting_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
SCIC_LOG_TRACE((
|
|
sci_base_object_get_logger(this_controller),
|
|
SCIC_LOG_OBJECT_CONTROLLER,
|
|
"scic_sds_controller_resetting_state_enter(0x%x) enter\n",
|
|
this_controller
|
|
));
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_RESETTING);
|
|
|
|
scic_sds_controller_reset_hardware(this_controller);
|
|
|
|
sci_base_state_machine_change_state(
|
|
scic_sds_controller_get_base_state_machine(this_controller),
|
|
SCI_BASE_CONTROLLER_STATE_RESET
|
|
);
|
|
}
|
|
|
|
static
|
|
SCI_STATUS scic_sds_abort_reqests(
|
|
SCIC_SDS_CONTROLLER_T * controller,
|
|
SCIC_SDS_REMOTE_DEVICE_T * remote_device,
|
|
SCIC_SDS_PORT_T * port
|
|
)
|
|
{
|
|
SCI_STATUS status = SCI_SUCCESS;
|
|
SCI_STATUS terminate_status = SCI_SUCCESS;
|
|
SCIC_SDS_REQUEST_T *the_request;
|
|
U32 index;
|
|
U32 request_count;
|
|
|
|
if (remote_device != NULL)
|
|
request_count = remote_device->started_request_count;
|
|
else if (port != NULL)
|
|
request_count = port->started_request_count;
|
|
else
|
|
request_count = SCI_MAX_IO_REQUESTS;
|
|
|
|
|
|
for (index = 0;
|
|
(index < SCI_MAX_IO_REQUESTS) && (request_count > 0);
|
|
index++)
|
|
{
|
|
the_request = controller->io_request_table[index];
|
|
|
|
if (the_request != NULL)
|
|
{
|
|
if (the_request->target_device == remote_device
|
|
|| the_request->target_device->owning_port == port
|
|
|| (remote_device == NULL && port == NULL))
|
|
{
|
|
terminate_status = scic_controller_terminate_request(
|
|
controller,
|
|
the_request->target_device,
|
|
the_request
|
|
);
|
|
|
|
if (terminate_status != SCI_SUCCESS)
|
|
status = terminate_status;
|
|
|
|
request_count--;
|
|
}
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
SCI_STATUS scic_sds_terminate_reqests(
|
|
SCIC_SDS_CONTROLLER_T *this_controller,
|
|
SCIC_SDS_REMOTE_DEVICE_T *this_remote_device,
|
|
SCIC_SDS_PORT_T *this_port
|
|
)
|
|
{
|
|
SCI_STATUS status = SCI_SUCCESS;
|
|
SCI_STATUS abort_status = SCI_SUCCESS;
|
|
|
|
// move all request to abort state
|
|
abort_status = scic_sds_abort_reqests(this_controller, this_remote_device, this_port);
|
|
|
|
if (abort_status != SCI_SUCCESS)
|
|
status = abort_status;
|
|
|
|
//move all request to complete state
|
|
if (this_controller->parent.error == SCI_CONTROLLER_FATAL_MEMORY_ERROR)
|
|
abort_status = scic_sds_abort_reqests(this_controller, this_remote_device, this_port);
|
|
|
|
if (abort_status != SCI_SUCCESS)
|
|
status = abort_status;
|
|
|
|
return status;
|
|
}
|
|
|
|
static
|
|
SCI_STATUS scic_sds_terminate_all_requests(
|
|
SCIC_SDS_CONTROLLER_T * controller
|
|
)
|
|
{
|
|
return scic_sds_terminate_reqests(controller, NULL, NULL);
|
|
}
|
|
|
|
/**
|
|
* This method implements the actions taken by the SCIC_SDS_CONTROLLER on
|
|
* entry to the SCI_BASE_CONTROLLER_STATE_FAILED.
|
|
* - Set the state handlers to the controllers failed state.
|
|
*
|
|
* @param[in] object This is the SCI_BASE_OBJECT which is cast to a
|
|
* SCIC_SDS_CONTROLLER object.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_controller_failed_state_enter(
|
|
SCI_BASE_OBJECT_T *object
|
|
)
|
|
{
|
|
SCIC_SDS_CONTROLLER_T *this_controller;
|
|
this_controller= (SCIC_SDS_CONTROLLER_T *)object;
|
|
|
|
scic_sds_controller_set_base_state_handlers(
|
|
this_controller, SCI_BASE_CONTROLLER_STATE_FAILED);
|
|
|
|
if (this_controller->parent.error == SCI_CONTROLLER_FATAL_MEMORY_ERROR)
|
|
scic_sds_terminate_all_requests(this_controller);
|
|
else
|
|
scic_sds_controller_release_resource(this_controller);
|
|
|
|
//notify framework the controller failed.
|
|
scic_cb_controller_error(this_controller,
|
|
this_controller->parent.error);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
SCI_BASE_STATE_T
|
|
scic_sds_controller_state_table[SCI_BASE_CONTROLLER_MAX_STATES] =
|
|
{
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_INITIAL,
|
|
scic_sds_controller_initial_state_enter,
|
|
NULL,
|
|
},
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_RESET,
|
|
scic_sds_controller_reset_state_enter,
|
|
NULL,
|
|
},
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_INITIALIZING,
|
|
scic_sds_controller_initializing_state_enter,
|
|
NULL,
|
|
},
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_INITIALIZED,
|
|
scic_sds_controller_initialized_state_enter,
|
|
NULL,
|
|
},
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_STARTING,
|
|
scic_sds_controller_starting_state_enter,
|
|
scic_sds_controller_starting_state_exit,
|
|
},
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_READY,
|
|
scic_sds_controller_ready_state_enter,
|
|
scic_sds_controller_ready_state_exit,
|
|
},
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_RESETTING,
|
|
scic_sds_controller_resetting_state_enter,
|
|
NULL,
|
|
},
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_STOPPING,
|
|
scic_sds_controller_stopping_state_enter,
|
|
scic_sds_controller_stopping_state_exit,
|
|
},
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_STOPPED,
|
|
scic_sds_controller_stopped_state_enter,
|
|
NULL,
|
|
},
|
|
{
|
|
SCI_BASE_CONTROLLER_STATE_FAILED,
|
|
scic_sds_controller_failed_state_enter,
|
|
NULL,
|
|
}
|
|
};
|
|
|