int rtw_resume_process(_adapter *padapter) { struct net_device *pnetdev; struct pwrctrl_priv *pwrpriv; u8 is_pwrlock_hold_by_caller; u8 is_directly_called_by_auto_resume; int ret = 0; u32 start_time = rtw_get_current_time(); _func_enter_; DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid); if(padapter) { pnetdev= padapter->pnetdev; pwrpriv = &padapter->pwrctrlpriv; } else { ret =-1; goto exit; } rtw_reset_drv_sw(padapter); pwrpriv->bkeepfwalive = _FALSE; DBG_871X("bkeepfwalive(%x)\n",pwrpriv->bkeepfwalive); if(pm_netdev_open(pnetdev,_TRUE) != 0) { ret = -1; goto exit; } netif_device_attach(pnetdev); netif_carrier_on(pnetdev); if( padapter->pid[1]!=0) { DBG_871X("pid[1]:%d\n",padapter->pid[1]); rtw_signal_process(padapter->pid[1], SIGUSR2); } #ifdef CONFIG_LAYER2_ROAMING_RESUME rtw_roaming(padapter, NULL); #endif #ifdef CONFIG_RESUME_IN_WORKQUEUE rtw_unlock_suspend(); #endif //CONFIG_RESUME_IN_WORKQUEUE exit: DBG_871X("<=== %s return %d.............. in %dms\n", __FUNCTION__ , ret, rtw_get_passing_time_ms(start_time)); _func_exit_; return ret; }
u32 rtl8821cu_hal_init(PADAPTER padapter) { u8 status = _SUCCESS; u32 init_start_time = rtw_get_current_time(); if (_FALSE == rtl8821c_hal_init(padapter)) return _FAIL; RTW_INFO("%s in %dms\n", __func__, rtw_get_passing_time_ms(init_start_time)); return status; }
void rtw_ips_pwr_down(struct adapter *padapter) { u32 start_time = jiffies; DBG_88E("===> rtw_ips_pwr_down...................\n"); padapter->net_closed = true; rtw_led_control(padapter, LED_CTL_POWER_OFF); rtw_ips_dev_unload(padapter); DBG_88E("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time)); }
void rtw_update_mem_stat(u8 flag, u32 sz) { static u32 update_time = 0; int peak, alloc; if(!update_time) { ATOMIC_SET(&rtw_dbg_mem_stat.vir_alloc,0); ATOMIC_SET(&rtw_dbg_mem_stat.vir_peak,0); ATOMIC_SET(&rtw_dbg_mem_stat.vir_alloc_err,0); ATOMIC_SET(&rtw_dbg_mem_stat.phy_alloc,0); ATOMIC_SET(&rtw_dbg_mem_stat.phy_peak,0); ATOMIC_SET(&rtw_dbg_mem_stat.phy_alloc_err,0); } switch(flag) { case MEM_STAT_VIR_ALLOC_SUCCESS: alloc = ATOMIC_ADD_RETURN(&rtw_dbg_mem_stat.vir_alloc, sz); peak=ATOMIC_READ(&rtw_dbg_mem_stat.vir_peak); if (peak<alloc) ATOMIC_SET(&rtw_dbg_mem_stat.vir_peak, alloc); break; case MEM_STAT_VIR_ALLOC_FAIL: ATOMIC_INC(&rtw_dbg_mem_stat.vir_alloc_err); break; case MEM_STAT_VIR_FREE: alloc = ATOMIC_SUB_RETURN(&rtw_dbg_mem_stat.vir_alloc, sz); break; case MEM_STAT_PHY_ALLOC_SUCCESS: alloc = ATOMIC_ADD_RETURN(&rtw_dbg_mem_stat.phy_alloc, sz); peak=ATOMIC_READ(&rtw_dbg_mem_stat.phy_peak); if (peak<alloc) ATOMIC_SET(&rtw_dbg_mem_stat.phy_peak, alloc); break; case MEM_STAT_PHY_ALLOC_FAIL: ATOMIC_INC(&rtw_dbg_mem_stat.phy_alloc_err); break; case MEM_STAT_PHY_FREE: alloc = ATOMIC_SUB_RETURN(&rtw_dbg_mem_stat.phy_alloc, sz); }; if (rtw_get_passing_time_ms(update_time) > 5000) { rtw_dump_mem_stat(); update_time=rtw_get_current_time(); } }
void rtw_ips_pwr_down(struct rtl_priv *rtlpriv) { u32 start_time = jiffies; DBG_871X("===> rtw_ips_pwr_down...................\n"); rtlpriv->bCardDisableWOHSM = _TRUE; rtlpriv->net_closed = _TRUE; rtw_ips_dev_unload(rtlpriv); rtlpriv->bCardDisableWOHSM = _FALSE; DBG_871X("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time)); }
void rtw_ips_pwr_down(_adapter *padapter) { u32 start_time = rtw_get_current_time(); DBG_8192C("===> rtw_ips_pwr_down...................\n"); padapter->bCardDisableWOHSM = _TRUE; padapter->net_closed = _TRUE; rtw_led_control(padapter, LED_CTL_POWER_OFF); rtw_ips_dev_unload(padapter); padapter->bCardDisableWOHSM = _FALSE; DBG_8192C("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time)); }
u8Byte ODM_GetProgressingTime( IN PDM_ODM_T pDM_Odm, IN u8Byte Start_Time ) { #if(DM_ODM_SUPPORT_TYPE & (ODM_AP|ODM_ADSL)) return 0; #elif(DM_ODM_SUPPORT_TYPE & ODM_CE) return rtw_get_passing_time_ms((u4Byte)Start_Time); #elif(DM_ODM_SUPPORT_TYPE & ODM_WIN) return ((PlatformGetCurrentTime() - Start_Time)>>10); #endif }
void rtw_ips_pwr_down(struct adapter *padapter) { u32 start_time = rtw_get_current_time(); DBG_88E("===> rtw_ips_pwr_down...................\n"); padapter->bCardDisableWOHSM = true; padapter->net_closed = true; rtw_led_control(padapter, LED_CTL_POWER_OFF); rtw_ips_dev_unload(padapter); padapter->bCardDisableWOHSM = false; DBG_88E("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time)); }
int proc_get_survey_info(struct seq_file *m, void *v) { _irqL irqL; struct net_device *dev = m->private; _adapter *padapter = (_adapter *)rtw_netdev_priv(dev); struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); _queue *queue = &(pmlmepriv->scanned_queue); struct wlan_network *pnetwork = NULL; _list *plist, *phead; s32 notify_signal; u16 index = 0; _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); phead = get_list_head(queue); plist = get_next(phead); if ((!phead) || (!plist)) return 0; DBG_871X_SEL_NL(m, "%5s %-17s %3s %-3s %-4s %5s %s\n","index", "bssid", "ch", "dBm", "SdBm", "age", "ssid"); while(1) { if (rtw_end_of_queue_search(phead,plist)== _TRUE) break; pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); if (!pnetwork) break; if ( check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE && is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) { notify_signal = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);//dbm } else { notify_signal = translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength);//dbm } DBG_871X_SEL_NL(m, "%5d "MAC_FMT" %3d %3d %4d %5d %s\n", ++index, MAC_ARG(pnetwork->network.MacAddress), pnetwork->network.Configuration.DSConfig, (int)pnetwork->network.Rssi, notify_signal, rtw_get_passing_time_ms((u32)pnetwork->last_scanned), //translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength), pnetwork->network.Ssid.Ssid); plist = get_next(plist); } _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); return 0; }
int rtw_ips_pwr_up(_adapter *padapter) { int result; u32 start_time = rtw_get_current_time(); DBG_8192C("===> rtw_ips_pwr_up..............\n"); rtw_reset_drv_sw(padapter); result = ips_netdrv_open(padapter); rtw_led_control(padapter, LED_CTL_NO_LINK); DBG_8192C("<=== rtw_ips_pwr_up.............. in %dms\n", rtw_get_passing_time_ms(start_time)); return result; }
void sreset_reset(_adapter *padapter) { #ifdef DBG_CONFIG_ERROR_RESET HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter); struct sreset_priv *psrtpriv = &pHalData->srestpriv; struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); struct xmit_priv *pxmitpriv = &padapter->xmitpriv; _irqL irqL; u32 start = rtw_get_current_time(); struct dvobj_priv *psdpriv = padapter->dvobj; struct debug_priv *pdbgpriv = &psdpriv->drv_dbg; DBG_871X("%s\n", __FUNCTION__); psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS; #ifdef CONFIG_LPS rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0, "SRESET"); #endif//#ifdef CONFIG_LPS _enter_pwrlock(&pwrpriv->lock); psrtpriv->silent_reset_inprogress = _TRUE; pwrpriv->change_rfpwrstate = rf_off; sreset_stop_adapter(padapter); #ifdef CONFIG_CONCURRENT_MODE sreset_stop_adapter(padapter->pbuddy_adapter); #endif #ifdef CONFIG_IPS _ips_enter(padapter); _ips_leave(padapter); #endif sreset_start_adapter(padapter); #ifdef CONFIG_CONCURRENT_MODE sreset_start_adapter(padapter->pbuddy_adapter); #endif psrtpriv->silent_reset_inprogress = _FALSE; _exit_pwrlock(&pwrpriv->lock); DBG_871X("%s done in %d ms\n", __FUNCTION__, rtw_get_passing_time_ms(start)); pdbgpriv->dbg_sreset_cnt++; #endif }
s4Byte ODM_GetProgressingTime( IN PDM_ODM_T pDM_Odm, IN u4Byte Start_Time ) { #if(DM_ODM_SUPPORT_TYPE & (ODM_AP|ODM_ADSL)) return 0; #elif(DM_ODM_SUPPORT_TYPE & ODM_CE) return rtw_get_passing_time_ms(Start_Time); #elif(DM_ODM_SUPPORT_TYPE & ODM_WIN) return 0; #endif }
int rtw_ips_pwr_up(struct rtl_priv *rtlpriv) { int result; u32 start_time = jiffies; DBG_871X("===> rtw_ips_pwr_up..............\n"); rtw_reset_drv_sw(rtlpriv); result = ips_netdrv_open(rtlpriv); rtw_hal_led_control(rtlpriv, LED_CTL_NO_LINK); DBG_871X("<=== rtw_ips_pwr_up.............. in %dms\n", rtw_get_passing_time_ms(start_time)); return result; }
static int rtw_resume_process(struct adapter *padapter) { struct net_device *pnetdev; struct pwrctrl_priv *pwrpriv = NULL; int ret = -1; u32 start_time = jiffies; DBG_88E("==> %s (%s:%d)\n", __func__, current->comm, current->pid); if (padapter) { pnetdev = padapter->pnetdev; pwrpriv = &padapter->pwrctrlpriv; } else { goto exit; } _enter_pwrlock(&pwrpriv->lock); rtw_reset_drv_sw(padapter); pwrpriv->bkeepfwalive = false; DBG_88E("bkeepfwalive(%x)\n", pwrpriv->bkeepfwalive); if (pm_netdev_open(pnetdev, true) != 0) goto exit; netif_device_attach(pnetdev); netif_carrier_on(pnetdev); _exit_pwrlock(&pwrpriv->lock); if (padapter->pid[1] != 0) { DBG_88E("pid[1]:%d\n", padapter->pid[1]); rtw_signal_process(padapter->pid[1], SIGUSR2); } rtw_roaming(padapter, NULL); ret = 0; exit: if (pwrpriv) pwrpriv->bInSuspend = false; DBG_88E("<=== %s return %d.............. in %dms\n", __func__, ret, rtw_get_passing_time_ms(start_time)); return ret; }
void rtw_hal_read_chip_info(_adapter *padapter) { u8 hci_type = rtw_get_intf_type(padapter); u32 start = rtw_get_current_time(); /* before access eFuse, make sure card enable has been called */ if ((hci_type == RTW_SDIO || hci_type == RTW_GSPI) && !rtw_is_hw_init_completed(padapter)) rtw_hal_power_on(padapter); padapter->HalFunc.read_adapter_info(padapter); if ((hci_type == RTW_SDIO || hci_type == RTW_GSPI) && !rtw_is_hw_init_completed(padapter)) rtw_hal_power_off(padapter); DBG_871X("%s in %d ms\n", __func__, rtw_get_passing_time_ms(start)); }
u8 _rtw_mi_busy_traffic_check(_adapter *padapter, void *data) { u32 passtime; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; bool check_sc_interval = *(bool *)data; if (pmlmepriv->LinkDetectInfo.bBusyTraffic == _TRUE) { if (check_sc_interval) { /* Miracast can't do AP scan*/ passtime = rtw_get_passing_time_ms(pmlmepriv->lastscantime); pmlmepriv->lastscantime = rtw_get_current_time(); if (passtime > BUSY_TRAFFIC_SCAN_DENY_PERIOD) { RTW_INFO(ADPT_FMT" bBusyTraffic == _TRUE\n", ADPT_ARG(padapter)); return _TRUE; } } else return _TRUE; } return _FALSE; }
void sreset_reset(_adapter *padapter) { #ifdef DBG_CONFIG_ERROR_RESET HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter); struct sreset_priv *psrtpriv = &pHalData->srestpriv; struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); struct xmit_priv *pxmitpriv = &padapter->xmitpriv; _irqL irqL; u32 start = rtw_get_current_time(); DBG_871X("%s\n", __FUNCTION__); psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS; _enter_critical_mutex(&psrtpriv->silentreset_mutex, &irqL); psrtpriv->silent_reset_inprogress = _TRUE; pwrpriv->change_rfpwrstate = rf_off; sreset_stop_adapter(padapter); #ifdef CONFIG_CONCURRENT_MODE sreset_stop_adapter(padapter->pbuddy_adapter); #endif #ifdef CONFIG_IPS ips_enter(padapter); ips_leave(padapter); #endif sreset_start_adapter(padapter); #ifdef CONFIG_CONCURRENT_MODE sreset_start_adapter(padapter->pbuddy_adapter); #endif psrtpriv->silent_reset_inprogress = _FALSE; _exit_critical_mutex(&psrtpriv->silentreset_mutex, &irqL); DBG_871X("%s done in %d ms\n", __FUNCTION__, rtw_get_passing_time_ms(start)); #endif }
void rtw_lps_leave(struct rtw_adapter *padapter) { #define LPS_LEAVE_TIMEOUT_MS 100 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; u32 start_time; bool bAwake = false; #ifdef CONFIG_CONCURRENT_MODE if (padapter->iface_type != IFACE_PORT0) return; /* Skip power saving for concurrent mode port 1 */ #endif if (pwrpriv->bLeisurePs) { if (pwrpriv->pwr_mode != PS_MODE_ACTIVE) { rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0); if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) { start_time = rtw_get_current_time(); while (1) { rtw_hal_get_hwreg(padapter, HW_VAR_FWLPS_RF_ON, (u8 *)(&bAwake)); if (bAwake || padapter->bSurpriseRemoved) break; if (rtw_get_passing_time_ms(start_time) > LPS_LEAVE_TIMEOUT_MS) { DBG_8192D ("Wait for FW LPS leave more than %u ms!!!\n", LPS_LEAVE_TIMEOUT_MS); break; } rtw_usleep_os(100); } } } } }
s32 iol_execute(struct adapter *padapter, u8 control) { s32 status = _FAIL; u8 reg_0x88 = 0; u32 start = 0, passing_time = 0; control = control&0x0f; reg_0x88 = usb_read8(padapter, REG_HMEBOX_E0); usb_write8(padapter, REG_HMEBOX_E0, reg_0x88|control); start = jiffies; while ((reg_0x88 = usb_read8(padapter, REG_HMEBOX_E0)) & control && (passing_time = rtw_get_passing_time_ms(start)) < 1000) { ; } reg_0x88 = usb_read8(padapter, REG_HMEBOX_E0); status = (reg_0x88 & control) ? _FAIL : _SUCCESS; if (reg_0x88 & control<<4) status = _FAIL; return status; }
int _rtw_pwr_wakeup(struct adapter *padapter, u32 ips_deffer_ms, const char *caller) { struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; unsigned long expires; int ret = _SUCCESS; expires = jiffies + msecs_to_jiffies(ips_deffer_ms); if (time_before(pwrpriv->ips_deny_time, expires)) pwrpriv->ips_deny_time = jiffies + msecs_to_jiffies(ips_deffer_ms); { u32 start = jiffies; if (pwrpriv->ps_processing) { DBG_88E("%s wait ps_processing...\n", __func__); while (pwrpriv->ps_processing && rtw_get_passing_time_ms(start) <= 3000) usleep_range(1000, 3000); if (pwrpriv->ps_processing) DBG_88E("%s wait ps_processing timeout\n", __func__); else DBG_88E("%s wait ps_processing done\n", __func__); } } /* System suspend is not allowed to wakeup */ if ((!pwrpriv->bInternalAutoSuspend) && (pwrpriv->bInSuspend)) { ret = _FAIL; goto exit; } /* block??? */ if ((pwrpriv->bInternalAutoSuspend) && (padapter->net_closed)) { ret = _FAIL; goto exit; } /* I think this should be check in IPS, LPS, autosuspend functions... */ if (check_fwstate(pmlmepriv, _FW_LINKED)) { ret = _SUCCESS; goto exit; } if (rf_off == pwrpriv->rf_pwrstate) { DBG_88E("%s call ips_leave....\n", __func__); if (_FAIL == ips_leave(padapter)) { DBG_88E("======> ips_leave fail.............\n"); ret = _FAIL; goto exit; } } /* TODO: the following checking need to be merged... */ if (padapter->bDriverStopped || !padapter->bup || !padapter->hw_init_completed) { DBG_88E("%s: bDriverStopped=%d, bup=%d, hw_init_completed =%u\n" , caller , padapter->bDriverStopped , padapter->bup , padapter->hw_init_completed); ret = false; goto exit; } exit: expires = jiffies + msecs_to_jiffies(ips_deffer_ms); if (time_before(pwrpriv->ips_deny_time, expires)) pwrpriv->ips_deny_time = jiffies + msecs_to_jiffies(ips_deffer_ms); return ret; }
/* * * Parameters * padapter * pslv power state level, only could be PS_STATE_S0 ~ PS_STATE_S4 * */ void rtw_set_rpwm(PADAPTER padapter, u8 pslv) { u8 rpwm; struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); #ifdef CONFIG_DETECT_CPWM_BY_POLLING u8 cpwm_orig = 0; u8 cpwm_now = 0; u32 cpwm_polling_start_time = 0; u8 pollingRes = _FAIL; #endif _func_enter_; pslv = PS_STATE(pslv); if (_TRUE == pwrpriv->btcoex_rfon) { if (pslv < PS_STATE_S4) pslv = PS_STATE_S3; } #ifdef CONFIG_LPS_RPWM_TIMER if (pwrpriv->brpwmtimeout == _TRUE) { DBG_871X("%s: RPWM timeout, force to set RPWM(0x%02X) again!\n", __FUNCTION__, pslv); } else #endif // CONFIG_LPS_RPWM_TIMER { if ( (pwrpriv->rpwm == pslv) #ifdef CONFIG_LPS_LCLK #ifndef CONFIG_RTL8723A || ((pwrpriv->rpwm >= PS_STATE_S2)&&(pslv >= PS_STATE_S2)) #endif #endif ) { RT_TRACE(_module_rtl871x_pwrctrl_c_,_drv_err_, ("%s: Already set rpwm[0x%02X], new=0x%02X!\n", __FUNCTION__, pwrpriv->rpwm, pslv)); return; } } if ((padapter->bSurpriseRemoved == _TRUE) || (padapter->hw_init_completed == _FALSE)) { RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_, ("%s: SurpriseRemoved(%d) hw_init_completed(%d)\n", __FUNCTION__, padapter->bSurpriseRemoved, padapter->hw_init_completed)); pwrpriv->cpwm = PS_STATE_S4; return; } if (padapter->bDriverStopped == _TRUE) { RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_, ("%s: change power state(0x%02X) when DriverStopped\n", __FUNCTION__, pslv)); if (pslv < PS_STATE_S2) { RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_, ("%s: Reject to enter PS_STATE(0x%02X) lower than S2 when DriverStopped!!\n", __FUNCTION__, pslv)); return; } } rpwm = pslv | pwrpriv->tog; #ifdef CONFIG_LPS_LCLK // only when from PS_STATE S0/S1 to S2 and higher needs ACK if ((pwrpriv->cpwm < PS_STATE_S2) && (pslv >= PS_STATE_S2)) rpwm |= PS_ACK; #endif RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_, ("rtw_set_rpwm: rpwm=0x%02x cpwm=0x%02x\n", rpwm, pwrpriv->cpwm)); pwrpriv->rpwm = pslv; #ifdef CONFIG_DETECT_CPWM_BY_POLLING if (rpwm & PS_ACK) { //cpwm_orig = rtw_read8(padapter, SDIO_LOCAL_BASE | SDIO_REG_HCPWM1); rtw_hal_get_hwreg(padapter, HW_VAR_GET_CPWM, (u8 *)(&cpwm_orig)); } #endif #if defined(CONFIG_LPS_RPWM_TIMER) && !defined(CONFIG_DETECT_CPWM_BY_POLLING) if (rpwm & PS_ACK) _set_timer(&pwrpriv->pwr_rpwm_timer, LPS_RPWM_WAIT_MS); #endif // CONFIG_LPS_RPWM_TIMER && !CONFIG_DETECT_CPWM_BY_POLLING rtw_hal_set_hwreg(padapter, HW_VAR_SET_RPWM, (u8 *)(&rpwm)); pwrpriv->tog += 0x80; #ifdef CONFIG_LPS_LCLK // No LPS 32K, No Ack if (!(rpwm & PS_ACK)) #endif { pwrpriv->cpwm = pslv; } #ifdef CONFIG_DETECT_CPWM_BY_POLLING if (rpwm & PS_ACK) { cpwm_polling_start_time = rtw_get_current_time(); //polling cpwm do{ rtw_mdelay_os(1); //cpwm_now = rtw_read8(padapter, SDIO_LOCAL_BASE | SDIO_REG_HCPWM1); rtw_hal_get_hwreg(padapter, HW_VAR_GET_CPWM, (u8 *)(&cpwm_now)); if ((cpwm_orig ^ cpwm_now) & 0x80) { #ifdef CONFIG_LPS_LCLK #ifdef CONFIG_RTL8723A pwrpriv->cpwm = PS_STATE(cpwm_now); #else // !CONFIG_RTL8723A pwrpriv->cpwm = PS_STATE_S4; #endif // !CONFIG_RTL8723A pwrpriv->cpwm_tog = cpwm_now & PS_TOGGLE; #endif pollingRes = _SUCCESS; break; } }while (rtw_get_passing_time_ms(cpwm_polling_start_time) < LPS_RPWM_WAIT_MS); if (pollingRes == _FAIL) { #ifdef CONFIG_LPS_RPWM_TIMER _set_timer(&pwrpriv->pwr_rpwm_timer, 1); #endif DBG_871X("%s polling cpwm timeout!!!!!!!!!!\n", __FUNCTION__); } } #endif _func_exit_; }
void rtw_set_ps_mode(PADAPTER padapter, u8 ps_mode, u8 smart_ps, u8 bcn_ant_mode) { struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; #ifdef CONFIG_P2P struct wifidirect_info *pwdinfo = &( padapter->wdinfo ); #endif //CONFIG_P2P #ifdef CONFIG_TDLS struct sta_priv *pstapriv = &padapter->stapriv; _irqL irqL; int i, j; _list *plist, *phead; struct sta_info *ptdls_sta; #endif //CONFIG_TDLS _func_enter_; RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_, ("%s: PowerMode=%d Smart_PS=%d\n", __FUNCTION__, ps_mode, smart_ps)); if(ps_mode > PM_Card_Disable) { RT_TRACE(_module_rtl871x_pwrctrl_c_,_drv_err_,("ps_mode:%d error\n", ps_mode)); return; } if (pwrpriv->pwr_mode == ps_mode) { if (PS_MODE_ACTIVE == ps_mode) return; if ((pwrpriv->smart_ps == smart_ps) && (pwrpriv->bcn_ant_mode == bcn_ant_mode)) { return; } } #ifdef CONFIG_LPS_LCLK _enter_pwrlock(&pwrpriv->lock); #endif //if(pwrpriv->pwr_mode == PS_MODE_ACTIVE) if(ps_mode == PS_MODE_ACTIVE) { #ifdef CONFIG_P2P_PS if(pwdinfo->opp_ps == 0) #endif //CONFIG_P2P_PS { DBG_871X("rtw_set_ps_mode: Leave 802.11 power save\n"); #ifdef CONFIG_TDLS _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL); for(i=0; i< NUM_STA; i++) { phead = &(pstapriv->sta_hash[i]); plist = get_next(phead); while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) { ptdls_sta = LIST_CONTAINOR(plist, struct sta_info, hash_list); if( ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE ) issue_nulldata_to_TDLS_peer_STA(padapter, ptdls_sta, 0); plist = get_next(plist); } } _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL); #endif //CONFIG_TDLS pwrpriv->pwr_mode = ps_mode; rtw_set_rpwm(padapter, PS_STATE_S4); #ifdef CONFIG_WOWLAN if (padapter->pwrctrlpriv.wowlan_mode == _TRUE) { u32 start_time, delay_ms; u8 val8; delay_ms = 20; start_time = rtw_get_current_time(); do { val8 = rtw_read8(padapter, 0x90); if (!(val8 & BIT(0))) break; if (rtw_get_passing_time_ms(start_time) > delay_ms) { DBG_871X("%s: Wait for FW 32K leave more than %u ms!!!\n", __FUNCTION__, delay_ms); break; } rtw_usleep_os(100); } while (1); pwrpriv->cpwm = PS_STATE_S4; } #endif rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode)); pwrpriv->bFwCurrentInPSMode = _FALSE; } }
void SetHwReg(_adapter *adapter, HW_VARIABLES variable, u8 *val) { HAL_DATA_TYPE *hal_data = GET_HAL_DATA(adapter); struct dm_priv *dm = &(hal_data->dmpriv); switch (variable) { case HW_VAR_DM_FLAG: dm->DMFlag = *((u8*)val); break; case HW_VAR_ENC_BMC_ENABLE: { u8 seccfg; struct security_priv *psecuritypriv = &adapter->securitypriv; //enable MC/BC hw decrypt seccfg = (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)? 0xcc: 0xcf; rtw_write8(adapter, REG_SECCFG, seccfg); break; } case HW_VAR_ENC_BMC_DISABLE: { struct security_priv *psecuritypriv = &adapter->securitypriv; rtw_write8(adapter, REG_SECCFG, 0x0c|BIT(5));// enable tx enc and rx dec engine, and no key search for MC/BC break; } case HW_VAR_CHECK_TXBUF: { u8 retry_limit; u16 val16; u32 reg_200 = 0, reg_204 = 0; u32 init_reg_200 = 0, init_reg_204 = 0; u32 start = rtw_get_current_time(); u32 pass_ms; int i = 0; retry_limit = 0x01; val16 = retry_limit << RETRY_LIMIT_SHORT_SHIFT | retry_limit << RETRY_LIMIT_LONG_SHIFT; rtw_write16(adapter, REG_RL, val16); while (rtw_get_passing_time_ms(start) < 2000 && !adapter->bDriverStopped && !adapter->bSurpriseRemoved ) { reg_200 = rtw_read32(adapter, 0x200); reg_204 = rtw_read32(adapter, 0x204); if (i == 0) { init_reg_200 = reg_200; init_reg_204 = reg_204; } i++; if ((reg_200 & 0x00ffffff) != (reg_204 & 0x00ffffff)) { //DBG_871X("%s: (HW_VAR_CHECK_TXBUF)TXBUF NOT empty - 0x204=0x%x, 0x200=0x%x (%d)\n", __FUNCTION__, reg_204, reg_200, i); rtw_msleep_os(10); } else { break; } } pass_ms = rtw_get_passing_time_ms(start); if (adapter->bDriverStopped || adapter->bSurpriseRemoved) { } else if (pass_ms >= 2000 || (reg_200 & 0x00ffffff) != (reg_204 & 0x00ffffff)) { DBG_871X_LEVEL(_drv_always_, "%s:(HW_VAR_CHECK_TXBUF)NOT empty(%d) in %d ms\n", __FUNCTION__, i, pass_ms); DBG_871X_LEVEL(_drv_always_, "%s:(HW_VAR_CHECK_TXBUF)0x200=0x%08x, 0x204=0x%08x (0x%08x, 0x%08x)\n", __FUNCTION__, reg_200, reg_204, init_reg_200, init_reg_204); //rtw_warn_on(1); } else { DBG_871X("%s:(HW_VAR_CHECK_TXBUF)TXBUF Empty(%d) in %d ms\n", __FUNCTION__, i, pass_ms); } retry_limit = 0x30; val16 = retry_limit << RETRY_LIMIT_SHORT_SHIFT | retry_limit << RETRY_LIMIT_LONG_SHIFT; rtw_write16(adapter, REG_RL, val16); } break; default: if(0) DBG_871X_LEVEL(_drv_always_, "%s: [WARNING] HW_VARIABLES(%d) not defined!\n", __FUNCTION__, variable); break; } }
static int rtw_suspend(struct usb_interface *pusb_intf, pm_message_t message) { struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf); struct adapter *padapter = dvobj->if1; struct net_device *pnetdev = padapter->pnetdev; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; int ret = 0; u32 start_time = jiffies; DBG_88E("==> %s (%s:%d)\n", __func__, current->comm, current->pid); if ((!padapter->bup) || (padapter->bDriverStopped) || (padapter->bSurpriseRemoved)) { DBG_88E("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n", padapter->bup, padapter->bDriverStopped, padapter->bSurpriseRemoved); goto exit; } pwrpriv->bInSuspend = true; rtw_cancel_all_timer(padapter); LeaveAllPowerSaveMode(padapter); _enter_pwrlock(&pwrpriv->lock); /* s1. */ if (pnetdev) { netif_carrier_off(pnetdev); netif_tx_stop_all_queues(pnetdev); } /* s2. */ rtw_disassoc_cmd(padapter, 0, false); if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)) { DBG_88E("%s:%d %s(%pM), length:%d assoc_ssid.length:%d\n", __func__, __LINE__, pmlmepriv->cur_network.network.Ssid.Ssid, pmlmepriv->cur_network.network.MacAddress, pmlmepriv->cur_network.network.Ssid.SsidLength, pmlmepriv->assoc_ssid.SsidLength); pmlmepriv->to_roaming = 1; } /* s2-2. indicate disconnect to os */ rtw_indicate_disconnect(padapter); /* s2-3. */ rtw_free_assoc_resources(padapter, 1); /* s2-4. */ rtw_free_network_queue(padapter, true); rtw_dev_unload(padapter); _exit_pwrlock(&pwrpriv->lock); if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) rtw_indicate_scan_done(padapter, 1); if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) rtw_indicate_disconnect(padapter); exit: DBG_88E("<=== %s return %d.............. in %dms\n", __func__ , ret, rtw_get_passing_time_ms(start_time)); return ret; }
int rtw_resume_process(_adapter *padapter) { struct net_device *pnetdev; struct pwrctrl_priv *pwrpriv; u8 is_pwrlock_hold_by_caller; u8 is_directly_called_by_auto_resume; int ret = 0; u32 start_time = rtw_get_current_time(); _func_enter_; DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid); rtw_wifi_gpio_wlan_ctrl(WLAN_PWDN_ON); rtw_mdelay_os(1); { u32 ret = 0; DBG_8192C("read start:\n"); //spi_write8_endian(padapter, SPI_LOCAL_OFFSET | 0xF0, 0x01, 1); rtw_write8(padapter, SPI_LOCAL_OFFSET | 0xF0, 0x03); ret = rtw_read32(padapter, SPI_LOCAL_OFFSET | 0xF0); DBG_8192C("read end 0xF0 read32:%x:\n", ret); DBG_8192C("read end 0xF0 read8:%x:\n", rtw_read8(padapter, SPI_LOCAL_OFFSET | 0xF0)); } if (padapter) { pnetdev = padapter->pnetdev; pwrpriv = &padapter->pwrctrlpriv; } else { ret = -1; goto exit; } // interface init if (gspi_init(adapter_to_dvobj(padapter)) != _SUCCESS) { ret = -1; RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: initialize SDIO Failed!!\n", __FUNCTION__)); goto exit; } rtw_hal_disable_interrupt(padapter); if (gspi_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS) { ret = -1; RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: gspi_alloc_irq Failed!!\n", __FUNCTION__)); goto exit; } rtw_reset_drv_sw(padapter); pwrpriv->bkeepfwalive = _FALSE; DBG_871X("bkeepfwalive(%x)\n",pwrpriv->bkeepfwalive); if(pm_netdev_open(pnetdev,_TRUE) != 0) { ret = -1; goto exit; } netif_device_attach(pnetdev); netif_carrier_on(pnetdev); if( padapter->pid[1]!=0) { DBG_871X("pid[1]:%d\n",padapter->pid[1]); rtw_signal_process(padapter->pid[1], SIGUSR2); } #ifdef CONFIG_LAYER2_ROAMING_RESUME rtw_roaming(padapter, NULL); #endif #ifdef CONFIG_RESUME_IN_WORKQUEUE rtw_unlock_suspend(); #endif //CONFIG_RESUME_IN_WORKQUEUE exit: pwrpriv->bInSuspend = _FALSE; DBG_871X("<=== %s return %d.............. in %dms\n", __FUNCTION__ , ret, rtw_get_passing_time_ms(start_time)); _func_exit_; return ret; }
static int rtw_gspi_suspend(struct spi_device *spi, pm_message_t mesg) { struct dvobj_priv *dvobj = spi_get_drvdata(spi); PADAPTER padapter = dvobj->if1; struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; struct net_device *pnetdev = padapter->pnetdev; int ret = 0; u32 start_time = rtw_get_current_time(); _func_enter_; DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid); pwrpriv->bInSuspend = _TRUE; while (pwrpriv->bips_processing == _TRUE) rtw_msleep_os(1); if((!padapter->bup) || (padapter->bDriverStopped)||(padapter->bSurpriseRemoved)) { DBG_871X("%s bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n", __FUNCTION__ ,padapter->bup, padapter->bDriverStopped,padapter->bSurpriseRemoved); goto exit; } rtw_cancel_all_timer(padapter); LeaveAllPowerSaveMode(padapter); //padapter->net_closed = _TRUE; //s1. if(pnetdev) { netif_carrier_off(pnetdev); rtw_netif_stop_queue(pnetdev); } #ifdef CONFIG_WOWLAN padapter->pwrctrlpriv.bSupportRemoteWakeup=_TRUE; #else //s2. //s2-1. issue rtw_disassoc_cmd to fw disconnect_hdl(padapter, NULL); //rtw_disassoc_cmd(padapter); #endif #ifdef CONFIG_LAYER2_ROAMING_RESUME if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED) ) { DBG_871X("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n",__FUNCTION__, pmlmepriv->cur_network.network.Ssid.Ssid, MAC_ARG(pmlmepriv->cur_network.network.MacAddress), pmlmepriv->cur_network.network.Ssid.SsidLength, pmlmepriv->assoc_ssid.SsidLength); pmlmepriv->to_roaming = 1; } #endif //s2-2. indicate disconnect to os rtw_indicate_disconnect(padapter); //s2-3. rtw_free_assoc_resources(padapter, 1); //s2-4. rtw_free_network_queue(padapter, _TRUE); rtw_led_control(padapter, LED_CTL_POWER_OFF); rtw_dev_unload(padapter); if(check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) rtw_indicate_scan_done(padapter, 1); if(check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) rtw_indicate_disconnect(padapter); // interface deinit gspi_deinit(dvobj); RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("%s: deinit GSPI complete!\n", __FUNCTION__)); rtw_wifi_gpio_wlan_ctrl(WLAN_PWDN_OFF); rtw_mdelay_os(1); exit: DBG_871X("<=== %s return %d.............. in %dms\n", __FUNCTION__ , ret, rtw_get_passing_time_ms(start_time)); _func_exit_; 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; }
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; }
static int rtw_sdio_suspend(struct device *dev) { struct sdio_func *func =dev_to_sdio_func(dev); struct dvobj_priv *psdpriv = sdio_get_drvdata(func); _adapter *padapter = psdpriv->padapter; struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; struct net_device *pnetdev = padapter->pnetdev; int ret = 0; u32 start_time = rtw_get_current_time(); _func_enter_; DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid); if((!padapter->bup) || (padapter->bDriverStopped)||(padapter->bSurpriseRemoved)) { DBG_871X("%s bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n", __FUNCTION__ ,padapter->bup, padapter->bDriverStopped,padapter->bSurpriseRemoved); goto exit; } pwrpriv->bInSuspend = _TRUE; rtw_cancel_all_timer(padapter); LeaveAllPowerSaveMode(padapter); //padapter->net_closed = _TRUE; //s1. if(pnetdev) { netif_carrier_off(pnetdev); netif_stop_queue(pnetdev); } #ifdef CONFIG_WOWLAN padapter->pwrctrlpriv.bSupportWakeOnWlan=_TRUE; #else //s2. //s2-1. issue rtw_disassoc_cmd to fw disconnect_hdl(padapter, NULL); //rtw_disassoc_cmd(padapter); #endif #ifdef CONFIG_LAYER2_ROAMING_RESUME if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED) ) { DBG_871X("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n",__FUNCTION__, pmlmepriv->cur_network.network.Ssid.Ssid, MAC_ARG(pmlmepriv->cur_network.network.MacAddress), pmlmepriv->cur_network.network.Ssid.SsidLength, pmlmepriv->assoc_ssid.SsidLength); pmlmepriv->to_roaming = 1; } #endif //s2-2. indicate disconnect to os rtw_indicate_disconnect(padapter); //s2-3. rtw_free_assoc_resources(padapter, 1); //s2-4. rtw_free_network_queue(padapter, _TRUE); rtw_led_control(padapter, LED_CTL_POWER_OFF); rtw_dev_unload(padapter); exit: DBG_871X("<=== %s return %d.............. in %dms\n", __FUNCTION__ , ret, rtw_get_passing_time_ms(start_time)); /*depends on sunxi power control */ #if defined(CONFIG_MMC_SUNXI_POWER_CONTROL) // sunximmc_rescan_card(SDIOID, 0); // rtl8723as_sdio_poweroff(); printk("[rtl8723as] %s: suspend end.\n", __FUNCTION__); #endif _func_exit_; return ret; }