drivers/staging/rtl8192e/rtl8192e/rtl_ps.c

   1 /******************************************************************************
   2  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
   3  *
   4  * Based on the r8180 driver, which is:
   5  * Copyright 2004-2005 Andrea Merello <andrea.merello@gmail.com>, et al.
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of version 2 of the GNU General Public License as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * The full GNU General Public License is included in this distribution in the
  16  * file called LICENSE.
  17  *
  18  * Contact Information:
  19  * wlanfae <wlanfae@realtek.com>
  20  *****************************************************************************/
  21 #include "rtl_ps.h"
  22 #include "rtl_core.h"
  23 #include "r8192E_phy.h"
  24 #include "r8192E_phyreg.h"
  25 #include "r8190P_rtl8256.h" /* RTL8225 Radio frontend */
  26 #include "r8192E_cmdpkt.h"
  27 #include <linux/jiffies.h>
  28
  29 static void _rtl92e_hw_sleep(struct net_device *dev)
  30 {
  31         struct r8192_priv *priv = rtllib_priv(dev);
  32         unsigned long flags = 0;
  33
  34         spin_lock_irqsave(&priv->rf_ps_lock, flags);
  35         if (priv->RFChangeInProgress) {
  36                 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
  37                 RT_TRACE(COMP_DBG,
  38                          "_rtl92e_hw_sleep(): RF Change in progress!\n");
  39                 return;
  40         }
  41         spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
  42         RT_TRACE(COMP_DBG, "%s()============>come to sleep down\n", __func__);
  43
  44         rtl92e_set_rf_state(dev, eRfSleep, RF_CHANGE_BY_PS);
  45 }
  46
  47 void rtl92e_hw_sleep_wq(void *data)
  48 {
  49         struct rtllib_device *ieee = container_of_dwork_rsl(data,
  50                                      struct rtllib_device, hw_sleep_wq);
  51         struct net_device *dev = ieee->dev;
  52
  53         _rtl92e_hw_sleep(dev);
  54 }
  55
  56 void rtl92e_hw_wakeup(struct net_device *dev)
  57 {
  58         struct r8192_priv *priv = rtllib_priv(dev);
  59         unsigned long flags = 0;
  60
  61         spin_lock_irqsave(&priv->rf_ps_lock, flags);
  62         if (priv->RFChangeInProgress) {
  63                 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
  64                 RT_TRACE(COMP_DBG,
  65                          "rtl92e_hw_wakeup(): RF Change in progress!\n");
  66                 queue_delayed_work_rsl(priv->rtllib->wq,
  67                                        &priv->rtllib->hw_wakeup_wq,
  68                                        msecs_to_jiffies(10));
  69                 return;
  70         }
  71         spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
  72         RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __func__);
  73         rtl92e_set_rf_state(dev, eRfOn, RF_CHANGE_BY_PS);
  74 }
  75
  76 void rtl92e_hw_wakeup_wq(void *data)
  77 {
  78         struct rtllib_device *ieee = container_of_dwork_rsl(data,
  79                                      struct rtllib_device, hw_wakeup_wq);
  80         struct net_device *dev = ieee->dev;
  81
  82         rtl92e_hw_wakeup(dev);
  83 }
  84
  85 #define MIN_SLEEP_TIME 50
  86 #define MAX_SLEEP_TIME 10000
  87 void rtl92e_enter_sleep(struct net_device *dev, u64 time)
  88 {
  89         struct r8192_priv *priv = rtllib_priv(dev);
  90
  91         u32 tmp;
  92         unsigned long flags;
  93         unsigned long timeout;
  94
  95         spin_lock_irqsave(&priv->ps_lock, flags);
  96
  97         time -= msecs_to_jiffies(8 + 16 + 7);
  98
  99         timeout = jiffies + msecs_to_jiffies(MIN_SLEEP_TIME);
 100         if (time_before((unsigned long)time, timeout)) {
 101                 spin_unlock_irqrestore(&priv->ps_lock, flags);
 102                 netdev_info(dev, "too short to sleep::%lld < %ld\n",
 103                             time - jiffies, msecs_to_jiffies(MIN_SLEEP_TIME));
 104                 return;
 105         }
 106         timeout = jiffies + msecs_to_jiffies(MAX_SLEEP_TIME);
 107         if (time_after((unsigned long)time, timeout)) {
 108                 netdev_info(dev, "========>too long to sleep:%lld > %ld\n",
 109                             time - jiffies, msecs_to_jiffies(MAX_SLEEP_TIME));
 110                 spin_unlock_irqrestore(&priv->ps_lock, flags);
 111                 return;
 112         }
 113         tmp = time - jiffies;
 114         queue_delayed_work_rsl(priv->rtllib->wq,
 115                         &priv->rtllib->hw_wakeup_wq, tmp);
 116         queue_delayed_work_rsl(priv->rtllib->wq,
 117                         (void *)&priv->rtllib->hw_sleep_wq, 0);
 118         spin_unlock_irqrestore(&priv->ps_lock, flags);
 119 }
 120
 121 static void _rtl92e_ps_update_rf_state(struct net_device *dev)
 122 {
 123         struct r8192_priv *priv = rtllib_priv(dev);
 124         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
 125                                         &(priv->rtllib->PowerSaveControl);
 126
 127         RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state() --------->\n");
 128         pPSC->bSwRfProcessing = true;
 129
 130         RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state(): Set RF to %s.\n",
 131                  pPSC->eInactivePowerState == eRfOff ? "OFF" : "ON");
 132         rtl92e_set_rf_state(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
 133
 134         pPSC->bSwRfProcessing = false;
 135         RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state() <---------\n");
 136 }
 137
 138 void rtl92e_ips_enter(struct net_device *dev)
 139 {
 140         struct r8192_priv *priv = rtllib_priv(dev);
 141         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
 142                                         &(priv->rtllib->PowerSaveControl);
 143         enum rt_rf_power_state rtState;
 144
 145         if (pPSC->bInactivePs) {
 146                 rtState = priv->rtllib->eRFPowerState;
 147                 if (rtState == eRfOn && !pPSC->bSwRfProcessing &&
 148                         (priv->rtllib->state != RTLLIB_LINKED) &&
 149                         (priv->rtllib->iw_mode != IW_MODE_MASTER)) {
 150                         RT_TRACE(COMP_PS, "rtl92e_ips_enter(): Turn off RF.\n");
 151                         pPSC->eInactivePowerState = eRfOff;
 152                         priv->isRFOff = true;
 153                         priv->bInPowerSaveMode = true;
 154                         _rtl92e_ps_update_rf_state(dev);
 155                 }
 156         }
 157 }
 158
 159 void rtl92e_ips_leave(struct net_device *dev)
 160 {
 161         struct r8192_priv *priv = rtllib_priv(dev);
 162         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
 163                                         &(priv->rtllib->PowerSaveControl);
 164         enum rt_rf_power_state rtState;
 165
 166         if (pPSC->bInactivePs) {
 167                 rtState = priv->rtllib->eRFPowerState;
 168                 if (rtState != eRfOn  && !pPSC->bSwRfProcessing &&
 169                     priv->rtllib->RfOffReason <= RF_CHANGE_BY_IPS) {
 170                         RT_TRACE(COMP_PS, "rtl92e_ips_leave(): Turn on RF.\n");
 171                         pPSC->eInactivePowerState = eRfOn;
 172                         priv->bInPowerSaveMode = false;
 173                         _rtl92e_ps_update_rf_state(dev);
 174                 }
 175         }
 176 }
 177
 178 void rtl92e_ips_leave_wq(void *data)
 179 {
 180         struct rtllib_device *ieee = container_of_work_rsl(data,
 181                                      struct rtllib_device, ips_leave_wq);
 182         struct net_device *dev = ieee->dev;
 183         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 184
 185         down(&priv->rtllib->ips_sem);
 186         rtl92e_ips_leave(dev);
 187         up(&priv->rtllib->ips_sem);
 188 }
 189
 190 void rtl92e_rtllib_ips_leave_wq(struct net_device *dev)
 191 {
 192         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 193         enum rt_rf_power_state rtState;
 194
 195         rtState = priv->rtllib->eRFPowerState;
 196
 197         if (priv->rtllib->PowerSaveControl.bInactivePs) {
 198                 if (rtState == eRfOff) {
 199                         if (priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS) {
 200                                 netdev_warn(dev, "%s(): RF is OFF.\n",
 201                                             __func__);
 202                                 return;
 203                         }
 204                         netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n",
 205                                     __func__);
 206                         queue_work_rsl(priv->rtllib->wq,
 207                                        &priv->rtllib->ips_leave_wq);
 208                 }
 209         }
 210 }
 211
 212 void rtl92e_rtllib_ips_leave(struct net_device *dev)
 213 {
 214         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 215
 216         down(&priv->rtllib->ips_sem);
 217         rtl92e_ips_leave(dev);
 218         up(&priv->rtllib->ips_sem);
 219 }
 220
 221 static bool _rtl92e_ps_set_mode(struct net_device *dev, u8 rtPsMode)
 222 {
 223         struct r8192_priv *priv = rtllib_priv(dev);
 224
 225         if (priv->rtllib->iw_mode == IW_MODE_ADHOC)
 226                 return false;
 227
 228         RT_TRACE(COMP_LPS, "%s(): set ieee->ps = %x\n", __func__, rtPsMode);
 229         if (!priv->ps_force)
 230                 priv->rtllib->ps = rtPsMode;
 231         if (priv->rtllib->sta_sleep != LPS_IS_WAKE &&
 232             rtPsMode == RTLLIB_PS_DISABLED) {
 233                 unsigned long flags;
 234
 235                 rtl92e_hw_wakeup(dev);
 236                 priv->rtllib->sta_sleep = LPS_IS_WAKE;
 237
 238                 spin_lock_irqsave(&(priv->rtllib->mgmt_tx_lock), flags);
 239                 RT_TRACE(COMP_DBG,
 240                          "LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
 241                 rtllib_sta_ps_send_null_frame(priv->rtllib, 0);
 242                 spin_unlock_irqrestore(&(priv->rtllib->mgmt_tx_lock), flags);
 243         }
 244
 245         return true;
 246 }
 247
 248 void rtl92e_leisure_ps_enter(struct net_device *dev)
 249 {
 250         struct r8192_priv *priv = rtllib_priv(dev);
 251         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
 252                                         &(priv->rtllib->PowerSaveControl);
 253
 254         RT_TRACE(COMP_PS, "rtl92e_leisure_ps_enter()...\n");
 255         RT_TRACE(COMP_PS,
 256                  "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
 257                  pPSC->bLeisurePs, priv->rtllib->ps, pPSC->LpsIdleCount,
 258                  RT_CHECK_FOR_HANG_PERIOD);
 259
 260         if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) &&
 261             (priv->rtllib->state == RTLLIB_LINKED))
 262             || (priv->rtllib->iw_mode == IW_MODE_ADHOC) ||
 263             (priv->rtllib->iw_mode == IW_MODE_MASTER))
 264                 return;
 265
 266         if (pPSC->bLeisurePs) {
 267                 if (pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) {
 268
 269                         if (priv->rtllib->ps == RTLLIB_PS_DISABLED) {
 270
 271                                 RT_TRACE(COMP_LPS,
 272                                          "rtl92e_leisure_ps_enter(): Enter 802.11 power save mode...\n");
 273
 274                                 if (!pPSC->bFwCtrlLPS) {
 275                                         if (priv->rtllib->SetFwCmdHandler)
 276                                                 priv->rtllib->SetFwCmdHandler(
 277                                                         dev, FW_CMD_LPS_ENTER);
 278                                 }
 279                                 _rtl92e_ps_set_mode(dev, RTLLIB_PS_MBCAST |
 280                                                          RTLLIB_PS_UNICAST);
 281                         }
 282                 } else
 283                         pPSC->LpsIdleCount++;
 284         }
 285 }
 286
 287 void rtl92e_leisure_ps_leave(struct net_device *dev)
 288 {
 289         struct r8192_priv *priv = rtllib_priv(dev);
 290         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
 291                                         &(priv->rtllib->PowerSaveControl);
 292
 293
 294         RT_TRACE(COMP_PS, "rtl92e_leisure_ps_leave()...\n");
 295         RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d\n",
 296                 pPSC->bLeisurePs, priv->rtllib->ps);
 297
 298         if (pPSC->bLeisurePs) {
 299                 if (priv->rtllib->ps != RTLLIB_PS_DISABLED) {
 300                         RT_TRACE(COMP_LPS,
 301                                  "rtl92e_leisure_ps_leave(): Busy Traffic , Leave 802.11 power save..\n");
 302                         _rtl92e_ps_set_mode(dev, RTLLIB_PS_DISABLED);
 303
 304                         if (!pPSC->bFwCtrlLPS) {
 305                                 if (priv->rtllib->SetFwCmdHandler)
 306                                         priv->rtllib->SetFwCmdHandler(dev,
 307                                                          FW_CMD_LPS_LEAVE);
 308                     }
 309                 }
 310         }
 311 }