inline void rtw_lock_ext_suspend_timeout(u32 timeout_ms)
{
#ifdef CONFIG_WAKELOCK
wake_lock_timeout(&rtw_suspend_ext_lock, rtw_ms_to_systime(timeout_ms));
#elif defined(CONFIG_ANDROID_POWER)
android_lock_suspend_auto_expire(&rtw_suspend_ext_lock, rtw_ms_to_systime(timeout_ms));
#endif
}
inline void rtw_lock_resume_scan_timeout(u32 timeout_ms)
{
#ifdef CONFIG_WAKELOCK
wake_lock_timeout(&rtw_resume_scan_lock, rtw_ms_to_systime(timeout_ms));
#elif defined(CONFIG_ANDROID_POWER)
android_lock_suspend_auto_expire(&rtw_resume_scan_lock, rtw_ms_to_systime(timeout_ms));
#endif
//DBG_871X("resume scan lock:%d\n", timeout_ms);
}
inline void rtw_lock_traffic_suspend_timeout(u32 timeout_ms)
{
#ifdef CONFIG_WAKELOCK
wake_lock_timeout(&rtw_suspend_traffic_lock, rtw_ms_to_systime(timeout_ms));
#elif defined(CONFIG_ANDROID_POWER)
android_lock_suspend_auto_expire(&rtw_suspend_traffic_lock, rtw_ms_to_systime(timeout_ms));
#endif
//DBG_871X("traffic lock timeout:%d\n", timeout_ms);
}
inline void rtw_lock_resume_scan_timeout(u32 timeout_ms)
{
#ifdef CONFIG_WAKELOCK
wake_lock_timeout(&rtw_resume_scan_lock, rtw_ms_to_systime(timeout_ms));
#endif
//DBG_871X("resume scan lock:%d\n", timeout_ms);
}
inline void rtw_lock_traffic_suspend_timeout(u32 timeout_ms)
{
#ifdef CONFIG_WAKELOCK
wake_lock_timeout(&rtw_suspend_traffic_lock, rtw_ms_to_systime(timeout_ms));
#endif
//DBG_871X("traffic lock timeout:%d\n", timeout_ms);
}
int _rtw_pwr_wakeup(struct rtl_priv *rtlpriv, uint32_t ips_deffer_ms, const char *caller)
{
struct pwrctrl_priv *pwrpriv = &rtlpriv->pwrctrlpriv;
struct mlme_priv *pmlmepriv = &rtlpriv->mlmepriv;
int ret = _SUCCESS;
uint32_t start = jiffies;
if (pwrpriv->ips_deny_time < jiffies + rtw_ms_to_systime(ips_deffer_ms))
pwrpriv->ips_deny_time = jiffies + rtw_ms_to_systime(ips_deffer_ms);
if (pwrpriv->ps_processing) {
DBG_871X("%s wait ps_processing...\n", __func__);
while (pwrpriv->ps_processing && rtw_get_passing_time_ms(start) <= 3000)
msleep(10);
if (pwrpriv->ps_processing)
DBG_871X("%s wait ps_processing timeout\n", __func__);
else
DBG_871X("%s wait ps_processing done\n", __func__);
}
if (pwrpriv->bInternalAutoSuspend == _FALSE && pwrpriv->bInSuspend) {
DBG_871X("%s wait bInSuspend...\n", __func__);
while (pwrpriv->bInSuspend
&& ((rtw_get_passing_time_ms(start) <= 3000)
|| (rtw_get_passing_time_ms(start) <= 500))
) {
msleep(10);
}
if (pwrpriv->bInSuspend)
DBG_871X("%s wait bInSuspend timeout\n", __func__);
else
DBG_871X("%s wait bInSuspend done\n", __func__);
}
//System suspend is not allowed to wakeup
if ((pwrpriv->bInternalAutoSuspend == _FALSE) && (_TRUE == pwrpriv->bInSuspend )){
ret = _FAIL;
goto exit;
}
//block???
if ((pwrpriv->bInternalAutoSuspend == _TRUE) && (rtlpriv->net_closed == _TRUE)) {
ret = _FAIL;
goto exit;
}
//I think this should be check in IPS, LPS, autosuspend functions...
if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
ret = _SUCCESS;
goto exit;
}
if (rf_off == pwrpriv->rf_pwrstate ) {
#ifdef CONFIG_AUTOSUSPEND
if (pwrpriv->brfoffbyhw==_TRUE) {
DBG_8192C("hw still in rf_off state ...........\n");
ret = _FAIL;
goto exit;
} else if (rtlpriv->registrypriv.usbss_enable) {
DBG_8192C("%s call autoresume_enter....\n",__FUNCTION__);
if (_FAIL == autoresume_enter(rtlpriv)) {
DBG_8192C("======> autoresume fail.............\n");
ret = _FAIL;
goto exit;
}
} else
#endif
{
DBG_8192C("%s call ips_leave....\n",__FUNCTION__);
if (_FAIL == rtw_ips_leave(rtlpriv)) {
DBG_8192C("======> ips_leave fail.............\n");
ret = _FAIL;
goto exit;
}
}
}
//TODO: the following checking need to be merged...
if (rtlpriv->bDriverStopped
|| !rtlpriv->bup
|| !rtlpriv->hw_init_completed
){
DBG_8192C("%s: bDriverStopped=%d, bup=%d, hw_init_completed=%u\n"
, caller
, rtlpriv->bDriverStopped
, rtlpriv->bup
, rtlpriv->hw_init_completed);
ret= _FALSE;
goto exit;
}
exit:
if (pwrpriv->ips_deny_time < jiffies + rtw_ms_to_systime(ips_deffer_ms))
pwrpriv->ips_deny_time = jiffies + rtw_ms_to_systime(ips_deffer_ms);
return ret;
}
/*
* rtw_pwr_wakeup - Wake the NIC up from: 1)IPS. 2)USB autosuspend
* @adapter: pointer to _adapter structure
* @ips_deffer_ms: the ms wiil prevent from falling into IPS after wakeup
* Return _SUCCESS or _FAIL
*/
int _rtw_pwr_wakeup(struct rtw_adapter *padapter, u32 ips_deffer_ms,
const char *caller)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
int ret = _SUCCESS;
u32 start = rtw_get_current_time();
#ifdef CONFIG_CONCURRENT_MODE
if (padapter->pbuddy_adapter)
LeaveAllPowerSaveMode(padapter->pbuddy_adapter);
if ((padapter->isprimary == false) && padapter->pbuddy_adapter) {
padapter = padapter->pbuddy_adapter;
pwrpriv = &padapter->pwrctrlpriv;
pmlmepriv = &padapter->mlmepriv;
}
#endif
if (pwrpriv->ips_deny_time <
rtw_get_current_time() + rtw_ms_to_systime(ips_deffer_ms))
pwrpriv->ips_deny_time =
rtw_get_current_time() + rtw_ms_to_systime(ips_deffer_ms);
if (pwrpriv->ps_processing) {
DBG_8192D("%s wait ps_processing...\n", __func__);
while (pwrpriv->ps_processing &&
rtw_get_passing_time_ms(start) <= 3000)
rtw_msleep_os(10);
if (pwrpriv->ps_processing)
DBG_8192D("%s wait ps_processing timeout\n", __func__);
else
DBG_8192D("%s wait ps_processing done\n", __func__);
}
if (pwrpriv->bInternalAutoSuspend == false && pwrpriv->bInSuspend) {
DBG_8192D("%s wait bInSuspend...\n", __func__);
while (pwrpriv->bInSuspend &&
((rtw_get_passing_time_ms(start) <= 3000 &&
!rtw_is_do_late_resume(pwrpriv)) ||
(rtw_get_passing_time_ms(start) <= 500 &&
rtw_is_do_late_resume(pwrpriv)))) {
rtw_msleep_os(10);
}
if (pwrpriv->bInSuspend)
DBG_8192D("%s wait bInSuspend timeout\n", __func__);
else
DBG_8192D("%s wait bInSuspend done\n", __func__);
}
/* System suspend is not allowed to wakeup */
if ((pwrpriv->bInternalAutoSuspend == false) &&
(true == pwrpriv->bInSuspend)) {
ret = _FAIL;
goto exit;
}
/* block??? */
if ((pwrpriv->bInternalAutoSuspend == true) &&
(padapter->net_closed == true)) {
ret = _FAIL;
goto exit;
}
/* I think this should be check in IPS, LPS, autosuspend functions... */
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
ret = _SUCCESS;
goto exit;
}
if (rf_off == pwrpriv->rf_pwrstate) {
#ifdef CONFIG_AUTOSUSPEND
if (pwrpriv->brfoffbyhw == true) {
DBG_8192D("hw still in rf_off state ...........\n");
ret = _FAIL;
goto exit;
} else if (padapter->registrypriv.usbss_enable) {
DBG_8192D("%s call autoresume_enter....\n", __func__);
if (_FAIL == autoresume_enter(padapter)) {
DBG_8192D
("======> autoresume fail.............\n");
ret = _FAIL;
goto exit;
}
} else
#endif
{
#ifdef CONFIG_IPS
DBG_8192D("%s call ips_leave....\n", __func__);
if (_FAIL == ips_leave(padapter)) {
DBG_8192D
("======> ips_leave fail.............\n");
ret = _FAIL;
goto exit;
}
#endif
}
}
/* TODO: the following checking need to be merged... */
if (padapter->bDriverStopped || !padapter->bup ||
!padapter->hw_init_completed) {
DBG_8192D
("%s: bDriverStopped=%d, bup=%d, hw_init_completed=%u\n",
caller, padapter->bDriverStopped, padapter->bup,
padapter->hw_init_completed);
ret = false;
goto exit;
}
exit:
if (pwrpriv->ips_deny_time <
rtw_get_current_time() + rtw_ms_to_systime(ips_deffer_ms))
pwrpriv->ips_deny_time =
rtw_get_current_time() + rtw_ms_to_systime(ips_deffer_ms);
return ret;
}
inline void rtw_set_ips_deny(struct rtw_adapter *padapter, u32 ms)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
pwrpriv->ips_deny_time = rtw_get_current_time() + rtw_ms_to_systime(ms);
}
inline void rtw_lock_suspend_timeout(u32 timeout_ms)
{
#ifdef CONFIG_WAKELOCK
wake_lock_timeout(&rtw_suspend_lock, rtw_ms_to_systime(timeout_ms));
#endif
}
