[deliverable/linux.git] / drivers / staging / rtl8192e / rtl8192e / rtl_ps.c

/******************************************************************************
 * 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.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * 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,
			 "_rtl92e_hw_sleep(): RF Change in progress!\n");
		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,
			 "rtl92e_hw_wakeup(): RF Change in progress!\n");
		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, "_rtl92e_ps_update_rf_state() --------->\n");
	pPSC->bSwRfProcessing = true;

	RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state(): Set RF to %s.\n",
		 pPSC->eInactivePowerState == eRfOff ? "OFF" : "ON");
	rtl92e_set_rf_state(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);

	pPSC->bSwRfProcessing = false;
	RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state() <---------\n");
}

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, "rtl92e_ips_enter(): Turn off RF.\n");
			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, "rtl92e_ips_leave(): Turn on RF.\n");
			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, "rtl92e_leisure_ps_enter()...\n");
	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,
					 "rtl92e_leisure_ps_enter(): Enter 802.11 power save mode...\n");

				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, "rtl92e_leisure_ps_leave()...\n");
	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,
				 "rtl92e_leisure_ps_leave(): Busy Traffic , Leave 802.11 power save..\n");
			_rtl92e_ps_set_mode(dev, RTLLIB_PS_DISABLED);

			if (!pPSC->bFwCtrlLPS) {
				if (priv->rtllib->SetFwCmdHandler)
					priv->rtllib->SetFwCmdHandler(dev,
							 FW_CMD_LPS_LEAVE);
		    }
		}
	}
}
Commit	Line	Data
94a79942 LF	1	/******************************************************************************
	2	* Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
	3	*
	4	* Based on the r8180 driver, which is:
559a4c31	5	* Copyright 2004-2005 Andrea Merello <andrea.merello@gmail.com>, et al.
94a79942 LF	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	*
94a79942 LF	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"
b68cecbe	27	#include <linux/jiffies.h>
94a79942	28
3831d405	29	static void _rtl92e_hw_sleep(struct net_device *dev)
94a79942 LF	30	{
	31	struct r8192_priv *priv = rtllib_priv(dev);
	32	unsigned long flags = 0;
3a6b70c3	33
08d348a0	34	spin_lock_irqsave(&priv->rf_ps_lock, flags);
94a79942	35	if (priv->RFChangeInProgress) {
08d348a0	36	spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
0822339b	37	RT_TRACE(COMP_DBG,
3831d405	38	"_rtl92e_hw_sleep(): RF Change in progress!\n");
94a79942 LF	39	return;
94a79942 LF	40	}
08d348a0	41	spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
94a79942 LF	42	RT_TRACE(COMP_DBG, "%s()============>come to sleep down\n", __func__);
94a79942 LF	43
2937a5d2	44	rtl92e_set_rf_state(dev, eRfSleep, RF_CHANGE_BY_PS);
94a79942 LF	45	}
94a79942 LF	46
bcdcc1ea	47	void rtl92e_hw_sleep_wq(void *data)
94a79942	48	{
08d348a0 LF	49	struct rtllib_device *ieee = container_of_dwork_rsl(data,
08d348a0 LF	50	struct rtllib_device, hw_sleep_wq);
94a79942	51	struct net_device *dev = ieee->dev;
3a6b70c3	52
3831d405	53	_rtl92e_hw_sleep(dev);
94a79942 LF	54	}
94a79942 LF	55
43bcb3b4	56	void rtl92e_hw_wakeup(struct net_device *dev)
94a79942 LF	57	{
	58	struct r8192_priv *priv = rtllib_priv(dev);
	59	unsigned long flags = 0;
3a6b70c3	60
08d348a0	61	spin_lock_irqsave(&priv->rf_ps_lock, flags);
94a79942	62	if (priv->RFChangeInProgress) {
08d348a0	63	spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
0822339b	64	RT_TRACE(COMP_DBG,
43bcb3b4	65	"rtl92e_hw_wakeup(): RF Change in progress!\n");
354605f4 AKC	66	schedule_delayed_work(&priv->rtllib->hw_wakeup_wq,
354605f4 AKC	67	msecs_to_jiffies(10));
94a79942 LF	68	return;
94a79942 LF	69	}
08d348a0	70	spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
94a79942	71	RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __func__);
2937a5d2	72	rtl92e_set_rf_state(dev, eRfOn, RF_CHANGE_BY_PS);
94a79942 LF	73	}
94a79942 LF	74
c34b29f7	75	void rtl92e_hw_wakeup_wq(void *data)
94a79942	76	{
08d348a0 LF	77	struct rtllib_device *ieee = container_of_dwork_rsl(data,
08d348a0 LF	78	struct rtllib_device, hw_wakeup_wq);
94a79942	79	struct net_device *dev = ieee->dev;
94a79942	80
43bcb3b4	81	rtl92e_hw_wakeup(dev);
94a79942 LF	82	}
	83
	84	#define MIN_SLEEP_TIME 50
	85	#define MAX_SLEEP_TIME 10000
feb257e5	86	void rtl92e_enter_sleep(struct net_device *dev, u64 time)
94a79942 LF	87	{
	88	struct r8192_priv *priv = rtllib_priv(dev);
	89
0dd56506	90	u32 tmp;
94a79942	91	unsigned long flags;
b68cecbe	92	unsigned long timeout;
94a79942	93
08d348a0	94	spin_lock_irqsave(&priv->ps_lock, flags);
94a79942	95
8b9733c1	96	time -= msecs_to_jiffies(8 + 16 + 7);
94a79942	97
e32e1928	98	timeout = jiffies + msecs_to_jiffies(MIN_SLEEP_TIME);
512e9031	99	if (time_before((unsigned long)time, timeout)) {
08d348a0	100	spin_unlock_irqrestore(&priv->ps_lock, flags);
d69d2054 MK	101	netdev_info(dev, "too short to sleep::%lld < %ld\n",
d69d2054 MK	102	time - jiffies, msecs_to_jiffies(MIN_SLEEP_TIME));
94a79942 LF	103	return;
94a79942 LF	104	}
b68cecbe GEHP	105	timeout = jiffies + msecs_to_jiffies(MAX_SLEEP_TIME);
b68cecbe GEHP	106	if (time_after((unsigned long)time, timeout)) {
d69d2054 MK	107	netdev_info(dev, "========>too long to sleep:%lld > %ld\n",
d69d2054 MK	108	time - jiffies, msecs_to_jiffies(MAX_SLEEP_TIME));
08d348a0	109	spin_unlock_irqrestore(&priv->ps_lock, flags);
94a79942 LF	110	return;
94a79942 LF	111	}
0dd56506	112	tmp = time - jiffies;
354605f4 AKC	113	schedule_delayed_work(&priv->rtllib->hw_wakeup_wq, tmp);
354605f4 AKC	114	schedule_delayed_work(&priv->rtllib->hw_sleep_wq, 0);
08d348a0	115	spin_unlock_irqrestore(&priv->ps_lock, flags);
94a79942 LF	116	}
94a79942 LF	117
fcc3df4f	118	static void _rtl92e_ps_update_rf_state(struct net_device *dev)
94a79942 LF	119	{
94a79942 LF	120	struct r8192_priv *priv = rtllib_priv(dev);
08d348a0 LF	121	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )
08d348a0 LF	122	&(priv->rtllib->PowerSaveControl);
94a79942	123
fcc3df4f	124	RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state() --------->\n");
94a79942 LF	125	pPSC->bSwRfProcessing = true;
94a79942 LF	126
fcc3df4f	127	RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state(): Set RF to %s.\n",
08d348a0	128	pPSC->eInactivePowerState == eRfOff ? "OFF" : "ON");
2937a5d2	129	rtl92e_set_rf_state(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
94a79942	130
94a79942	131	pPSC->bSwRfProcessing = false;
fcc3df4f	132	RT_TRACE(COMP_PS, "_rtl92e_ps_update_rf_state() <---------\n");
94a79942 LF	133	}
94a79942 LF	134
410d6fc9	135	void rtl92e_ips_enter(struct net_device *dev)
94a79942 LF	136	{
94a79942 LF	137	struct r8192_priv *priv = rtllib_priv(dev);
08d348a0 LF	138	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )
08d348a0 LF	139	&(priv->rtllib->PowerSaveControl);
de7c885a	140	enum rt_rf_power_state rtState;
94a79942	141
08d348a0	142	if (pPSC->bInactivePs) {
94a79942	143	rtState = priv->rtllib->eRFPowerState;
08d348a0 LF	144	if (rtState == eRfOn && !pPSC->bSwRfProcessing &&
	145	(priv->rtllib->state != RTLLIB_LINKED) &&
	146	(priv->rtllib->iw_mode != IW_MODE_MASTER)) {
410d6fc9	147	RT_TRACE(COMP_PS, "rtl92e_ips_enter(): Turn off RF.\n");
94a79942 LF	148	pPSC->eInactivePowerState = eRfOff;
	149	priv->isRFOff = true;
	150	priv->bInPowerSaveMode = true;
fcc3df4f	151	_rtl92e_ps_update_rf_state(dev);
94a79942 LF	152	}
	153	}
	154	}
	155
2ab2aba2	156	void rtl92e_ips_leave(struct net_device *dev)
94a79942 LF	157	{
94a79942 LF	158	struct r8192_priv *priv = rtllib_priv(dev);
08d348a0 LF	159	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )
08d348a0 LF	160	&(priv->rtllib->PowerSaveControl);
de7c885a	161	enum rt_rf_power_state rtState;
94a79942	162
08d348a0	163	if (pPSC->bInactivePs) {
94a79942	164	rtState = priv->rtllib->eRFPowerState;
08d348a0 LF	165	if (rtState != eRfOn && !pPSC->bSwRfProcessing &&
08d348a0 LF	166	priv->rtllib->RfOffReason <= RF_CHANGE_BY_IPS) {
2ab2aba2	167	RT_TRACE(COMP_PS, "rtl92e_ips_leave(): Turn on RF.\n");
94a79942 LF	168	pPSC->eInactivePowerState = eRfOn;
94a79942 LF	169	priv->bInPowerSaveMode = false;
fcc3df4f	170	_rtl92e_ps_update_rf_state(dev);
94a79942 LF	171	}
	172	}
	173	}
08d348a0	174
a514c798	175	void rtl92e_ips_leave_wq(void *data)
94a79942	176	{
08d348a0 LF	177	struct rtllib_device *ieee = container_of_work_rsl(data,
08d348a0 LF	178	struct rtllib_device, ips_leave_wq);
94a79942 LF	179	struct net_device *dev = ieee->dev;
94a79942 LF	180	struct r8192_priv priv = (struct r8192_priv )rtllib_priv(dev);
3a6b70c3	181
38bee763	182	mutex_lock(&priv->rtllib->ips_mutex);
2ab2aba2	183	rtl92e_ips_leave(dev);
38bee763	184	mutex_unlock(&priv->rtllib->ips_mutex);
94a79942 LF	185	}
94a79942 LF	186
d66e938e	187	void rtl92e_rtllib_ips_leave_wq(struct net_device *dev)
94a79942 LF	188	{
94a79942 LF	189	struct r8192_priv priv = (struct r8192_priv )rtllib_priv(dev);
de7c885a	190	enum rt_rf_power_state rtState;
3a6b70c3	191
94a79942 LF	192	rtState = priv->rtllib->eRFPowerState;
94a79942 LF	193
08d348a0 LF	194	if (priv->rtllib->PowerSaveControl.bInactivePs) {
	195	if (rtState == eRfOff) {
	196	if (priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS) {
3b4140af MK	197	netdev_warn(dev, "%s(): RF is OFF.\n",
3b4140af MK	198	__func__);
94a79942	199	return;
94a79942	200	}
2ab2aba2	201	netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n",
285b7c00	202	__func__);
354605f4	203	schedule_work(&priv->rtllib->ips_leave_wq);
94a79942 LF	204	}
	205	}
	206	}
08d348a0	207
bf135a16	208	void rtl92e_rtllib_ips_leave(struct net_device *dev)
94a79942 LF	209	{
94a79942 LF	210	struct r8192_priv priv = (struct r8192_priv )rtllib_priv(dev);
3a6b70c3	211
38bee763	212	mutex_lock(&priv->rtllib->ips_mutex);
2ab2aba2	213	rtl92e_ips_leave(dev);
38bee763	214	mutex_unlock(&priv->rtllib->ips_mutex);
94a79942 LF	215	}
94a79942 LF	216
79f387e7	217	static bool _rtl92e_ps_set_mode(struct net_device *dev, u8 rtPsMode)
94a79942 LF	218	{
	219	struct r8192_priv *priv = rtllib_priv(dev);
	220
	221	if (priv->rtllib->iw_mode == IW_MODE_ADHOC)
	222	return false;
	223
08d348a0 LF	224	RT_TRACE(COMP_LPS, "%s(): set ieee->ps = %x\n", __func__, rtPsMode);
08d348a0 LF	225	if (!priv->ps_force)
94a79942	226	priv->rtllib->ps = rtPsMode;
08d348a0 LF	227	if (priv->rtllib->sta_sleep != LPS_IS_WAKE &&
	228	rtPsMode == RTLLIB_PS_DISABLED) {
	229	unsigned long flags;
94a79942	230
43bcb3b4	231	rtl92e_hw_wakeup(dev);
94a79942 LF	232	priv->rtllib->sta_sleep = LPS_IS_WAKE;
94a79942 LF	233
08d348a0	234	spin_lock_irqsave(&(priv->rtllib->mgmt_tx_lock), flags);
0822339b MK	235	RT_TRACE(COMP_DBG,
0822339b MK	236	"LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
94a79942	237	rtllib_sta_ps_send_null_frame(priv->rtllib, 0);
08d348a0	238	spin_unlock_irqrestore(&(priv->rtllib->mgmt_tx_lock), flags);
94a79942 LF	239	}
	240
	241	return true;
	242	}
	243
04197ef2	244	void rtl92e_leisure_ps_enter(struct net_device *dev)
94a79942 LF	245	{
94a79942 LF	246	struct r8192_priv *priv = rtllib_priv(dev);
08d348a0 LF	247	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )
08d348a0 LF	248	&(priv->rtllib->PowerSaveControl);
94a79942	249
04197ef2	250	RT_TRACE(COMP_PS, "rtl92e_leisure_ps_enter()...\n");
0822339b MK	251	RT_TRACE(COMP_PS,
0822339b MK	252	"pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
08d348a0 LF	253	pPSC->bLeisurePs, priv->rtllib->ps, pPSC->LpsIdleCount,
	254	RT_CHECK_FOR_HANG_PERIOD);
	255
	256	if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) &&
	257	(priv->rtllib->state == RTLLIB_LINKED))
	258	\|\| (priv->rtllib->iw_mode == IW_MODE_ADHOC) \|\|
	259	(priv->rtllib->iw_mode == IW_MODE_MASTER))
94a79942 LF	260	return;
	261
	262	if (pPSC->bLeisurePs) {
	263	if (pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) {
	264
	265	if (priv->rtllib->ps == RTLLIB_PS_DISABLED) {
	266
0822339b	267	RT_TRACE(COMP_LPS,
04197ef2	268	"rtl92e_leisure_ps_enter(): Enter 802.11 power save mode...\n");
94a79942 LF	269
	270	if (!pPSC->bFwCtrlLPS) {
	271	if (priv->rtllib->SetFwCmdHandler)
08d348a0 LF	272	priv->rtllib->SetFwCmdHandler(
08d348a0 LF	273	dev, FW_CMD_LPS_ENTER);
94a79942	274	}
79f387e7	275	_rtl92e_ps_set_mode(dev, RTLLIB_PS_MBCAST \|
08d348a0	276	RTLLIB_PS_UNICAST);
94a79942 LF	277	}
	278	} else
	279	pPSC->LpsIdleCount++;
	280	}
	281	}
	282
9c4a55d1	283	void rtl92e_leisure_ps_leave(struct net_device *dev)
94a79942 LF	284	{
94a79942 LF	285	struct r8192_priv *priv = rtllib_priv(dev);
08d348a0 LF	286	struct rt_pwr_save_ctrl pPSC = (struct rt_pwr_save_ctrl )
08d348a0 LF	287	&(priv->rtllib->PowerSaveControl);
94a79942 LF	288
94a79942 LF	289
9c4a55d1	290	RT_TRACE(COMP_PS, "rtl92e_leisure_ps_leave()...\n");
94a79942 LF	291	RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d\n",
	292	pPSC->bLeisurePs, priv->rtllib->ps);
	293
08d348a0 LF	294	if (pPSC->bLeisurePs) {
08d348a0 LF	295	if (priv->rtllib->ps != RTLLIB_PS_DISABLED) {
0822339b	296	RT_TRACE(COMP_LPS,
9c4a55d1	297	"rtl92e_leisure_ps_leave(): Busy Traffic , Leave 802.11 power save..\n");
79f387e7	298	_rtl92e_ps_set_mode(dev, RTLLIB_PS_DISABLED);
94a79942	299
08d348a0	300	if (!pPSC->bFwCtrlLPS) {
94a79942	301	if (priv->rtllib->SetFwCmdHandler)
08d348a0 LF	302	priv->rtllib->SetFwCmdHandler(dev,
	303	FW_CMD_LPS_LEAVE);
	304	}
94a79942 LF	305	}
	306	}
	307	}