drivers/staging/rtl8712/rtl871x_pwrctrl.c

   1 /******************************************************************************
   2  * rtl871x_pwrctrl.c
   3  *
   4  * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
   5  * Linux device driver for RTL8192SU
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of version 2 of the GNU General Public License as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  19  *
  20  * Modifications for inclusion into the Linux staging tree are
  21  * Copyright(c) 2010 Larry Finger. All rights reserved.
  22  *
  23  * Contact information:
  24  * WLAN FAE <wlanfae@realtek.com>
  25  * Larry Finger <Larry.Finger@lwfinger.net>
  26  *
  27  ******************************************************************************/
  28
  29 #define _RTL871X_PWRCTRL_C_
  30
  31 #include "osdep_service.h"
  32 #include "drv_types.h"
  33 #include "osdep_intf.h"
  34
  35 #define RTL8712_SDIO_LOCAL_BASE 0X10100000
  36 #define SDIO_HCPWM (RTL8712_SDIO_LOCAL_BASE + 0x0081)
  37
  38 void r8712_set_rpwm(struct _adapter *padapter, u8 val8)
  39 {
  40         u8      rpwm;
  41         struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
  42
  43         if (pwrpriv->rpwm == val8) {
  44                 if (pwrpriv->rpwm_retry == 0)
  45                         return;
  46         }
  47         if (padapter->bDriverStopped || padapter->bSurpriseRemoved)
  48                 return;
  49         rpwm = val8 | pwrpriv->tog;
  50         switch (val8) {
  51         case PS_STATE_S1:
  52                 pwrpriv->cpwm = val8;
  53                 break;
  54         case PS_STATE_S2:/* only for USB normal powersave mode use,
  55                           * temp mark some code.
  56                           */
  57         case PS_STATE_S3:
  58         case PS_STATE_S4:
  59                 pwrpriv->cpwm = val8;
  60                 break;
  61         default:
  62                 break;
  63         }
  64         pwrpriv->rpwm_retry = 0;
  65         pwrpriv->rpwm = val8;
  66         r8712_write8(padapter, 0x1025FE58, rpwm);
  67         pwrpriv->tog += 0x80;
  68 }
  69
  70 void r8712_set_ps_mode(struct _adapter *padapter, uint ps_mode, uint smart_ps)
  71 {
  72         struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
  73
  74         if (ps_mode > PM_Card_Disable)
  75                 return;
  76         /* if driver is in active state, we dont need set smart_ps.*/
  77         if (ps_mode == PS_MODE_ACTIVE)
  78                 smart_ps = 0;
  79         if ((pwrpriv->pwr_mode != ps_mode) || (pwrpriv->smart_ps != smart_ps)) {
  80                 if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
  81                         pwrpriv->bSleep = true;
  82                 else
  83                         pwrpriv->bSleep = false;
  84                 pwrpriv->pwr_mode = ps_mode;
  85                 pwrpriv->smart_ps = smart_ps;
  86                 schedule_work(&pwrpriv->SetPSModeWorkItem);
  87         }
  88 }
  89
  90 /*
  91  * Caller:ISR handler...
  92  *
  93  * This will be called when CPWM interrupt is up.
  94  *
  95  * using to update cpwn of drv; and drv will make a decision to up or
  96  * down pwr level
  97  */
  98 void r8712_cpwm_int_hdl(struct _adapter *padapter,
  99                         struct reportpwrstate_parm *preportpwrstate)
 100 {
 101         struct pwrctrl_priv *pwrpriv = &(padapter->pwrctrlpriv);
 102         struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
 103
 104         if (pwrpriv->cpwm_tog == ((preportpwrstate->state) & 0x80))
 105                 return;
 106         del_timer(&padapter->pwrctrlpriv.rpwm_check_timer);
 107         mutex_lock(&pwrpriv->mutex_lock);
 108         pwrpriv->cpwm = (preportpwrstate->state) & 0xf;
 109         if (pwrpriv->cpwm >= PS_STATE_S2) {
 110                 if (pwrpriv->alives & CMD_ALIVE)
 111                         complete(&(pcmdpriv->cmd_queue_comp));
 112         }
 113         pwrpriv->cpwm_tog = (preportpwrstate->state) & 0x80;
 114         mutex_unlock(&pwrpriv->mutex_lock);
 115 }
 116
 117 static inline void register_task_alive(struct pwrctrl_priv *pwrctrl, uint tag)
 118 {
 119                 pwrctrl->alives |= tag;
 120 }
 121
 122 static inline void unregister_task_alive(struct pwrctrl_priv *pwrctrl, uint tag)
 123 {
 124         if (pwrctrl->alives & tag)
 125                 pwrctrl->alives ^= tag;
 126 }
 127
 128 static void _rpwm_check_handler (struct _adapter *padapter)
 129 {
 130         struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
 131
 132         if (padapter->bDriverStopped || padapter->bSurpriseRemoved)
 133                 return;
 134         if (pwrpriv->cpwm != pwrpriv->rpwm)
 135                 schedule_work(&pwrpriv->rpwm_workitem);
 136 }
 137
 138 static void SetPSModeWorkItemCallback(struct work_struct *work)
 139 {
 140         struct pwrctrl_priv *pwrpriv = container_of(work,
 141                                        struct pwrctrl_priv, SetPSModeWorkItem);
 142         struct _adapter *padapter = container_of(pwrpriv,
 143                                     struct _adapter, pwrctrlpriv);
 144         if (!pwrpriv->bSleep) {
 145                 mutex_lock(&pwrpriv->mutex_lock);
 146                 if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
 147                         r8712_set_rpwm(padapter, PS_STATE_S4);
 148                 mutex_unlock(&pwrpriv->mutex_lock);
 149         }
 150 }
 151
 152 static void rpwm_workitem_callback(struct work_struct *work)
 153 {
 154         struct pwrctrl_priv *pwrpriv = container_of(work,
 155                                        struct pwrctrl_priv, rpwm_workitem);
 156         struct _adapter *padapter = container_of(pwrpriv,
 157                                     struct _adapter, pwrctrlpriv);
 158         if (pwrpriv->cpwm != pwrpriv->rpwm) {
 159                 mutex_lock(&pwrpriv->mutex_lock);
 160                 r8712_read8(padapter, SDIO_HCPWM);
 161                 pwrpriv->rpwm_retry = 1;
 162                 r8712_set_rpwm(padapter, pwrpriv->rpwm);
 163                 mutex_unlock(&pwrpriv->mutex_lock);
 164         }
 165 }
 166
 167 static void rpwm_check_handler (struct timer_list *t)
 168 {
 169         struct _adapter *adapter =
 170                 from_timer(adapter, t, pwrctrlpriv.rpwm_check_timer);
 171
 172         _rpwm_check_handler(adapter);
 173 }
 174
 175 void r8712_init_pwrctrl_priv(struct _adapter *padapter)
 176 {
 177         struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
 178
 179         memset((unsigned char *)pwrctrlpriv, 0, sizeof(struct pwrctrl_priv));
 180         mutex_init(&pwrctrlpriv->mutex_lock);
 181         pwrctrlpriv->cpwm = PS_STATE_S4;
 182         pwrctrlpriv->pwr_mode = PS_MODE_ACTIVE;
 183         pwrctrlpriv->smart_ps = 0;
 184         pwrctrlpriv->tog = 0x80;
 185 /* clear RPWM to ensure driver and fw back to initial state. */
 186         r8712_write8(padapter, 0x1025FE58, 0);
 187         INIT_WORK(&pwrctrlpriv->SetPSModeWorkItem, SetPSModeWorkItemCallback);
 188         INIT_WORK(&pwrctrlpriv->rpwm_workitem, rpwm_workitem_callback);
 189         timer_setup(&pwrctrlpriv->rpwm_check_timer, rpwm_check_handler, 0);
 190 }
 191
 192 /*
 193  * Caller: r8712_cmd_thread
 194  * Check if the fw_pwrstate is okay for issuing cmd.
 195  * If not (cpwm should be is less than P2 state), then the sub-routine
 196  * will raise the cpwm to be greater than or equal to P2.
 197  * Calling Context: Passive
 198  * Return Value:
 199  * _SUCCESS: r8712_cmd_thread can issue cmds to firmware afterwards.
 200  * _FAIL: r8712_cmd_thread can not do anything.
 201  */
 202 sint r8712_register_cmd_alive(struct _adapter *padapter)
 203 {
 204         uint res = _SUCCESS;
 205         struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
 206
 207         mutex_lock(&pwrctrl->mutex_lock);
 208         register_task_alive(pwrctrl, CMD_ALIVE);
 209         if (pwrctrl->cpwm < PS_STATE_S2) {
 210                 r8712_set_rpwm(padapter, PS_STATE_S3);
 211                 res = _FAIL;
 212         }
 213         mutex_unlock(&pwrctrl->mutex_lock);
 214         return res;
 215 }
 216
 217 /*
 218  * Caller: ISR
 219  * If ISR's txdone,
 220  * No more pkts for TX,
 221  * Then driver shall call this fun. to power down firmware again.
 222  */
 223 void r8712_unregister_cmd_alive(struct _adapter *padapter)
 224 {
 225         struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
 226
 227         mutex_lock(&pwrctrl->mutex_lock);
 228         unregister_task_alive(pwrctrl, CMD_ALIVE);
 229         if ((pwrctrl->cpwm > PS_STATE_S2) &&
 230            (pwrctrl->pwr_mode > PS_MODE_ACTIVE)) {
 231                 if ((pwrctrl->alives == 0) &&
 232                     (check_fwstate(&padapter->mlmepriv,
 233                      _FW_UNDER_LINKING) != true)) {
 234                         r8712_set_rpwm(padapter, PS_STATE_S0);
 235                 }
 236         }
 237         mutex_unlock(&pwrctrl->mutex_lock);
 238 }