/**
* @brief This method will ensure all internal requests destined for
* devices contained in the supplied domain are properly removed
* from the high priority request queue.
*
* @param[in] fw_hprq This parameter specifies the high priority request
* queue object for which to attempt to remove elements.
* @param[in] fw_domain This parameter specifies the domain for which to
* remove all high priority requests.
*
* @return none
*/
void scif_sas_high_priority_request_queue_purge_domain(
SCIF_SAS_HIGH_PRIORITY_REQUEST_QUEUE_T * fw_hprq,
SCIF_SAS_DOMAIN_T * fw_domain
)
{
SCIF_SAS_IO_REQUEST_T * fw_io;
POINTER_UINT io_address;
U32 index;
U32 element_count;
SCIF_LOG_TRACE((
sci_base_object_get_logger(&fw_hprq->lock),
SCIF_LOG_OBJECT_CONTROLLER | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
"scif_sas_high_priority_request_queue_purge_domain(0x%x,0x%x) enter\n",
fw_hprq, fw_domain
));
element_count = sci_pool_count(fw_hprq->pool);
scif_cb_lock_acquire(fw_domain->controller, &fw_hprq->lock);
for (index = 0; index < element_count; index++)
{
sci_pool_get(fw_hprq->pool, io_address);
fw_io = (SCIF_SAS_IO_REQUEST_T*) io_address;
// If the high priority request is not intended for this domain,
// then it can be left in the pool.
if (fw_io->parent.device->domain != fw_domain)
{
sci_pool_put(fw_hprq->pool, io_address);
}
else
{
if (fw_io->parent.is_internal)
{
SCIF_SAS_INTERNAL_IO_REQUEST_T * fw_internal_io =
(SCIF_SAS_INTERNAL_IO_REQUEST_T *)fw_io;
// The request was intended for a device in the domain. Put it
// back in the pool of freely available internal request memory
// objects. The internal IO's timer is to be destoyed.
scif_sas_internal_io_request_destruct(fw_domain->controller, fw_internal_io);
}
}
}
scif_cb_lock_release(fw_domain->controller, &fw_hprq->lock);
}
/**
* @brief This methods takes care of completion of an internal request about its
* "internal" related feature, including the memory recycling and timer.
*
* @param[in] fw_controller The framework controller object.
* @param[in] fw_internal_io The internal io to be completed.
* @param[in] completion_status the completeion status by core and framework so
* far.
*
* @return none
*/
void scif_sas_internal_io_request_complete(
SCIF_SAS_CONTROLLER_T * fw_controller,
SCIF_SAS_INTERNAL_IO_REQUEST_T * fw_internal_io,
SCI_STATUS completion_status
)
{
SCIF_LOG_TRACE((
sci_base_object_get_logger(fw_controller),
SCIF_LOG_OBJECT_IO_REQUEST,
"scif_sas_internal_io_request_complete(0x%x, 0x%x, 0x%x) enter\n",
fw_controller, fw_internal_io, completion_status
));
scif_cb_timer_stop(fw_controller, fw_internal_io->internal_io_timer);
scif_sas_internal_io_request_destruct(fw_controller, fw_internal_io);
}
/**
* @brief This method constructs an internal smp request.
*
* @param[in] fw_controller The framework controller
* @param[in] fw_device The smp device that the internal io targets to.
* @param[in] internal_io_memory The memory space for the internal io.
* @param[in] io_tag The io tag for the internl io to be constructed.
* @param[in] smp_command A pointer to the smp request data structure according
* to SAS protocol.
*
* @return Indicate if the internal io was successfully constructed.
* @retval SCI_SUCCESS This value is returned if the internal io was
* successfully constructed.
* @retval SCI_FAILURE This value is returned if the internal io was failed to
* be constructed.
*/
SCI_STATUS scif_sas_internal_io_request_construct_smp(
SCIF_SAS_CONTROLLER_T * fw_controller,
SCIF_SAS_REMOTE_DEVICE_T * fw_device,
void * internal_io_memory,
U16 io_tag,
SMP_REQUEST_T * smp_command
)
{
SCIF_SAS_INTERNAL_IO_REQUEST_T * fw_internal_io =
(SCIF_SAS_INTERNAL_IO_REQUEST_T*)internal_io_memory;
SCIF_SAS_IO_REQUEST_T * fw_io =
(SCIF_SAS_IO_REQUEST_T*)internal_io_memory;
SCI_STATUS status;
//call common smp request construct routine.
status = scif_sas_io_request_construct_smp(
fw_controller,
fw_device,
internal_io_memory,
(char *)internal_io_memory + sizeof(SCIF_SAS_INTERNAL_IO_REQUEST_T),
SCI_CONTROLLER_INVALID_IO_TAG,
smp_command,
NULL //there is no associated user io object.
);
//Codes below are all internal io related.
if (status == SCI_SUCCESS)
{
//set the is_internal flag
fw_io->parent.is_internal = TRUE;
if (fw_internal_io->internal_io_timer == NULL)
{
//create the timer for this internal request.
fw_internal_io->internal_io_timer =
scif_cb_timer_create(
(SCI_CONTROLLER_HANDLE_T *)fw_controller,
scif_sas_internal_io_request_timeout_handler,
(void*)fw_io
);
}
else
{
ASSERT (0);
}
//insert into high priority queue
if ( !sci_pool_full(fw_controller->hprq.pool) )
{
sci_pool_put(
fw_controller->hprq.pool, (POINTER_UINT) internal_io_memory
);
}
else
{
SCIF_LOG_ERROR((
sci_base_object_get_logger(fw_controller),
SCIF_LOG_OBJECT_CONTROLLER | SCIF_LOG_OBJECT_REMOTE_DEVICE,
"scif_sas_internal_io_request_construct_smp, high priority queue full!\n"
));
scif_sas_internal_io_request_destruct(fw_controller, fw_internal_io);
//return failure status.
return SCI_FAILURE_INSUFFICIENT_RESOURCES;
}
}
return status;
}
