1 /******************************************************************************
3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 ******************************************************************************/
15 #define _RTW_PWRCTRL_C_
17 #include <osdep_service.h>
18 #include <drv_types.h>
19 #include <osdep_intf.h>
21 #ifdef CONFIG_8723AU_BT_COEXIST
22 #include <rtl8723a_hal.h>
25 void ips_enter23a(struct rtw_adapter * padapter)
27 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
31 pwrpriv->bips_processing = true;
33 /* syn ips_mode with request */
34 pwrpriv->ips_mode = pwrpriv->ips_mode_req;
36 pwrpriv->ips_enter23a_cnts++;
37 DBG_8723A("==>ips_enter23a cnts:%d\n", pwrpriv->ips_enter23a_cnts);
38 #ifdef CONFIG_8723AU_BT_COEXIST
39 BTDM_TurnOffBtCoexistBeforeEnterIPS(padapter);
41 if (rf_off == pwrpriv->change_rfpwrstate)
43 pwrpriv->bpower_saving = true;
44 DBG_8723A_LEVEL(_drv_always_, "nolinked power save enter\n");
46 if (pwrpriv->ips_mode == IPS_LEVEL_2)
47 pwrpriv->bkeepfwalive = true;
49 rtw_ips_pwr_down23a(padapter);
50 pwrpriv->rf_pwrstate = rf_off;
52 pwrpriv->bips_processing = false;
57 int ips_leave23a(struct rtw_adapter * padapter)
59 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
60 struct security_priv *psecuritypriv = &padapter->securitypriv;
61 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
62 int result = _SUCCESS;
67 if ((pwrpriv->rf_pwrstate == rf_off) &&!pwrpriv->bips_processing)
69 pwrpriv->bips_processing = true;
70 pwrpriv->change_rfpwrstate = rf_on;
71 pwrpriv->ips_leave23a_cnts++;
72 DBG_8723A("==>ips_leave23a cnts:%d\n", pwrpriv->ips_leave23a_cnts);
74 if ((result = rtw_ips_pwr_up23a(padapter)) == _SUCCESS) {
75 pwrpriv->rf_pwrstate = rf_on;
77 DBG_8723A_LEVEL(_drv_always_, "nolinked power save leave\n");
79 if ((_WEP40_ == psecuritypriv->dot11PrivacyAlgrthm) ||(_WEP104_ == psecuritypriv->dot11PrivacyAlgrthm))
81 DBG_8723A("==>%s, channel(%d), processing(%x)\n", __func__, padapter->mlmeextpriv.cur_channel, pwrpriv->bips_processing);
82 set_channel_bwmode23a(padapter, padapter->mlmeextpriv.cur_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
83 for (keyid = 0;keyid<4;keyid++) {
84 if (pmlmepriv->key_mask & CHKBIT(keyid)) {
85 if (keyid == psecuritypriv->dot11PrivacyKeyIndex)
86 result = rtw_set_key23a(padapter, psecuritypriv, keyid, 1);
88 result = rtw_set_key23a(padapter, psecuritypriv, keyid, 0);
93 DBG_8723A("==> ips_leave23a.....LED(0x%08x)...\n", rtw_read32(padapter, 0x4c));
94 pwrpriv->bips_processing = false;
96 pwrpriv->bkeepfwalive = false;
97 pwrpriv->bpower_saving = false;
106 static bool rtw_pwr_unassociated_idle(struct rtw_adapter *adapter)
108 struct rtw_adapter *buddy = adapter->pbuddy_adapter;
109 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
110 struct xmit_priv *pxmit_priv = &adapter->xmitpriv;
111 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
115 if (time_after_eq(adapter->pwrctrlpriv.ips_deny_time, jiffies))
118 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)
119 || check_fwstate(pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
120 || check_fwstate(pmlmepriv, WIFI_AP_STATE)
121 || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
122 || !rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)
127 /* consider buddy, if exist */
129 struct mlme_priv *b_pmlmepriv = &buddy->mlmepriv;
130 struct wifidirect_info *b_pwdinfo = &buddy->wdinfo;
132 if (check_fwstate(b_pmlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)
133 || check_fwstate(b_pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
134 || check_fwstate(b_pmlmepriv, WIFI_AP_STATE)
135 || check_fwstate(b_pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
136 || !rtw_p2p_chk_state(b_pwdinfo, P2P_STATE_NONE)
142 if (pxmit_priv->free_xmitbuf_cnt != NR_XMITBUFF ||
143 pxmit_priv->free_xmit_extbuf_cnt != NR_XMIT_EXTBUFF) {
144 DBG_8723A_LEVEL(_drv_always_, "There are some pkts to transmit\n");
145 DBG_8723A_LEVEL(_drv_info_, "free_xmitbuf_cnt: %d, free_xmit_extbuf_cnt: %d\n",
146 pxmit_priv->free_xmitbuf_cnt, pxmit_priv->free_xmit_extbuf_cnt);
156 void rtw_ps_processor23a(struct rtw_adapter*padapter)
158 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
159 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
160 enum rt_rf_power_state rfpwrstate;
162 pwrpriv->ps_processing = true;
164 if (pwrpriv->bips_processing == true)
167 if (padapter->pwrctrlpriv.bHWPwrPindetect) {
168 rfpwrstate = RfOnOffDetect23a(padapter);
169 DBG_8723A("@@@@- #2 %s ==> rfstate:%s\n", __func__, (rfpwrstate == rf_on)?"rf_on":"rf_off");
171 if (rfpwrstate!= pwrpriv->rf_pwrstate) {
172 if (rfpwrstate == rf_off) {
173 pwrpriv->change_rfpwrstate = rf_off;
174 pwrpriv->brfoffbyhw = true;
175 padapter->bCardDisableWOHSM = true;
176 rtw_hw_suspend23a(padapter);
178 pwrpriv->change_rfpwrstate = rf_on;
179 rtw_hw_resume23a(padapter);
181 DBG_8723A("current rf_pwrstate(%s)\n", (pwrpriv->rf_pwrstate == rf_off)?"rf_off":"rf_on");
183 pwrpriv->pwr_state_check_cnts ++;
186 if (pwrpriv->ips_mode_req == IPS_NONE)
189 if (rtw_pwr_unassociated_idle(padapter) == false)
192 if ((pwrpriv->rf_pwrstate == rf_on) && ((pwrpriv->pwr_state_check_cnts%4) == 0))
194 DBG_8723A("==>%s .fw_state(%x)\n", __func__, get_fwstate(pmlmepriv));
195 pwrpriv->change_rfpwrstate = rf_off;
196 ips_enter23a(padapter);
199 rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
200 pwrpriv->ps_processing = false;
204 static void pwr_state_check_handler(unsigned long data)
206 struct rtw_adapter *padapter = (struct rtw_adapter *)data;
207 rtw_ps_cmd23a(padapter);
214 * pslv power state level, only could be PS_STATE_S0 ~ PS_STATE_S4
217 void rtw_set_rpwm23a(struct rtw_adapter *padapter, u8 pslv)
220 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
224 pslv = PS_STATE(pslv);
226 if (true == pwrpriv->btcoex_rfon)
228 if (pslv < PS_STATE_S4)
232 if (pwrpriv->rpwm == pslv) {
233 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
234 ("%s: Already set rpwm[0x%02X], new = 0x%02X!\n", __func__, pwrpriv->rpwm, pslv));
238 if ((padapter->bSurpriseRemoved == true) ||
239 (padapter->hw_init_completed == false)) {
240 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
241 ("%s: SurpriseRemoved(%d) hw_init_completed(%d)\n",
242 __func__, padapter->bSurpriseRemoved, padapter->hw_init_completed));
244 pwrpriv->cpwm = PS_STATE_S4;
249 if (padapter->bDriverStopped == true) {
250 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
251 ("%s: change power state(0x%02X) when DriverStopped\n", __func__, pslv));
253 if (pslv < PS_STATE_S2) {
254 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
255 ("%s: Reject to enter PS_STATE(0x%02X) lower than S2 when DriverStopped!!\n", __func__, pslv));
260 rpwm = pslv | pwrpriv->tog;
261 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
262 ("rtw_set_rpwm23a: rpwm = 0x%02x cpwm = 0x%02x\n", rpwm, pwrpriv->cpwm));
264 pwrpriv->rpwm = pslv;
266 rtl8723a_set_rpwm(padapter, rpwm);
268 pwrpriv->tog += 0x80;
269 pwrpriv->cpwm = pslv;
274 u8 PS_RDY_CHECK(struct rtw_adapter * padapter)
276 unsigned long delta_time;
277 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
278 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
280 delta_time = jiffies - pwrpriv->DelayLPSLastTimeStamp;
282 if (delta_time < LPS_DELAY_TIME)
287 if ((check_fwstate(pmlmepriv, _FW_LINKED) == false) ||
288 (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true) ||
289 (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) ||
290 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
291 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true))
293 if (true == pwrpriv->bInSuspend)
295 if ((padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) && (padapter->securitypriv.binstallGrpkey == false))
297 DBG_8723A("Group handshake still in progress !!!\n");
300 if (!rtw_cfg80211_pwr_mgmt(padapter))
306 void rtw_set_ps_mode23a(struct rtw_adapter *padapter, u8 ps_mode, u8 smart_ps, u8 bcn_ant_mode)
308 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
309 #ifdef CONFIG_8723AU_P2P
310 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
311 #endif /* CONFIG_8723AU_P2P */
315 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
316 ("%s: PowerMode =%d Smart_PS =%d\n",
317 __func__, ps_mode, smart_ps));
319 if (ps_mode > PM_Card_Disable) {
320 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_, ("ps_mode:%d error\n", ps_mode));
324 if (pwrpriv->pwr_mode == ps_mode)
326 if (PS_MODE_ACTIVE == ps_mode) return;
328 if ((pwrpriv->smart_ps == smart_ps) &&
329 (pwrpriv->bcn_ant_mode == bcn_ant_mode))
335 if (ps_mode == PS_MODE_ACTIVE) {
336 #ifdef CONFIG_8723AU_P2P
337 if (pwdinfo->opp_ps == 0)
338 #endif /* CONFIG_8723AU_P2P */
340 DBG_8723A("rtw_set_ps_mode23a: Leave 802.11 power save\n");
342 pwrpriv->pwr_mode = ps_mode;
343 rtw_set_rpwm23a(padapter, PS_STATE_S4);
344 rtl8723a_set_FwPwrMode_cmd(padapter, ps_mode);
345 pwrpriv->bFwCurrentInPSMode = false;
348 if (PS_RDY_CHECK(padapter)
349 #ifdef CONFIG_8723AU_BT_COEXIST
350 || (BT_1Ant(padapter) == true)
353 DBG_8723A("%s: Enter 802.11 power save\n", __func__);
355 pwrpriv->bFwCurrentInPSMode = true;
356 pwrpriv->pwr_mode = ps_mode;
357 pwrpriv->smart_ps = smart_ps;
358 pwrpriv->bcn_ant_mode = bcn_ant_mode;
359 rtl8723a_set_FwPwrMode_cmd(padapter, ps_mode);
361 #ifdef CONFIG_8723AU_P2P
362 /* Set CTWindow after LPS */
363 if (pwdinfo->opp_ps == 1)
364 p2p_ps_wk_cmd23a(padapter, P2P_PS_ENABLE, 0);
365 #endif /* CONFIG_8723AU_P2P */
367 rtw_set_rpwm23a(padapter, PS_STATE_S2);
378 s32 LPS_RF_ON_check23a(struct rtw_adapter *padapter, u32 delay_ms)
380 unsigned long start_time, end_time;
384 start_time = jiffies;
385 end_time = start_time + msecs_to_jiffies(delay_ms);
389 rtw23a_hal_get_hwreg(padapter, HW_VAR_FWLPS_RF_ON, &bAwake);
393 if (true == padapter->bSurpriseRemoved)
396 DBG_8723A("%s: device surprise removed!!\n", __func__);
400 if (time_after(jiffies, end_time)) {
402 DBG_8723A("%s: Wait for FW LPS leave more than %u ms!!!\n", __func__, delay_ms);
412 /* Enter the leisure power save mode. */
413 void LPS_Enter23a(struct rtw_adapter *padapter)
415 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
417 if (!PS_RDY_CHECK(padapter))
420 if (pwrpriv->bLeisurePs) {
421 /* Idle for a while if we connect to AP a while ago. */
422 if (pwrpriv->LpsIdleCount >= 2) { /* 4 Sec */
423 if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) {
424 pwrpriv->bpower_saving = true;
425 DBG_8723A("%s smart_ps:%d\n", __func__, pwrpriv->smart_ps);
426 /* For Tenda W311R IOT issue */
427 rtw_set_ps_mode23a(padapter, pwrpriv->power_mgnt, pwrpriv->smart_ps, 0);
430 pwrpriv->LpsIdleCount++;
436 /* Leave the leisure power save mode. */
437 void LPS_Leave23a(struct rtw_adapter *padapter)
439 #define LPS_LEAVE_TIMEOUT_MS 100
441 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
443 if (pwrpriv->bLeisurePs) {
444 if (pwrpriv->pwr_mode != PS_MODE_ACTIVE) {
445 rtw_set_ps_mode23a(padapter, PS_MODE_ACTIVE, 0, 0);
447 if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
448 LPS_RF_ON_check23a(padapter, LPS_LEAVE_TIMEOUT_MS);
452 pwrpriv->bpower_saving = false;
455 /* Description: Leave all power save mode: LPS, FwLPS, IPS if needed. */
456 /* Move code to function by tynli. 2010.03.26. */
457 void LeaveAllPowerSaveMode23a(struct rtw_adapter *Adapter)
459 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
464 /* DBG_8723A("%s.....\n", __func__); */
465 if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
467 #ifdef CONFIG_8723AU_P2P
468 p2p_ps_wk_cmd23a(Adapter, P2P_PS_DISABLE, enqueue);
469 #endif /* CONFIG_8723AU_P2P */
471 rtw_lps_ctrl_wk_cmd23a(Adapter, LPS_CTRL_LEAVE, enqueue);
477 void rtw_init_pwrctrl_priv23a(struct rtw_adapter *padapter)
479 struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
481 sema_init(&pwrctrlpriv->lock, 1);
482 pwrctrlpriv->rf_pwrstate = rf_on;
483 pwrctrlpriv->ips_enter23a_cnts = 0;
484 pwrctrlpriv->ips_leave23a_cnts = 0;
485 pwrctrlpriv->bips_processing = false;
487 pwrctrlpriv->ips_mode = padapter->registrypriv.ips_mode;
488 pwrctrlpriv->ips_mode_req = padapter->registrypriv.ips_mode;
490 pwrctrlpriv->pwr_state_check_interval = RTW_PWR_STATE_CHK_INTERVAL;
491 pwrctrlpriv->pwr_state_check_cnts = 0;
492 pwrctrlpriv->bInternalAutoSuspend = false;
493 pwrctrlpriv->bInSuspend = false;
494 pwrctrlpriv->bkeepfwalive = false;
496 pwrctrlpriv->LpsIdleCount = 0;
497 pwrctrlpriv->power_mgnt = padapter->registrypriv.power_mgnt;/* PS_MODE_MIN; */
498 pwrctrlpriv->bLeisurePs = (PS_MODE_ACTIVE != pwrctrlpriv->power_mgnt)?true:false;
500 pwrctrlpriv->bFwCurrentInPSMode = false;
502 pwrctrlpriv->rpwm = 0;
503 pwrctrlpriv->cpwm = PS_STATE_S4;
505 pwrctrlpriv->pwr_mode = PS_MODE_ACTIVE;
506 pwrctrlpriv->smart_ps = padapter->registrypriv.smart_ps;
507 pwrctrlpriv->bcn_ant_mode = 0;
509 pwrctrlpriv->tog = 0x80;
511 pwrctrlpriv->btcoex_rfon = false;
513 setup_timer(&pwrctrlpriv->pwr_state_check_timer,
514 pwr_state_check_handler, (unsigned long)padapter);
519 void rtw_free_pwrctrl_priv(struct rtw_adapter *adapter)
523 u8 rtw_interface_ps_func23a(struct rtw_adapter *padapter, enum hal_intf_ps_func efunc_id, u8* val)
526 rtw_hal_intf_ps_func23a(padapter, efunc_id, val);
531 inline void rtw_set_ips_deny23a(struct rtw_adapter *padapter, u32 ms)
533 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
534 pwrpriv->ips_deny_time = jiffies + msecs_to_jiffies(ms);
538 * rtw_pwr_wakeup - Wake the NIC up from: 1)IPS. 2)USB autosuspend
539 * @adapter: pointer to _adapter structure
540 * @ips_deffer_ms: the ms wiil prevent from falling into IPS after wakeup
541 * Return _SUCCESS or _FAIL
544 int _rtw_pwr_wakeup23a(struct rtw_adapter *padapter, u32 ips_deffer_ms, const char *caller)
546 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
547 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
549 unsigned long start = jiffies;
550 unsigned long new_deny_time;
552 new_deny_time = jiffies + msecs_to_jiffies(ips_deffer_ms);
554 if (time_before(pwrpriv->ips_deny_time, new_deny_time))
555 pwrpriv->ips_deny_time = new_deny_time;
557 if (pwrpriv->ps_processing) {
558 DBG_8723A("%s wait ps_processing...\n", __func__);
559 while (pwrpriv->ps_processing &&
560 jiffies_to_msecs(jiffies - start) <= 3000)
562 if (pwrpriv->ps_processing)
563 DBG_8723A("%s wait ps_processing timeout\n", __func__);
565 DBG_8723A("%s wait ps_processing done\n", __func__);
568 if (rtw_hal_sreset_inprogress(padapter)) {
569 DBG_8723A("%s wait sreset_inprogress...\n", __func__);
570 while (rtw_hal_sreset_inprogress(padapter) &&
571 jiffies_to_msecs(jiffies - start) <= 4000)
573 if (rtw_hal_sreset_inprogress(padapter))
574 DBG_8723A("%s wait sreset_inprogress timeout\n", __func__);
576 DBG_8723A("%s wait sreset_inprogress done\n", __func__);
579 if (pwrpriv->bInternalAutoSuspend == false && pwrpriv->bInSuspend) {
580 DBG_8723A("%s wait bInSuspend...\n", __func__);
581 while (pwrpriv->bInSuspend &&
582 (jiffies_to_msecs(jiffies - start) <= 3000)) {
585 if (pwrpriv->bInSuspend)
586 DBG_8723A("%s wait bInSuspend timeout\n", __func__);
588 DBG_8723A("%s wait bInSuspend done\n", __func__);
591 /* System suspend is not allowed to wakeup */
592 if ((pwrpriv->bInternalAutoSuspend == false) && (true == pwrpriv->bInSuspend)) {
598 if ((pwrpriv->bInternalAutoSuspend == true) && (padapter->net_closed == true)) {
603 /* I think this should be check in IPS, LPS, autosuspend functions... */
604 if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
610 if (rf_off == pwrpriv->rf_pwrstate) {
611 DBG_8723A("%s call ips_leave23a....\n", __func__);
612 if (_FAIL == ips_leave23a(padapter)) {
613 DBG_8723A("======> ips_leave23a fail.............\n");
619 /* TODO: the following checking need to be merged... */
620 if (padapter->bDriverStopped || !padapter->bup ||
621 !padapter->hw_init_completed) {
622 DBG_8723A("%s: bDriverStopped =%d, bup =%d, hw_init_completed "
623 "=%u\n", caller, padapter->bDriverStopped,
624 padapter->bup, padapter->hw_init_completed);
630 new_deny_time = jiffies + msecs_to_jiffies(ips_deffer_ms);
631 if (time_before(pwrpriv->ips_deny_time, new_deny_time))
632 pwrpriv->ips_deny_time = new_deny_time;
636 int rtw_pm_set_lps23a(struct rtw_adapter *padapter, u8 mode)
639 struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
641 if (mode < PS_MODE_NUM)
643 if (pwrctrlpriv->power_mgnt != mode)
645 if (PS_MODE_ACTIVE == mode)
647 LeaveAllPowerSaveMode23a(padapter);
651 pwrctrlpriv->LpsIdleCount = 2;
653 pwrctrlpriv->power_mgnt = mode;
654 pwrctrlpriv->bLeisurePs = (PS_MODE_ACTIVE != pwrctrlpriv->power_mgnt)?true:false;
665 int rtw_pm_set_ips23a(struct rtw_adapter *padapter, u8 mode)
667 struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
669 if (mode == IPS_NORMAL || mode == IPS_LEVEL_2) {
670 rtw_ips_mode_req(pwrctrlpriv, mode);
671 DBG_8723A("%s %s\n", __func__, mode == IPS_NORMAL?"IPS_NORMAL":"IPS_LEVEL_2");
674 else if (mode == IPS_NONE) {
675 rtw_ips_mode_req(pwrctrlpriv, mode);
676 DBG_8723A("%s %s\n", __func__, "IPS_NONE");
677 if ((padapter->bSurpriseRemoved == 0)&&_FAIL == rtw_pwr_wakeup(padapter))