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>
20 #include <rtl8723a_cmd.h>
22 #ifdef CONFIG_8723AU_BT_COEXIST
23 #include <rtl8723a_hal.h>
26 void ips_enter23a(struct rtw_adapter
* padapter
)
28 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
32 pwrpriv
->bips_processing
= true;
34 /* syn ips_mode with request */
35 pwrpriv
->ips_mode
= pwrpriv
->ips_mode_req
;
37 pwrpriv
->ips_enter23a_cnts
++;
38 DBG_8723A("==>ips_enter23a cnts:%d\n", pwrpriv
->ips_enter23a_cnts
);
39 #ifdef CONFIG_8723AU_BT_COEXIST
40 BTDM_TurnOffBtCoexistBeforeEnterIPS(padapter
);
42 if (rf_off
== pwrpriv
->change_rfpwrstate
)
44 pwrpriv
->bpower_saving
= true;
45 DBG_8723A_LEVEL(_drv_always_
, "nolinked power save enter\n");
47 if (pwrpriv
->ips_mode
== IPS_LEVEL_2
)
48 pwrpriv
->bkeepfwalive
= true;
50 rtw_ips_pwr_down23a(padapter
);
51 pwrpriv
->rf_pwrstate
= rf_off
;
53 pwrpriv
->bips_processing
= false;
58 int ips_leave23a(struct rtw_adapter
* padapter
)
60 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
61 struct security_priv
*psecuritypriv
= &padapter
->securitypriv
;
62 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
63 int result
= _SUCCESS
;
68 if ((pwrpriv
->rf_pwrstate
== rf_off
) &&!pwrpriv
->bips_processing
)
70 pwrpriv
->bips_processing
= true;
71 pwrpriv
->change_rfpwrstate
= rf_on
;
72 pwrpriv
->ips_leave23a_cnts
++;
73 DBG_8723A("==>ips_leave23a cnts:%d\n", pwrpriv
->ips_leave23a_cnts
);
75 if ((result
= rtw_ips_pwr_up23a(padapter
)) == _SUCCESS
) {
76 pwrpriv
->rf_pwrstate
= rf_on
;
78 DBG_8723A_LEVEL(_drv_always_
, "nolinked power save leave\n");
80 if ((_WEP40_
== psecuritypriv
->dot11PrivacyAlgrthm
) ||(_WEP104_
== psecuritypriv
->dot11PrivacyAlgrthm
))
82 DBG_8723A("==>%s, channel(%d), processing(%x)\n", __func__
, padapter
->mlmeextpriv
.cur_channel
, pwrpriv
->bips_processing
);
83 set_channel_bwmode23a(padapter
, padapter
->mlmeextpriv
.cur_channel
, HAL_PRIME_CHNL_OFFSET_DONT_CARE
, HT_CHANNEL_WIDTH_20
);
84 for (keyid
= 0;keyid
<4;keyid
++) {
85 if (pmlmepriv
->key_mask
& CHKBIT(keyid
)) {
86 if (keyid
== psecuritypriv
->dot11PrivacyKeyIndex
)
87 result
= rtw_set_key23a(padapter
, psecuritypriv
, keyid
, 1);
89 result
= rtw_set_key23a(padapter
, psecuritypriv
, keyid
, 0);
94 DBG_8723A("==> ips_leave23a.....LED(0x%08x)...\n", rtw_read32(padapter
, 0x4c));
95 pwrpriv
->bips_processing
= false;
97 pwrpriv
->bkeepfwalive
= false;
98 pwrpriv
->bpower_saving
= false;
107 static bool rtw_pwr_unassociated_idle(struct rtw_adapter
*adapter
)
109 struct rtw_adapter
*buddy
= adapter
->pbuddy_adapter
;
110 struct mlme_priv
*pmlmepriv
= &adapter
->mlmepriv
;
111 struct xmit_priv
*pxmit_priv
= &adapter
->xmitpriv
;
112 struct wifidirect_info
*pwdinfo
= &adapter
->wdinfo
;
116 if (time_after_eq(adapter
->pwrctrlpriv
.ips_deny_time
, jiffies
))
119 if (check_fwstate(pmlmepriv
, WIFI_ASOC_STATE
|WIFI_SITE_MONITOR
)
120 || check_fwstate(pmlmepriv
, WIFI_UNDER_LINKING
|WIFI_UNDER_WPS
)
121 || check_fwstate(pmlmepriv
, WIFI_AP_STATE
)
122 || check_fwstate(pmlmepriv
, WIFI_ADHOC_MASTER_STATE
|WIFI_ADHOC_STATE
)
123 || !rtw_p2p_chk_state(pwdinfo
, P2P_STATE_NONE
)
128 /* consider buddy, if exist */
130 struct mlme_priv
*b_pmlmepriv
= &buddy
->mlmepriv
;
131 struct wifidirect_info
*b_pwdinfo
= &buddy
->wdinfo
;
133 if (check_fwstate(b_pmlmepriv
, WIFI_ASOC_STATE
|WIFI_SITE_MONITOR
)
134 || check_fwstate(b_pmlmepriv
, WIFI_UNDER_LINKING
|WIFI_UNDER_WPS
)
135 || check_fwstate(b_pmlmepriv
, WIFI_AP_STATE
)
136 || check_fwstate(b_pmlmepriv
, WIFI_ADHOC_MASTER_STATE
|WIFI_ADHOC_STATE
)
137 || !rtw_p2p_chk_state(b_pwdinfo
, P2P_STATE_NONE
)
143 if (pxmit_priv
->free_xmitbuf_cnt
!= NR_XMITBUFF
||
144 pxmit_priv
->free_xmit_extbuf_cnt
!= NR_XMIT_EXTBUFF
) {
145 DBG_8723A_LEVEL(_drv_always_
, "There are some pkts to transmit\n");
146 DBG_8723A_LEVEL(_drv_info_
, "free_xmitbuf_cnt: %d, free_xmit_extbuf_cnt: %d\n",
147 pxmit_priv
->free_xmitbuf_cnt
, pxmit_priv
->free_xmit_extbuf_cnt
);
157 void rtw_ps_processor23a(struct rtw_adapter
*padapter
)
159 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
160 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
161 enum rt_rf_power_state rfpwrstate
;
163 pwrpriv
->ps_processing
= true;
165 if (pwrpriv
->bips_processing
== true)
168 if (padapter
->pwrctrlpriv
.bHWPwrPindetect
) {
169 rfpwrstate
= RfOnOffDetect23a(padapter
);
170 DBG_8723A("@@@@- #2 %s ==> rfstate:%s\n", __func__
, (rfpwrstate
== rf_on
)?"rf_on":"rf_off");
172 if (rfpwrstate
!= pwrpriv
->rf_pwrstate
) {
173 if (rfpwrstate
== rf_off
) {
174 pwrpriv
->change_rfpwrstate
= rf_off
;
175 pwrpriv
->brfoffbyhw
= true;
176 padapter
->bCardDisableWOHSM
= true;
177 rtw_hw_suspend23a(padapter
);
179 pwrpriv
->change_rfpwrstate
= rf_on
;
180 rtw_hw_resume23a(padapter
);
182 DBG_8723A("current rf_pwrstate(%s)\n", (pwrpriv
->rf_pwrstate
== rf_off
)?"rf_off":"rf_on");
184 pwrpriv
->pwr_state_check_cnts
++;
187 if (pwrpriv
->ips_mode_req
== IPS_NONE
)
190 if (rtw_pwr_unassociated_idle(padapter
) == false)
193 if ((pwrpriv
->rf_pwrstate
== rf_on
) && ((pwrpriv
->pwr_state_check_cnts
%4) == 0))
195 DBG_8723A("==>%s .fw_state(%x)\n", __func__
, get_fwstate(pmlmepriv
));
196 pwrpriv
->change_rfpwrstate
= rf_off
;
197 ips_enter23a(padapter
);
200 rtw_set_pwr_state_check_timer(&padapter
->pwrctrlpriv
);
201 pwrpriv
->ps_processing
= false;
205 static void pwr_state_check_handler(unsigned long data
)
207 struct rtw_adapter
*padapter
= (struct rtw_adapter
*)data
;
208 rtw_ps_cmd23a(padapter
);
215 * pslv power state level, only could be PS_STATE_S0 ~ PS_STATE_S4
218 void rtw_set_rpwm23a(struct rtw_adapter
*padapter
, u8 pslv
)
221 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
225 pslv
= PS_STATE(pslv
);
227 if (true == pwrpriv
->btcoex_rfon
)
229 if (pslv
< PS_STATE_S4
)
233 if (pwrpriv
->rpwm
== pslv
) {
234 RT_TRACE(_module_rtl871x_pwrctrl_c_
, _drv_err_
,
235 ("%s: Already set rpwm[0x%02X], new = 0x%02X!\n", __func__
, pwrpriv
->rpwm
, pslv
));
239 if ((padapter
->bSurpriseRemoved
== true) ||
240 (padapter
->hw_init_completed
== false)) {
241 RT_TRACE(_module_rtl871x_pwrctrl_c_
, _drv_err_
,
242 ("%s: SurpriseRemoved(%d) hw_init_completed(%d)\n",
243 __func__
, padapter
->bSurpriseRemoved
, padapter
->hw_init_completed
));
245 pwrpriv
->cpwm
= PS_STATE_S4
;
250 if (padapter
->bDriverStopped
== true) {
251 RT_TRACE(_module_rtl871x_pwrctrl_c_
, _drv_err_
,
252 ("%s: change power state(0x%02X) when DriverStopped\n", __func__
, pslv
));
254 if (pslv
< PS_STATE_S2
) {
255 RT_TRACE(_module_rtl871x_pwrctrl_c_
, _drv_err_
,
256 ("%s: Reject to enter PS_STATE(0x%02X) lower than S2 when DriverStopped!!\n", __func__
, pslv
));
261 rpwm
= pslv
| pwrpriv
->tog
;
262 RT_TRACE(_module_rtl871x_pwrctrl_c_
, _drv_notice_
,
263 ("rtw_set_rpwm23a: rpwm = 0x%02x cpwm = 0x%02x\n", rpwm
, pwrpriv
->cpwm
));
265 pwrpriv
->rpwm
= pslv
;
267 rtl8723a_set_rpwm(padapter
, rpwm
);
269 pwrpriv
->tog
+= 0x80;
270 pwrpriv
->cpwm
= pslv
;
275 u8
PS_RDY_CHECK(struct rtw_adapter
* padapter
)
277 unsigned long delta_time
;
278 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
279 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
281 delta_time
= jiffies
- pwrpriv
->DelayLPSLastTimeStamp
;
283 if (delta_time
< LPS_DELAY_TIME
)
288 if ((check_fwstate(pmlmepriv
, _FW_LINKED
) == false) ||
289 (check_fwstate(pmlmepriv
, _FW_UNDER_SURVEY
) == true) ||
290 (check_fwstate(pmlmepriv
, WIFI_AP_STATE
) == true) ||
291 (check_fwstate(pmlmepriv
, WIFI_ADHOC_MASTER_STATE
) == true) ||
292 (check_fwstate(pmlmepriv
, WIFI_ADHOC_STATE
) == true))
294 if (true == pwrpriv
->bInSuspend
)
296 if ((padapter
->securitypriv
.dot11AuthAlgrthm
== dot11AuthAlgrthm_8021X
) && (padapter
->securitypriv
.binstallGrpkey
== false))
298 DBG_8723A("Group handshake still in progress !!!\n");
301 if (!rtw_cfg80211_pwr_mgmt(padapter
))
307 void rtw_set_ps_mode23a(struct rtw_adapter
*padapter
, u8 ps_mode
, u8 smart_ps
, u8 bcn_ant_mode
)
309 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
310 #ifdef CONFIG_8723AU_P2P
311 struct wifidirect_info
*pwdinfo
= &padapter
->wdinfo
;
312 #endif /* CONFIG_8723AU_P2P */
316 RT_TRACE(_module_rtl871x_pwrctrl_c_
, _drv_notice_
,
317 ("%s: PowerMode =%d Smart_PS =%d\n",
318 __func__
, ps_mode
, smart_ps
));
320 if (ps_mode
> PM_Card_Disable
) {
321 RT_TRACE(_module_rtl871x_pwrctrl_c_
, _drv_err_
, ("ps_mode:%d error\n", ps_mode
));
325 if (pwrpriv
->pwr_mode
== ps_mode
)
327 if (PS_MODE_ACTIVE
== ps_mode
) return;
329 if ((pwrpriv
->smart_ps
== smart_ps
) &&
330 (pwrpriv
->bcn_ant_mode
== bcn_ant_mode
))
336 if (ps_mode
== PS_MODE_ACTIVE
) {
337 #ifdef CONFIG_8723AU_P2P
338 if (pwdinfo
->opp_ps
== 0)
339 #endif /* CONFIG_8723AU_P2P */
341 DBG_8723A("rtw_set_ps_mode23a: Leave 802.11 power save\n");
343 pwrpriv
->pwr_mode
= ps_mode
;
344 rtw_set_rpwm23a(padapter
, PS_STATE_S4
);
345 rtl8723a_set_FwPwrMode_cmd(padapter
, ps_mode
);
346 pwrpriv
->bFwCurrentInPSMode
= false;
349 if (PS_RDY_CHECK(padapter
)
350 #ifdef CONFIG_8723AU_BT_COEXIST
351 || (BT_1Ant(padapter
) == true)
354 DBG_8723A("%s: Enter 802.11 power save\n", __func__
);
356 pwrpriv
->bFwCurrentInPSMode
= true;
357 pwrpriv
->pwr_mode
= ps_mode
;
358 pwrpriv
->smart_ps
= smart_ps
;
359 pwrpriv
->bcn_ant_mode
= bcn_ant_mode
;
360 rtl8723a_set_FwPwrMode_cmd(padapter
, ps_mode
);
362 #ifdef CONFIG_8723AU_P2P
363 /* Set CTWindow after LPS */
364 if (pwdinfo
->opp_ps
== 1)
365 p2p_ps_wk_cmd23a(padapter
, P2P_PS_ENABLE
, 0);
366 #endif /* CONFIG_8723AU_P2P */
368 rtw_set_rpwm23a(padapter
, PS_STATE_S2
);
379 s32
LPS_RF_ON_check23a(struct rtw_adapter
*padapter
, u32 delay_ms
)
381 unsigned long start_time
, end_time
;
385 start_time
= jiffies
;
386 end_time
= start_time
+ msecs_to_jiffies(delay_ms
);
390 bAwake
= rtl8723a_get_fwlps_rf_on(padapter
);
394 if (padapter
->bSurpriseRemoved
== true) {
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
))