staging/rtl8712/rtl871x_pwrctrl.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /******************************************************************************
0003  * rtl871x_pwrctrl.c
0004  *
0005  * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
0006  * Linux device driver for RTL8192SU
0007  *
0008  * Modifications for inclusion into the Linux staging tree are
0009  * Copyright(c) 2010 Larry Finger. All rights reserved.
0010  *
0011  * Contact information:
0012  * WLAN FAE <wlanfae@realtek.com>
0013  * Larry Finger <Larry.Finger@lwfinger.net>
0014  *
0015  ******************************************************************************/
0016
0017 #define _RTL871X_PWRCTRL_C_
0018
0019 #include "osdep_service.h"
0020 #include "drv_types.h"
0021 #include "osdep_intf.h"
0022
0023 #define RTL8712_SDIO_LOCAL_BASE 0X10100000
0024 #define SDIO_HCPWM (RTL8712_SDIO_LOCAL_BASE + 0x0081)
0025
0026 void r8712_set_rpwm(struct _adapter *padapter, u8 val8)
0027 {
0028     u8  rpwm;
0029     struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
0030
0031     if (pwrpriv->rpwm == val8) {
0032         if (pwrpriv->rpwm_retry == 0)
0033             return;
0034     }
0035     if (padapter->driver_stopped || padapter->surprise_removed)
0036         return;
0037     rpwm = val8 | pwrpriv->tog;
0038     switch (val8) {
0039     case PS_STATE_S1:
0040         pwrpriv->cpwm = val8;
0041         break;
0042     case PS_STATE_S2:/* only for USB normal powersave mode use,
0043               * temp mark some code.
0044               */
0045     case PS_STATE_S3:
0046     case PS_STATE_S4:
0047         pwrpriv->cpwm = val8;
0048         break;
0049     default:
0050         break;
0051     }
0052     pwrpriv->rpwm_retry = 0;
0053     pwrpriv->rpwm = val8;
0054     r8712_write8(padapter, 0x1025FE58, rpwm);
0055     pwrpriv->tog += 0x80;
0056 }
0057
0058 void r8712_set_ps_mode(struct _adapter *padapter, uint ps_mode, uint smart_ps)
0059 {
0060     struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
0061
0062     if (ps_mode > PM_Card_Disable)
0063         return;
0064     /* if driver is in active state, we dont need set smart_ps.*/
0065     if (ps_mode == PS_MODE_ACTIVE)
0066         smart_ps = 0;
0067     if ((pwrpriv->pwr_mode != ps_mode) || (pwrpriv->smart_ps != smart_ps)) {
0068         if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
0069             pwrpriv->bSleep = true;
0070         else
0071             pwrpriv->bSleep = false;
0072         pwrpriv->pwr_mode = ps_mode;
0073         pwrpriv->smart_ps = smart_ps;
0074         schedule_work(&pwrpriv->SetPSModeWorkItem);
0075     }
0076 }
0077
0078 /*
0079  * Caller:ISR handler...
0080  *
0081  * This will be called when CPWM interrupt is up.
0082  *
0083  * using to update cpwn of drv; and drv will make a decision to up or
0084  * down pwr level
0085  */
0086 void r8712_cpwm_int_hdl(struct _adapter *padapter,
0087             struct reportpwrstate_parm *preportpwrstate)
0088 {
0089     struct pwrctrl_priv *pwrpriv = &(padapter->pwrctrlpriv);
0090     struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
0091
0092     if (pwrpriv->cpwm_tog == ((preportpwrstate->state) & 0x80))
0093         return;
0094     del_timer(&padapter->pwrctrlpriv.rpwm_check_timer);
0095     mutex_lock(&pwrpriv->mutex_lock);
0096     pwrpriv->cpwm = (preportpwrstate->state) & 0xf;
0097     if (pwrpriv->cpwm >= PS_STATE_S2) {
0098         if (pwrpriv->alives & CMD_ALIVE)
0099             complete(&(pcmdpriv->cmd_queue_comp));
0100     }
0101     pwrpriv->cpwm_tog = (preportpwrstate->state) & 0x80;
0102     mutex_unlock(&pwrpriv->mutex_lock);
0103 }
0104
0105 static inline void register_task_alive(struct pwrctrl_priv *pwrctrl, uint tag)
0106 {
0107         pwrctrl->alives |= tag;
0108 }
0109
0110 static inline void unregister_task_alive(struct pwrctrl_priv *pwrctrl, uint tag)
0111 {
0112     if (pwrctrl->alives & tag)
0113         pwrctrl->alives ^= tag;
0114 }
0115
0116 static void _rpwm_check_handler (struct _adapter *padapter)
0117 {
0118     struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
0119
0120     if (padapter->driver_stopped || padapter->surprise_removed)
0121         return;
0122     if (pwrpriv->cpwm != pwrpriv->rpwm)
0123         schedule_work(&pwrpriv->rpwm_workitem);
0124 }
0125
0126 static void SetPSModeWorkItemCallback(struct work_struct *work)
0127 {
0128     struct pwrctrl_priv *pwrpriv = container_of(work,
0129                        struct pwrctrl_priv, SetPSModeWorkItem);
0130     struct _adapter *padapter = container_of(pwrpriv,
0131                     struct _adapter, pwrctrlpriv);
0132     if (!pwrpriv->bSleep) {
0133         mutex_lock(&pwrpriv->mutex_lock);
0134         if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
0135             r8712_set_rpwm(padapter, PS_STATE_S4);
0136         mutex_unlock(&pwrpriv->mutex_lock);
0137     }
0138 }
0139
0140 static void rpwm_workitem_callback(struct work_struct *work)
0141 {
0142     struct pwrctrl_priv *pwrpriv = container_of(work,
0143                        struct pwrctrl_priv, rpwm_workitem);
0144     struct _adapter *padapter = container_of(pwrpriv,
0145                     struct _adapter, pwrctrlpriv);
0146     if (pwrpriv->cpwm != pwrpriv->rpwm) {
0147         mutex_lock(&pwrpriv->mutex_lock);
0148         r8712_read8(padapter, SDIO_HCPWM);
0149         pwrpriv->rpwm_retry = 1;
0150         r8712_set_rpwm(padapter, pwrpriv->rpwm);
0151         mutex_unlock(&pwrpriv->mutex_lock);
0152     }
0153 }
0154
0155 static void rpwm_check_handler (struct timer_list *t)
0156 {
0157     struct _adapter *adapter =
0158         from_timer(adapter, t, pwrctrlpriv.rpwm_check_timer);
0159
0160     _rpwm_check_handler(adapter);
0161 }
0162
0163 void r8712_init_pwrctrl_priv(struct _adapter *padapter)
0164 {
0165     struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
0166
0167     memset((unsigned char *)pwrctrlpriv, 0, sizeof(struct pwrctrl_priv));
0168     mutex_init(&pwrctrlpriv->mutex_lock);
0169     pwrctrlpriv->cpwm = PS_STATE_S4;
0170     pwrctrlpriv->pwr_mode = PS_MODE_ACTIVE;
0171     pwrctrlpriv->smart_ps = 0;
0172     pwrctrlpriv->tog = 0x80;
0173 /* clear RPWM to ensure driver and fw back to initial state. */
0174     r8712_write8(padapter, 0x1025FE58, 0);
0175     INIT_WORK(&pwrctrlpriv->SetPSModeWorkItem, SetPSModeWorkItemCallback);
0176     INIT_WORK(&pwrctrlpriv->rpwm_workitem, rpwm_workitem_callback);
0177     timer_setup(&pwrctrlpriv->rpwm_check_timer, rpwm_check_handler, 0);
0178 }
0179
0180 /*
0181  * Caller: r8712_cmd_thread
0182  * Check if the fw_pwrstate is okay for issuing cmd.
0183  * If not (cpwm should be is less than P2 state), then the sub-routine
0184  * will raise the cpwm to be greater than or equal to P2.
0185  * Calling Context: Passive
0186  * Return Value:
0187  * 0:       r8712_cmd_thread can issue cmds to firmware afterwards.
0188  * -EINVAL: r8712_cmd_thread can not do anything.
0189  */
0190 int r8712_register_cmd_alive(struct _adapter *padapter)
0191 {
0192     int res = 0;
0193     struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
0194
0195     mutex_lock(&pwrctrl->mutex_lock);
0196     register_task_alive(pwrctrl, CMD_ALIVE);
0197     if (pwrctrl->cpwm < PS_STATE_S2) {
0198         r8712_set_rpwm(padapter, PS_STATE_S3);
0199         res = -EINVAL;
0200     }
0201     mutex_unlock(&pwrctrl->mutex_lock);
0202     return res;
0203 }
0204
0205 /*
0206  * Caller: ISR
0207  * If ISR's txdone,
0208  * No more pkts for TX,
0209  * Then driver shall call this fun. to power down firmware again.
0210  */
0211 void r8712_unregister_cmd_alive(struct _adapter *padapter)
0212 {
0213     struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
0214
0215     mutex_lock(&pwrctrl->mutex_lock);
0216     unregister_task_alive(pwrctrl, CMD_ALIVE);
0217     if ((pwrctrl->cpwm > PS_STATE_S2) &&
0218        (pwrctrl->pwr_mode > PS_MODE_ACTIVE)) {
0219         if ((pwrctrl->alives == 0) &&
0220             (check_fwstate(&padapter->mlmepriv,
0221              _FW_UNDER_LINKING) != true)) {
0222             r8712_set_rpwm(padapter, PS_STATE_S0);
0223         }
0224     }
0225     mutex_unlock(&pwrctrl->mutex_lock);
0226 }
0227
0228 void r8712_flush_rwctrl_works(struct _adapter *padapter)
0229 {
0230     struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
0231
0232     flush_work(&pwrctrl->SetPSModeWorkItem);
0233     flush_work(&pwrctrl->rpwm_workitem);
0234 }