static SCI_STATUS scic_sds_remote_node_context_posting_state_event_handler( struct SCIC_SDS_REMOTE_NODE_CONTEXT * this_rnc, U32 event_code ) { SCI_STATUS status; switch (scu_get_event_code(event_code)) { case SCU_EVENT_POST_RNC_COMPLETE: status = SCI_SUCCESS; sci_base_state_machine_change_state( &this_rnc->state_machine, SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE ); break; default: status = SCI_FAILURE; SCIC_LOG_WARNING(( sci_base_object_get_logger(this_rnc->device), SCIC_LOG_OBJECT_SSP_REMOTE_TARGET | SCIC_LOG_OBJECT_SMP_REMOTE_TARGET | SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote Node Context 0x%x requested to process unexpected event 0x%x while in posting state\n", this_rnc, event_code )); break; } return status; }
static SCI_STATUS scic_sds_remote_node_context_resuming_state_event_handler( struct SCIC_SDS_REMOTE_NODE_CONTEXT * this_rnc, U32 event_code ) { SCI_STATUS status; if (scu_get_event_code(event_code) == SCU_EVENT_POST_RCN_RELEASE) { status = SCI_SUCCESS; sci_base_state_machine_change_state( &this_rnc->state_machine, SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE ); } else { switch (scu_get_event_type(event_code)) { case SCU_EVENT_TYPE_RNC_SUSPEND_TX: case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX: // We really dont care if the hardware is going to suspend // the device since it's being resumed anyway SCIC_LOG_INFO(( sci_base_object_get_logger(this_rnc->device), SCIC_LOG_OBJECT_SSP_REMOTE_TARGET | SCIC_LOG_OBJECT_SMP_REMOTE_TARGET | SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote Node Context 0x%x was suspeneded by hardware while being resumed.\n", this_rnc )); status = SCI_SUCCESS; break; default: SCIC_LOG_WARNING(( sci_base_object_get_logger(this_rnc->device), SCIC_LOG_OBJECT_SSP_REMOTE_TARGET | SCIC_LOG_OBJECT_SMP_REMOTE_TARGET | SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote Node Context 0x%x requested to process event 0x%x while in state %d.\n", this_rnc, event_code, sci_base_state_machine_get_state(&this_rnc->state_machine) )); status = SCI_FAILURE; break; } } return status; }
static SCI_STATUS scic_sds_remote_node_context_await_suspension_state_event_handler( struct SCIC_SDS_REMOTE_NODE_CONTEXT * this_rnc, U32 event_code ) { SCI_STATUS status; switch (scu_get_event_type(event_code)) { case SCU_EVENT_TL_RNC_SUSPEND_TX: sci_base_state_machine_change_state( &this_rnc->state_machine, SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE ); this_rnc->suspension_code = scu_get_event_specifier(event_code); status = SCI_SUCCESS; break; case SCU_EVENT_TL_RNC_SUSPEND_TX_RX: sci_base_state_machine_change_state( &this_rnc->state_machine, SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE ); this_rnc->suspension_code = scu_get_event_specifier(event_code); status = SCI_SUCCESS; break; default: SCIC_LOG_WARNING(( sci_base_object_get_logger(this_rnc->device), SCIC_LOG_OBJECT_SSP_REMOTE_TARGET | SCIC_LOG_OBJECT_SMP_REMOTE_TARGET | SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote Node Context 0x%x requested to process event 0x%x while in state %d.\n", this_rnc, event_code, sci_base_state_machine_get_state(&this_rnc->state_machine) )); status = SCI_FAILURE; break; } return status; }
// --------------------------------------------------------------------------- static SCI_STATUS scic_sds_remote_node_context_reset_required_start_io_handler( struct SCIC_SDS_REMOTE_NODE_CONTEXT * this_rnc, struct SCIC_SDS_REQUEST * the_request ) { SCIC_LOG_WARNING(( sci_base_object_get_logger(this_rnc->device), SCIC_LOG_OBJECT_SSP_REMOTE_TARGET | SCIC_LOG_OBJECT_SMP_REMOTE_TARGET | SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote Node Context 0x%x requested to start io 0x%x while in wrong state %d\n", this_rnc, the_request, sci_base_state_machine_get_state(&this_rnc->state_machine) )); return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED; }
static SCI_STATUS scic_sds_remote_node_context_default_event_handler( struct SCIC_SDS_REMOTE_NODE_CONTEXT * this_rnc, U32 event_code ) { SCIC_LOG_WARNING(( sci_base_object_get_logger(this_rnc->device), SCIC_LOG_OBJECT_SSP_REMOTE_TARGET | SCIC_LOG_OBJECT_SMP_REMOTE_TARGET | SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote Node Context 0x%x requested to process event 0x%x while in wrong state %d\n", this_rnc, event_code, sci_base_state_machine_get_state(&this_rnc->state_machine) )); return SCI_FAILURE_INVALID_STATE; }
static SCI_STATUS scic_sds_remote_node_context_default_resume_handler( SCIC_SDS_REMOTE_NODE_CONTEXT_T * this_rnc, SCIC_SDS_REMOTE_NODE_CONTEXT_CALLBACK the_callback, void * callback_parameter ) { SCIC_LOG_WARNING(( sci_base_object_get_logger(this_rnc->device), SCIC_LOG_OBJECT_SSP_REMOTE_TARGET | SCIC_LOG_OBJECT_SMP_REMOTE_TARGET | SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote Node Context 0x%x requested to resume while in wrong state %d\n", this_rnc, sci_base_state_machine_get_state(&this_rnc->state_machine) )); return SCI_FAILURE_INVALID_STATE; }
static SCI_STATUS scic_sds_remote_node_context_default_destruct_handler( SCIC_SDS_REMOTE_NODE_CONTEXT_T * this_rnc, SCIC_SDS_REMOTE_NODE_CONTEXT_CALLBACK the_callback, void * callback_parameter ) { SCIC_LOG_WARNING(( sci_base_object_get_logger(this_rnc->device), SCIC_LOG_OBJECT_SSP_REMOTE_TARGET | SCIC_LOG_OBJECT_SMP_REMOTE_TARGET | SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote Node Context 0x%x requested to stop while in unexpected state %d\n", this_rnc, sci_base_state_machine_get_state(&this_rnc->state_machine) )); // We have decided that the destruct request on the remote node context can not fail // since it is either in the initial/destroyed state or is can be destroyed. return SCI_SUCCESS; }
/** * This method will handle events received while the STP device is in the * ready command substate. * * @param [in] this_device This is the device object that is receiving the * event. * @param [in] event_code The event code to process. * * @return SCI_STATUS */ static SCI_STATUS scic_sds_stp_remote_device_ready_ncq_substate_event_handler( SCIC_SDS_REMOTE_DEVICE_T * this_device, U32 event_code ) { SCI_STATUS status; status = scic_sds_remote_device_general_event_handler(this_device, event_code); switch (scu_get_event_code(event_code)) { case SCU_EVENT_TL_RNC_SUSPEND_TX: case SCU_EVENT_TL_RNC_SUSPEND_TX_RX: /// @todo We need to decode and understand why the hardware suspended the device. /// The suspension reason was probably due to an SDB error FIS received. break; case SCU_EVENT_TL_RNC_SUSPEND_TX_DONE_DATA_LEN_ERR: case SCU_EVENT_TL_RNC_SUSPEND_TX_DONE_OFFSET_ERR: case SCU_EVENT_TL_RNC_SUSPEND_TX_DONE_DMASETUP_DIERR: case SCU_EVENT_TL_RNC_SUSPEND_TX_DONE_XFERCNT_ERR: case SCU_EVENT_TL_RNC_SUSPEND_TX_RX_DONE_PLD_LEN_ERR: this_device->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED; sci_base_state_machine_change_state( &this_device->ready_substate_machine, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR ); // We have a notification that the driver requested a suspend operation // this should not happen. SCIC_LOG_WARNING(( sci_base_object_get_logger(this_device), SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote device 0x%x received driver suspend event %x while in ncq ready substate %d\n", this_device, event_code, sci_base_state_machine_get_state(&this_device->ready_substate_machine) )); // Since we didn't expect to get here start the device again. status = scic_sds_remote_device_resume(this_device); break; case SCU_EVENT_POST_RCN_RELEASE: /// @todo Do we need to store the suspend state on the device? SCIC_LOG_INFO(( sci_base_object_get_logger(this_device), SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote device 0x%x received driver release event %x while in the ready substate %d\n", this_device, event_code, sci_base_state_machine_get_state(&this_device->ready_substate_machine) )); break; default: // Some other event just log it and continue SCIC_LOG_WARNING(( sci_base_object_get_logger(this_device), SCIC_LOG_OBJECT_STP_REMOTE_TARGET, "SCIC Remote device 0x%x received driver unexpected event %x while in the ready substate %d\n", this_device, event_code, sci_base_state_machine_get_state(&this_device->ready_substate_machine) )); status = SCI_FAILURE_INVALID_STATE; break; } return status; }
/** * @brief This method processes the completions transport layer (TL) status * to determine if the RAW task management frame was sent successfully. * If the raw frame was sent successfully, then the state for the * task request transitions to waiting for a response frame. * * @param[in] this_request This parameter specifies the request for which * the TC completion was received. * @param[in] completion_code This parameter indicates the completion status * information for the TC. * * @return Indicate if the tc completion handler was successful. * @retval SCI_SUCCESS currently this method always returns success. */ static SCI_STATUS scic_sds_ssp_task_request_await_tc_completion_tc_completion_handler( SCIC_SDS_REQUEST_T * this_request, U32 completion_code ) { SCIC_LOG_TRACE(( sci_base_object_get_logger(this_request), SCIC_LOG_OBJECT_TASK_MANAGEMENT, "scic_sds_ssp_task_request_await_tc_completion_tc_completion_handler(0x%x, 0x%x) enter\n", this_request, completion_code )); switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) { case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD): scic_sds_request_set_status( this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS ); sci_base_state_machine_change_state( &this_request->started_substate_machine, SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE ); break; case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO): // Currently, the decision is to simply allow the task request to // timeout if the task IU wasn't received successfully. // There is a potential for receiving multiple task responses if we // decide to send the task IU again. SCIC_LOG_WARNING(( sci_base_object_get_logger(this_request), SCIC_LOG_OBJECT_TASK_MANAGEMENT, "TaskRequest:0x%x CompletionCode:%x - ACK/NAK timeout\n", this_request, completion_code )); sci_base_state_machine_change_state( &this_request->started_substate_machine, SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE ); break; default: // All other completion status cause the IO to be complete. If a NAK // was received, then it is up to the user to retry the request. scic_sds_request_set_status( this_request, SCU_NORMALIZE_COMPLETION_STATUS(completion_code), SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR ); sci_base_state_machine_change_state( &this_request->parent.state_machine, SCI_BASE_REQUEST_STATE_COMPLETED ); break; } return SCI_SUCCESS; }