drivers/staging/rtl8723bs/core/rtw_pwrctrl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   5  *
   6  ******************************************************************************/
   7 #define _RTW_PWRCTRL_C_
   8
   9 #include <drv_types.h>
  10 #include <rtw_debug.h>
  11 #include <hal_data.h>
  12 #include <linux/jiffies.h>
  13
  14
  15 void _ips_enter(struct adapter *padapter)
  16 {
  17         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
  18
  19         pwrpriv->bips_processing = true;
  20
  21         /*  syn ips_mode with request */
  22         pwrpriv->ips_mode = pwrpriv->ips_mode_req;
  23
  24         pwrpriv->ips_enter_cnts++;
  25         DBG_871X("==>ips_enter cnts:%d\n", pwrpriv->ips_enter_cnts);
  26
  27         if (rf_off == pwrpriv->change_rfpwrstate) {
  28                 pwrpriv->bpower_saving = true;
  29                 DBG_871X("nolinked power save enter\n");
  30
  31                 if (pwrpriv->ips_mode == IPS_LEVEL_2)
  32                         pwrpriv->bkeepfwalive = true;
  33
  34                 rtw_ips_pwr_down(padapter);
  35                 pwrpriv->rf_pwrstate = rf_off;
  36         }
  37         pwrpriv->bips_processing = false;
  38
  39 }
  40
  41 void ips_enter(struct adapter *padapter)
  42 {
  43         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
  44
  45
  46         rtw_btcoex_IpsNotify(padapter, pwrpriv->ips_mode_req);
  47
  48         down(&pwrpriv->lock);
  49         _ips_enter(padapter);
  50         up(&pwrpriv->lock);
  51 }
  52
  53 int _ips_leave(struct adapter *padapter)
  54 {
  55         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
  56         int result = _SUCCESS;
  57
  58         if ((pwrpriv->rf_pwrstate == rf_off) && (!pwrpriv->bips_processing)) {
  59                 pwrpriv->bips_processing = true;
  60                 pwrpriv->change_rfpwrstate = rf_on;
  61                 pwrpriv->ips_leave_cnts++;
  62                 DBG_871X("==>ips_leave cnts:%d\n", pwrpriv->ips_leave_cnts);
  63
  64                 result = rtw_ips_pwr_up(padapter);
  65                 if (result == _SUCCESS) {
  66                         pwrpriv->rf_pwrstate = rf_on;
  67                 }
  68                 DBG_871X("nolinked power save leave\n");
  69
  70                 DBG_871X("==> ips_leave.....LED(0x%08x)...\n", rtw_read32(padapter, 0x4c));
  71                 pwrpriv->bips_processing = false;
  72
  73                 pwrpriv->bkeepfwalive = false;
  74                 pwrpriv->bpower_saving = false;
  75         }
  76
  77         return result;
  78 }
  79
  80 int ips_leave(struct adapter *padapter)
  81 {
  82         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
  83         int ret;
  84
  85         if (!is_primary_adapter(padapter))
  86                 return _SUCCESS;
  87
  88         down(&pwrpriv->lock);
  89         ret = _ips_leave(padapter);
  90         up(&pwrpriv->lock);
  91
  92         if (_SUCCESS == ret)
  93                 rtw_btcoex_IpsNotify(padapter, IPS_NONE);
  94
  95         return ret;
  96 }
  97
  98 static bool rtw_pwr_unassociated_idle(struct adapter *adapter)
  99 {
 100         struct adapter *buddy = adapter->pbuddy_adapter;
 101         struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
 102         struct xmit_priv *pxmit_priv = &adapter->xmitpriv;
 103
 104         bool ret = false;
 105
 106         if (adapter_to_pwrctl(adapter)->bpower_saving == true) {
 107                 /* DBG_871X("%s: already in LPS or IPS mode\n", __func__); */
 108                 goto exit;
 109         }
 110
 111         if (time_before(jiffies, adapter_to_pwrctl(adapter)->ips_deny_time)) {
 112                 /* DBG_871X("%s ips_deny_time\n", __func__); */
 113                 goto exit;
 114         }
 115
 116         if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)
 117                 || check_fwstate(pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
 118                 || check_fwstate(pmlmepriv, WIFI_AP_STATE)
 119                 || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
 120         )
 121                 goto exit;
 122
 123         /* consider buddy, if exist */
 124         if (buddy) {
 125                 struct mlme_priv *b_pmlmepriv = &(buddy->mlmepriv);
 126
 127                 if (check_fwstate(b_pmlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)
 128                         || check_fwstate(b_pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
 129                         || check_fwstate(b_pmlmepriv, WIFI_AP_STATE)
 130                         || check_fwstate(b_pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
 131                 )
 132                         goto exit;
 133         }
 134
 135         if (pxmit_priv->free_xmitbuf_cnt != NR_XMITBUFF ||
 136                 pxmit_priv->free_xmit_extbuf_cnt != NR_XMIT_EXTBUFF) {
 137                 DBG_871X_LEVEL(_drv_always_, "There are some pkts to transmit\n");
 138                 DBG_871X_LEVEL(_drv_always_, "free_xmitbuf_cnt: %d, free_xmit_extbuf_cnt: %d\n",
 139                         pxmit_priv->free_xmitbuf_cnt, pxmit_priv->free_xmit_extbuf_cnt);
 140                 goto exit;
 141         }
 142
 143         ret = true;
 144
 145 exit:
 146         return ret;
 147 }
 148
 149
 150 /*
 151  * ATTENTION:
 152  *rtw_ps_processor() doesn't handle LPS.
 153  */
 154 void rtw_ps_processor(struct adapter *padapter)
 155 {
 156         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 157         struct dvobj_priv *psdpriv = padapter->dvobj;
 158         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
 159         u32 ps_deny = 0;
 160
 161         down(&adapter_to_pwrctl(padapter)->lock);
 162         ps_deny = rtw_ps_deny_get(padapter);
 163         up(&adapter_to_pwrctl(padapter)->lock);
 164         if (ps_deny != 0) {
 165                 DBG_871X(FUNC_ADPT_FMT ": ps_deny = 0x%08X, skip power save!\n",
 166                         FUNC_ADPT_ARG(padapter), ps_deny);
 167                 goto exit;
 168         }
 169
 170         if (pwrpriv->bInSuspend == true) {/* system suspend or autosuspend */
 171                 pdbgpriv->dbg_ps_insuspend_cnt++;
 172                 DBG_871X("%s, pwrpriv->bInSuspend == true ignore this process\n", __func__);
 173                 return;
 174         }
 175
 176         pwrpriv->ps_processing = true;
 177
 178         if (pwrpriv->ips_mode_req == IPS_NONE)
 179                 goto exit;
 180
 181         if (rtw_pwr_unassociated_idle(padapter) == false)
 182                 goto exit;
 183
 184         if ((pwrpriv->rf_pwrstate == rf_on) && ((pwrpriv->pwr_state_check_cnts%4) == 0)) {
 185                 DBG_871X("==>%s\n", __func__);
 186                 pwrpriv->change_rfpwrstate = rf_off;
 187                 {
 188                         ips_enter(padapter);
 189                 }
 190         }
 191 exit:
 192         pwrpriv->ps_processing = false;
 193         return;
 194 }
 195
 196 static void pwr_state_check_handler(struct timer_list *t)
 197 {
 198         struct pwrctrl_priv *pwrctrlpriv =
 199                 from_timer(pwrctrlpriv, t, pwr_state_check_timer);
 200         struct adapter *padapter = pwrctrlpriv->adapter;
 201
 202         rtw_ps_cmd(padapter);
 203 }
 204
 205 void traffic_check_for_leave_lps(struct adapter *padapter, u8 tx, u32 tx_packets)
 206 {
 207         static unsigned long start_time;
 208         static u32 xmit_cnt;
 209         u8 bLeaveLPS = false;
 210         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 211
 212
 213
 214         if (tx) { /* from tx */
 215                 xmit_cnt += tx_packets;
 216
 217                 if (start_time == 0)
 218                         start_time = jiffies;
 219
 220                 if (jiffies_to_msecs(jiffies - start_time) > 2000) { /*  2 sec == watch dog timer */
 221                         if (xmit_cnt > 8) {
 222                                 if ((adapter_to_pwrctl(padapter)->bLeisurePs)
 223                                         && (adapter_to_pwrctl(padapter)->pwr_mode != PS_MODE_ACTIVE)
 224                                         && (rtw_btcoex_IsBtControlLps(padapter) == false)
 225                                         ) {
 226                                         DBG_871X("leave lps via Tx = %d\n", xmit_cnt);
 227                                         bLeaveLPS = true;
 228                                 }
 229                         }
 230
 231                         start_time = jiffies;
 232                         xmit_cnt = 0;
 233                 }
 234
 235         } else { /*  from rx path */
 236                 if (pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 4/*2*/) {
 237                         if ((adapter_to_pwrctl(padapter)->bLeisurePs)
 238                                 && (adapter_to_pwrctl(padapter)->pwr_mode != PS_MODE_ACTIVE)
 239                                 && (rtw_btcoex_IsBtControlLps(padapter) == false)
 240                                 ) {
 241                                 DBG_871X("leave lps via Rx = %d\n", pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod);
 242                                 bLeaveLPS = true;
 243                         }
 244                 }
 245         }
 246
 247         if (bLeaveLPS)
 248                 /* DBG_871X("leave lps via %s, Tx = %d, Rx = %d\n", tx?"Tx":"Rx", pmlmepriv->LinkDetectInfo.NumTxOkInPeriod, pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod); */
 249                 /* rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1); */
 250                 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, tx?0:1);
 251 }
 252
 253 /*
 254  * Description:
 255  *This function MUST be called under power lock protect
 256  *
 257  * Parameters
 258  *padapter
 259  *pslv                  power state level, only could be PS_STATE_S0 ~ PS_STATE_S4
 260  *
 261  */
 262 void rtw_set_rpwm(struct adapter *padapter, u8 pslv)
 263 {
 264         u8 rpwm;
 265         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 266         u8 cpwm_orig;
 267
 268         pslv = PS_STATE(pslv);
 269
 270         if (pwrpriv->brpwmtimeout == true) {
 271                 DBG_871X("%s: RPWM timeout, force to set RPWM(0x%02X) again!\n", __func__, pslv);
 272         } else{
 273                 if ((pwrpriv->rpwm == pslv)
 274                         || ((pwrpriv->rpwm >= PS_STATE_S2) && (pslv >= PS_STATE_S2))) {
 275                         RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
 276                                 ("%s: Already set rpwm[0x%02X], new = 0x%02X!\n", __func__, pwrpriv->rpwm, pslv));
 277                         return;
 278                 }
 279         }
 280
 281         if ((padapter->bSurpriseRemoved == true) ||
 282                 (padapter->hw_init_completed == false)) {
 283                 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
 284                                  ("%s: SurpriseRemoved(%d) hw_init_completed(%d)\n",
 285                                   __func__, padapter->bSurpriseRemoved, padapter->hw_init_completed));
 286
 287                 pwrpriv->cpwm = PS_STATE_S4;
 288
 289                 return;
 290         }
 291
 292         if (padapter->bDriverStopped == true) {
 293                 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
 294                                  ("%s: change power state(0x%02X) when DriverStopped\n", __func__, pslv));
 295
 296                 if (pslv < PS_STATE_S2) {
 297                         RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
 298                                          ("%s: Reject to enter PS_STATE(0x%02X) lower than S2 when DriverStopped!!\n", __func__, pslv));
 299                         return;
 300                 }
 301         }
 302
 303         rpwm = pslv | pwrpriv->tog;
 304         /*  only when from PS_STATE S0/S1 to S2 and higher needs ACK */
 305         if ((pwrpriv->cpwm < PS_STATE_S2) && (pslv >= PS_STATE_S2))
 306                 rpwm |= PS_ACK;
 307         RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
 308                          ("rtw_set_rpwm: rpwm = 0x%02x cpwm = 0x%02x\n", rpwm, pwrpriv->cpwm));
 309
 310         pwrpriv->rpwm = pslv;
 311
 312         cpwm_orig = 0;
 313         if (rpwm & PS_ACK)
 314                 rtw_hal_get_hwreg(padapter, HW_VAR_CPWM, &cpwm_orig);
 315
 316         if (rpwm & PS_ACK)
 317                 _set_timer(&pwrpriv->pwr_rpwm_timer, LPS_RPWM_WAIT_MS);
 318         rtw_hal_set_hwreg(padapter, HW_VAR_SET_RPWM, (u8 *)(&rpwm));
 319
 320         pwrpriv->tog += 0x80;
 321
 322         /*  No LPS 32K, No Ack */
 323         if (rpwm & PS_ACK) {
 324                 unsigned long start_time;
 325                 u8 cpwm_now;
 326                 u8 poll_cnt = 0;
 327
 328                 start_time = jiffies;
 329
 330                 /*  polling cpwm */
 331                 do {
 332                         mdelay(1);
 333                         poll_cnt++;
 334                         rtw_hal_get_hwreg(padapter, HW_VAR_CPWM, &cpwm_now);
 335                         if ((cpwm_orig ^ cpwm_now) & 0x80) {
 336                                 pwrpriv->cpwm = PS_STATE_S4;
 337                                 pwrpriv->cpwm_tog = cpwm_now & PS_TOGGLE;
 338                                 break;
 339                         }
 340
 341                         if (jiffies_to_msecs(jiffies - start_time) > LPS_RPWM_WAIT_MS) {
 342                                 DBG_871X("%s: polling cpwm timeout! poll_cnt =%d, cpwm_orig =%02x, cpwm_now =%02x\n", __func__, poll_cnt, cpwm_orig, cpwm_now);
 343                                 _set_timer(&pwrpriv->pwr_rpwm_timer, 1);
 344                                 break;
 345                         }
 346                 } while (1);
 347         } else
 348                 pwrpriv->cpwm = pslv;
 349 }
 350
 351 static u8 PS_RDY_CHECK(struct adapter *padapter)
 352 {
 353         unsigned long curr_time, delta_time;
 354         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 355         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 356
 357 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
 358         if (true == pwrpriv->bInSuspend && pwrpriv->wowlan_mode)
 359                 return true;
 360         else if (true == pwrpriv->bInSuspend && pwrpriv->wowlan_ap_mode)
 361                 return true;
 362         else if (true == pwrpriv->bInSuspend)
 363                 return false;
 364 #else
 365         if (true == pwrpriv->bInSuspend)
 366                 return false;
 367 #endif
 368
 369         curr_time = jiffies;
 370
 371         delta_time = curr_time - pwrpriv->DelayLPSLastTimeStamp;
 372
 373         if (delta_time < LPS_DELAY_TIME)
 374                 return false;
 375
 376         if (check_fwstate(pmlmepriv, WIFI_SITE_MONITOR)
 377                 || check_fwstate(pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
 378                 || check_fwstate(pmlmepriv, WIFI_AP_STATE)
 379                 || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
 380                 || rtw_is_scan_deny(padapter)
 381         )
 382                 return false;
 383
 384         if ((padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) && (padapter->securitypriv.binstallGrpkey == false)) {
 385                 DBG_871X("Group handshake still in progress !!!\n");
 386                 return false;
 387         }
 388
 389         if (!rtw_cfg80211_pwr_mgmt(padapter))
 390                 return false;
 391
 392         return true;
 393 }
 394
 395 void rtw_set_ps_mode(struct adapter *padapter, u8 ps_mode, u8 smart_ps, u8 bcn_ant_mode, const char *msg)
 396 {
 397         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 398 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
 399         struct debug_priv *pdbgpriv = &padapter->dvobj->drv_dbg;
 400 #endif
 401
 402         RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
 403                          ("%s: PowerMode =%d Smart_PS =%d\n",
 404                           __func__, ps_mode, smart_ps));
 405
 406         if (ps_mode > PM_Card_Disable) {
 407                 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_, ("ps_mode:%d error\n", ps_mode));
 408                 return;
 409         }
 410
 411         if (pwrpriv->pwr_mode == ps_mode)
 412                 if (PS_MODE_ACTIVE == ps_mode)
 413                         return;
 414
 415
 416         down(&pwrpriv->lock);
 417
 418         /* if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) */
 419         if (ps_mode == PS_MODE_ACTIVE) {
 420                 if (1
 421                         && (((rtw_btcoex_IsBtControlLps(padapter) == false)
 422                                         )
 423                                 || ((rtw_btcoex_IsBtControlLps(padapter) == true)
 424                                         && (rtw_btcoex_IsLpsOn(padapter) == false))
 425                                 )
 426                         ) {
 427                         DBG_871X(FUNC_ADPT_FMT" Leave 802.11 power save - %s\n",
 428                                 FUNC_ADPT_ARG(padapter), msg);
 429
 430                         pwrpriv->pwr_mode = ps_mode;
 431                         rtw_set_rpwm(padapter, PS_STATE_S4);
 432
 433 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
 434                         if (pwrpriv->wowlan_mode == true ||
 435                                         pwrpriv->wowlan_ap_mode == true) {
 436                                 unsigned long start_time;
 437                                 u32 delay_ms;
 438                                 u8 val8;
 439                                 delay_ms = 20;
 440                                 start_time = jiffies;
 441                                 do {
 442                                         rtw_hal_get_hwreg(padapter, HW_VAR_SYS_CLKR, &val8);
 443                                         if (!(val8 & BIT(4))) { /* 0x08 bit4 = 1 --> in 32k, bit4 = 0 --> leave 32k */
 444                                                 pwrpriv->cpwm = PS_STATE_S4;
 445                                                 break;
 446                                         }
 447                                         if (jiffies_to_msecs(jiffies - start_time) > delay_ms) {
 448                                                 DBG_871X("%s: Wait for FW 32K leave more than %u ms!!!\n",
 449                                                                 __func__, delay_ms);
 450                                                 pdbgpriv->dbg_wow_leave_ps_fail_cnt++;
 451                                                 break;
 452                                         }
 453                                         msleep(1);
 454                                 } while (1);
 455                         }
 456 #endif
 457                         rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode));
 458                         pwrpriv->bFwCurrentInPSMode = false;
 459
 460                         rtw_btcoex_LpsNotify(padapter, ps_mode);
 461                 }
 462         } else{
 463                 if ((PS_RDY_CHECK(padapter) && check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE))
 464                         || ((rtw_btcoex_IsBtControlLps(padapter) == true)
 465                                 && (rtw_btcoex_IsLpsOn(padapter) == true))
 466                         ) {
 467                         u8 pslv;
 468
 469                         DBG_871X(FUNC_ADPT_FMT" Enter 802.11 power save - %s\n",
 470                                 FUNC_ADPT_ARG(padapter), msg);
 471
 472                         rtw_btcoex_LpsNotify(padapter, ps_mode);
 473
 474                         pwrpriv->bFwCurrentInPSMode = true;
 475                         pwrpriv->pwr_mode = ps_mode;
 476                         pwrpriv->smart_ps = smart_ps;
 477                         pwrpriv->bcn_ant_mode = bcn_ant_mode;
 478                         rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode));
 479
 480                         pslv = PS_STATE_S2;
 481                         if (pwrpriv->alives == 0)
 482                                 pslv = PS_STATE_S0;
 483
 484                         if ((rtw_btcoex_IsBtDisabled(padapter) == false)
 485                                 && (rtw_btcoex_IsBtControlLps(padapter) == true)) {
 486                                 u8 val8;
 487
 488                                 val8 = rtw_btcoex_LpsVal(padapter);
 489                                 if (val8 & BIT(4))
 490                                         pslv = PS_STATE_S2;
 491                         }
 492
 493                         rtw_set_rpwm(padapter, pslv);
 494                 }
 495         }
 496
 497         up(&pwrpriv->lock);
 498 }
 499
 500 /*
 501  * Return:
 502  *0:    Leave OK
 503  *-1:   Timeout
 504  *-2:   Other error
 505  */
 506 s32 LPS_RF_ON_check(struct adapter *padapter, u32 delay_ms)
 507 {
 508         unsigned long start_time;
 509         u8 bAwake = false;
 510         s32 err = 0;
 511
 512
 513         start_time = jiffies;
 514         while (1) {
 515                 rtw_hal_get_hwreg(padapter, HW_VAR_FWLPS_RF_ON, &bAwake);
 516                 if (true == bAwake)
 517                         break;
 518
 519                 if (true == padapter->bSurpriseRemoved) {
 520                         err = -2;
 521                         DBG_871X("%s: device surprise removed!!\n", __func__);
 522                         break;
 523                 }
 524
 525                 if (jiffies_to_msecs(jiffies - start_time) > delay_ms) {
 526                         err = -1;
 527                         DBG_871X("%s: Wait for FW LPS leave more than %u ms!!!\n", __func__, delay_ms);
 528                         break;
 529                 }
 530                 msleep(1);
 531         }
 532
 533         return err;
 534 }
 535
 536 /*  */
 537 /*      Description: */
 538 /*              Enter the leisure power save mode. */
 539 /*  */
 540 void LPS_Enter(struct adapter *padapter, const char *msg)
 541 {
 542         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 543         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
 544         int n_assoc_iface = 0;
 545         char buf[32] = {0};
 546
 547         if (rtw_btcoex_IsBtControlLps(padapter) == true)
 548                 return;
 549
 550         /* Skip lps enter request if number of assocated adapters is not 1 */
 551         if (check_fwstate(&(dvobj->padapters->mlmepriv), WIFI_ASOC_STATE))
 552                 n_assoc_iface++;
 553         if (n_assoc_iface != 1)
 554                 return;
 555
 556         /* Skip lps enter request for adapter not port0 */
 557         if (get_iface_type(padapter) != IFACE_PORT0)
 558                 return;
 559
 560         if (PS_RDY_CHECK(dvobj->padapters) == false)
 561                         return;
 562
 563         if (pwrpriv->bLeisurePs) {
 564                 /*  Idle for a while if we connect to AP a while ago. */
 565                 if (pwrpriv->LpsIdleCount >= 2) { /*   4 Sec */
 566                         if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) {
 567                                 sprintf(buf, "WIFI-%s", msg);
 568                                 pwrpriv->bpower_saving = true;
 569                                 rtw_set_ps_mode(padapter, pwrpriv->power_mgnt, padapter->registrypriv.smart_ps, 0, buf);
 570                         }
 571                 } else
 572                         pwrpriv->LpsIdleCount++;
 573         }
 574
 575 /*      DBG_871X("-LeisurePSEnter\n"); */
 576 }
 577
 578 /*  */
 579 /*      Description: */
 580 /*              Leave the leisure power save mode. */
 581 /*  */
 582 void LPS_Leave(struct adapter *padapter, const char *msg)
 583 {
 584 #define LPS_LEAVE_TIMEOUT_MS 100
 585
 586         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 587         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
 588         char buf[32] = {0};
 589
 590 /*      DBG_871X("+LeisurePSLeave\n"); */
 591
 592         if (rtw_btcoex_IsBtControlLps(padapter) == true)
 593                 return;
 594
 595         if (pwrpriv->bLeisurePs) {
 596                 if (pwrpriv->pwr_mode != PS_MODE_ACTIVE) {
 597                         sprintf(buf, "WIFI-%s", msg);
 598                         rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0, buf);
 599
 600                         if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
 601                                 LPS_RF_ON_check(padapter, LPS_LEAVE_TIMEOUT_MS);
 602                 }
 603         }
 604
 605         pwrpriv->bpower_saving = false;
 606 /*      DBG_871X("-LeisurePSLeave\n"); */
 607
 608 }
 609
 610 void LeaveAllPowerSaveModeDirect(struct adapter *Adapter)
 611 {
 612         struct adapter *pri_padapter = GET_PRIMARY_ADAPTER(Adapter);
 613         struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
 614         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(Adapter);
 615
 616         DBG_871X("%s.....\n", __func__);
 617
 618         if (true == Adapter->bSurpriseRemoved) {
 619                 DBG_871X(FUNC_ADPT_FMT ": bSurpriseRemoved =%d Skip!\n",
 620                         FUNC_ADPT_ARG(Adapter), Adapter->bSurpriseRemoved);
 621                 return;
 622         }
 623
 624         if ((check_fwstate(pmlmepriv, _FW_LINKED) == true)) { /* connect */
 625
 626                 if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) {
 627                         DBG_871X("%s: Driver Already Leave LPS\n", __func__);
 628                         return;
 629                 }
 630
 631                 down(&pwrpriv->lock);
 632
 633                 rtw_set_rpwm(Adapter, PS_STATE_S4);
 634
 635                 up(&pwrpriv->lock);
 636
 637                 rtw_lps_ctrl_wk_cmd(pri_padapter, LPS_CTRL_LEAVE, 0);
 638         } else{
 639                 if (pwrpriv->rf_pwrstate == rf_off)
 640                         if (false == ips_leave(pri_padapter))
 641                                 DBG_871X("======> ips_leave fail.............\n");
 642         }
 643 }
 644
 645 /*  */
 646 /*  Description: Leave all power save mode: LPS, FwLPS, IPS if needed. */
 647 /*  Move code to function by tynli. 2010.03.26. */
 648 /*  */
 649 void LeaveAllPowerSaveMode(struct adapter *Adapter)
 650 {
 651         struct dvobj_priv *dvobj = adapter_to_dvobj(Adapter);
 652         u8 enqueue = 0;
 653         int n_assoc_iface = 0;
 654
 655         if (!Adapter->bup) {
 656                 DBG_871X(FUNC_ADPT_FMT ": bup =%d Skip!\n",
 657                         FUNC_ADPT_ARG(Adapter), Adapter->bup);
 658                 return;
 659         }
 660
 661         if (Adapter->bSurpriseRemoved) {
 662                 DBG_871X(FUNC_ADPT_FMT ": bSurpriseRemoved =%d Skip!\n",
 663                         FUNC_ADPT_ARG(Adapter), Adapter->bSurpriseRemoved);
 664                 return;
 665         }
 666
 667         if (check_fwstate(&(dvobj->padapters->mlmepriv), WIFI_ASOC_STATE))
 668                 n_assoc_iface++;
 669
 670         if (n_assoc_iface) { /* connect */
 671                 enqueue = 1;
 672
 673                 rtw_lps_ctrl_wk_cmd(Adapter, LPS_CTRL_LEAVE, enqueue);
 674
 675                 LPS_Leave_check(Adapter);
 676         } else {
 677                 if (adapter_to_pwrctl(Adapter)->rf_pwrstate == rf_off) {
 678                         if (false == ips_leave(Adapter))
 679                                 DBG_871X("======> ips_leave fail.............\n");
 680                 }
 681         }
 682 }
 683
 684 void LPS_Leave_check(
 685         struct adapter *padapter)
 686 {
 687         struct pwrctrl_priv *pwrpriv;
 688         unsigned long   start_time;
 689         u8 bReady;
 690
 691         pwrpriv = adapter_to_pwrctl(padapter);
 692
 693         bReady = false;
 694         start_time = jiffies;
 695
 696         cond_resched();
 697
 698         while (1) {
 699                 down(&pwrpriv->lock);
 700
 701                 if ((padapter->bSurpriseRemoved == true)
 702                         || (padapter->hw_init_completed == false)
 703                         || (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
 704                         )
 705                         bReady = true;
 706
 707                 up(&pwrpriv->lock);
 708
 709                 if (true == bReady)
 710                         break;
 711
 712                 if (jiffies_to_msecs(jiffies - start_time) > 100) {
 713                         DBG_871X("Wait for cpwm event  than 100 ms!!!\n");
 714                         break;
 715                 }
 716                 msleep(1);
 717         }
 718 }
 719
 720 /*
 721  * Caller:ISR handler...
 722  *
 723  * This will be called when CPWM interrupt is up.
 724  *
 725  * using to update cpwn of drv; and drv willl make a decision to up or down pwr level
 726  */
 727 void cpwm_int_hdl(
 728         struct adapter *padapter,
 729         struct reportpwrstate_parm *preportpwrstate)
 730 {
 731         struct pwrctrl_priv *pwrpriv;
 732
 733         pwrpriv = adapter_to_pwrctl(padapter);
 734
 735         down(&pwrpriv->lock);
 736
 737         if (pwrpriv->rpwm < PS_STATE_S2) {
 738                 DBG_871X("%s: Redundant CPWM Int. RPWM = 0x%02X CPWM = 0x%02x\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
 739                 up(&pwrpriv->lock);
 740                 goto exit;
 741         }
 742
 743         pwrpriv->cpwm = PS_STATE(preportpwrstate->state);
 744         pwrpriv->cpwm_tog = preportpwrstate->state & PS_TOGGLE;
 745
 746         if (pwrpriv->cpwm >= PS_STATE_S2) {
 747                 if (pwrpriv->alives & CMD_ALIVE)
 748                         up(&padapter->cmdpriv.cmd_queue_sema);
 749
 750                 if (pwrpriv->alives & XMIT_ALIVE)
 751                         up(&padapter->xmitpriv.xmit_sema);
 752         }
 753
 754         up(&pwrpriv->lock);
 755
 756 exit:
 757         RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
 758                          ("cpwm_int_hdl: cpwm = 0x%02x\n", pwrpriv->cpwm));
 759 }
 760
 761 static void cpwm_event_callback(struct work_struct *work)
 762 {
 763         struct pwrctrl_priv *pwrpriv = container_of(work, struct pwrctrl_priv, cpwm_event);
 764         struct dvobj_priv *dvobj = pwrctl_to_dvobj(pwrpriv);
 765         struct adapter *adapter = dvobj->if1;
 766         struct reportpwrstate_parm report;
 767
 768         /* DBG_871X("%s\n", __func__); */
 769
 770         report.state = PS_STATE_S2;
 771         cpwm_int_hdl(adapter, &report);
 772 }
 773
 774 static void rpwmtimeout_workitem_callback(struct work_struct *work)
 775 {
 776         struct adapter *padapter;
 777         struct dvobj_priv *dvobj;
 778         struct pwrctrl_priv *pwrpriv;
 779
 780
 781         pwrpriv = container_of(work, struct pwrctrl_priv, rpwmtimeoutwi);
 782         dvobj = pwrctl_to_dvobj(pwrpriv);
 783         padapter = dvobj->if1;
 784 /*      DBG_871X("+%s: rpwm = 0x%02X cpwm = 0x%02X\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm); */
 785
 786         down(&pwrpriv->lock);
 787         if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2)) {
 788                 DBG_871X("%s: rpwm = 0x%02X cpwm = 0x%02X CPWM done!\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
 789                 goto exit;
 790         }
 791         up(&pwrpriv->lock);
 792
 793         if (rtw_read8(padapter, 0x100) != 0xEA) {
 794                 struct reportpwrstate_parm report;
 795
 796                 report.state = PS_STATE_S2;
 797                 DBG_871X("\n%s: FW already leave 32K!\n\n", __func__);
 798                 cpwm_int_hdl(padapter, &report);
 799
 800                 return;
 801         }
 802
 803         down(&pwrpriv->lock);
 804
 805         if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2)) {
 806                 DBG_871X("%s: cpwm =%d, nothing to do!\n", __func__, pwrpriv->cpwm);
 807                 goto exit;
 808         }
 809         pwrpriv->brpwmtimeout = true;
 810         rtw_set_rpwm(padapter, pwrpriv->rpwm);
 811         pwrpriv->brpwmtimeout = false;
 812
 813 exit:
 814         up(&pwrpriv->lock);
 815 }
 816
 817 /*
 818  * This function is a timer handler, can't do any IO in it.
 819  */
 820 static void pwr_rpwm_timeout_handler(struct timer_list *t)
 821 {
 822         struct pwrctrl_priv *pwrpriv = from_timer(pwrpriv, t, pwr_rpwm_timer);
 823
 824         DBG_871X("+%s: rpwm = 0x%02X cpwm = 0x%02X\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
 825
 826         if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2)) {
 827                 DBG_871X("+%s: cpwm =%d, nothing to do!\n", __func__, pwrpriv->cpwm);
 828                 return;
 829         }
 830
 831         _set_workitem(&pwrpriv->rpwmtimeoutwi);
 832 }
 833
 834 static __inline void register_task_alive(struct pwrctrl_priv *pwrctrl, u32 tag)
 835 {
 836         pwrctrl->alives |= tag;
 837 }
 838
 839 static __inline void unregister_task_alive(struct pwrctrl_priv *pwrctrl, u32 tag)
 840 {
 841         pwrctrl->alives &= ~tag;
 842 }
 843
 844
 845 /*
 846  * Description:
 847  *Check if the fw_pwrstate is okay for I/O.
 848  *If not (cpwm is less than S2), then the sub-routine
 849  *will raise the cpwm to be greater than or equal to S2.
 850  *
 851  *Calling Context: Passive
 852  *
 853  *Constraint:
 854  *      1. this function will request pwrctrl->lock
 855  *
 856  * Return Value:
 857  *_SUCCESS      hardware is ready for I/O
 858  *_FAIL         can't I/O right now
 859  */
 860 s32 rtw_register_task_alive(struct adapter *padapter, u32 task)
 861 {
 862         s32 res;
 863         struct pwrctrl_priv *pwrctrl;
 864         u8 pslv;
 865
 866         res = _SUCCESS;
 867         pwrctrl = adapter_to_pwrctl(padapter);
 868         pslv = PS_STATE_S2;
 869
 870         down(&pwrctrl->lock);
 871
 872         register_task_alive(pwrctrl, task);
 873
 874         if (pwrctrl->bFwCurrentInPSMode == true) {
 875                 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
 876                                  ("%s: task = 0x%x cpwm = 0x%02x alives = 0x%08x\n",
 877                                   __func__, task, pwrctrl->cpwm, pwrctrl->alives));
 878
 879                 if (pwrctrl->cpwm < pslv) {
 880                         if (pwrctrl->cpwm < PS_STATE_S2)
 881                                 res = _FAIL;
 882                         if (pwrctrl->rpwm < pslv)
 883                                 rtw_set_rpwm(padapter, pslv);
 884                 }
 885         }
 886
 887         up(&pwrctrl->lock);
 888
 889         if (_FAIL == res)
 890                 if (pwrctrl->cpwm >= PS_STATE_S2)
 891                         res = _SUCCESS;
 892
 893         return res;
 894 }
 895
 896 /*
 897  * Description:
 898  *If task is done, call this func. to power down firmware again.
 899  *
 900  *Constraint:
 901  *      1. this function will request pwrctrl->lock
 902  *
 903  * Return Value:
 904  *none
 905  */
 906 void rtw_unregister_task_alive(struct adapter *padapter, u32 task)
 907 {
 908         struct pwrctrl_priv *pwrctrl;
 909         u8 pslv;
 910
 911         pwrctrl = adapter_to_pwrctl(padapter);
 912         pslv = PS_STATE_S0;
 913
 914         if ((rtw_btcoex_IsBtDisabled(padapter) == false)
 915                 && (rtw_btcoex_IsBtControlLps(padapter) == true)) {
 916                 u8 val8;
 917
 918                 val8 = rtw_btcoex_LpsVal(padapter);
 919                 if (val8 & BIT(4))
 920                         pslv = PS_STATE_S2;
 921         }
 922
 923         down(&pwrctrl->lock);
 924
 925         unregister_task_alive(pwrctrl, task);
 926
 927         if ((pwrctrl->pwr_mode != PS_MODE_ACTIVE)
 928                 && (pwrctrl->bFwCurrentInPSMode == true)) {
 929                 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
 930                                  ("%s: cpwm = 0x%02x alives = 0x%08x\n",
 931                                   __func__, pwrctrl->cpwm, pwrctrl->alives));
 932
 933                 if (pwrctrl->cpwm > pslv)
 934                         if ((pslv >= PS_STATE_S2) || (pwrctrl->alives == 0))
 935                                 rtw_set_rpwm(padapter, pslv);
 936
 937         }
 938
 939         up(&pwrctrl->lock);
 940 }
 941
 942 /*
 943  * Caller: rtw_xmit_thread
 944  *
 945  * Check if the fw_pwrstate is okay for xmit.
 946  * If not (cpwm is less than S3), then the sub-routine
 947  * will raise the cpwm to be greater than or equal to S3.
 948  *
 949  * Calling Context: Passive
 950  *
 951  * Return Value:
 952  * _SUCCESS     rtw_xmit_thread can write fifo/txcmd afterwards.
 953  * _FAIL                rtw_xmit_thread can not do anything.
 954  */
 955 s32 rtw_register_tx_alive(struct adapter *padapter)
 956 {
 957         s32 res;
 958         struct pwrctrl_priv *pwrctrl;
 959         u8 pslv;
 960
 961         res = _SUCCESS;
 962         pwrctrl = adapter_to_pwrctl(padapter);
 963         pslv = PS_STATE_S2;
 964
 965         down(&pwrctrl->lock);
 966
 967         register_task_alive(pwrctrl, XMIT_ALIVE);
 968
 969         if (pwrctrl->bFwCurrentInPSMode == true) {
 970                 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
 971                                  ("rtw_register_tx_alive: cpwm = 0x%02x alives = 0x%08x\n",
 972                                   pwrctrl->cpwm, pwrctrl->alives));
 973
 974                 if (pwrctrl->cpwm < pslv) {
 975                         if (pwrctrl->cpwm < PS_STATE_S2)
 976                                 res = _FAIL;
 977                         if (pwrctrl->rpwm < pslv)
 978                                 rtw_set_rpwm(padapter, pslv);
 979                 }
 980         }
 981
 982         up(&pwrctrl->lock);
 983
 984         if (_FAIL == res)
 985                 if (pwrctrl->cpwm >= PS_STATE_S2)
 986                         res = _SUCCESS;
 987
 988         return res;
 989 }
 990
 991 /*
 992  * Caller: rtw_cmd_thread
 993  *
 994  * Check if the fw_pwrstate is okay for issuing cmd.
 995  * If not (cpwm should be is less than S2), then the sub-routine
 996  * will raise the cpwm to be greater than or equal to S2.
 997  *
 998  * Calling Context: Passive
 999  *
1000  * Return Value:
1001  *_SUCCESS      rtw_cmd_thread can issue cmds to firmware afterwards.
1002  *_FAIL         rtw_cmd_thread can not do anything.
1003  */
1004 s32 rtw_register_cmd_alive(struct adapter *padapter)
1005 {
1006         s32 res;
1007         struct pwrctrl_priv *pwrctrl;
1008         u8 pslv;
1009
1010         res = _SUCCESS;
1011         pwrctrl = adapter_to_pwrctl(padapter);
1012         pslv = PS_STATE_S2;
1013
1014         down(&pwrctrl->lock);
1015
1016         register_task_alive(pwrctrl, CMD_ALIVE);
1017
1018         if (pwrctrl->bFwCurrentInPSMode == true) {
1019                 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_info_,
1020                                  ("rtw_register_cmd_alive: cpwm = 0x%02x alives = 0x%08x\n",
1021                                   pwrctrl->cpwm, pwrctrl->alives));
1022
1023                 if (pwrctrl->cpwm < pslv) {
1024                         if (pwrctrl->cpwm < PS_STATE_S2)
1025                                 res = _FAIL;
1026                         if (pwrctrl->rpwm < pslv)
1027                                 rtw_set_rpwm(padapter, pslv);
1028                 }
1029         }
1030
1031         up(&pwrctrl->lock);
1032
1033         if (_FAIL == res)
1034                 if (pwrctrl->cpwm >= PS_STATE_S2)
1035                         res = _SUCCESS;
1036
1037         return res;
1038 }
1039
1040 /*
1041  * Caller: ISR
1042  *
1043  * If ISR's txdone,
1044  * No more pkts for TX,
1045  * Then driver shall call this fun. to power down firmware again.
1046  */
1047 void rtw_unregister_tx_alive(struct adapter *padapter)
1048 {
1049         struct pwrctrl_priv *pwrctrl;
1050         u8 pslv;
1051
1052         pwrctrl = adapter_to_pwrctl(padapter);
1053         pslv = PS_STATE_S0;
1054
1055         if ((rtw_btcoex_IsBtDisabled(padapter) == false)
1056                 && (rtw_btcoex_IsBtControlLps(padapter) == true)) {
1057                 u8 val8;
1058
1059                 val8 = rtw_btcoex_LpsVal(padapter);
1060                 if (val8 & BIT(4))
1061                         pslv = PS_STATE_S2;
1062         }
1063
1064         down(&pwrctrl->lock);
1065
1066         unregister_task_alive(pwrctrl, XMIT_ALIVE);
1067
1068         if ((pwrctrl->pwr_mode != PS_MODE_ACTIVE)
1069                 && (pwrctrl->bFwCurrentInPSMode == true)) {
1070                 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
1071                                  ("%s: cpwm = 0x%02x alives = 0x%08x\n",
1072                                   __func__, pwrctrl->cpwm, pwrctrl->alives));
1073
1074                 if (pwrctrl->cpwm > pslv)
1075                         if ((pslv >= PS_STATE_S2) || (pwrctrl->alives == 0))
1076                                 rtw_set_rpwm(padapter, pslv);
1077         }
1078
1079         up(&pwrctrl->lock);
1080 }
1081
1082 /*
1083  * Caller: ISR
1084  *
1085  * If all commands have been done,
1086  * and no more command to do,
1087  * then driver shall call this fun. to power down firmware again.
1088  */
1089 void rtw_unregister_cmd_alive(struct adapter *padapter)
1090 {
1091         struct pwrctrl_priv *pwrctrl;
1092         u8 pslv;
1093
1094         pwrctrl = adapter_to_pwrctl(padapter);
1095         pslv = PS_STATE_S0;
1096
1097         if ((rtw_btcoex_IsBtDisabled(padapter) == false)
1098                 && (rtw_btcoex_IsBtControlLps(padapter) == true)) {
1099                 u8 val8;
1100
1101                 val8 = rtw_btcoex_LpsVal(padapter);
1102                 if (val8 & BIT(4))
1103                         pslv = PS_STATE_S2;
1104         }
1105
1106         down(&pwrctrl->lock);
1107
1108         unregister_task_alive(pwrctrl, CMD_ALIVE);
1109
1110         if ((pwrctrl->pwr_mode != PS_MODE_ACTIVE)
1111                 && (pwrctrl->bFwCurrentInPSMode == true)) {
1112                 RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_info_,
1113                                  ("%s: cpwm = 0x%02x alives = 0x%08x\n",
1114                                   __func__, pwrctrl->cpwm, pwrctrl->alives));
1115
1116                 if (pwrctrl->cpwm > pslv) {
1117                         if ((pslv >= PS_STATE_S2) || (pwrctrl->alives == 0))
1118                                 rtw_set_rpwm(padapter, pslv);
1119                 }
1120         }
1121
1122         up(&pwrctrl->lock);
1123 }
1124
1125 void rtw_init_pwrctrl_priv(struct adapter *padapter)
1126 {
1127         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
1128
1129         sema_init(&pwrctrlpriv->lock, 1);
1130         sema_init(&pwrctrlpriv->check_32k_lock, 1);
1131         pwrctrlpriv->rf_pwrstate = rf_on;
1132         pwrctrlpriv->ips_enter_cnts = 0;
1133         pwrctrlpriv->ips_leave_cnts = 0;
1134         pwrctrlpriv->bips_processing = false;
1135
1136         pwrctrlpriv->ips_mode = padapter->registrypriv.ips_mode;
1137         pwrctrlpriv->ips_mode_req = padapter->registrypriv.ips_mode;
1138
1139         pwrctrlpriv->pwr_state_check_interval = RTW_PWR_STATE_CHK_INTERVAL;
1140         pwrctrlpriv->pwr_state_check_cnts = 0;
1141         pwrctrlpriv->bInternalAutoSuspend = false;
1142         pwrctrlpriv->bInSuspend = false;
1143         pwrctrlpriv->bkeepfwalive = false;
1144
1145         pwrctrlpriv->LpsIdleCount = 0;
1146         pwrctrlpriv->power_mgnt = padapter->registrypriv.power_mgnt;/*  PS_MODE_MIN; */
1147         pwrctrlpriv->bLeisurePs = pwrctrlpriv->power_mgnt != PS_MODE_ACTIVE;
1148
1149         pwrctrlpriv->bFwCurrentInPSMode = false;
1150
1151         pwrctrlpriv->rpwm = 0;
1152         pwrctrlpriv->cpwm = PS_STATE_S4;
1153
1154         pwrctrlpriv->pwr_mode = PS_MODE_ACTIVE;
1155         pwrctrlpriv->smart_ps = padapter->registrypriv.smart_ps;
1156         pwrctrlpriv->bcn_ant_mode = 0;
1157         pwrctrlpriv->dtim = 0;
1158
1159         pwrctrlpriv->tog = 0x80;
1160
1161         rtw_hal_set_hwreg(padapter, HW_VAR_SET_RPWM, (u8 *)(&pwrctrlpriv->rpwm));
1162
1163         _init_workitem(&pwrctrlpriv->cpwm_event, cpwm_event_callback, NULL);
1164
1165         pwrctrlpriv->brpwmtimeout = false;
1166         pwrctrlpriv->adapter = padapter;
1167         _init_workitem(&pwrctrlpriv->rpwmtimeoutwi, rpwmtimeout_workitem_callback, NULL);
1168         timer_setup(&pwrctrlpriv->pwr_rpwm_timer, pwr_rpwm_timeout_handler, 0);
1169         timer_setup(&pwrctrlpriv->pwr_state_check_timer,
1170                     pwr_state_check_handler, 0);
1171
1172         pwrctrlpriv->wowlan_mode = false;
1173         pwrctrlpriv->wowlan_ap_mode = false;
1174
1175 #ifdef CONFIG_PNO_SUPPORT
1176         pwrctrlpriv->pno_inited = false;
1177         pwrctrlpriv->pnlo_info = NULL;
1178         pwrctrlpriv->pscan_info = NULL;
1179         pwrctrlpriv->pno_ssid_list = NULL;
1180         pwrctrlpriv->pno_in_resume = true;
1181 #endif
1182 }
1183
1184
1185 void rtw_free_pwrctrl_priv(struct adapter *adapter)
1186 {
1187 #ifdef CONFIG_PNO_SUPPORT
1188         if (pwrctrlpriv->pnlo_info != NULL)
1189                 printk("****** pnlo_info memory leak********\n");
1190
1191         if (pwrctrlpriv->pscan_info != NULL)
1192                 printk("****** pscan_info memory leak********\n");
1193
1194         if (pwrctrlpriv->pno_ssid_list != NULL)
1195                 printk("****** pno_ssid_list memory leak********\n");
1196 #endif
1197 }
1198
1199 inline void rtw_set_ips_deny(struct adapter *padapter, u32 ms)
1200 {
1201         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1202         pwrpriv->ips_deny_time = jiffies + msecs_to_jiffies(ms);
1203 }
1204
1205 /*
1206 * rtw_pwr_wakeup - Wake the NIC up from: 1)IPS. 2)USB autosuspend
1207 * @adapter: pointer to struct adapter structure
1208 * @ips_deffer_ms: the ms wiil prevent from falling into IPS after wakeup
1209 * Return _SUCCESS or _FAIL
1210 */
1211
1212 int _rtw_pwr_wakeup(struct adapter *padapter, u32 ips_deffer_ms, const char *caller)
1213 {
1214         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1215         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
1216         struct mlme_priv *pmlmepriv;
1217         int ret = _SUCCESS;
1218         unsigned long start = jiffies;
1219         unsigned long deny_time = jiffies + msecs_to_jiffies(ips_deffer_ms);
1220
1221         /* for LPS */
1222         LeaveAllPowerSaveMode(padapter);
1223
1224         /* IPS still bound with primary adapter */
1225         padapter = GET_PRIMARY_ADAPTER(padapter);
1226         pmlmepriv = &padapter->mlmepriv;
1227
1228         if (time_before(pwrpriv->ips_deny_time, deny_time))
1229                 pwrpriv->ips_deny_time = deny_time;
1230
1231
1232         if (pwrpriv->ps_processing) {
1233                 DBG_871X("%s wait ps_processing...\n", __func__);
1234                 while (pwrpriv->ps_processing && jiffies_to_msecs(jiffies - start) <= 3000)
1235                         msleep(10);
1236                 if (pwrpriv->ps_processing)
1237                         DBG_871X("%s wait ps_processing timeout\n", __func__);
1238                 else
1239                         DBG_871X("%s wait ps_processing done\n", __func__);
1240         }
1241
1242         if (pwrpriv->bInternalAutoSuspend == false && pwrpriv->bInSuspend) {
1243                 DBG_871X("%s wait bInSuspend...\n", __func__);
1244                 while (pwrpriv->bInSuspend
1245                         && jiffies_to_msecs(jiffies - start) <= 3000
1246                 ) {
1247                         msleep(10);
1248                 }
1249                 if (pwrpriv->bInSuspend)
1250                         DBG_871X("%s wait bInSuspend timeout\n", __func__);
1251                 else
1252                         DBG_871X("%s wait bInSuspend done\n", __func__);
1253         }
1254
1255         /* System suspend is not allowed to wakeup */
1256         if ((pwrpriv->bInternalAutoSuspend == false) && (true == pwrpriv->bInSuspend)) {
1257                 ret = _FAIL;
1258                 goto exit;
1259         }
1260
1261         /* block??? */
1262         if ((pwrpriv->bInternalAutoSuspend == true)  && (padapter->net_closed == true)) {
1263                 ret = _FAIL;
1264                 goto exit;
1265         }
1266
1267         /* I think this should be check in IPS, LPS, autosuspend functions... */
1268         if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
1269                 ret = _SUCCESS;
1270                 goto exit;
1271         }
1272
1273         if (rf_off == pwrpriv->rf_pwrstate) {
1274                 {
1275                         DBG_8192C("%s call ips_leave....\n", __func__);
1276                         if (_FAIL ==  ips_leave(padapter)) {
1277                                 DBG_8192C("======> ips_leave fail.............\n");
1278                                 ret = _FAIL;
1279                                 goto exit;
1280                         }
1281                 }
1282         }
1283
1284         /* TODO: the following checking need to be merged... */
1285         if (padapter->bDriverStopped
1286                 || !padapter->bup
1287                 || !padapter->hw_init_completed
1288         ) {
1289                 DBG_8192C("%s: bDriverStopped =%d, bup =%d, hw_init_completed =%u\n"
1290                         , caller
1291                         , padapter->bDriverStopped
1292                         , padapter->bup
1293                         , padapter->hw_init_completed);
1294                 ret = false;
1295                 goto exit;
1296         }
1297
1298 exit:
1299         deny_time = jiffies + msecs_to_jiffies(ips_deffer_ms);
1300         if (time_before(pwrpriv->ips_deny_time, deny_time))
1301                 pwrpriv->ips_deny_time = deny_time;
1302         return ret;
1303
1304 }
1305
1306 int rtw_pm_set_lps(struct adapter *padapter, u8 mode)
1307 {
1308         int     ret = 0;
1309         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
1310
1311         if (mode < PS_MODE_NUM) {
1312                 if (pwrctrlpriv->power_mgnt != mode) {
1313                         if (PS_MODE_ACTIVE == mode)
1314                                 LeaveAllPowerSaveMode(padapter);
1315                         else
1316                                 pwrctrlpriv->LpsIdleCount = 2;
1317
1318                         pwrctrlpriv->power_mgnt = mode;
1319                         pwrctrlpriv->bLeisurePs =
1320                                 pwrctrlpriv->power_mgnt != PS_MODE_ACTIVE;
1321                 }
1322         } else
1323                 ret = -EINVAL;
1324
1325         return ret;
1326 }
1327
1328 int rtw_pm_set_ips(struct adapter *padapter, u8 mode)
1329 {
1330         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
1331
1332         if (mode == IPS_NORMAL || mode == IPS_LEVEL_2) {
1333                 rtw_ips_mode_req(pwrctrlpriv, mode);
1334                 DBG_871X("%s %s\n", __func__, mode == IPS_NORMAL?"IPS_NORMAL":"IPS_LEVEL_2");
1335                 return 0;
1336         } else if (mode == IPS_NONE) {
1337                 rtw_ips_mode_req(pwrctrlpriv, mode);
1338                 DBG_871X("%s %s\n", __func__, "IPS_NONE");
1339                 if ((padapter->bSurpriseRemoved == 0) && (_FAIL == rtw_pwr_wakeup(padapter)))
1340                         return -EFAULT;
1341         } else
1342                 return -EINVAL;
1343
1344         return 0;
1345 }
1346
1347 /*
1348  * ATTENTION:
1349  *This function will request pwrctrl LOCK!
1350  */
1351 void rtw_ps_deny(struct adapter *padapter, enum PS_DENY_REASON reason)
1352 {
1353         struct pwrctrl_priv *pwrpriv;
1354
1355 /*      DBG_871X("+" FUNC_ADPT_FMT ": Request PS deny for %d (0x%08X)\n", */
1356 /*              FUNC_ADPT_ARG(padapter), reason, BIT(reason)); */
1357
1358         pwrpriv = adapter_to_pwrctl(padapter);
1359
1360         down(&pwrpriv->lock);
1361         if (pwrpriv->ps_deny & BIT(reason)) {
1362                 DBG_871X(FUNC_ADPT_FMT ": [WARNING] Reason %d had been set before!!\n",
1363                         FUNC_ADPT_ARG(padapter), reason);
1364         }
1365         pwrpriv->ps_deny |= BIT(reason);
1366         up(&pwrpriv->lock);
1367
1368 /*      DBG_871X("-" FUNC_ADPT_FMT ": Now PS deny for 0x%08X\n", */
1369 /*              FUNC_ADPT_ARG(padapter), pwrpriv->ps_deny); */
1370 }
1371
1372 /*
1373  * ATTENTION:
1374  *This function will request pwrctrl LOCK!
1375  */
1376 void rtw_ps_deny_cancel(struct adapter *padapter, enum PS_DENY_REASON reason)
1377 {
1378         struct pwrctrl_priv *pwrpriv;
1379
1380
1381 /*      DBG_871X("+" FUNC_ADPT_FMT ": Cancel PS deny for %d(0x%08X)\n", */
1382 /*              FUNC_ADPT_ARG(padapter), reason, BIT(reason)); */
1383
1384         pwrpriv = adapter_to_pwrctl(padapter);
1385
1386         down(&pwrpriv->lock);
1387         if ((pwrpriv->ps_deny & BIT(reason)) == 0) {
1388                 DBG_871X(FUNC_ADPT_FMT ": [ERROR] Reason %d had been canceled before!!\n",
1389                         FUNC_ADPT_ARG(padapter), reason);
1390         }
1391         pwrpriv->ps_deny &= ~BIT(reason);
1392         up(&pwrpriv->lock);
1393
1394 /*      DBG_871X("-" FUNC_ADPT_FMT ": Now PS deny for 0x%08X\n", */
1395 /*              FUNC_ADPT_ARG(padapter), pwrpriv->ps_deny); */
1396 }
1397
1398 /*
1399  * ATTENTION:
1400  *Before calling this function pwrctrl lock should be occupied already,
1401  *otherwise it may return incorrect value.
1402  */
1403 u32 rtw_ps_deny_get(struct adapter *padapter)
1404 {
1405         u32 deny;
1406
1407
1408         deny = adapter_to_pwrctl(padapter)->ps_deny;
1409
1410         return deny;
1411 }