// SPDX-License-Identifier: GPL-2.0
|
/*
|
* Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
|
*
|
* Based on the r8180 driver, which is:
|
* Copyright 2004-2005 Andrea Merello <andrea.merello@gmail.com>, et al.
|
*
|
* Contact Information: wlanfae <wlanfae@realtek.com>
|
*/
|
#include "rtl_ps.h"
|
#include "rtl_core.h"
|
#include "r8192E_phy.h"
|
#include "r8192E_phyreg.h"
|
#include "r8190P_rtl8256.h" /* RTL8225 Radio frontend */
|
#include "r8192E_cmdpkt.h"
|
#include <linux/jiffies.h>
|
|
static void _rtl92e_hw_sleep(struct net_device *dev)
|
{
|
struct r8192_priv *priv = rtllib_priv(dev);
|
unsigned long flags = 0;
|
|
spin_lock_irqsave(&priv->rf_ps_lock, flags);
|
if (priv->RFChangeInProgress) {
|
spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
|
RT_TRACE(COMP_DBG,
|
"%s(): RF Change in progress!\n", __func__);
|
return;
|
}
|
spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
|
RT_TRACE(COMP_DBG, "%s()============>come to sleep down\n", __func__);
|
|
rtl92e_set_rf_state(dev, eRfSleep, RF_CHANGE_BY_PS);
|
}
|
|
void rtl92e_hw_sleep_wq(void *data)
|
{
|
struct rtllib_device *ieee = container_of_dwork_rsl(data,
|
struct rtllib_device, hw_sleep_wq);
|
struct net_device *dev = ieee->dev;
|
|
_rtl92e_hw_sleep(dev);
|
}
|
|
void rtl92e_hw_wakeup(struct net_device *dev)
|
{
|
struct r8192_priv *priv = rtllib_priv(dev);
|
unsigned long flags = 0;
|
|
spin_lock_irqsave(&priv->rf_ps_lock, flags);
|
if (priv->RFChangeInProgress) {
|
spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
|
RT_TRACE(COMP_DBG,
|
"%s(): RF Change in progress!\n", __func__);
|
schedule_delayed_work(&priv->rtllib->hw_wakeup_wq,
|
msecs_to_jiffies(10));
|
return;
|
}
|
spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
|
RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __func__);
|
rtl92e_set_rf_state(dev, eRfOn, RF_CHANGE_BY_PS);
|
}
|
|
void rtl92e_hw_wakeup_wq(void *data)
|
{
|
struct rtllib_device *ieee = container_of_dwork_rsl(data,
|
struct rtllib_device, hw_wakeup_wq);
|
struct net_device *dev = ieee->dev;
|
|
rtl92e_hw_wakeup(dev);
|
}
|
|
#define MIN_SLEEP_TIME 50
|
#define MAX_SLEEP_TIME 10000
|
void rtl92e_enter_sleep(struct net_device *dev, u64 time)
|
{
|
struct r8192_priv *priv = rtllib_priv(dev);
|
|
u32 tmp;
|
unsigned long flags;
|
unsigned long timeout;
|
|
spin_lock_irqsave(&priv->ps_lock, flags);
|
|
time -= msecs_to_jiffies(8 + 16 + 7);
|
|
timeout = jiffies + msecs_to_jiffies(MIN_SLEEP_TIME);
|
if (time_before((unsigned long)time, timeout)) {
|
spin_unlock_irqrestore(&priv->ps_lock, flags);
|
netdev_info(dev, "too short to sleep::%lld < %ld\n",
|
time - jiffies, msecs_to_jiffies(MIN_SLEEP_TIME));
|
return;
|
}
|
timeout = jiffies + msecs_to_jiffies(MAX_SLEEP_TIME);
|
if (time_after((unsigned long)time, timeout)) {
|
netdev_info(dev, "========>too long to sleep:%lld > %ld\n",
|
time - jiffies, msecs_to_jiffies(MAX_SLEEP_TIME));
|
spin_unlock_irqrestore(&priv->ps_lock, flags);
|
return;
|
}
|
tmp = time - jiffies;
|
schedule_delayed_work(&priv->rtllib->hw_wakeup_wq, tmp);
|
schedule_delayed_work(&priv->rtllib->hw_sleep_wq, 0);
|
spin_unlock_irqrestore(&priv->ps_lock, flags);
|
}
|
|
static void _rtl92e_ps_update_rf_state(struct net_device *dev)
|
{
|
struct r8192_priv *priv = rtllib_priv(dev);
|
struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
|
&(priv->rtllib->PowerSaveControl);
|
|
RT_TRACE(COMP_PS, "%s() --------->\n", __func__);
|
pPSC->bSwRfProcessing = true;
|
|
RT_TRACE(COMP_PS, "%s(): Set RF to %s.\n", __func__,
|
pPSC->eInactivePowerState == eRfOff ? "OFF" : "ON");
|
rtl92e_set_rf_state(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
|
|
pPSC->bSwRfProcessing = false;
|
RT_TRACE(COMP_PS, "%s() <---------\n", __func__);
|
}
|
|
void rtl92e_ips_enter(struct net_device *dev)
|
{
|
struct r8192_priv *priv = rtllib_priv(dev);
|
struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
|
&(priv->rtllib->PowerSaveControl);
|
enum rt_rf_power_state rtState;
|
|
if (pPSC->bInactivePs) {
|
rtState = priv->rtllib->eRFPowerState;
|
if (rtState == eRfOn && !pPSC->bSwRfProcessing &&
|
(priv->rtllib->state != RTLLIB_LINKED) &&
|
(priv->rtllib->iw_mode != IW_MODE_MASTER)) {
|
RT_TRACE(COMP_PS, "%s(): Turn off RF.\n", __func__);
|
pPSC->eInactivePowerState = eRfOff;
|
priv->isRFOff = true;
|
priv->bInPowerSaveMode = true;
|
_rtl92e_ps_update_rf_state(dev);
|
}
|
}
|
}
|
|
void rtl92e_ips_leave(struct net_device *dev)
|
{
|
struct r8192_priv *priv = rtllib_priv(dev);
|
struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
|
&(priv->rtllib->PowerSaveControl);
|
enum rt_rf_power_state rtState;
|
|
if (pPSC->bInactivePs) {
|
rtState = priv->rtllib->eRFPowerState;
|
if (rtState != eRfOn && !pPSC->bSwRfProcessing &&
|
priv->rtllib->RfOffReason <= RF_CHANGE_BY_IPS) {
|
RT_TRACE(COMP_PS, "%s(): Turn on RF.\n", __func__);
|
pPSC->eInactivePowerState = eRfOn;
|
priv->bInPowerSaveMode = false;
|
_rtl92e_ps_update_rf_state(dev);
|
}
|
}
|
}
|
|
void rtl92e_ips_leave_wq(void *data)
|
{
|
struct rtllib_device *ieee = container_of_work_rsl(data,
|
struct rtllib_device, ips_leave_wq);
|
struct net_device *dev = ieee->dev;
|
struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
|
|
mutex_lock(&priv->rtllib->ips_mutex);
|
rtl92e_ips_leave(dev);
|
mutex_unlock(&priv->rtllib->ips_mutex);
|
}
|
|
void rtl92e_rtllib_ips_leave_wq(struct net_device *dev)
|
{
|
struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
|
enum rt_rf_power_state rtState;
|
|
rtState = priv->rtllib->eRFPowerState;
|
|
if (priv->rtllib->PowerSaveControl.bInactivePs) {
|
if (rtState == eRfOff) {
|
if (priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS) {
|
netdev_warn(dev, "%s(): RF is OFF.\n",
|
__func__);
|
return;
|
}
|
netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n",
|
__func__);
|
schedule_work(&priv->rtllib->ips_leave_wq);
|
}
|
}
|
}
|
|
void rtl92e_rtllib_ips_leave(struct net_device *dev)
|
{
|
struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
|
|
mutex_lock(&priv->rtllib->ips_mutex);
|
rtl92e_ips_leave(dev);
|
mutex_unlock(&priv->rtllib->ips_mutex);
|
}
|
|
static bool _rtl92e_ps_set_mode(struct net_device *dev, u8 rtPsMode)
|
{
|
struct r8192_priv *priv = rtllib_priv(dev);
|
|
if (priv->rtllib->iw_mode == IW_MODE_ADHOC)
|
return false;
|
|
RT_TRACE(COMP_LPS, "%s(): set ieee->ps = %x\n", __func__, rtPsMode);
|
if (!priv->ps_force)
|
priv->rtllib->ps = rtPsMode;
|
if (priv->rtllib->sta_sleep != LPS_IS_WAKE &&
|
rtPsMode == RTLLIB_PS_DISABLED) {
|
unsigned long flags;
|
|
rtl92e_hw_wakeup(dev);
|
priv->rtllib->sta_sleep = LPS_IS_WAKE;
|
|
spin_lock_irqsave(&(priv->rtllib->mgmt_tx_lock), flags);
|
RT_TRACE(COMP_DBG,
|
"LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
|
rtllib_sta_ps_send_null_frame(priv->rtllib, 0);
|
spin_unlock_irqrestore(&(priv->rtllib->mgmt_tx_lock), flags);
|
}
|
|
return true;
|
}
|
|
void rtl92e_leisure_ps_enter(struct net_device *dev)
|
{
|
struct r8192_priv *priv = rtllib_priv(dev);
|
struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
|
&(priv->rtllib->PowerSaveControl);
|
|
RT_TRACE(COMP_PS, "%s()...\n", __func__);
|
RT_TRACE(COMP_PS,
|
"pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
|
pPSC->bLeisurePs, priv->rtllib->ps, pPSC->LpsIdleCount,
|
RT_CHECK_FOR_HANG_PERIOD);
|
|
if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) &&
|
(priv->rtllib->state == RTLLIB_LINKED))
|
|| (priv->rtllib->iw_mode == IW_MODE_ADHOC) ||
|
(priv->rtllib->iw_mode == IW_MODE_MASTER))
|
return;
|
|
if (pPSC->bLeisurePs) {
|
if (pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) {
|
|
if (priv->rtllib->ps == RTLLIB_PS_DISABLED) {
|
|
RT_TRACE(COMP_LPS,
|
"%s(): Enter 802.11 power save mode...\n", __func__);
|
|
if (!pPSC->bFwCtrlLPS) {
|
if (priv->rtllib->SetFwCmdHandler)
|
priv->rtllib->SetFwCmdHandler(
|
dev, FW_CMD_LPS_ENTER);
|
}
|
_rtl92e_ps_set_mode(dev, RTLLIB_PS_MBCAST |
|
RTLLIB_PS_UNICAST);
|
}
|
} else
|
pPSC->LpsIdleCount++;
|
}
|
}
|
|
void rtl92e_leisure_ps_leave(struct net_device *dev)
|
{
|
struct r8192_priv *priv = rtllib_priv(dev);
|
struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
|
&(priv->rtllib->PowerSaveControl);
|
|
|
RT_TRACE(COMP_PS, "%s()...\n", __func__);
|
RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d\n",
|
pPSC->bLeisurePs, priv->rtllib->ps);
|
|
if (pPSC->bLeisurePs) {
|
if (priv->rtllib->ps != RTLLIB_PS_DISABLED) {
|
RT_TRACE(COMP_LPS,
|
"%s(): Busy Traffic , Leave 802.11 power save..\n", __func__);
|
_rtl92e_ps_set_mode(dev, RTLLIB_PS_DISABLED);
|
|
if (!pPSC->bFwCtrlLPS) {
|
if (priv->rtllib->SetFwCmdHandler)
|
priv->rtllib->SetFwCmdHandler(dev,
|
FW_CMD_LPS_LEAVE);
|
}
|
}
|
}
|
}
|
