void EsifActConfigExit()
{
if (NULL != g_actMgr.RemoveActType) {
g_actMgr.RemoveActType(&g_actMgr, 0);
}
ESIF_TRACE_EXIT_INFO();
}
void EsifActExit()
{
EsifActConfigExit();
EsifActConstExit();
EsifActSystemExit();
ESIF_TRACE_EXIT_INFO();
}
void EsifAppMgrExit()
{
u8 i = 0;
EsifAppPtr a_app_ptr = NULL;
ESIF_TRACE_ENTRY_INFO();
EsifEventMgr_UnregisterEventByType(ESIF_EVENT_PARTICIPANT_SUSPEND, EVENT_MGR_MATCH_ANY, EVENT_MGR_DOMAIN_D0, EsifAppMgr_EventCallback, NULL);
EsifEventMgr_UnregisterEventByType(ESIF_EVENT_PARTICIPANT_RESUME, EVENT_MGR_MATCH_ANY, EVENT_MGR_DOMAIN_D0, EsifAppMgr_EventCallback, NULL);
EsifAppExit();
ESIF_TRACE_DEBUG("Exit Action Manager (APPMGR)");
esif_ccb_read_lock(&g_appMgr.fLock);
for (i = 0; i < ESIF_MAX_APPS; i++) {
a_app_ptr = &g_appMgr.fEntries[i];
// Attempt to gracefully shutdown App before forcing library unload
if (a_app_ptr->fLibNamePtr != NULL) {
EsifAppStop(a_app_ptr);
}
if (a_app_ptr->fLibNamePtr != NULL) {
esif_ccb_library_unload(a_app_ptr->fLibHandle);
esif_ccb_free(a_app_ptr->fLibNamePtr);
esif_ccb_memset(a_app_ptr, 0, sizeof(*a_app_ptr));
}
}
esif_ccb_read_unlock(&g_appMgr.fLock);
esif_ccb_lock_uninit(&g_appMgr.fLock);
ESIF_TRACE_EXIT_INFO();
}
void EsifEventMgr_Exit(void)
{
UInt8 i;
EsifLinkListPtr listPtr = NULL;
ESIF_TRACE_ENTRY_INFO();
/* Remove all listeners */
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
for (i = 0; i < NUM_EVENT_LISTS; i++) {
listPtr = g_EsifEventMgr.observerLists[i];
esif_link_list_free_data_and_destroy(listPtr, EsifEventMgr_LLEntryDestroyCallback);
g_EsifEventMgr.observerLists[i] = NULL;
}
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
/* Destroy the event thread */
/* Event thread should already be destroyed in the disable func. Destroy the queue */
esif_queue_destroy(g_EsifEventMgr.eventQueuePtr, EsifEventMgr_QueueDestroyCallback);
g_EsifEventMgr.eventQueuePtr = NULL;
/* Destroy the garbage list */
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
esif_link_list_free_data_and_destroy(g_EsifEventMgr.garbageList, EsifEventMgr_LLEntryDestroyCallback);
g_EsifEventMgr.garbageList = NULL;
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
esif_ccb_lock_uninit(&g_EsifEventMgr.listLock);
ESIF_TRACE_EXIT_INFO();
}
void EsifActMgrExit()
{
u8 i = 0;
EsifActPtr a_act_ptr = NULL;
ESIF_TRACE_ENTRY_INFO();
/* Call before destroying action manager */
EsifActExit();
if (NULL != g_actMgr.fActTypes) {
esif_link_list_destroy(g_actMgr.fActTypes);
g_actMgr.fActTypes = NULL; //set to null so that it will be caught if mid-execution
}
esif_ccb_read_lock(&g_actMgr.fLock);
for (i = 0; i < ESIF_MAX_ACTIONS; i++) {
a_act_ptr = &g_actMgr.fEnrtries[i];
esif_ccb_free(a_act_ptr->fLibNamePtr);
esif_ccb_library_unload(a_act_ptr->fLibHandle);
esif_ccb_memset(a_act_ptr, 0, sizeof(*a_act_ptr));
}
esif_ccb_read_unlock(&g_actMgr.fLock);
esif_ccb_lock_uninit(&g_actMgr.fLock);
ESIF_TRACE_EXIT_INFO();
}
enum esif_rc EsifActSystemInit()
{
if (NULL != g_actMgr.AddActType) {
g_actMgr.AddActType(&g_actMgr, &g_system);
}
ESIF_TRACE_EXIT_INFO();
return ESIF_OK;
}
eEsifError EsifActInit()
{
EsifActConfigInit();
EsifActConstInit();
EsifActSystemInit();
ESIF_TRACE_EXIT_INFO();
return ESIF_OK;
}
enum esif_rc EsifActConfigInit()
{
if (NULL != g_actMgr.AddActType) {
g_actMgr.AddActType(&g_actMgr, &g_config);
}
ESIF_TRACE_EXIT_INFO();
return ESIF_OK;
}
static void *ESIF_CALLCONV esif_web_worker_thread(void *ptr)
{
UNREFERENCED_PARAMETER(ptr);
ESIF_TRACE_ENTRY_INFO();
esif_ws_init();
ESIF_TRACE_EXIT_INFO();
return 0;
}
void EsifDspMgrExit(void)
{
ESIF_TRACE_ENTRY_INFO();
esif_dsp_table_destroy();
esif_ccb_lock_uninit(&g_dm.lock);
ESIF_TRACE_EXIT_INFO();
}
static void EsifActMgr_UninitActions()
{
EsifActConfigExit();
EsifActConstExit();
EsifActSystemExit();
EsifActDelegateExit();
esif_ccb_imp_spec_actions_exit();
ESIF_TRACE_EXIT_INFO();
}
void EsifEventMgr_Disable(void)
{
ESIF_TRACE_ENTRY_INFO();
/* Release and destroy the event thread */
g_EsifEventMgr.eventQueueExitFlag = ESIF_TRUE;
esif_queue_signal_event(g_EsifEventMgr.eventQueuePtr);
esif_ccb_thread_join(&g_EsifEventMgr.eventQueueThread);
ESIF_TRACE_EXIT_INFO();
}
// IPC Disconnect
void ipc_disconnect()
{
ESIF_TRACE_ENTRY_INFO();
if (g_ipc_handle != ESIF_INVALID_HANDLE) {
esif_ipc_disconnect(g_ipc_handle);
g_ipc_handle = ESIF_INVALID_HANDLE;
ESIF_TRACE_DEBUG("ESIF IPC Kernel Device Closed\n");
}
ESIF_TRACE_EXIT_INFO();
}
static eEsifError EsifActMgr_InitActions()
{
EsifActMgr_RegisterDelayedLoadAction(ESIF_ACTION_DPTFWWAN);
EsifActConfigInit();
EsifActConstInit();
EsifActSystemInit();
EsifActDelegateInit();
esif_ccb_imp_spec_actions_init();
ESIF_TRACE_EXIT_INFO();
return ESIF_OK;
}
eEsifError EsifCnjMgrInit()
{
eEsifError rc = ESIF_OK;
ESIF_TRACE_DEBUG("%s: Init Action Manager (CNJMGR)", ESIF_FUNC);
esif_ccb_lock_init(&g_cnjMgr.fLock);
EsifCnjInit();
ESIF_TRACE_EXIT_INFO();
return rc;
}
// Event Worker Thread
// Processes ESIF Events
void *esif_event_worker_thread(void *ptr)
{
int rc = 0;
fd_set rfds = {0};
struct timeval tv = {0};
UNREFERENCED_PARAMETER(ptr);
ESIF_TRACE_ENTRY_INFO();
CMD_OUT("Start ESIF Event Thread\n");
// Connect To Kernel IPC with infinite timeout
ipc_autoconnect(0);
// Run Until Told To Quit
while (!g_quit) {
#ifdef ESIF_FEAT_OPT_ACTION_SYSFS
esif_ccb_sleep_msec(250);
#else
if (g_ipc_handle == ESIF_INVALID_HANDLE) {
break;
}
if (rc > 0) {
EsifEvent_GetAndSignalIpcEvent();
}
FD_ZERO(&rfds);
FD_SET((esif_ccb_socket_t)g_ipc_handle, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 50000; /* 50 msec */
#ifdef ESIF_ATTR_OS_LINUX
rc = select(g_ipc_handle + 1, &rfds, NULL, NULL, &tv);
#endif
#ifdef ESIF_ATTR_OS_WINDOWS
// Windows does not support select/poll so we simulate here
esif_ccb_sleep_msec(50);
rc = 1;
#endif
#endif
}
if (g_ipc_handle != ESIF_INVALID_HANDLE) {
ipc_disconnect();
}
ESIF_TRACE_EXIT_INFO();
return 0;
}
void esif_memtrace_init()
{
struct memalloc_s *mem = NULL;
esif_ccb_lock_init(&g_memtrace.lock);
esif_ccb_write_lock(&g_memtrace.lock);
mem = g_memtrace.allocated;
// Ignore any allocations made before this function was called
while (mem) {
struct memalloc_s *node = mem;
mem = mem->next;
native_free(node);
}
g_memtrace.allocated = NULL;
esif_ccb_write_unlock(&g_memtrace.lock);
ESIF_TRACE_EXIT_INFO();
}
void EsifLogMgrExit(void)
{
int j;
ESIF_TRACE_ENTRY_INFO();
for (j=0; j < MAX_ESIFLOG; j++) {
if (g_EsifLogFile[j].handle != NULL) {
esif_ccb_fclose(g_EsifLogFile[j].handle);
}
esif_ccb_free(g_EsifLogFile[j].name);
esif_ccb_free(g_EsifLogFile[j].filename);
esif_ccb_lock_uninit(&g_EsifLogFile[j].lock);
}
esif_ccb_memset(g_EsifLogFile, 0, sizeof(g_EsifLogFile));
ESIF_TRACE_EXIT_INFO();
}
eEsifError EsifLogMgrInit(void)
{
int j;
ESIF_TRACE_ENTRY_INFO();
esif_ccb_memset(g_EsifLogFile, 0, sizeof(g_EsifLogFile));
for (j=0; j < MAX_ESIFLOG; j++) {
esif_ccb_lock_init(&g_EsifLogFile[j].lock);
}
g_EsifLogFile[ESIF_LOG_EVENTLOG].name = esif_ccb_strdup("event");
g_EsifLogFile[ESIF_LOG_DEBUGGER].name = esif_ccb_strdup("debug");
g_EsifLogFile[ESIF_LOG_SHELL].name = esif_ccb_strdup("shell");
g_EsifLogFile[ESIF_LOG_TRACE].name = esif_ccb_strdup("trace");
g_EsifLogFile[ESIF_LOG_UI].name = esif_ccb_strdup("ui");
ESIF_TRACE_EXIT_INFO();
return ESIF_OK;
}
void EsifActMgrExit()
{
ESIF_TRACE_ENTRY_INFO();
/* Call before destroying action manager */
EsifActMgr_UninitActions();
esif_ccb_write_lock(&g_actMgr.mgrLock);
esif_link_list_free_data_and_destroy(g_actMgr.actions, EsifActMgr_LLEntryDestroyCallback);
g_actMgr.actions = NULL;
esif_link_list_free_data_and_destroy(g_actMgr.possibleActions, EsifActMgr_LLEntryDestroyCallback);
g_actMgr.possibleActions = NULL;
esif_ccb_write_unlock(&g_actMgr.mgrLock);
esif_ccb_lock_uninit(&g_actMgr.mgrLock);
ESIF_TRACE_EXIT_INFO();
}
void EsifCnjMgrExit()
{
u8 i = 0;
EsifCnjPtr a_conjure_ptr = NULL;
EsifCnjExit();
ESIF_TRACE_DEBUG("%s: Exit Action Manager (CNJMGR)", ESIF_FUNC);
esif_ccb_read_lock(&g_cnjMgr.fLock);
for (i = 0; i < ESIF_MAX_CONJURES; i++) {
a_conjure_ptr = &g_cnjMgr.fEnrtries[i];
esif_ccb_free(a_conjure_ptr->fLibNamePtr);
esif_ccb_library_unload(a_conjure_ptr->fLibHandle);
esif_ccb_memset(a_conjure_ptr, 0, sizeof(*a_conjure_ptr));
}
esif_ccb_read_unlock(&g_cnjMgr.fLock);
esif_ccb_lock_uninit(&g_cnjMgr.fLock);
ESIF_TRACE_EXIT_INFO();
}
void esif_uf_exit()
{
/* Stop event thread */
g_quit = ESIF_TRUE;
/* Stop web server if it is running */
EsifWebStop();
EsifDataLogStop();
EsifUFPollStop();
/* Stop all Apps before dependent components they may be using */
EsifAppMgrExit();
/* OS Specific */
esif_uf_os_exit();
/* OS Agnostic - Call in reverse order of Init */
EsifUpPm_Exit();
EsifActMgrExit();
EsifDspMgrExit();
EsifEventMgr_Exit();
EsifCnjMgrExit();
EsifCfgMgrExit();
EsifLogMgrExit();
esif_ccb_tmrm_exit();
esif_ht_exit();
esif_link_list_exit();
esif_ccb_mempool_uninit_tracking();
// Re-Initialize necessary global variables in case ESIF restarted
g_esif_started = ESIF_FALSE;
ESIF_TRACE_DEBUG("Exit Upper Framework (UF)");
#ifdef ESIF_ATTR_SHELL_LOCK
esif_ccb_mutex_uninit(&g_shellLock);
#endif
ESIF_TRACE_EXIT_INFO();
}
static void *ESIF_CALLCONV EsifDataLogWorkerThread(void *ptr)
{
eEsifError rc = ESIF_OK;
UNREFERENCED_PARAMETER(ptr);
ESIF_TRACE_ENTRY_INFO();
while (!g_dataLogQuit) {
esif_ccb_time_t msecStart = 0;
esif_ccb_time_t msecStop = 0;
esif_ccb_time_t msecDif = 0;
UInt32 sleepMs = 0;
esif_ccb_system_time(&msecStart);
EsifDataLogFire(0);
esif_ccb_system_time(&msecStop);
/* Determine how long processing actually took */
msecDif = msecStop - msecStart;
/* Determine next sleep time based on previous processing time*/
sleepMs = g_dataLogInterval - ((int) msecDif);
if ((sleepMs < MIN_STATUS_LOG_INTERVAL_ADJUSTED) || (msecDif > g_dataLogInterval)){
sleepMs = MIN_STATUS_LOG_INTERVAL_ADJUSTED;
}
rc = EsifTimedEventWait(&g_dataLogQuitEvent, sleepMs);
if (rc != ESIF_OK) {
ESIF_TRACE_ERROR("Error waiting on data log event\n");
goto exit;
}
}
exit:
ESIF_TRACE_EXIT_INFO();
return 0;
}
void EsifActConfigExit()
{
EsifActMgr_UnregisterAction((EsifActIfacePtr)&g_config);
ESIF_TRACE_EXIT_INFO();
}
eEsifError EsifActConfigInit()
{
EsifActMgr_RegisterAction((EsifActIfacePtr)&g_config);
ESIF_TRACE_EXIT_INFO();
return ESIF_OK;
}
eEsifError EsifActDelegateInit()
{
EsifActMgr_RegisterAction((EsifActIfacePtr)&g_delegate);
ESIF_TRACE_EXIT_INFO();
return ESIF_OK;
}
void EsifActDelegateExit()
{
EsifActMgr_UnregisterAction((EsifActIfacePtr)&g_delegate);
ESIF_TRACE_EXIT_INFO();
}
/* Create A Conjure Library */
static eEsifError ConjureCreate(
EsifCnjPtr conjurePtr,
GetIfaceFuncPtr ifaceFuncPtr
)
{
eEsifError rc = ESIF_OK;
EsifConjureServiceInterface conjure_service_iface;
char name[ESIF_NAME_LEN] = "";
ESIF_DATA(data_name, ESIF_DATA_STRING, name, ESIF_NAME_LEN);
char desc[ESIF_DESC_LEN] = "";
ESIF_DATA(data_desc, ESIF_DATA_STRING, desc, ESIF_DESC_LEN);
char version[ESIF_DESC_LEN] = "";
ESIF_DATA(data_version, ESIF_DATA_STRING, version, ESIF_DESC_LEN);
ESIF_ASSERT(conjurePtr != NULL);
ESIF_ASSERT(ifaceFuncPtr != NULL);
/* Assign the EsifInterface Functions */
conjure_service_iface.fIfaceType = eIfaceTypeConjureService;
conjure_service_iface.fIfaceVersion = 1;
conjure_service_iface.fIfaceSize = (UInt16)sizeof(EsifConjureServiceInterface);
conjure_service_iface.fRegisterParticipantFuncPtr = RegisterParticipant;
conjure_service_iface.fUnRegisterParticipantFuncPtr = UnRegisterParticipant;
/* GetConjureInterface Handleshake send ESIF receive APP Interface */
rc = ifaceFuncPtr(&conjurePtr->fInterface);
if (ESIF_OK != rc) {
goto exit;
}
/* Check EsifAppInterface */
if (conjurePtr->fInterface.fIfaceType != eIfaceTypeConjure ||
conjurePtr->fInterface.fIfaceSize != (UInt16)sizeof(EsifConjureInterface) ||
conjurePtr->fInterface.fIfaceVersion != 1 ||
/* Functions Pointers */
conjurePtr->fInterface.fConjureCreateFuncPtr == NULL ||
conjurePtr->fInterface.fConjureDestroyFuncPtr == NULL ||
conjurePtr->fInterface.fConjureGetAboutFuncPtr == NULL ||
conjurePtr->fInterface.fConjureGetDescriptionFuncPtr == NULL ||
conjurePtr->fInterface.fConjureGetGuidFuncPtr == NULL ||
conjurePtr->fInterface.fConjureGetNameFuncPtr == NULL ||
conjurePtr->fInterface.fConjureGetVersionFuncPtr == NULL) {
ESIF_TRACE_ERROR("The required function pointer of EsifConjureInterface is NULL\n");
goto exit;
}
/* Callback for application information */
rc = conjurePtr->fInterface.fConjureGetNameFuncPtr(&data_name);
if (ESIF_OK != rc) {
goto exit;
}
rc = conjurePtr->fInterface.fConjureGetDescriptionFuncPtr(&data_desc);
if (ESIF_OK != rc) {
goto exit;
}
rc = conjurePtr->fInterface.fConjureGetVersionFuncPtr(&data_version);
if (ESIF_OK != rc) {
goto exit;
}
ESIF_TRACE_DEBUG("%s\n\n"
"Conjure Lib Name : %s\n"
"Conjure Lib Desc : %s\n"
"Conjure Lib Type : %s\n"
"Conjure Lib Version: %s\n\n",
ESIF_FUNC,
(EsifString)data_name.buf_ptr,
(EsifString)data_desc.buf_ptr,
(EsifString)"plugin",
(EsifString)data_version.buf_ptr);
/* Create The Conjure */
rc = conjurePtr->fInterface.fConjureCreateFuncPtr(
&conjure_service_iface,
NULL,
&conjurePtr->fHandle);
if (ESIF_OK != rc) {
goto exit;
}
exit:
ESIF_TRACE_EXIT_INFO();
return ESIF_OK;
}
