/* * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved. * * Previously licensed under the ISC license by Qualcomm Atheros, Inc. * * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the * above copyright notice and this permission notice appear in all * copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ /* * This file was originally distributed by Qualcomm Atheros, Inc. * under proprietary terms before Copyright ownership was assigned * to the Linux Foundation. */ /**========================================================================= EDIT HISTORY FOR FILE This section contains comments describing changes made to the module. Notice that changes are listed in reverse chronological order. $Header:$ $DateTime: $ $Author: $ when who what, where, why -------- --- -------------------------------------------------------- 03/29/11 tbh Created module. ==========================================================================*/ /*---------------------------------------------------------------------------- * Include Files * -------------------------------------------------------------------------*/ #include #include #ifdef ANI_BUS_TYPE_PLATFORM #include #else #include #endif // ANI_BUS_TYP_PLATFORM /*---------------------------------------------------------------------------- * Preprocessor Definitions and Constants * -------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- * Type Declarations * -------------------------------------------------------------------------*/ /*------------------------------------------------------------------------- * Global variables. *-------------------------------------------------------------------------*/ /*------------------------------------------------------------------------- * Local variables. *-------------------------------------------------------------------------*/ /* Reference VoIP, 100msec delay make disconnect. * So TX sleep must be less than 100msec * Every 20msec TX frame will goes out. * 10 frame means 2seconds TX operation */ static const hdd_tmLevelAction_t thermalMigrationAction[WLAN_HDD_TM_LEVEL_MAX] = { /* TM Level 0, Do nothing, just normal operaton */ {1, 0, 0, 0, 0xFFFFF}, /* Tm Level 1, disable TX AMPDU */ {0, 0, 0, 0, 0xFFFFF}, /* TM Level 2, disable AMDPU, * TX sleep 100msec if TX frame count is larger than 16 during 300msec */ {0, 0, 100, 300, 16}, /* TM Level 3, disable AMDPU, * TX sleep 500msec if TX frame count is larger than 11 during 500msec */ {0, 0, 500, 500, 11}, /* TM Level 4, MAX TM level, enter IMPS */ {0, 1, 1000, 500, 10} }; #ifdef HAVE_WCNSS_SUSPEND_RESUME_NOTIFY static bool suspend_notify_sent; #endif #ifdef FEATURE_WLAN_DIAG_SUPPORT /** * hdd_wlan_suspend_resume_event()- send suspend/resume state * * @state: suspend/resume state * * This Function send send suspend resume state diag event * * Return: void. */ void hdd_wlan_suspend_resume_event(uint8_t state) { WLAN_VOS_DIAG_EVENT_DEF(suspend_state, struct vos_event_suspend); vos_mem_zero( &suspend_state, sizeof(suspend_state)); suspend_state.state= state; WLAN_VOS_DIAG_EVENT_REPORT(&suspend_state, EVENT_WLAN_SUSPEND_RESUME); } #endif /*---------------------------------------------------------------------------- @brief Function to suspend the wlan driver. @param hdd_context_t pHddCtx Global hdd context @return None ----------------------------------------------------------------------------*/ static int wlan_suspend(hdd_context_t* pHddCtx) { long rc = 0; pVosSchedContext vosSchedContext = NULL; /* Get the global VOSS context */ vosSchedContext = get_vos_sched_ctxt(); if(!vosSchedContext) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_FATAL,"%s: Global VOS_SCHED context is Null",__func__); return 0; } if (!pHddCtx->last_suspend_success) pHddCtx->last_suspend_success = vos_timer_get_system_time(); if (!vos_is_apps_power_collapse_allowed(pHddCtx)) { /* Fail this suspend */ pHddCtx->continuous_suspend_fail_cnt++; VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN, FL("Fail wlan suspend: not in IMPS/BMPS, continuous Failcnt %d"), pHddCtx->continuous_suspend_fail_cnt); /* call fatal event if power collapse fails for * WLAN_POWER_COLLAPSE_FAIL_THRESHOLD time. */ if ((vos_timer_get_system_time() - pHddCtx->last_suspend_success) >= WLAN_POWER_COLLAPSE_FAIL_THRESHOLD) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, FL("Current time: %lu Last suspend fail time: %lu continuous fail count: %d"), vos_timer_get_system_time(), pHddCtx->last_suspend_success, pHddCtx->continuous_suspend_fail_cnt); pHddCtx->last_suspend_success = 0; vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL, WLAN_LOG_INDICATOR_HOST_DRIVER, WLAN_LOG_REASON_POWER_COLLAPSE_FAIL, FALSE, TRUE); } return -EPERM; } pHddCtx->continuous_suspend_fail_cnt = 0; /* Suspending MC Thread, Rx Thread and Tx Thread as the platform driver is going to Suspend. */ VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: Suspending Mc, Rx and Tx Threads",__func__); INIT_COMPLETION(pHddCtx->tx_sus_event_var); /* Indicate Tx Thread to Suspend */ set_bit(TX_SUSPEND_EVENT, &vosSchedContext->txEventFlag); wake_up_interruptible(&vosSchedContext->txWaitQueue); /* Wait for Suspend Confirmation from Tx Thread */ rc = wait_for_completion_interruptible_timeout(&pHddCtx->tx_sus_event_var, msecs_to_jiffies(200)); if (rc <= 0) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s: TX Thread: timeout while suspending %ld" , __func__, rc); /* There is a race condition here, where the TX Thread can process the * SUSPEND_EVENT even after the wait_for_completion has timed out. * Check the SUSPEND_EVENT_MASK, if it is already cleared by the TX * Thread then it means it is going to suspend, so do not return failure * from here. */ if (!test_and_clear_bit(TX_SUSPEND_EVENT, &vosSchedContext->txEventFlag)) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: TX Thread: will still suspend", __func__); goto tx_suspend; } /* call fatal event if suspend for * WLAN_POWER_COLLAPSE_FAIL_THRESHOLD time. */ if ((vos_timer_get_system_time() - pHddCtx->last_suspend_success) >= WLAN_POWER_COLLAPSE_FAIL_THRESHOLD) { pHddCtx->last_suspend_success = 0; vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL, WLAN_LOG_INDICATOR_HOST_DRIVER, WLAN_LOG_REASON_POWER_COLLAPSE_FAIL, FALSE, TRUE); } return -ETIME; } tx_suspend: /* Set the Tx Thread as Suspended */ pHddCtx->isTxThreadSuspended = TRUE; INIT_COMPLETION(pHddCtx->rx_sus_event_var); /* Indicate Rx Thread to Suspend */ set_bit(RX_SUSPEND_EVENT, &vosSchedContext->rxEventFlag); wake_up_interruptible(&vosSchedContext->rxWaitQueue); /* Wait for Suspend Confirmation from Rx Thread */ rc = wait_for_completion_interruptible_timeout(&pHddCtx->rx_sus_event_var, msecs_to_jiffies(200)); if (rc <= 0) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s: RX Thread: timeout while suspending %ld", __func__, rc); /* There is a race condition here, where the RX Thread can process the * SUSPEND_EVENT even after the wait_for_completion has timed out. * Check the SUSPEND_EVENT_MASK, if it is already cleared by the RX * Thread then it means it is going to suspend, so do not return failure * from here. */ if (!test_and_clear_bit(RX_SUSPEND_EVENT, &vosSchedContext->rxEventFlag)) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: RX Thread: will still suspend", __func__); goto rx_suspend; } /* Indicate Tx Thread to Resume */ complete(&vosSchedContext->ResumeTxEvent); /* Set the Tx Thread as Resumed */ pHddCtx->isTxThreadSuspended = FALSE; /* call fatal event if suspend for * WLAN_POWER_COLLAPSE_FAIL_THRESHOLD time. */ if ((vos_timer_get_system_time() - pHddCtx->last_suspend_success) >= WLAN_POWER_COLLAPSE_FAIL_THRESHOLD) { pHddCtx->last_suspend_success = 0; vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL, WLAN_LOG_INDICATOR_HOST_DRIVER, WLAN_LOG_REASON_POWER_COLLAPSE_FAIL, FALSE, TRUE); } return -ETIME; } rx_suspend: /* Set the Rx Thread as Suspended */ pHddCtx->isRxThreadSuspended = TRUE; INIT_COMPLETION(pHddCtx->mc_sus_event_var); /* Indicate MC Thread to Suspend */ set_bit(MC_SUSPEND_EVENT, &vosSchedContext->mcEventFlag); wake_up_interruptible(&vosSchedContext->mcWaitQueue); /* Wait for Suspend Confirmation from MC Thread */ rc = wait_for_completion_interruptible_timeout(&pHddCtx->mc_sus_event_var, msecs_to_jiffies(200)); if (rc <= 0) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s: MC Thread: timeout while suspending %ld", __func__, rc); /* There is a race condition here, where the MC Thread can process the * SUSPEND_EVENT even after the wait_for_completion has timed out. * Check the SUSPEND_EVENT_MASK, if it is already cleared by the MC * Thread then it means it is going to suspend, so do not return failure * from here. */ if (!test_and_clear_bit(MC_SUSPEND_EVENT, &vosSchedContext->mcEventFlag)) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: MC Thread: will still suspend", __func__); goto mc_suspend; } /* Indicate Rx Thread to Resume */ complete(&vosSchedContext->ResumeRxEvent); /* Set the Rx Thread as Resumed */ pHddCtx->isRxThreadSuspended = FALSE; /* Indicate Tx Thread to Resume */ complete(&vosSchedContext->ResumeTxEvent); /* Set the Tx Thread as Resumed */ pHddCtx->isTxThreadSuspended = FALSE; /* call fatal event if suspend for * WLAN_POWER_COLLAPSE_FAIL_THRESHOLD time. */ if ((vos_timer_get_system_time() - pHddCtx->last_suspend_success) >= WLAN_POWER_COLLAPSE_FAIL_THRESHOLD) { pHddCtx->last_suspend_success = 0; vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL, WLAN_LOG_INDICATOR_HOST_DRIVER, WLAN_LOG_REASON_POWER_COLLAPSE_FAIL, FALSE, TRUE); } return -ETIME; } mc_suspend: /* Set the Mc Thread as Suspended */ pHddCtx->isMcThreadSuspended = TRUE; /* Set the Station state as Suspended */ pHddCtx->isWlanSuspended = TRUE; pHddCtx->last_suspend_success = 0; pHddCtx->rx_wow_dump = true; hdd_wlan_suspend_resume_event(HDD_WLAN_SUSPEND); return 0; } /*---------------------------------------------------------------------------- @brief Function to resume the wlan driver. @param hdd_context_t pHddCtx Global hdd context @return None ----------------------------------------------------------------------------*/ static void wlan_resume(hdd_context_t* pHddCtx) { pVosSchedContext vosSchedContext = NULL; //Get the global VOSS context. vosSchedContext = get_vos_sched_ctxt(); if(!vosSchedContext) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_FATAL,"%s: Global VOS_SCHED context is Null",__func__); return; } /* Resuming Mc, Rx and Tx Thread as platform Driver is resuming. */ VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: Resuming Mc, Rx and Tx Thread",__func__); /* Indicate MC Thread to Resume */ complete(&vosSchedContext->ResumeMcEvent); /* Set the Mc Thread as Resumed */ pHddCtx->isMcThreadSuspended = FALSE; /* Indicate Rx Thread to Resume */ complete(&vosSchedContext->ResumeRxEvent); /* Set the Rx Thread as Resumed */ pHddCtx->isRxThreadSuspended = FALSE; /* Indicate Tx Thread to Resume */ complete(&vosSchedContext->ResumeTxEvent); /* Set the Tx Thread as Resumed */ pHddCtx->isTxThreadSuspended = FALSE; /* Set the Station state as Suspended */ pHddCtx->isWlanSuspended = FALSE; hdd_wlan_suspend_resume_event(HDD_WLAN_RESUME); } /*---------------------------------------------------------------------------- @brief Function to suspend the wlan driver. This function will get called by platform driver Suspend on System Suspend @param dev platform_func_device @return None ----------------------------------------------------------------------------*/ int __hddDevSuspendHdlr(struct device *dev) { int ret = 0; hdd_context_t* pHddCtx = NULL; ENTER(); pHddCtx = (hdd_context_t*)wcnss_wlan_get_drvdata(dev); /* Get the HDD context */ ret = wlan_hdd_validate_context(pHddCtx); if (0 != ret) { return ret; } if(pHddCtx->isWlanSuspended == TRUE) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_FATAL,"%s: WLAN is already in suspended state",__func__); return 0; } /* Suspend the wlan driver */ ret = wlan_suspend(pHddCtx); if(ret != 0) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_FATAL,"%s: Not able to suspend wlan",__func__); return ret; } #ifdef HAVE_WCNSS_SUSPEND_RESUME_NOTIFY if(hdd_is_suspend_notify_allowed(pHddCtx)) { wcnss_suspend_notify(); suspend_notify_sent = true; } #endif EXIT(); return 0; } int __hddDevSuspendNoIrqHdlr(struct device *dev) { int ret = 0; hdd_context_t* pHddCtx = NULL; pVosContextType pVosContext; pVosSchedContext pSchedContext; ENTER(); pHddCtx = (hdd_context_t*)wcnss_wlan_get_drvdata(dev); /* Get the HDD context */ ret = wlan_hdd_validate_context(pHddCtx); if (0 != ret) { return ret; } if(pHddCtx->isWlanSuspended != TRUE) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_FATAL, "%s: WLAN is not in suspended state",__func__); return -EPERM; } pVosContext = vos_get_global_context(VOS_MODULE_ID_SYS, NULL); if(pVosContext == NULL) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_FATAL, "%s: Failed vos_get_global_context",__func__); return -EPERM; } pSchedContext = &pVosContext->vosSched; if (test_bit(RX_POST_EVENT, &pSchedContext->rxEventFlag)) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_INFO, "%s: WLAN suspend is not honored",__func__); return -EPERM; } VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: Suspend No IRQ done successfully",__func__); EXIT(); return 0; } int hddDevSuspendHdlr(struct device *dev) { int ret; vos_ssr_protect(__func__); ret = __hddDevSuspendHdlr(dev); vos_ssr_unprotect(__func__); return ret; } int hddDevSuspendNoIrqHdlr(struct device *dev) { int ret; vos_ssr_protect(__func__); ret = __hddDevSuspendNoIrqHdlr(dev); vos_ssr_unprotect(__func__); return ret; } int hddDevResumeNoIrqHdlr(struct device *dev) { return 0; } /*---------------------------------------------------------------------------- @brief Function to resume the wlan driver. This function will get called by platform driver Resume on System Resume @param dev platform_func_device @return None ----------------------------------------------------------------------------*/ int __hddDevResumeHdlr(struct device *dev) { hdd_context_t* pHddCtx = NULL; int ret = 0; ENTER(); pHddCtx = (hdd_context_t*)wcnss_wlan_get_drvdata(dev); ret = wlan_hdd_validate_context(pHddCtx); if (0 != ret) { return ret; } if(pHddCtx->isWlanSuspended != TRUE) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_FATAL,"%s: WLAN is already in resumed state",__func__); return 0; } /* Resume the wlan driver */ wlan_resume(pHddCtx); #ifdef HAVE_WCNSS_SUSPEND_RESUME_NOTIFY if(suspend_notify_sent == true) { wcnss_resume_notify(); suspend_notify_sent = false; } #endif EXIT(); return 0; } int hddDevResumeHdlr(struct device *dev) { int ret; vos_ssr_protect(__func__); ret = __hddDevResumeHdlr(dev); vos_ssr_unprotect(__func__); return ret; } static const struct dev_pm_ops pm_ops = { .suspend = hddDevSuspendHdlr, .resume = hddDevResumeHdlr, .suspend_noirq = hddDevSuspendNoIrqHdlr, .resume_noirq = hddDevResumeNoIrqHdlr }; /*---------------------------------------------------------------------------- * @brief Registration function. Register suspend, resume callback functions with platform driver. @param hdd_context_t pHddCtx Global hdd context @return General status code VOS_STATUS_SUCCESS Registration Success VOS_STATUS_E_FAILURE Registration Fail ----------------------------------------------------------------------------*/ VOS_STATUS hddRegisterPmOps(hdd_context_t *pHddCtx) { wcnss_wlan_register_pm_ops(pHddCtx->parent_dev, &pm_ops); return VOS_STATUS_SUCCESS; } /*---------------------------------------------------------------------------- @brief De-registration function. Deregister the suspend, resume callback functions with platform driver @param hdd_context_t pHddCtx Global hdd context @return General status code VOS_STATUS_SUCCESS De-Registration Success VOS_STATUS_E_FAILURE De-Registration Fail ----------------------------------------------------------------------------*/ VOS_STATUS hddDeregisterPmOps(hdd_context_t *pHddCtx) { wcnss_wlan_unregister_pm_ops(pHddCtx->parent_dev, &pm_ops); return VOS_STATUS_SUCCESS; } /*---------------------------------------------------------------------------- @brief TX frame block timeout handler Resume TX, and reset TX frame count @param hdd_context_t pHddCtx Global hdd context @return NONE ----------------------------------------------------------------------------*/ void hddDevTmTxBlockTimeoutHandler(void *usrData) { hdd_context_t *pHddCtx = (hdd_context_t *)usrData; hdd_adapter_t *staAdapater; ENTER(); if (0 != (wlan_hdd_validate_context(pHddCtx))) { return; } staAdapater = hdd_get_adapter(pHddCtx, WLAN_HDD_INFRA_STATION); if ((NULL == staAdapater) || (WLAN_HDD_ADAPTER_MAGIC != staAdapater->magic)) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR, FL("invalid Adapter %pK"), staAdapater); VOS_ASSERT(0); return; } if(mutex_lock_interruptible(&pHddCtx->tmInfo.tmOperationLock)) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR, "%s: Acquire lock fail", __func__); return; } pHddCtx->tmInfo.txFrameCount = 0; /* Resume TX flow */ hddLog(VOS_TRACE_LEVEL_INFO, FL("Enabling queues")); netif_tx_wake_all_queues(staAdapater->dev); pHddCtx->tmInfo.qBlocked = VOS_FALSE; mutex_unlock(&pHddCtx->tmInfo.tmOperationLock); EXIT(); return; } /*---------------------------------------------------------------------------- @brief TM Level Change handler Received Tm Level changed notification @param dev : Device context changedTmLevel : Changed new TM level @return ----------------------------------------------------------------------------*/ void hddDevTmLevelChangedHandler(struct device *dev, int changedTmLevel) { hdd_context_t *pHddCtx = NULL; WLAN_TmLevelEnumType newTmLevel = changedTmLevel; hdd_adapter_t *staAdapater; pHddCtx = (hdd_context_t*)wcnss_wlan_get_drvdata(dev); if ((pHddCtx->tmInfo.currentTmLevel == newTmLevel) || (!pHddCtx->cfg_ini->thermalMitigationEnable)) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_WARN, "%s: TM Not enabled %d or Level does not changed %d", __func__, pHddCtx->cfg_ini->thermalMitigationEnable, newTmLevel); /* TM Level does not changed, * Or feature does not enabled * do nothing */ return; } /* Only STA mode support TM now * all other mode, TM feature should be disabled */ if (~VOS_STA & pHddCtx->concurrency_mode) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR, "%s: CMODE 0x%x, TM disable", __func__, pHddCtx->concurrency_mode); newTmLevel = WLAN_HDD_TM_LEVEL_0; } if ((newTmLevel < WLAN_HDD_TM_LEVEL_0) || (newTmLevel >= WLAN_HDD_TM_LEVEL_MAX)) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR, "%s: TM level %d out of range", __func__, newTmLevel); return; } if (newTmLevel != WLAN_HDD_TM_LEVEL_4) sme_SetTmLevel(pHddCtx->hHal, newTmLevel, 0); if (mutex_lock_interruptible(&pHddCtx->tmInfo.tmOperationLock)) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR, "%s: Acquire lock fail", __func__); return; } pHddCtx->tmInfo.currentTmLevel = newTmLevel; pHddCtx->tmInfo.txFrameCount = 0; vos_mem_copy(&pHddCtx->tmInfo.tmAction, &thermalMigrationAction[newTmLevel], sizeof(hdd_tmLevelAction_t)); if (pHddCtx->tmInfo.tmAction.enterImps) { staAdapater = hdd_get_adapter(pHddCtx, WLAN_HDD_INFRA_STATION); if (staAdapater) { if (hdd_connIsConnected(WLAN_HDD_GET_STATION_CTX_PTR(staAdapater))) { sme_RoamDisconnect(pHddCtx->hHal, staAdapater->sessionId, eCSR_DISCONNECT_REASON_UNSPECIFIED); } } } mutex_unlock(&pHddCtx->tmInfo.tmOperationLock); return; } /*---------------------------------------------------------------------------- @brief Register function Register Thermal Mitigation Level Changed handle callback function @param hdd_context_t pHddCtx Global hdd context @return General status code VOS_STATUS_SUCCESS Registration Success VOS_STATUS_E_FAILURE Registration Fail ----------------------------------------------------------------------------*/ VOS_STATUS hddDevTmRegisterNotifyCallback(hdd_context_t *pHddCtx) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_INFO, "%s: Register TM Handler", __func__); wcnss_register_thermal_mitigation(pHddCtx->parent_dev ,hddDevTmLevelChangedHandler); /* Set Default TM Level as Lowest, do nothing */ pHddCtx->tmInfo.currentTmLevel = WLAN_HDD_TM_LEVEL_0; vos_mem_zero(&pHddCtx->tmInfo.tmAction, sizeof(hdd_tmLevelAction_t)); vos_timer_init(&pHddCtx->tmInfo.txSleepTimer, VOS_TIMER_TYPE_SW, hddDevTmTxBlockTimeoutHandler, (void *)pHddCtx); mutex_init(&pHddCtx->tmInfo.tmOperationLock); pHddCtx->tmInfo.txFrameCount = 0; pHddCtx->tmInfo.blockedQueue = NULL; pHddCtx->tmInfo.qBlocked = VOS_FALSE; return VOS_STATUS_SUCCESS; } /*---------------------------------------------------------------------------- @brief Un-Register function Un-Register Thermal Mitigation Level Changed handle callback function @param hdd_context_t pHddCtx Global hdd context @return General status code VOS_STATUS_SUCCESS Un-Registration Success VOS_STATUS_E_FAILURE Un-Registration Fail ----------------------------------------------------------------------------*/ VOS_STATUS hddDevTmUnregisterNotifyCallback(hdd_context_t *pHddCtx) { VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; wcnss_unregister_thermal_mitigation(hddDevTmLevelChangedHandler); if(VOS_TIMER_STATE_RUNNING == vos_timer_getCurrentState(&pHddCtx->tmInfo.txSleepTimer)) { vosStatus = vos_timer_stop(&pHddCtx->tmInfo.txSleepTimer); if(!VOS_IS_STATUS_SUCCESS(vosStatus)) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: Timer stop fail", __func__); } } // Destroy the vos timer... vosStatus = vos_timer_destroy(&pHddCtx->tmInfo.txSleepTimer); if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR, "%s: Fail to destroy timer", __func__); } return VOS_STATUS_SUCCESS; }