static eEsifError ESIF_CALLCONV EsifAct_EventCallback(
void *contextPtr,
UInt8 upInstance,
UInt16 domainId,
EsifFpcEventPtr fpcEventPtr,
EsifDataPtr eventDataPtr
)
{
eEsifError rc = ESIF_OK;
EsifActPtr actPtr = NULL;
if (NULL == fpcEventPtr) {
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
actPtr = EsifActMgr_GetAction((UInt8)(size_t)contextPtr);
if (NULL == actPtr) {
rc = ESIF_E_NOT_FOUND;
goto exit;
}
rc = EsifActIface_SendIfaceEvent(&actPtr->iface,
actPtr->actCtx,
fpcEventPtr->esif_event,
upInstance,
domainId,
eventDataPtr);
exit:
EsifAct_PutRef(actPtr);
return rc;
}
static eEsifError EsifActMgr_CreateAction(
EsifActMgrEntryPtr entryPtr,
EsifActIfacePtr actIfacePtr
)
{
eEsifError rc = ESIF_OK;
enum esif_action_type actType = 0;
EsifActPtr actPtr = NULL;
ESIF_ASSERT(entryPtr != NULL);
ESIF_ASSERT(actIfacePtr != NULL);
/* Check EsifActIface */
if (actIfacePtr->hdr.fIfaceType != eIfaceTypeAction ||
actIfacePtr->hdr.fIfaceVersion > ESIF_ACT_FACE_VER_MAX ||
actIfacePtr->hdr.fIfaceSize != EsifActIface_Sizeof(actIfacePtr->hdr.fIfaceVersion)) {
ESIF_TRACE_ERROR("The action interface does not meet requirements\n");
goto exit;
}
/* Check if this type is already available; we only allow one instance */
rc = EsifActIface_GetType(actIfacePtr, &actType);
if (rc != ESIF_OK) {
goto exit;
}
actPtr = EsifActMgr_GetAction(actType, ACT_MGR_NO_UPINSTANCE);
if (actPtr != NULL) {
EsifAct_PutRef(actPtr);
rc = ESIF_E_ACTION_ALREADY_STARTED;
goto exit;
}
rc = EsifAct_CreateAction(actIfacePtr, entryPtr->upInstance, &actPtr);
if (rc != ESIF_OK) {
goto exit;
}
entryPtr->type = actPtr->type;
entryPtr->actCtx = actPtr->actCtx;
entryPtr->actPtr = actPtr;
exit:
return rc;
}
EsifActPtr EsifActMgr_GetAction(
enum esif_action_type type,
const UInt8 instance
)
{
eEsifError rc = ESIF_OK;
EsifActPtr actPtr = NULL;
EsifActMgrEntryPtr entryPtr = NULL;
struct esif_link_list_node *nodePtr = NULL;
esif_ccb_write_lock(&g_actMgr.mgrLock);
/* First see if the action is available, else see if it can be loaded */
entryPtr = EsifActMgr_GetActionEntry_Locked(type);
if (NULL == entryPtr) {
esif_ccb_write_unlock(&g_actMgr.mgrLock);
goto exit;
}
if (entryPtr->loadDelayed != ESIF_TRUE) {
actPtr = entryPtr->actPtr;
rc = EsifAct_GetRef(actPtr);
if (rc != ESIF_OK) {
actPtr = NULL;
}
esif_ccb_write_unlock(&g_actMgr.mgrLock);
} else {
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);
EsifActMgr_LoadDelayLoadAction(type, instance);
actPtr = EsifActMgr_GetAction(type, instance);
}
exit:
return actPtr;
}
/* 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;
}
