/* Insert Action Into List */
static eEsifError AddAction(
EsifActMgrPtr THIS,
EsifActTypePtr actionPtr
)
{
ESIF_TRACE_DEBUG("Item %p", actionPtr);
return esif_link_list_add_at_back(THIS->fActTypes, (void *)actionPtr);
}
/* Insert Domain Into Linked List */
static eEsifError insert_domain(
EsifDspPtr dspPtr,
EsifFpcDomainPtr domainPtr
)
{
if ((NULL == dspPtr) || (NULL == domainPtr)) {
return ESIF_E_PARAMETER_IS_NULL;
}
return esif_link_list_add_at_back(dspPtr->domain_ptr, (void *)domainPtr);
}
/* Insert Event Into Linked List */
static eEsifError insert_event(
EsifDspPtr dspPtr,
EsifFpcEventPtr evtPtr
)
{
if ((NULL == dspPtr) || (NULL == evtPtr)) {
return ESIF_E_PARAMETER_IS_NULL;
}
return esif_link_list_add_at_back(dspPtr->evt_ptr, (void *)evtPtr);
}
/* Insert Algorithm Into Linked List */
static eEsifError insert_algorithm(
EsifDspPtr dspPtr,
EsifFpcAlgorithmPtr algoPtr
)
{
if ((NULL == dspPtr) || (NULL == algoPtr)) {
return ESIF_E_PARAMETER_IS_NULL;
}
return esif_link_list_add_at_back(dspPtr->algo_ptr, (void *)algoPtr);
}
static void esif_ccb_tmrm_add_destroy_event(
struct esif_tmrm_item *self,
esif_ccb_event_t *event_ptr
)
{
ESIF_ASSERT(self != NULL);
ESIF_ASSERT(self->destroy_list_ptr != NULL);
if (event_ptr != NULL) {
esif_link_list_add_at_back(self->destroy_list_ptr, event_ptr);
}
}
enum esif_rc esif_ht_add_item(
struct esif_ht *self,
u8 *key_ptr,
u32 key_length,
void *item_ptr
)
{
enum esif_rc rc = ESIF_OK;
struct esif_link_list *ll_ptr = NULL;
struct esif_ht_node *ht_node = NULL;
if ((key_ptr == NULL) || (self == NULL)) {
ESIF_TRACE_DYN_VERB("NULL ptr passed in \n");
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
ll_ptr = esif_ht_get_ll(self, key_ptr, key_length);
if (ll_ptr == NULL) {
ESIF_ASSERT(ESIF_FALSE); /* Should never happen */
ESIF_TRACE_DYN_VERB("LL NULL for passed in key\n");
rc = ESIF_E_NOT_FOUND;
goto exit;
}
ht_node = esif_alloc_ht_node(key_ptr, key_length, item_ptr);
if (ht_node == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
rc = esif_link_list_add_at_back(ll_ptr, (void *)ht_node);
if (rc != ESIF_OK) {
ESIF_TRACE_ERROR("Unable to add new HT link list node\n");
goto exit;
}
ESIF_TRACE_DYN_VERB(
"Key %p, key size %d, item %p, table %p ll %p\n",
key_ptr,
key_length,
item_ptr,
self,
ll_ptr);
exit:
if (rc != ESIF_OK) {
if (ht_node != NULL)
esif_destroy_ht_node(ht_node);
}
return rc;
}
/* Every init should have a matching kill */
enum esif_rc esif_ccb_timer_init(
esif_ccb_timer_t *timer_ptr,
esif_ccb_timer_cb function_ptr, /* Callback when timer fires */
void *context_ptr /* Callback context if any */
)
{
enum esif_rc rc = ESIF_OK;
struct esif_tmrm_item *tmrm_item_ptr = NULL;
if ((NULL == timer_ptr) || (NULL == function_ptr)) {
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
rc = esif_ccb_tmrm_is_ready();
if (rc != ESIF_OK)
goto exit;
rc = esif_ccb_tmrm_create_tmrm_item(function_ptr,
context_ptr,
&tmrm_item_ptr);
if (rc != ESIF_OK)
goto exit;
/* Place the handle into the timer being initialized*/
timer_ptr->timer_handle = tmrm_item_ptr->timer_handle;
/*
* We create the manager list dynamically so that we don't have to call
* init/exit functions and can destroy the linked list
*/
esif_ccb_write_lock(&g_tmrm.mgr_lock);
if (NULL == g_tmrm.timer_list_ptr) {
g_tmrm.timer_list_ptr = esif_link_list_create();
if(NULL == g_tmrm.timer_list_ptr) {
rc = ESIF_E_NO_MEMORY;
goto lock_exit;
}
}
rc = esif_link_list_add_at_back(g_tmrm.timer_list_ptr, tmrm_item_ptr);
lock_exit:
esif_ccb_write_unlock(&g_tmrm.mgr_lock);
exit:
if (rc != ESIF_OK)
esif_ccb_tmrm_destroy_tmrm_item(tmrm_item_ptr);
return rc;
}
/* Write lock should be held when called */
static eEsifError EsifEventMgr_MoveEntryToGarbage(EventMgrEntryPtr entryPtr)
{
eEsifError rc = ESIF_OK;
EsifLinkListPtr listPtr = g_EsifEventMgr.garbageList;
ESIF_ASSERT(NULL != entryPtr);
if (NULL == listPtr) {
rc = ESIF_E_UNSPECIFIED;
goto exit;
}
rc = esif_link_list_add_at_back(listPtr, (void *)entryPtr);
exit:
return rc;
}
static eEsifError EsifActMgr_AddEntry(
EsifActMgrEntryPtr entryPtr
)
{
eEsifError rc = ESIF_OK;
ESIF_ASSERT(entryPtr != NULL);
esif_ccb_write_lock(&g_actMgr.mgrLock);
rc = esif_link_list_add_at_back(g_actMgr.actions, (void *)entryPtr);
if (rc != ESIF_OK) {
goto exit;
}
g_actMgr.numActions++;
exit:
esif_ccb_write_unlock(&g_actMgr.mgrLock);
return rc;
}
static eEsifError EsifActMgr_CreatePossActList_Locked()
{
eEsifError rc = ESIF_OK;
struct esif_ccb_file curFile = {0};
esif_ccb_file_enum_t fileIter = {0};
char libPath[ESIF_LIBPATH_LEN];
char *dotPtr = NULL;
EsifActMgrEntryPtr newPossPtr = NULL;
EsifString filePattern = ESIF_UPE_FILE_PREFIX "*" ESIF_LIB_EXT;
g_actMgr.possibleActions = esif_link_list_create();
if (NULL == g_actMgr.possibleActions) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
/* Get the loadable action directory path */
esif_build_path(libPath, sizeof(libPath), ESIF_PATHTYPE_DLL, NULL, NULL);
fileIter = esif_ccb_file_enum_first(libPath, filePattern, &curFile);
if (INVALID_HANDLE_VALUE == fileIter) {
goto exit;
}
do {
newPossPtr = esif_ccb_malloc(sizeof(*newPossPtr));
if(NULL == newPossPtr) {
break;
}
dotPtr = esif_ccb_strchr(curFile.filename, '.');
if (dotPtr != NULL) {
*dotPtr = '\0';
newPossPtr->libName = (esif_string)esif_ccb_strdup(curFile.filename);
esif_link_list_add_at_back(g_actMgr.possibleActions, (void *)newPossPtr);
}
} while (esif_ccb_file_enum_next(fileIter, filePattern, &curFile));
esif_ccb_file_enum_close(fileIter);
exit:
return rc;
}
