rtlwifi: Update power-save routines for 062814 driver (d3feae41) · Commits · e / devices / android_kernel_xiaomi_nabu

drivers/net/wireless/rtlwifi/ps.c

+124 −159

Original line number	Diff line number	Diff line
		@@ -11,10 +11,6 @@
		* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
		* more details.
		*
		* You should have received a copy of the GNU General Public License along with
		* this program; if not, write to the Free Software Foundation, Inc.,
		* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
		*
		* The full GNU General Public License is included in this distribution in the
		* file called LICENSE.
		*
		@@ -27,110 +23,11 @@
		*
		*****************************************************************************/

		#include <linux/export.h>
		#include "wifi.h"
		#include "base.h"
		#include "ps.h"

		/* Description:
		* This routine deals with the Power Configuration CMD
		* parsing for RTL8723/RTL8188E Series IC.
		* Assumption:
		* We should follow specific format that was released from HW SD.
		*/
		bool rtl_hal_pwrseqcmdparsing(struct rtl_priv *rtlpriv, u8 cut_version,
		u8 faversion, u8 interface_type,
		struct wlan_pwr_cfg pwrcfgcmd[])
		{
		struct wlan_pwr_cfg cfg_cmd = {0};
		bool polling_bit = false;
		u32 ary_idx = 0;
		u8 value = 0;
		u32 offset = 0;
		u32 polling_count = 0;
		u32 max_polling_cnt = 5000;

		do {
		cfg_cmd = pwrcfgcmd[ary_idx];
		RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
		"rtl_hal_pwrseqcmdparsing(): offset(%#x),cut_msk(%#x), famsk(%#x),"
		"interface_msk(%#x), base(%#x), cmd(%#x), msk(%#x), value(%#x)\n",
		GET_PWR_CFG_OFFSET(cfg_cmd),
		GET_PWR_CFG_CUT_MASK(cfg_cmd),
		GET_PWR_CFG_FAB_MASK(cfg_cmd),
		GET_PWR_CFG_INTF_MASK(cfg_cmd),
		GET_PWR_CFG_BASE(cfg_cmd), GET_PWR_CFG_CMD(cfg_cmd),
		GET_PWR_CFG_MASK(cfg_cmd), GET_PWR_CFG_VALUE(cfg_cmd));

		if ((GET_PWR_CFG_FAB_MASK(cfg_cmd)&faversion) &&
		(GET_PWR_CFG_CUT_MASK(cfg_cmd)&cut_version) &&
		(GET_PWR_CFG_INTF_MASK(cfg_cmd)&interface_type)) {
		switch (GET_PWR_CFG_CMD(cfg_cmd)) {
		case PWR_CMD_READ:
		RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
		"rtl_hal_pwrseqcmdparsing(): PWR_CMD_READ\n");
		break;
		case PWR_CMD_WRITE:
		RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
		"rtl_hal_pwrseqcmdparsing(): PWR_CMD_WRITE\n");
		offset = GET_PWR_CFG_OFFSET(cfg_cmd);

		/Read the value from system register/
		value = rtl_read_byte(rtlpriv, offset);
		value &= (~(GET_PWR_CFG_MASK(cfg_cmd)));
		value \|= (GET_PWR_CFG_VALUE(cfg_cmd) &
		GET_PWR_CFG_MASK(cfg_cmd));

		/Write the value back to sytem register/
		rtl_write_byte(rtlpriv, offset, value);
		break;
		case PWR_CMD_POLLING:
		RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
		"rtl_hal_pwrseqcmdparsing(): PWR_CMD_POLLING\n");
		polling_bit = false;
		offset = GET_PWR_CFG_OFFSET(cfg_cmd);

		do {
		value = rtl_read_byte(rtlpriv, offset);

		value &= GET_PWR_CFG_MASK(cfg_cmd);
		if (value ==
		(GET_PWR_CFG_VALUE(cfg_cmd)
		& GET_PWR_CFG_MASK(cfg_cmd)))
		polling_bit = true;
		else
		udelay(10);

		if (polling_count++ > max_polling_cnt)
		return false;
		} while (!polling_bit);
		break;
		case PWR_CMD_DELAY:
		RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
		"rtl_hal_pwrseqcmdparsing(): PWR_CMD_DELAY\n");
		if (GET_PWR_CFG_VALUE(cfg_cmd) ==
		PWRSEQ_DELAY_US)
		udelay(GET_PWR_CFG_OFFSET(cfg_cmd));
		else
		mdelay(GET_PWR_CFG_OFFSET(cfg_cmd));
		break;
		case PWR_CMD_END:
		RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
		"rtl_hal_pwrseqcmdparsing(): PWR_CMD_END\n");
		return true;
		default:
		RT_ASSERT(false,
		"rtl_hal_pwrseqcmdparsing(): Unknown CMD!!\n");
		break;
		}

		}
		ary_idx++;
		} while (1);

		return true;
		}
		EXPORT_SYMBOL(rtl_hal_pwrseqcmdparsing);
		#include <linux/export.h>
		#include "btcoexist/rtl_btc.h"

		bool rtl_ps_enable_nic(struct ieee80211_hw *hw)
		{
		@@ -181,11 +78,49 @@ EXPORT_SYMBOL(rtl_ps_disable_nic);

		bool rtl_ps_set_rf_state(struct ieee80211_hw *hw,
		enum rf_pwrstate state_toset,
		u32 changesource)
		u32 changesource, bool protect_or_not)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);
		struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
		enum rf_pwrstate rtstate;
		bool actionallowed = false;
		u16 rfwait_cnt = 0;

		if (protect_or_not)
		goto no_protect;

		/*Only one thread can change
		*the RF state at one time, and others
		*should wait to be executed.
		*/
		while (true) {
		spin_lock(&rtlpriv->locks.rf_ps_lock);
		if (ppsc->rfchange_inprogress) {
		spin_unlock(&rtlpriv->locks.rf_ps_lock);

		RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
		"RF Change in progress! Wait to set..state_toset(%d).\n",
		state_toset);

		/* Set RF after the previous action is done. */
		while (ppsc->rfchange_inprogress) {
		rfwait_cnt++;
		mdelay(1);
		/*Wait too long, return false to avoid
		*to be stuck here.
		*/
		if (rfwait_cnt > 100)
		return false;
		}
		} else {
		ppsc->rfchange_inprogress = true;
		spin_unlock(&rtlpriv->locks.rf_ps_lock);
		break;
		}
		}

		no_protect:
		rtstate = ppsc->rfpwr_state;

		switch (state_toset) {
		case ERFON:
		@@ -227,6 +162,12 @@ bool rtl_ps_set_rf_state(struct ieee80211_hw *hw,
		if (actionallowed)
		rtlpriv->cfg->ops->set_rf_power_state(hw, state_toset);

		if (!protect_or_not) {
		spin_lock(&rtlpriv->locks.rf_ps_lock);
		ppsc->rfchange_inprogress = false;
		spin_unlock(&rtlpriv->locks.rf_ps_lock);
		}

		return actionallowed;
		}
		EXPORT_SYMBOL(rtl_ps_set_rf_state);
		@@ -249,7 +190,8 @@ static void _rtl_ps_inactive_ps(struct ieee80211_hw *hw)
		}
		}

		rtl_ps_set_rf_state(hw, ppsc->inactive_pwrstate, RF_CHANGE_BY_IPS);
		rtl_ps_set_rf_state(hw, ppsc->inactive_pwrstate,
		RF_CHANGE_BY_IPS, false);

		if (ppsc->inactive_pwrstate == ERFOFF &&
		rtlhal->interface == INTF_PCI) {
		@@ -318,6 +260,11 @@ void rtl_ips_nic_off_wq_callback(void *data)
		ppsc->inactive_pwrstate = ERFOFF;
		ppsc->in_powersavemode = true;

		/* call before RF off */
		if (rtlpriv->cfg->ops->get_btc_status())
		rtlpriv->btcoexist.btc_ops->btc_ips_notify(rtlpriv,
		ppsc->inactive_pwrstate);

		/rtl_pci_reset_trx_ring(hw); /
		_rtl_ps_inactive_ps(hw);
		}
		@@ -328,8 +275,7 @@ void rtl_ips_nic_off(struct ieee80211_hw *hw)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);

		/*
		*because when link with ap, mac80211 will ask us
		/* because when link with ap, mac80211 will ask us
		* to disable nic quickly after scan before linking,
		* this will cause link failed, so we delay 100ms here
		*/
		@@ -343,16 +289,12 @@ void rtl_ips_nic_off(struct ieee80211_hw *hw)
		void rtl_ips_nic_on(struct ieee80211_hw *hw)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);
		struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
		struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
		enum rf_pwrstate rtstate;
		unsigned long flags;

		if (mac->opmode != NL80211_IFTYPE_STATION)
		return;

		spin_lock_irqsave(&rtlpriv->locks.ips_lock, flags);
		cancel_delayed_work(&rtlpriv->works.ips_nic_off_wq);

		spin_lock(&rtlpriv->locks.ips_lock);
		if (ppsc->inactiveps) {
		rtstate = ppsc->rfpwr_state;

		@@ -362,12 +304,14 @@ void rtl_ips_nic_on(struct ieee80211_hw *hw)

		ppsc->inactive_pwrstate = ERFON;
		ppsc->in_powersavemode = false;

		_rtl_ps_inactive_ps(hw);
		/* call after RF on */
		if (rtlpriv->cfg->ops->get_btc_status())
		rtlpriv->btcoexist.btc_ops->btc_ips_notify(rtlpriv,
		ppsc->inactive_pwrstate);
		}
		}

		spin_unlock_irqrestore(&rtlpriv->locks.ips_lock, flags);
		spin_unlock(&rtlpriv->locks.ips_lock);
		}
		EXPORT_SYMBOL_GPL(rtl_ips_nic_on);

		@@ -404,7 +348,7 @@ static bool rtl_get_fwlps_doze(struct ieee80211_hw *hw)
		}

		/* Change current and default preamble mode.*/
		static void rtl_lps_set_psmode(struct ieee80211_hw *hw, u8 rt_psmode)
		void rtl_lps_set_psmode(struct ieee80211_hw *hw, u8 rt_psmode)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);
		struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
		@@ -441,17 +385,20 @@ static void rtl_lps_set_psmode(struct ieee80211_hw *hw, u8 rt_psmode)
		enter_fwlps = false;
		ppsc->pwr_mode = FW_PS_ACTIVE_MODE;
		ppsc->smart_ps = 0;
		rtlpriv->cfg->ops->set_hw_reg(hw,
		HW_VAR_FW_LPS_ACTION,
		rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_FW_LPS_ACTION,
		(u8 *)(&enter_fwlps));
		if (ppsc->p2p_ps_info.opp_ps)
		rtl_p2p_ps_cmd(hw , P2P_PS_ENABLE);

		if (rtlpriv->cfg->ops->get_btc_status())
		rtlpriv->btcoexist.btc_ops->btc_lps_notify(rtlpriv, rt_psmode);
		} else {
		if (rtl_get_fwlps_doze(hw)) {
		RT_TRACE(rtlpriv, COMP_RF, DBG_DMESG,
		"FW LPS enter ps_mode:%x\n",
		ppsc->fwctrl_psmode);
		if (rtlpriv->cfg->ops->get_btc_status())
		rtlpriv->btcoexist.btc_ops->btc_lps_notify(rtlpriv, rt_psmode);
		enter_fwlps = true;
		ppsc->pwr_mode = ppsc->fwctrl_psmode;
		ppsc->smart_ps = 2;
		@@ -473,6 +420,7 @@ void rtl_lps_enter(struct ieee80211_hw *hw)
		struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
		struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
		struct rtl_priv *rtlpriv = rtl_priv(hw);
		unsigned long flag;

		if (!ppsc->fwctrl_lps)
		return;
		@@ -493,7 +441,7 @@ void rtl_lps_enter(struct ieee80211_hw *hw)
		if (mac->link_state != MAC80211_LINKED)
		return;

		mutex_lock(&rtlpriv->locks.ps_mutex);
		spin_lock_irqsave(&rtlpriv->locks.lps_lock, flag);

		/* Idle for a while if we connect to AP a while ago. */
		if (mac->cnt_after_linked >= 2) {
		@@ -505,8 +453,9 @@ void rtl_lps_enter(struct ieee80211_hw *hw)
		}
		}

		mutex_unlock(&rtlpriv->locks.ps_mutex);
		spin_unlock_irqrestore(&rtlpriv->locks.lps_lock, flag);
		}
		EXPORT_SYMBOL(rtl_lps_enter);

		/Leave the leisure power save mode./
		void rtl_lps_leave(struct ieee80211_hw *hw)
		@@ -514,14 +463,15 @@ void rtl_lps_leave(struct ieee80211_hw *hw)
		struct rtl_priv *rtlpriv = rtl_priv(hw);
		struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
		struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
		unsigned long flag;

		mutex_lock(&rtlpriv->locks.ps_mutex);
		spin_lock_irqsave(&rtlpriv->locks.lps_lock, flag);

		if (ppsc->fwctrl_lps) {
		if (ppsc->dot11_psmode != EACTIVE) {

		/FIX ME /
		rtlpriv->cfg->ops->enable_interrupt(hw);
		/rtlpriv->cfg->ops->enable_interrupt(hw); /

		if (ppsc->reg_rfps_level & RT_RF_LPS_LEVEL_ASPM &&
		RT_IN_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM) &&
		@@ -536,8 +486,9 @@ void rtl_lps_leave(struct ieee80211_hw *hw)
		rtl_lps_set_psmode(hw, EACTIVE);
		}
		}
		mutex_unlock(&rtlpriv->locks.ps_mutex);
		spin_unlock_irqrestore(&rtlpriv->locks.lps_lock, flag);
		}
		EXPORT_SYMBOL(rtl_lps_leave);

		/* For sw LPS*/
		void rtl_swlps_beacon(struct ieee80211_hw hw, void data, unsigned int len)
		@@ -626,6 +577,7 @@ void rtl_swlps_rf_awake(struct ieee80211_hw *hw)
		struct rtl_priv *rtlpriv = rtl_priv(hw);
		struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
		struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
		unsigned long flag;

		if (!rtlpriv->psc.swctrl_lps)
		return;
		@@ -638,9 +590,9 @@ void rtl_swlps_rf_awake(struct ieee80211_hw *hw)
		RT_CLEAR_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM);
		}

		mutex_lock(&rtlpriv->locks.ps_mutex);
		rtl_ps_set_rf_state(hw, ERFON, RF_CHANGE_BY_PS);
		mutex_unlock(&rtlpriv->locks.ps_mutex);
		spin_lock_irqsave(&rtlpriv->locks.lps_lock, flag);
		rtl_ps_set_rf_state(hw, ERFON, RF_CHANGE_BY_PS, false);
		spin_unlock_irqrestore(&rtlpriv->locks.lps_lock, flag);
		}

		void rtl_swlps_rfon_wq_callback(void *data)
		@@ -657,6 +609,7 @@ void rtl_swlps_rf_sleep(struct ieee80211_hw *hw)
		struct rtl_priv *rtlpriv = rtl_priv(hw);
		struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
		struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
		unsigned long flag;
		u8 sleep_intv;

		if (!rtlpriv->psc.sw_ps_enabled)
		@@ -673,9 +626,16 @@ void rtl_swlps_rf_sleep(struct ieee80211_hw *hw)
		if (rtlpriv->link_info.busytraffic)
		return;

		mutex_lock(&rtlpriv->locks.ps_mutex);
		rtl_ps_set_rf_state(hw, ERFSLEEP, RF_CHANGE_BY_PS);
		mutex_unlock(&rtlpriv->locks.ps_mutex);
		spin_lock(&rtlpriv->locks.rf_ps_lock);
		if (rtlpriv->psc.rfchange_inprogress) {
		spin_unlock(&rtlpriv->locks.rf_ps_lock);
		return;
		}
		spin_unlock(&rtlpriv->locks.rf_ps_lock);

		spin_lock_irqsave(&rtlpriv->locks.lps_lock, flag);
		rtl_ps_set_rf_state(hw, ERFSLEEP, RF_CHANGE_BY_PS , false);
		spin_unlock_irqrestore(&rtlpriv->locks.lps_lock, flag);

		if (ppsc->reg_rfps_level & RT_RF_OFF_LEVL_ASPM &&
		!RT_IN_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM)) {
		@@ -952,19 +912,19 @@ void rtl_p2p_ps_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
		p2pinfo->p2p_ps_state = p2p_ps_state;
		rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_H2C_FW_P2P_PS_OFFLOAD,
		&p2p_ps_state);

		p2pinfo->noa_index = 0;
		p2pinfo->ctwindow = 0;
		p2pinfo->opp_ps = 0;
		p2pinfo->noa_num = 0;
		p2pinfo->p2p_ps_mode = P2P_PS_NONE;
		if (rtlps->fw_current_inpsmode == true) {
		if (rtlps->fw_current_inpsmode) {
		if (rtlps->smart_ps == 0) {
		rtlps->smart_ps = 2;
		rtlpriv->cfg->ops->set_hw_reg(hw,
		HW_VAR_H2C_FW_PWRMODE,
		&rtlps->pwr_mode);
		}

		}
		break;
		case P2P_PS_ENABLE:
		@@ -982,6 +942,7 @@ void rtl_p2p_ps_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
		rtlpriv->cfg->ops->set_hw_reg(hw,
		HW_VAR_H2C_FW_P2P_PS_OFFLOAD,
		&p2p_ps_state);

		}
		break;
		case P2P_PS_SCAN:
		@@ -998,12 +959,16 @@ void rtl_p2p_ps_cmd(struct ieee80211_hw *hw, u8 p2p_ps_state)
		break;
		}
		RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD,
		"ctwindow %x oppps %x\n", p2pinfo->ctwindow, p2pinfo->opp_ps);
		"ctwindow %x oppps %x\n",
		p2pinfo->ctwindow , p2pinfo->opp_ps);
		RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD,
		"count %x duration %x index %x interval %x start time %x noa num %x\n",
		p2pinfo->noa_count_type[0], p2pinfo->noa_duration[0],
		p2pinfo->noa_index, p2pinfo->noa_interval[0],
		p2pinfo->noa_start_time[0], p2pinfo->noa_num);
		p2pinfo->noa_count_type[0],
		p2pinfo->noa_duration[0],
		p2pinfo->noa_index,
		p2pinfo->noa_interval[0],
		p2pinfo->noa_start_time[0],
		p2pinfo->noa_num);
		RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD, "end\n");
		}

drivers/net/wireless/rtlwifi/ps.h

+5 −66

Original line number	Diff line number	Diff line
		@@ -11,10 +11,6 @@
		* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
		* more details.
		*
		* You should have received a copy of the GNU General Public License along with
		* this program; if not, write to the Free Software Foundation, Inc.,
		* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
		*
		* The full GNU General Public License is included in this distribution in the
		* file called LICENSE.
		*
		@@ -32,68 +28,9 @@

		#define MAX_SW_LPS_SLEEP_INTV 5

		/*---------------------------------------------
		* 3 The value of cmd: 4 bits
		*---------------------------------------------
		*/
		#define PWR_CMD_READ 0x00
		#define PWR_CMD_WRITE 0x01
		#define PWR_CMD_POLLING 0x02
		#define PWR_CMD_DELAY 0x03
		#define PWR_CMD_END 0x04

		/* define the base address of each block */
		#define PWR_BASEADDR_MAC 0x00
		#define PWR_BASEADDR_USB 0x01
		#define PWR_BASEADDR_PCIE 0x02
		#define PWR_BASEADDR_SDIO 0x03

		#define PWR_FAB_ALL_MSK (BIT(0)\|BIT(1)\|BIT(2)\|BIT(3))
		#define PWR_CUT_TESTCHIP_MSK BIT(0)
		#define PWR_CUT_A_MSK BIT(1)
		#define PWR_CUT_B_MSK BIT(2)
		#define PWR_CUT_C_MSK BIT(3)
		#define PWR_CUT_D_MSK BIT(4)
		#define PWR_CUT_E_MSK BIT(5)
		#define PWR_CUT_F_MSK BIT(6)
		#define PWR_CUT_G_MSK BIT(7)
		#define PWR_CUT_ALL_MSK 0xFF
		#define PWR_INTF_SDIO_MSK BIT(0)
		#define PWR_INTF_USB_MSK BIT(1)
		#define PWR_INTF_PCI_MSK BIT(2)
		#define PWR_INTF_ALL_MSK (BIT(0)\|BIT(1)\|BIT(2)\|BIT(3))

		enum pwrseq_delay_unit {
		PWRSEQ_DELAY_US,
		PWRSEQ_DELAY_MS,
		};

		struct wlan_pwr_cfg {
		u16 offset;
		u8 cut_msk;
		u8 fab_msk:4;
		u8 interface_msk:4;
		u8 base:4;
		u8 cmd:4;
		u8 msk;
		u8 value;
		};

		#define GET_PWR_CFG_OFFSET(__PWR_CMD) (__PWR_CMD.offset)
		#define GET_PWR_CFG_CUT_MASK(__PWR_CMD) (__PWR_CMD.cut_msk)
		#define GET_PWR_CFG_FAB_MASK(__PWR_CMD) (__PWR_CMD.fab_msk)
		#define GET_PWR_CFG_INTF_MASK(__PWR_CMD) (__PWR_CMD.interface_msk)
		#define GET_PWR_CFG_BASE(__PWR_CMD) (__PWR_CMD.base)
		#define GET_PWR_CFG_CMD(__PWR_CMD) (__PWR_CMD.cmd)
		#define GET_PWR_CFG_MASK(__PWR_CMD) (__PWR_CMD.msk)
		#define GET_PWR_CFG_VALUE(__PWR_CMD) (__PWR_CMD.value)

		bool rtl_hal_pwrseqcmdparsing(struct rtl_priv *rtlpriv, u8 cut_version,
		u8 fab_version, u8 interface_type,
		struct wlan_pwr_cfg pwrcfgcmd[]);

		bool rtl_ps_set_rf_state(struct ieee80211_hw *hw,
		enum rf_pwrstate state_toset, u32 changesource);
		enum rf_pwrstate state_toset, u32 changesource,
		bool protect_or_not);
		bool rtl_ps_enable_nic(struct ieee80211_hw *hw);
		bool rtl_ps_disable_nic(struct ieee80211_hw *hw);
		void rtl_ips_nic_off(struct ieee80211_hw *hw);
		@@ -102,6 +39,8 @@ void rtl_ips_nic_off_wq_callback(void *data);
		void rtl_lps_enter(struct ieee80211_hw *hw);
		void rtl_lps_leave(struct ieee80211_hw *hw);

		void rtl_lps_set_psmode(struct ieee80211_hw *hw, u8 rt_psmode);

		void rtl_swlps_beacon(struct ieee80211_hw hw, void data, unsigned int len);
		void rtl_swlps_wq_callback(void *data);
		void rtl_swlps_rfon_wq_callback(void *data);

drivers/net/wireless/rtlwifi/rtl8188ee/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -5,6 +5,7 @@ rtl8188ee-objs := \
		led.o \
		phy.o \
		pwrseq.o \
		pwrseqcmd.o \
		rf.o \
		sw.o \
		table.o \

drivers/net/wireless/rtlwifi/rtl8188ee/hw.c

+9 −8

Original line number	Diff line number	Diff line
		@@ -41,6 +41,7 @@
		#include "fw.h"
		#include "led.h"
		#include "hw.h"
		#include "pwrseqcmd.h"
		#include "pwrseq.h"

		#define LLT_CONFIG 5
		@@ -809,9 +810,9 @@ static bool _rtl88ee_init_mac(struct ieee80211_hw *hw)

		rtl_write_byte(rtlpriv, REG_RSV_CTRL, 0x00);
		/* HW Power on sequence */
		if (!rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK,
		if (!rtl88_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK,
		PWR_FAB_ALL_MSK, PWR_INTF_PCI_MSK,
		Rtl8188E_NIC_ENABLE_FLOW)) {
		RTL8188E_NIC_ENABLE_FLOW)) {
		RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
		"init MAC Fail as rtl_hal_pwrseqcmdparsing\n");
		return false;
		@@ -1352,9 +1353,9 @@ static void _rtl88ee_poweroff_adapter(struct ieee80211_hw *hw)
		}
		rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG+1, 0xFF);

		rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
		rtl88_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
		PWR_INTF_PCI_MSK,
		Rtl8188E_NIC_LPS_ENTER_FLOW);
		RTL8188E_NIC_LPS_ENTER_FLOW);

		rtl_write_byte(rtlpriv, REG_RF_CTRL, 0x00);

		@@ -1368,8 +1369,8 @@ static void _rtl88ee_poweroff_adapter(struct ieee80211_hw *hw)
		u1b_tmp = rtl_read_byte(rtlpriv, REG_32K_CTRL);
		rtl_write_byte(rtlpriv, REG_32K_CTRL, (u1b_tmp & (~BIT(0))));

		rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
		PWR_INTF_PCI_MSK, Rtl8188E_NIC_DISABLE_FLOW);
		rtl88_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
		PWR_INTF_PCI_MSK, RTL8188E_NIC_DISABLE_FLOW);

		u1b_tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL+1);
		rtl_write_byte(rtlpriv, REG_RSV_CTRL+1, (u1b_tmp & (~BIT(3))));

drivers/net/wireless/rtlwifi/rtl8188ee/pwrseq.h

+9 −9

Original line number	Diff line number	Diff line
		@@ -313,14 +313,14 @@ extern struct wlan_pwr_cfg rtl8188e_leave_lps_flow
		RTL8188E_TRANS_END_STEPS];

		/* RTL8723 Power Configuration CMDs for PCIe interface */
		#define Rtl8188E_NIC_PWR_ON_FLOW rtl8188e_power_on_flow
		#define Rtl8188E_NIC_RF_OFF_FLOW rtl8188e_radio_off_flow
		#define Rtl8188E_NIC_DISABLE_FLOW rtl8188e_card_disable_flow
		#define Rtl8188E_NIC_ENABLE_FLOW rtl8188e_card_enable_flow
		#define Rtl8188E_NIC_SUSPEND_FLOW rtl8188e_suspend_flow
		#define Rtl8188E_NIC_RESUME_FLOW rtl8188e_resume_flow
		#define Rtl8188E_NIC_PDN_FLOW rtl8188e_hwpdn_flow
		#define Rtl8188E_NIC_LPS_ENTER_FLOW rtl8188e_enter_lps_flow
		#define Rtl8188E_NIC_LPS_LEAVE_FLOW rtl8188e_leave_lps_flow
		#define RTL8188E_NIC_PWR_ON_FLOW rtl8188e_power_on_flow
		#define RTL8188E_NIC_RF_OFF_FLOW rtl8188e_radio_off_flow
		#define RTL8188E_NIC_DISABLE_FLOW rtl8188e_card_disable_flow
		#define RTL8188E_NIC_ENABLE_FLOW rtl8188e_card_enable_flow
		#define RTL8188E_NIC_SUSPEND_FLOW rtl8188e_suspend_flow
		#define RTL8188E_NIC_RESUME_FLOW rtl8188e_resume_flow
		#define RTL8188E_NIC_PDN_FLOW rtl8188e_hwpdn_flow
		#define RTL8188E_NIC_LPS_ENTER_FLOW rtl8188e_enter_lps_flow
		#define RTL8188E_NIC_LPS_LEAVE_FLOW rtl8188e_leave_lps_flow

		#endif