SCI_STATUS scif_io_request_construct_with_core ( SCI_CONTROLLER_HANDLE_T scif_controller, SCI_REMOTE_DEVICE_HANDLE_T scif_remote_device, void * scic_io_request, void * user_io_request_object, void * io_request_memory, SCI_IO_REQUEST_HANDLE_T * scif_io_request ) { SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T*) io_request_memory; SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*) scif_remote_device; SCI_STATUS status = SCI_SUCCESS; SCIF_LOG_TRACE(( sci_base_object_get_logger(fw_device), SCIF_LOG_OBJECT_IO_REQUEST, "scif_io_request_construct_pass_through(0x%x, 0x%x, 0x%x, 0x%x) enter\n", scif_remote_device, user_io_request_object, io_request_memory, scif_io_request )); // Initialize the users handle to the framework IO request. *scif_io_request = fw_io; // Construct the parent object first in order to ensure logging can // function. scif_sas_request_construct( &fw_io->parent, fw_device, sci_base_object_get_logger(fw_device), scif_sas_io_request_state_table ); fw_io->parent.core_object = scic_io_request; //set association sci_object_set_association(fw_io, user_io_request_object); sci_object_set_association(fw_io->parent.core_object, fw_io); sci_base_state_machine_logger_initialize( &fw_io->parent.parent.state_machine_logger, &fw_io->parent.parent.state_machine, &fw_io->parent.parent.parent, scif_cb_logger_log_states, "SCIF_IO_REQUEST_T", "base_state_machine", SCIF_LOG_OBJECT_IO_REQUEST ); return status; }
/** * This method will turn on logging of domain state changes. * * @param[in] fw_domain The domain for which the state logging is to be turned * on. */ void scif_sas_domain_initialize_state_logging( SCIF_SAS_DOMAIN_T *fw_domain ) { sci_base_state_machine_logger_initialize( &fw_domain->parent.state_machine_logger, &fw_domain->parent.state_machine, &fw_domain->parent.parent, scif_cb_logger_log_states, "SCIF_SAS_DOMAIN_T", "base state machine", SCIF_LOG_OBJECT_DOMAIN ); }
/** * This method will start state transition logging for the framework * controller object. * * @param[in] fw_controller The framework controller object on which to * observe state changes. * * @return none */ void scif_sas_controller_initialize_state_logging( SCIF_SAS_CONTROLLER_T * fw_controller ) { sci_base_state_machine_logger_initialize( &fw_controller->parent.state_machine_logger, &fw_controller->parent.state_machine, &fw_controller->parent.parent, scif_cb_logger_log_states, "SCIF_SAS_CONTROLLER_T", "base state machine", SCIF_LOG_OBJECT_CONTROLLER ); }
/** * This method will enable and turn on state transition logging for the remote * node context object. * * @param[in] this_rnc The remote node context for which state transition * logging is to be enabled. * * @return none */ void scic_sds_remote_node_context_initialize_state_logging( SCIC_SDS_REMOTE_NODE_CONTEXT_T * this_rnc ) { sci_base_state_machine_logger_initialize( &this_rnc->state_machine_logger, &this_rnc->state_machine, &this_rnc->parent, scic_cb_logger_log_states, "SCIC_SDS_REMOTE_NODE_CONTEXT_T", "state machine", SCIC_LOG_OBJECT_SSP_REMOTE_TARGET | SCIC_LOG_OBJECT_SMP_REMOTE_TARGET | SCIC_LOG_OBJECT_STP_REMOTE_TARGET ); }
static SCI_STATUS scif_sas_task_request_generic_construct( SCI_CONTROLLER_HANDLE_T scif_controller, SCI_REMOTE_DEVICE_HANDLE_T scif_remote_device, U16 io_tag, void * user_task_request_object, void * task_request_memory, SCI_TASK_REQUEST_HANDLE_T * scif_task_request, U8 task_function ) { SCI_STATUS status; SCIF_SAS_CONTROLLER_T * fw_controller = (SCIF_SAS_CONTROLLER_T*) scif_controller; SCIF_SAS_TASK_REQUEST_T * fw_task = (SCIF_SAS_TASK_REQUEST_T*) task_request_memory; SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*) scif_remote_device; U8 * core_request_memory; SCIF_LOG_TRACE(( sci_base_object_get_logger(fw_controller), SCIF_LOG_OBJECT_TASK_MANAGEMENT, "scif_task_request_construct(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) enter\n", scif_controller, scif_remote_device, io_tag, user_task_request_object, task_request_memory, scif_task_request )); // Initialize the user's handle to the framework task request. *scif_task_request = fw_task; // initialize affected request count fw_task->affected_request_count = 0; fw_task->io_tag_to_manage = SCI_CONTROLLER_INVALID_IO_TAG; fw_task->function = task_function; if (task_function == SCI_SAS_HARD_RESET ) { if (fw_device->containing_device != NULL ) {// Target Reset is for an expander attached device, // go down to construct smp Phy Control request. scif_sas_smp_request_construct_phy_control( fw_controller, fw_device->containing_device, PHY_OPERATION_HARD_RESET, fw_device->expander_phy_identifier, user_task_request_object, task_request_memory ); } else { scif_sas_request_construct( &fw_task->parent, fw_device, sci_base_object_get_logger(fw_controller), scif_sas_task_request_state_table ); // If target reset is for a DA device, don't build task at all. // Just set object association. sci_object_set_association(fw_task, user_task_request_object); } return SCI_SUCCESS; } // Construct the parent object first in order to ensure logging can // function. scif_sas_request_construct( &fw_task->parent, fw_device, sci_base_object_get_logger(fw_controller), scif_sas_task_request_state_table ); core_request_memory = (U8 *)task_request_memory + sizeof(SCIF_SAS_TASK_REQUEST_T); status = scic_task_request_construct( fw_controller->core_object, fw_device->core_object, io_tag, fw_task, core_request_memory, &fw_task->parent.core_object ); if (status == SCI_SUCCESS) { SMP_DISCOVER_RESPONSE_PROTOCOLS_T dev_protocols; // These associations must be set early for the core io request // object construction to complete correctly as there will be // callbacks into the user driver framework during core construction sci_object_set_association(fw_task, user_task_request_object); sci_object_set_association(fw_task->parent.core_object, fw_task); // Perform protocol specific core IO request construction. scic_remote_device_get_protocols(fw_device->core_object, &dev_protocols); if (dev_protocols.u.bits.attached_ssp_target) status = scic_task_request_construct_ssp(fw_task->parent.core_object); else if (dev_protocols.u.bits.attached_stp_target) status = scif_sas_stp_task_request_construct(fw_task); else status = SCI_FAILURE_UNSUPPORTED_PROTOCOL; if (status == SCI_SUCCESS) { sci_base_state_machine_logger_initialize( &fw_task->parent.parent.state_machine_logger, &fw_task->parent.parent.state_machine, &fw_task->parent.parent.parent, scif_cb_logger_log_states, "SCIF_SAS_TASK_REQUEST_T", "base_state_machine", SCIF_LOG_OBJECT_TASK_MANAGEMENT ); } else { SCIF_LOG_WARNING(( sci_base_object_get_logger(fw_task), SCIF_LOG_OBJECT_TASK_MANAGEMENT, "Device:0x%x TaskRequest:0x%x Function:0x%x construct failed\n", fw_device, fw_task, scif_sas_task_request_get_function(fw_task) )); } } return status; }
/** * @brief This method constructs an scif sas smp request. * * @param[in] fw_controller The framework controller * @param[in] fw_device The smp device that the smp request targets to. * @param[in] fw_io_memory The memory space for the smp request. * @param[in] core_io_memory The memory space for the core request. * @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_io_request_construct_smp( SCIF_SAS_CONTROLLER_T * fw_controller, SCIF_SAS_REMOTE_DEVICE_T * fw_device, void * fw_io_memory, void * core_io_memory, U16 io_tag, SMP_REQUEST_T * smp_command, void * user_request_object ) { SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T*)fw_io_memory; SCI_STATUS status = SCI_SUCCESS; SCIF_LOG_TRACE(( sci_base_object_get_logger(fw_device), SCIF_LOG_OBJECT_IO_REQUEST, "scif_sas_io_request_construct_smp(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) enter\n", fw_controller, fw_device, fw_io_memory, core_io_memory, io_tag, smp_command, user_request_object )); // Construct the parent object first in order to ensure logging can // function. scif_sas_request_construct( &fw_io->parent, fw_device, sci_base_object_get_logger(fw_controller), scif_sas_io_request_state_table ); status = scic_io_request_construct( fw_device->domain->controller->core_object, fw_device->core_object, io_tag, (void*)fw_io, (U8 *)core_io_memory, &fw_io->parent.core_object ); if (status == SCI_SUCCESS) { //set object association. sci_object_set_association(fw_io, user_request_object); sci_object_set_association(fw_io->parent.core_object, fw_io); scif_sas_smp_request_construct(&fw_io->parent, smp_command); fw_io->parent.is_high_priority = TRUE; sci_base_state_machine_logger_initialize( &fw_io->parent.parent.state_machine_logger, &fw_io->parent.parent.state_machine, &fw_io->parent.parent.parent, scif_cb_logger_log_states, "SCIF_IO_REQUEST_T", "base_state_machine", SCIF_LOG_OBJECT_IO_REQUEST ); } return status; }
/** * @brief This method represents common functionality for the * scif_io_request_construct() and scif_sas_io_request_continue() * methods. * * @return This method returns an indication as to whether the * construction succeeded. */ static SCI_STATUS scif_sas_io_request_construct( SCIF_SAS_REMOTE_DEVICE_T * fw_device, SCIF_SAS_IO_REQUEST_T * fw_io, U16 io_tag, void * user_io_request_object, SCI_IO_REQUEST_HANDLE_T * scif_io_request, BOOL is_initial_construction ) { SCI_STATUS status; SMP_DISCOVER_RESPONSE_PROTOCOLS_T dev_protocols; scic_remote_device_get_protocols(fw_device->core_object, &dev_protocols); //Currently, all the io requests sent to smp target are internal. //so we fail all the external io toward to it. //Todo: is there a better way to handle external io to smp target? if (dev_protocols.u.bits.attached_smp_target) return SCI_FAILURE_INVALID_REMOTE_DEVICE; SCIF_LOG_TRACE(( sci_base_object_get_logger(fw_device), SCIF_LOG_OBJECT_IO_REQUEST, "scif_sas_io_request_construct(0x%x,0x%x,0x%x,0x%x,0x%x,0x%x) enter\n", fw_device, fw_io, io_tag, user_io_request_object, scif_io_request, is_initial_construction )); // Initialize the users handle to the framework IO request. *scif_io_request = fw_io; // Construct the parent object first in order to ensure logging can // function. scif_sas_request_construct( &fw_io->parent, fw_device, sci_base_object_get_logger(fw_device), scif_sas_io_request_state_table ); status = scic_io_request_construct( fw_device->domain->controller->core_object, fw_device->core_object, io_tag, fw_io, ((U8 *)fw_io) + sizeof(SCIF_SAS_IO_REQUEST_T), &fw_io->parent.core_object ); if (status == SCI_SUCCESS) { // These associations must be set early for the core io request // object construction to complete correctly as there will be // callbacks into the user driver framework during core construction sci_object_set_association(fw_io, user_io_request_object); sci_object_set_association(fw_io->parent.core_object, fw_io); // Perform protocol specific core IO request construction. if (dev_protocols.u.bits.attached_ssp_target) status = scic_io_request_construct_basic_ssp(fw_io->parent.core_object); else if (dev_protocols.u.bits.attached_stp_target) { if (is_initial_construction == TRUE) sati_sequence_construct(&fw_io->parent.stp.sequence); #if !defined(DISABLE_ATAPI) if (!scic_remote_device_is_atapi(fw_device->core_object)) { #endif status = scif_sas_stp_io_request_construct(fw_io); #if !defined(DISABLE_ATAPI) } else status = scif_sas_stp_packet_io_request_construct(fw_io); #endif } sci_base_state_machine_logger_initialize( &fw_io->parent.parent.state_machine_logger, &fw_io->parent.parent.state_machine, &fw_io->parent.parent.parent, scif_cb_logger_log_states, "SCIF_IO_REQUEST_T", "base_state_machine", SCIF_LOG_OBJECT_IO_REQUEST ); } return status; }
SCI_STATUS scif_request_construct( SCI_CONTROLLER_HANDLE_T scif_controller, SCI_REMOTE_DEVICE_HANDLE_T scif_remote_device, U16 io_tag, void * user_io_request_object, void * io_request_memory, SCI_IO_REQUEST_HANDLE_T * scif_io_request ) { SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T*) io_request_memory; SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*) scif_remote_device; SCI_STATUS status; SCIF_LOG_TRACE(( sci_base_object_get_logger(fw_device), SCIF_LOG_OBJECT_IO_REQUEST, "scif_io_request_construct(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) enter\n", scif_controller, scif_remote_device, io_tag, user_io_request_object, io_request_memory, scif_io_request )); // Step 1: Create the scif io request. // Initialize the users handle to the framework IO request. *scif_io_request = fw_io; // Construct the parent object first in order to ensure logging can // function. scif_sas_request_construct( &fw_io->parent, fw_device, sci_base_object_get_logger(fw_device), scif_sas_io_request_state_table ); status = scic_io_request_construct( (void *) ((SCIF_SAS_CONTROLLER_T *)scif_controller)->core_object, (void *) fw_device->core_object, io_tag, fw_io, (U8 *)io_request_memory + sizeof(SCIF_SAS_IO_REQUEST_T), &fw_io->parent.core_object ); if (status == SCI_SUCCESS) { // These associations must be set early for the core io request // object construction to complete correctly as there will be // callbacks into the user driver framework during core construction sci_object_set_association(fw_io, user_io_request_object); sci_object_set_association(fw_io->parent.core_object, fw_io); sci_base_state_machine_logger_initialize( &fw_io->parent.parent.state_machine_logger, &fw_io->parent.parent.state_machine, &fw_io->parent.parent.parent, scif_cb_logger_log_states, "SCIF_IO_REQUEST_T", "base_state_machine", SCIF_LOG_OBJECT_IO_REQUEST ); } return status; }