/* See EsifUpDomain_InitIterator for usage */ static eEsifError get_next_fpc_domain( EsifDspPtr dspPtr, EsifFpcDomainIteratorPtr iteratorPtr, EsifFpcDomainPtr *fpcDomainPtr ) { eEsifError rc = ESIF_OK; if ((NULL == dspPtr) || (NULL == iteratorPtr) || (NULL == fpcDomainPtr)) { ESIF_TRACE_WARN("Parameter is NULL\n"); rc = ESIF_E_PARAMETER_IS_NULL; goto exit; } /* Verify the iterator is initialized */ if (iteratorPtr->marker != FPC_DOMAIN_ITERATOR_MARKER) { ESIF_TRACE_WARN("Iterator invalid\n"); rc = ESIF_E_INVALID_HANDLE; goto exit; } if (iteratorPtr->currPtr == NULL) { *fpcDomainPtr = NULL; rc = ESIF_E_ITERATION_DONE; } else { *fpcDomainPtr = (EsifFpcDomainPtr) iteratorPtr->currPtr->data_ptr; iteratorPtr->currPtr = iteratorPtr->currPtr->next_ptr; } exit: return rc; }
eEsifError EsifActCallPluginGet( esif_context_t actCtx, EsifUpPtr upPtr, const EsifFpcActionPtr fpcActionPtr, ActExecuteGetFunction actGetFuncPtr, const EsifDataPtr requestPtr, const EsifDataPtr responsePtr ) { eEsifError rc = ESIF_OK; EsifData params[NUMBER_OF_PARAMETERS_FOR_AN_ACTION] = {0}; /* Participant Check */ if (NULL == upPtr) { rc = ESIF_E_PARAMETER_IS_NULL; ESIF_TRACE_WARN("Participant For Participant ID %d NOT FOUND\n", EsifUp_GetInstance(upPtr)); goto exit; } if (NULL == fpcActionPtr) { rc = ESIF_E_PARAMETER_IS_NULL; ESIF_TRACE_WARN("NULL action pointer received\n"); goto exit; } if (NULL == actGetFuncPtr) { ESIF_TRACE_DEBUG("Plugin function pointer is NULL\n"); rc = ESIF_E_PARAMETER_IS_NULL; goto exit; } if (NULL == requestPtr) { rc = ESIF_E_PARAMETER_IS_NULL; ESIF_TRACE_WARN("NULL request pointer\n"); goto exit; } rc = EsifFpcAction_GetParams(fpcActionPtr, params, sizeof(params)/sizeof(*params)); if (ESIF_OK != rc) { goto exit; } rc = actGetFuncPtr(actCtx, (esif_handle_t)(size_t)upPtr->fInstance, upPtr->fMetadata.fDevicePath, ¶ms[0], ¶ms[1], ¶ms[2], ¶ms[3], ¶ms[4], requestPtr, responsePtr); exit: return rc; }
/* Unloads a pluggable UPE action by library name */ eEsifError EsifActMgr_StopUpe(EsifString upeName) { eEsifError rc = ESIF_OK; EsifActMgrEntryPtr entryPtr = NULL; struct esif_link_list_node *nodePtr = NULL; if (NULL == upeName) { rc = ESIF_E_PARAMETER_IS_NULL; goto exit; } esif_ccb_write_lock(&g_actMgr.mgrLock); entryPtr = EsifActMgr_GetActEntryByLibname_Locked(upeName); if (NULL == entryPtr) { esif_ccb_write_unlock(&g_actMgr.mgrLock); rc = ESIF_E_ACTION_NOT_IMPLEMENTED; ESIF_TRACE_WARN("Failed To Find Action: %s\n", upeName); goto exit; } nodePtr = EsifActMgr_GetNodeFromEntry_Locked(entryPtr); esif_link_list_node_remove(g_actMgr.actions, nodePtr); g_actMgr.numActions--; esif_ccb_write_unlock(&g_actMgr.mgrLock); EsifActMgr_DestroyEntry(entryPtr); ESIF_TRACE_DEBUG("Stopped Action: %s\n", upeName); exit: return rc; }
// IPC Execute enum esif_rc ipc_execute(struct esif_ipc *ipc) { enum esif_rc rc = ESIF_OK; struct timeval start = {0}; struct timeval finish = {0}; struct timeval result; if (g_ipc_handle == ESIF_INVALID_HANDLE) { ESIF_TRACE_WARN("ESIF LF is not available\n"); rc = ESIF_E_NO_LOWER_FRAMEWORK; goto exit; } if (g_timestamp) { esif_ccb_get_time(&start); } rc = esif_ipc_execute(g_ipc_handle, ipc); if (g_timestamp) { esif_ccb_get_time(&finish); } if (g_timestamp) { ESIF_TRACE_DEBUG("Start time: %06lu.%06lu\n", start.tv_sec, start.tv_usec); ESIF_TRACE_DEBUG("Finish time: %06lu.%06lu\n", finish.tv_sec, finish.tv_usec); timeval_subtract(&result, &finish, &start); ESIF_TRACE_DEBUG("IPC Exec Time: %06lu.%06lu (%06lu usecs)\n", result.tv_sec, result.tv_usec, result.tv_usec); } exit: return rc; }
// IPC Connect eEsifError ipc_connect() { eEsifError rc = ESIF_OK; int check_kernel_version = ESIF_TRUE; ESIF_TRACE_ENTRY_INFO(); // Exit if IPC already connected if (g_ipc_handle != ESIF_INVALID_HANDLE) { return ESIF_OK; } // Connect to LF g_ipc_handle = esif_ipc_connect((char *)SESSION_ID); if (g_ipc_handle == ESIF_INVALID_HANDLE) { ESIF_TRACE_WARN("ESIF LF is not available\n"); rc = ESIF_E_NO_LOWER_FRAMEWORK; } else { char *outbuf = esif_ccb_malloc(OUT_BUF_LEN); char *kern_str = (outbuf != NULL ? esif_cmd_info(outbuf) : NULL); ESIF_TRACE_DEBUG("ESIF IPC Kernel Device Opened\n"); if (NULL != kern_str) { // Extract just the Kernel LF Version from the result string extract_kernel_version(kern_str, OUT_BUF_LEN); // Bypass Kernel Version check for DEBUG builds #if defined(ESIF_ATTR_DEBUG) check_kernel_version = ESIF_FALSE; #endif // Validate Kernel LF version is compatible with UF version if (check_kernel_version == ESIF_FALSE || esif_ccb_strcmp(kern_str, ESIF_VERSION) == 0) { ESIF_TRACE_INFO("Kernel Version: %s\n", kern_str); esif_ccb_sprintf(sizeof(g_esif_kernel_version), g_esif_kernel_version, "%s", kern_str); } else { ESIF_TRACE_ERROR("ESIF_LF Version (%s) Incompatible with ESIF_UF Version (%s)\n", kern_str, ESIF_VERSION); ipc_disconnect(); rc = ESIF_E_NOT_SUPPORTED; } } esif_ccb_free(outbuf); } ESIF_TRACE_EXIT_INFO_W_STATUS(rc); return rc; }
/* Will sync any existing lower framework participatnts */ enum esif_rc sync_lf_participants() { eEsifError rc = ESIF_OK; struct esif_command_get_participants *data_ptr = NULL; const UInt32 data_len = sizeof(struct esif_command_get_participants); struct esif_ipc_command *command_ptr = NULL; UInt8 i = 0; UInt32 count = 0; struct esif_ipc *ipc_ptr = NULL; ESIF_TRACE_ENTRY_INFO(); ipc_ptr = esif_ipc_alloc_command(&command_ptr, data_len); if (NULL == ipc_ptr || NULL == command_ptr) { ESIF_TRACE_ERROR("Fail to allocate esif_ipc/esif_ipc_command\n"); rc = ESIF_E_NO_MEMORY; goto exit; } command_ptr->type = ESIF_COMMAND_TYPE_GET_PARTICIPANTS; command_ptr->req_data_type = ESIF_DATA_VOID; command_ptr->req_data_offset = 0; command_ptr->req_data_len = 0; command_ptr->rsp_data_type = ESIF_DATA_STRUCTURE; command_ptr->rsp_data_offset = 0; command_ptr->rsp_data_len = data_len; rc = ipc_execute(ipc_ptr); if (ESIF_OK != rc) { goto exit; } if (ESIF_OK != ipc_ptr->return_code) { rc = ipc_ptr->return_code; ESIF_TRACE_WARN("ipc_ptr return_code failure - %s\n", esif_rc_str(rc)); goto exit; } if (ESIF_OK != command_ptr->return_code) { rc = command_ptr->return_code; ESIF_TRACE_WARN("command_ptr return_code failure - %s\n", esif_rc_str(rc)); goto exit; } /* Participant Data */ data_ptr = (struct esif_command_get_participants *)(command_ptr + 1); count = data_ptr->count; for (i = 0; i < count; i++) { struct esif_ipc_event_data_create_participant participantData; EsifData esifParticipantData = {ESIF_DATA_BINARY, &participantData, sizeof(participantData), sizeof(participantData)}; rc = get_participant_data(&participantData, i); if (ESIF_OK != rc) { rc = ESIF_OK; /* Ignore RC for get_participant_data */ continue; } EsifEventMgr_SignalEvent(0, EVENT_MGR_DOMAIN_D0, ESIF_EVENT_PARTICIPANT_CREATE, &esifParticipantData); } exit: ESIF_TRACE_INFO("rc = %s(%u)", esif_rc_str(rc), rc); if (NULL != ipc_ptr) { esif_ipc_free(ipc_ptr); } ESIF_TRACE_EXIT_INFO_W_STATUS(rc); return rc; }
/* Work Around */ static enum esif_rc get_participant_data( struct esif_ipc_event_data_create_participant *pi_ptr, UInt8 participantId ) { eEsifError rc = ESIF_OK; struct esif_command_get_part_detail *data_ptr = NULL; struct esif_ipc_command *command_ptr = NULL; struct esif_ipc *ipc_ptr = NULL; const u32 data_len = sizeof(struct esif_command_get_part_detail); ipc_ptr = esif_ipc_alloc_command(&command_ptr, data_len); if (NULL == ipc_ptr || NULL == command_ptr) { ESIF_TRACE_ERROR("Fail to allocate esif_ipc/esif_ipc_command\n"); rc = ESIF_E_NO_MEMORY; goto exit; } command_ptr->type = ESIF_COMMAND_TYPE_GET_PARTICIPANT_DETAIL; command_ptr->req_data_type = ESIF_DATA_UINT32; command_ptr->req_data_offset = 0; command_ptr->req_data_len = 4; command_ptr->rsp_data_type = ESIF_DATA_STRUCTURE; command_ptr->rsp_data_offset = 0; command_ptr->rsp_data_len = data_len; // ID For Command *(u32 *)(command_ptr + 1) = participantId; rc = ipc_execute(ipc_ptr); if (ESIF_OK != rc) { goto exit; } if (ESIF_OK != ipc_ptr->return_code) { rc = ipc_ptr->return_code; ESIF_TRACE_WARN("ipc_ptr return_code failure - %s\n", esif_rc_str(rc)); goto exit; } if (ESIF_OK != command_ptr->return_code) { rc = command_ptr->return_code; ESIF_TRACE_WARN("command_ptr return_code failure - %s\n", esif_rc_str(rc)); goto exit; } // our data data_ptr = (struct esif_command_get_part_detail *)(command_ptr + 1); if (0 == data_ptr->version) { ESIF_TRACE_ERROR("Participant version is 0\n"); goto exit; } pi_ptr->id = (u8)data_ptr->id; pi_ptr->version = data_ptr->version; esif_ccb_memcpy(pi_ptr->class_guid, data_ptr->class_guid, ESIF_GUID_LEN); pi_ptr->enumerator = data_ptr->enumerator; pi_ptr->flags = data_ptr->flags; esif_ccb_strcpy(pi_ptr->name, data_ptr->name, ESIF_NAME_LEN); esif_ccb_strcpy(pi_ptr->desc, data_ptr->desc, ESIF_DESC_LEN); esif_ccb_strcpy(pi_ptr->driver_name, data_ptr->driver_name, ESIF_NAME_LEN); esif_ccb_strcpy(pi_ptr->device_name, data_ptr->device_name, ESIF_NAME_LEN); esif_ccb_strcpy(pi_ptr->device_path, data_ptr->device_path, ESIF_NAME_LEN); /* ACPI */ esif_ccb_strcpy(pi_ptr->acpi_device, data_ptr->acpi_device, ESIF_NAME_LEN); esif_ccb_strcpy(pi_ptr->acpi_scope, data_ptr->acpi_scope, ESIF_SCOPE_LEN); esif_ccb_strcpy(pi_ptr->acpi_uid, data_ptr->acpi_uid, sizeof(pi_ptr->acpi_uid)); pi_ptr->acpi_type = data_ptr->acpi_type; /* PCI */ pi_ptr->pci_vendor = data_ptr->pci_vendor; pi_ptr->pci_device = data_ptr->pci_device; pi_ptr->pci_bus = data_ptr->pci_bus; pi_ptr->pci_bus_device = data_ptr->pci_bus_device; pi_ptr->pci_function = data_ptr->pci_function; pi_ptr->pci_revision = data_ptr->pci_revision; pi_ptr->pci_class = data_ptr->pci_class; pi_ptr->pci_sub_class = data_ptr->pci_sub_class; pi_ptr->pci_prog_if = data_ptr->pci_prog_if; exit: if (NULL != ipc_ptr) { esif_ipc_free(ipc_ptr); } return rc; }
eEsifError esif_fpc_load( EsifFpcPtr fpcPtr, EsifDspPtr dspPtr ) { eEsifError rc = ESIF_OK; EsifFpcDomainPtr domainPtr; EsifFpcPrimitivePtr primitivePtr; EsifFpcAlgorithmPtr algoPtr; EsifFpcEventPtr eventPtr; unsigned long offset = 0; UInt8 *basePtr = (UInt8 *)fpcPtr; UInt32 numPrim = 0; UInt32 i; UInt32 j; if ((fpcPtr == NULL) || (dspPtr == NULL)) { ESIF_TRACE_ERROR("The fpc pointer or dsp pointer is NULL\n"); rc = ESIF_E_PARAMETER_IS_NULL; goto exit; } if (fpcPtr->number_of_domains < 1) { ESIF_TRACE_WARN("No domain error, number_of_domain = %d (less than 1)\n", fpcPtr->number_of_domains); rc = ESIF_E_PARAMETER_IS_NULL; goto exit; } dspPtr->domain_count = &fpcPtr->number_of_domains; /* Allocate Hash and List. Hash Size 31 Is Hard-Coded And Chosen By DSP Compiler */ dspPtr->ht_ptr = esif_ht_create(ESIF_DSP_HASHTABLE_SIZE); dspPtr->algo_ptr = esif_link_list_create(); dspPtr->domain_ptr = esif_link_list_create(); dspPtr->cap_ptr = esif_link_list_create(); dspPtr->evt_ptr = esif_link_list_create(); if (!dspPtr->ht_ptr || !dspPtr->algo_ptr || !dspPtr->domain_ptr || !dspPtr->cap_ptr || !dspPtr->evt_ptr) { ESIF_TRACE_ERROR("Fail to allocate linked list or hash table\n"); rc = ESIF_E_NO_MEMORY; goto exit; } ESIF_TRACE_DEBUG("<fpc @ %p> FPC name '%s' ver %x,%x desc '%s' size %u num_domains %d num_algorithms %d num_events %d", fpcPtr, fpcPtr->header.name, fpcPtr->header.ver_major, fpcPtr->header.ver_minor, fpcPtr->header.description, fpcPtr->size, fpcPtr->number_of_domains, fpcPtr->number_of_algorithms, fpcPtr->number_of_events); /* First Domain, Ok To Have Zero Primitive Of A Domain */ domainPtr = (EsifFpcDomainPtr)(fpcPtr + 1); for (i = 0; i < fpcPtr->number_of_domains; i++) { offset = (unsigned long)((UInt8 *)domainPtr - basePtr); ESIF_TRACE_DEBUG("<%04lu> Domain[%d] name %s size %d num_of_primitives %d " "num_of_capabilites %u (0x%x)", offset, i, domainPtr->descriptor.name, domainPtr->size, domainPtr->number_of_primitives, domainPtr->capability_for_domain.number_of_capability_flags, domainPtr->capability_for_domain.capability_flags); /* Insert Domain Into Linked List */ rc = dspPtr->insert_domain(dspPtr, domainPtr); if (ESIF_OK != rc) { ESIF_TRACE_ERROR("Fail to insert domain #%d\n", i); goto exit; } /* Capability */ for (j = 0; j < domainPtr->capability_for_domain.number_of_capability_flags; j++) { offset = (unsigned long)(((UInt8 *)&domainPtr->capability_for_domain) - basePtr); ESIF_TRACE_DEBUG("<%04lu> Capability[%d] 0x%x", offset, j, domainPtr->capability_for_domain.capability_mask[j]); } /* First Primtive */ primitivePtr = (EsifFpcPrimitivePtr)(domainPtr + 1); for (j = 0; j < domainPtr->number_of_primitives; j++, numPrim++) { offset = (unsigned long)(((UInt8 *)primitivePtr) - basePtr); ESIF_TRACE_DEBUG("<%04lu> Primitive[%03d]: size %3d tuple_id <%03u %03u %03u> " "operation %u(%s) req_type %u(%s) res_type %u(%s) num_actions %u", offset, j, primitivePtr->size, primitivePtr->tuple.id, primitivePtr->tuple.domain, primitivePtr->tuple.instance, primitivePtr->operation, esif_primitive_opcode_str(primitivePtr->operation), primitivePtr->request_type, esif_data_type_str(primitivePtr->request_type), primitivePtr->result_type, esif_data_type_str(primitivePtr->result_type), primitivePtr->num_actions); /* Insert Primitive Into Hash */ rc = dspPtr->insert_primitive(dspPtr, primitivePtr); if (ESIF_OK != rc) { ESIF_TRACE_ERROR("Fail to insert primitive (id = %d)\n", primitivePtr->tuple.id); goto exit; } /* Next Primitive */ primitivePtr = (EsifFpcPrimitivePtr)((UInt8 *)primitivePtr + primitivePtr->size); } /* Next Domain */ domainPtr = (EsifFpcDomainPtr)((UInt8 *)domainPtr + domainPtr->size); } /* First Algorithm (Laid After The Last Domain) */ algoPtr = (EsifFpcAlgorithmPtr)domainPtr; for (i = 0; i < fpcPtr->number_of_algorithms; i++) { offset = (unsigned long)((UInt8 *)algoPtr - basePtr); ESIF_TRACE_DEBUG("<%04lu> Algorithm[%03d]: action_type %u(%s) temp_xform %u " "tempC1 %u percent_xform %u size %u", offset, i, algoPtr->action_type, esif_action_type_str(algoPtr->action_type), algoPtr->temp_xform, algoPtr->tempC1, algoPtr->percent_xform, algoPtr->size); /* Insert Algorithm Into Linked List */ rc = dspPtr->insert_algorithm(dspPtr, algoPtr); if (ESIF_OK != rc) { ESIF_TRACE_ERROR("Fail to insert algorithm - %s\n", esif_action_type_str(algoPtr->action_type)); goto exit; } /* Next Algorithm */ algoPtr = (EsifFpcAlgorithmPtr)(algoPtr + 1); } /* First Event (Laid After The Last Algorithm) */ eventPtr = (EsifFpcEventPtr)algoPtr; for (i = 0; i < fpcPtr->number_of_events; i++) { offset = (unsigned long)((UInt8 *)eventPtr - basePtr); ESIF_TRACE_DEBUG("<%04lu> Event [%03d] type %s(%d)\n", offset, i, esif_event_type_str(eventPtr->esif_event), eventPtr->esif_event); /* Insert Algorithm Into Linked List */ rc = dspPtr->insert_event(dspPtr, eventPtr); if (ESIF_OK != rc) { ESIF_TRACE_ERROR("Fail to insert event - %s\n", esif_event_type_str(eventPtr->esif_event)); goto exit; } /* Next Event */ eventPtr = (EsifFpcEventPtr)(eventPtr + 1); } exit: if (fpcPtr != NULL) { ESIF_TRACE_DEBUG("%u domains, %u primitives and %u algorithms %u events inserted! status %s", fpcPtr->number_of_domains, numPrim, fpcPtr->number_of_algorithms, fpcPtr->number_of_events, esif_rc_str(rc)); } return rc; }
/* Provide registration for ESIF event */ eEsifError EsifApp_RegisterEvent( const void *esifHandle, const void *appHandle, const void *upHandle, const void *domainHandle, const EsifDataPtr eventGuidPtr ) { eEsifError rc = ESIF_OK; char guidStr[ESIF_GUID_PRINT_SIZE]; UNREFERENCED_PARAMETER(guidStr); if (NULL == esifHandle) { ESIF_TRACE_ERROR("Invalid esif handle\n"); return ESIF_E_INVALID_HANDLE; } if (NULL == appHandle) { ESIF_TRACE_ERROR("Invalid app handle\n"); return ESIF_E_INVALID_HANDLE; } if ((NULL == eventGuidPtr) || (NULL == eventGuidPtr->buf_ptr) || (ESIF_DATA_GUID != eventGuidPtr->type)) { ESIF_TRACE_ERROR("Invalid event GUID\n"); return ESIF_E_PARAMETER_IS_NULL; } ESIF_TRACE_DEBUG("Registering App Event\n\n" "ESIF Handle : %p\n" "App Handle : %p\n" "Participant Handle : %p\n" "Domain Handle : %p\n" "Event GUID : %s\n\n", esifHandle, appHandle, upHandle, domainHandle, esif_guid_print((esif_guid_t *)eventGuidPtr->buf_ptr, guidStr)); /* Determine what to do based on provided parameters */ switch (EsifApp_CategorizeEvent(appHandle, upHandle, domainHandle)) { case EVENT_CATEGORY_APP: { EsifAppPtr appPtr = NULL; EsifUpPtr upPtr = NULL; /* Find Our Participant 0 */ upPtr = EsifUpPm_GetAvailableParticipantByInstance(ESIF_INSTANCE_LF); if (NULL == upPtr) { ESIF_TRACE_WARN("Participant 0 was not found in UF participant manager\n"); rc = ESIF_E_UNSPECIFIED; goto exit; } ESIF_TRACE_DEBUG("Using Participant %s\n", EsifUp_GetName(upPtr)); EsifUp_PutRef(upPtr); appPtr = GetAppFromHandle(appHandle); if (NULL == appPtr) { ESIF_TRACE_ERROR("The app data was not found from app handle\n"); rc = ESIF_E_INVALID_HANDLE; goto exit; } rc = EsifEventMgr_RegisterEventByGuid(eventGuidPtr->buf_ptr, 0, EVENT_MGR_DOMAIN_D0, EsifApp_EventCallback, appPtr->fHandle); if (ESIF_OK != rc) { goto exit; } } break; case EVENT_CATEGORY_PARTICIPANT: { /* Register with participant */ AppParticipantDataMapPtr upMapPtr = NULL; EsifAppPtr appPtr = NULL; appPtr = GetAppFromHandle(appHandle); if (NULL == appPtr) { ESIF_TRACE_ERROR("The app data was not found from app handle\n"); rc = ESIF_E_INVALID_HANDLE; goto exit; } upMapPtr = EsifApp_GetParticipantDataMapFromHandle(appPtr, upHandle); if (NULL == upMapPtr) { ESIF_TRACE_ERROR("The app participant data was not found from participant handle\n"); rc = ESIF_E_INVALID_HANDLE; goto exit; } ESIF_TRACE_DEBUG("Using Participant %s\n", EsifUp_GetName(upMapPtr->fUpPtr)); rc = EsifEventMgr_RegisterEventByGuid(eventGuidPtr->buf_ptr, upMapPtr->fUpPtr->fInstance, EVENT_MGR_MATCH_ANY, EsifApp_EventCallback, appPtr->fHandle); if (ESIF_OK != rc) { goto exit; } } break; case EVENT_CATEGORY_DOMAIN: { /* Register with domain */ AppParticipantDataMapPtr upMapPtr = NULL; AppDomainDataMapPtr domainPtr = NULL; EsifAppPtr appPtr = NULL; appPtr = GetAppFromHandle(appHandle); if (NULL == appPtr) { ESIF_TRACE_ERROR("The app data was not found from app handle\n"); rc = ESIF_E_INVALID_HANDLE; goto exit; } upMapPtr = EsifApp_GetParticipantDataMapFromHandle(appPtr, upHandle); if (NULL == upMapPtr) { ESIF_TRACE_ERROR("The app participant data was not found from participant handle\n"); rc = ESIF_E_INVALID_HANDLE; goto exit; } domainPtr = EsifApp_GetDomainDataMapByHandle(upMapPtr, domainHandle); if (NULL == domainPtr) { ESIF_TRACE_ERROR("The app domain data was not found from domain handle\n"); rc = ESIF_E_INVALID_HANDLE; goto exit; } ESIF_TRACE_DEBUG("Using Participant %s\n", EsifUp_GetName(upMapPtr->fUpPtr)); rc = EsifEventMgr_RegisterEventByGuid(eventGuidPtr->buf_ptr, upMapPtr->fUpPtr->fInstance, domainPtr->fQualifierId, EsifApp_EventCallback, appPtr->fHandle); if (ESIF_OK != rc) { goto exit; } } break; default: ESIF_TRACE_ERROR("Unknown category type\n"); rc = ESIF_E_INVALID_HANDLE; break; } exit: return rc; }
/* See EsifUpPm_InitIterator for usage */ eEsifError EsifActMgr_GetNexAction( ActMgrIteratorPtr iteratorPtr, EsifActPtr *actPtr ) { eEsifError rc = ESIF_OK; EsifActPtr nextActPtr = NULL; struct esif_link_list_node *curNodePtr = NULL; struct esif_link_list_node *nextNodePtr = NULL; EsifActMgrEntryPtr entryPtr = NULL; if ((NULL == actPtr) || (NULL == iteratorPtr)) { ESIF_TRACE_WARN("Parameter is NULL\n"); rc = ESIF_E_PARAMETER_IS_NULL; goto exit; } /* Verify the iterator is initialized */ if (iteratorPtr->marker != ACT_MGR_ITERATOR_MARKER) { ESIF_TRACE_WARN("Iterator invalid\n"); rc = ESIF_E_INVALID_HANDLE; goto exit; } if (iteratorPtr->ref_taken) { EsifAct_PutRef(iteratorPtr->actPtr); iteratorPtr->actPtr = NULL; iteratorPtr->ref_taken = ESIF_FALSE; } esif_ccb_write_lock(&g_actMgr.mgrLock); if (g_actMgr.actions == NULL) { esif_ccb_write_unlock(&g_actMgr.mgrLock); rc = ESIF_E_UNSPECIFIED; goto exit; } curNodePtr = g_actMgr.actions->head_ptr; if (iteratorPtr->type == 0) { nextNodePtr = curNodePtr; } else { while (curNodePtr) { entryPtr = (EsifActMgrEntryPtr)curNodePtr->data_ptr; if (entryPtr != NULL) { if (entryPtr->type == iteratorPtr->type) { nextNodePtr = curNodePtr->next_ptr; break; } } curNodePtr = curNodePtr->next_ptr; } } iteratorPtr->type = 0; if (nextNodePtr != NULL) { entryPtr = (EsifActMgrEntryPtr)nextNodePtr->data_ptr; if (entryPtr != NULL) { iteratorPtr->type = entryPtr->type; } } esif_ccb_write_unlock(&g_actMgr.mgrLock); if (iteratorPtr->type != 0) { nextActPtr = EsifActMgr_GetAction(iteratorPtr->type, ACT_MGR_NO_UPINSTANCE); } *actPtr = nextActPtr; if (nextActPtr != NULL) { iteratorPtr->actPtr = nextActPtr; iteratorPtr->ref_taken = ESIF_TRUE; } else { rc = ESIF_E_ITERATION_DONE; } exit: return rc; }
static eEsifError RegisterParticipant(const EsifParticipantIfacePtr piPtr) { eEsifError rc = ESIF_OK; EsifUpPtr up_ptr = NULL; UInt8 temp = 0; char guid_str[ESIF_GUID_PRINT_SIZE]; EsifString dsp_code = ""; UNREFERENCED_PARAMETER(guid_str); ESIF_ASSERT(piPtr != NULL); ESIF_TRACE_INFO( "\n" "=======================================================\n" "ESIF CREATE CONJURE PARTICIPANT:\n" "=======================================================\n" "Version: %d\n" "Class: %s\n" "Enumerator: %s(%u)\n" "Flags: 0x%08x\n" "Name: %s\n" "Description: %s\n" "Driver Name: %s\n" "Device Name: %s\n" "Device Path: %s\n" "Object ID: %s\n\n", piPtr->version, esif_guid_print(&piPtr->class_guid, guid_str), esif_participant_enum_str(piPtr->enumerator), piPtr->enumerator, piPtr->flags, piPtr->name, piPtr->desc, piPtr->driver_name, piPtr->device_name, piPtr->device_path, piPtr->object_id); if (EsifUpManagerDoesAvailableParticipantExistByName(piPtr->name)) { ESIF_TRACE_WARN("Participant %s has already existed in upper framework\n", piPtr->name); rc = ESIF_E_UNSPECIFIED; up_ptr = NULL; goto exit; } ESIF_TRACE_DEBUG("Create Participant\n"); up_ptr = EsifUpManagerCreateParticipant(eParticipantOriginUF, &temp, piPtr); ESIF_TRACE_DEBUG("Create Participant up_ptr %p\n", up_ptr); /* Assign DSP Now */ if (NULL == up_ptr) { rc = ESIF_E_NO_MEMORY; goto exit; } dsp_code = esif_uf_dm_select_dsp(eParticipantOriginUF, piPtr); if (NULL == dsp_code) { ESIF_TRACE_ERROR("Unknown dsp name %s\n", piPtr->name); rc = ESIF_E_NEED_DSP; goto exit; } ESIF_TRACE_DEBUG("dsp_code %s\n", dsp_code); up_ptr->fDspPtr = esif_uf_dm_select_dsp_by_code(dsp_code); if (NULL == up_ptr->fDspPtr) { ESIF_TRACE_ERROR("Missed DSP Lookup %s\n", dsp_code); rc = ESIF_E_NEED_DSP; goto exit; } /* Report the participant to the apps */ EsifAppMgrCreateCreateParticipantInAllApps(up_ptr); ESIF_TRACE_DEBUG("Hit DSP Lookup %s\n", up_ptr->fDspPtr->code_ptr); up_ptr = NULL; /* Indicate the participant should not be destroyed. */ exit: /* * If up_ptr is non-NULL at this point, indicates a failure and the * participant must be disabled in the manager. If everything is * successful, up_ptr will be set to NULL above. */ if (up_ptr != NULL) { ESIF_TRACE_WARN("Unregister participant in UP manager due to participant data creation failure\n"); EsifUpManagerUnregisterParticipant(eParticipantOriginUF, up_ptr); } return rc; }