]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/commitdiff
Merge tag 'wireless-drivers-next-for-davem-2015-10-27' of git://git.kernel.org/pub...
authorDavid S. Miller <davem@davemloft.net>
Wed, 28 Oct 2015 02:56:56 +0000 (19:56 -0700)
committerDavid S. Miller <davem@davemloft.net>
Wed, 28 Oct 2015 02:56:56 +0000 (19:56 -0700)
Kalle Valo says:

====================
here's a bigger pull request for 4.4. The diffstat looks scary as we
created a new directory realtek for all realtek drivers. In the future
I'm planning to create similar directories for all vendors, currently we
just have ath, mediatek and realtek. This change has been in linux-next
for a couple of weeks so it should be safe, but of course you never
know.

There's also a new driver rtl8xxxu for few realtek USB devices. This
just made it to the last linux-next build.

Otherwise there's nothing really special, more info below. If time
permits, and it's ok for you, I'm hoping to send you a one more pull
request this week.

brcmfmac

* using netdev carrier state
* add and rework some cfg80211 callbacks mainly for AP mode
* use devcoredump when triggered by firmware event

realtek

* create new directory drivers/net/wireless/realtek/ for all realtek
  drivers, not visible to users (no kconfig changes etc)
* add rtl8xxxu, a new mac80211 driver for RTL8723AU, RTL8188CU,
  RTL8188RU, RTL8191CU, RTL8192CU and hopefully more in the future

ath10k

* add board 2 API support for automatically choosing correct board file
* data path optimisations
* disable PCI power save for qca988x and QCA99x0 due to interop reasons

wil6210

* BlockAckReq support
* firmware crashdump using devcoredump
* capture all frames with sniffer
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
1  2 
MAINTAINERS
drivers/net/wireless/ath/ath10k/hw.h
drivers/net/wireless/ath/ath6kl/cfg80211.c
drivers/net/wireless/realtek/rtlwifi/pci.h
drivers/net/wireless/realtek/rtlwifi/rtl8821ae/hw.c
drivers/net/wireless/realtek/rtlwifi/rtl8821ae/sw.c
drivers/net/wireless/realtek/rtlwifi/wifi.h

diff --cc MAINTAINERS
Simple merge
Simple merge
index 0000000000000000000000000000000000000000,d4567d12e07ebd13f17f0097baeec41a25702d31..5da6703942d9dd08017d896070404fdbe29a96e4
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,335 +1,337 @@@
+ /******************************************************************************
+  *
+  * Copyright(c) 2009-2012  Realtek Corporation.
+  *
+  * 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.
+  *
+  * 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.
+  *
+  * Contact Information:
+  * wlanfae <wlanfae@realtek.com>
+  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
+  * Hsinchu 300, Taiwan.
+  *
+  * Larry Finger <Larry.Finger@lwfinger.net>
+  *
+  *****************************************************************************/
+ #ifndef __RTL_PCI_H__
+ #define __RTL_PCI_H__
+ #include <linux/pci.h>
+ /*
+ 1: MSDU packet queue,
+ 2: Rx Command Queue
+ */
+ #define RTL_PCI_RX_MPDU_QUEUE                 0
+ #define RTL_PCI_RX_CMD_QUEUE                  1
+ #define RTL_PCI_MAX_RX_QUEUE                  2
+ #define RTL_PCI_MAX_RX_COUNT                  512/*64*/
+ #define RTL_PCI_MAX_TX_QUEUE_COUNT            9
+ #define RT_TXDESC_NUM                         128
+ #define TX_DESC_NUM_92E                               512
+ #define RT_TXDESC_NUM_BE_QUEUE                        256
+ #define BK_QUEUE                              0
+ #define BE_QUEUE                              1
+ #define VI_QUEUE                              2
+ #define VO_QUEUE                              3
+ #define BEACON_QUEUE                          4
+ #define TXCMD_QUEUE                           5
+ #define MGNT_QUEUE                            6
+ #define HIGH_QUEUE                            7
+ #define HCCA_QUEUE                            8
+ #define RTL_PCI_DEVICE(vend, dev, cfg)  \
+       .vendor = (vend), \
+       .device = (dev), \
+       .subvendor = PCI_ANY_ID, \
+       .subdevice = PCI_ANY_ID,\
+       .driver_data = (kernel_ulong_t)&(cfg)
+ #define INTEL_VENDOR_ID                               0x8086
+ #define SIS_VENDOR_ID                         0x1039
+ #define ATI_VENDOR_ID                         0x1002
+ #define ATI_DEVICE_ID                         0x7914
+ #define AMD_VENDOR_ID                         0x1022
+ #define PCI_MAX_BRIDGE_NUMBER                 255
+ #define PCI_MAX_DEVICES                               32
+ #define PCI_MAX_FUNCTION                      8
+ #define PCI_CONF_ADDRESS      0x0CF8  /*PCI Configuration Space Address */
+ #define PCI_CONF_DATA         0x0CFC  /*PCI Configuration Space Data */
+ #define PCI_CLASS_BRIDGE_DEV          0x06
+ #define PCI_SUBCLASS_BR_PCI_TO_PCI    0x04
+ #define PCI_CAPABILITY_ID_PCI_EXPRESS 0x10
+ #define PCI_CAP_ID_EXP                        0x10
+ #define U1DONTCARE                    0xFF
+ #define U2DONTCARE                    0xFFFF
+ #define U4DONTCARE                    0xFFFFFFFF
+ #define RTL_PCI_8192_DID      0x8192  /*8192 PCI-E */
+ #define RTL_PCI_8192SE_DID    0x8192  /*8192 SE */
+ #define RTL_PCI_8174_DID      0x8174  /*8192 SE */
+ #define RTL_PCI_8173_DID      0x8173  /*8191 SE Crab */
+ #define RTL_PCI_8172_DID      0x8172  /*8191 SE RE */
+ #define RTL_PCI_8171_DID      0x8171  /*8191 SE Unicron */
+ #define RTL_PCI_8723AE_DID    0x8723  /*8723AE */
+ #define RTL_PCI_0045_DID      0x0045  /*8190 PCI for Ceraga */
+ #define RTL_PCI_0046_DID      0x0046  /*8190 Cardbus for Ceraga */
+ #define RTL_PCI_0044_DID      0x0044  /*8192e PCIE for Ceraga */
+ #define RTL_PCI_0047_DID      0x0047  /*8192e Express Card for Ceraga */
+ #define RTL_PCI_700F_DID      0x700F
+ #define RTL_PCI_701F_DID      0x701F
+ #define RTL_PCI_DLINK_DID     0x3304
+ #define RTL_PCI_8723AE_DID    0x8723  /*8723e */
+ #define RTL_PCI_8192CET_DID   0x8191  /*8192ce */
+ #define RTL_PCI_8192CE_DID    0x8178  /*8192ce */
+ #define RTL_PCI_8191CE_DID    0x8177  /*8192ce */
+ #define RTL_PCI_8188CE_DID    0x8176  /*8192ce */
+ #define RTL_PCI_8192CU_DID    0x8191  /*8192ce */
+ #define RTL_PCI_8192DE_DID    0x8193  /*8192de */
+ #define RTL_PCI_8192DE_DID2   0x002B  /*92DE*/
+ #define RTL_PCI_8188EE_DID    0x8179  /*8188ee*/
+ #define RTL_PCI_8723BE_DID    0xB723  /*8723be*/
+ #define RTL_PCI_8192EE_DID    0x818B  /*8192ee*/
+ #define RTL_PCI_8821AE_DID    0x8821  /*8821ae*/
+ #define RTL_PCI_8812AE_DID    0x8812  /*8812ae*/
+ /*8192 support 16 pages of IO registers*/
+ #define RTL_MEM_MAPPED_IO_RANGE_8190PCI               0x1000
+ #define RTL_MEM_MAPPED_IO_RANGE_8192PCIE      0x4000
+ #define RTL_MEM_MAPPED_IO_RANGE_8192SE                0x4000
+ #define RTL_MEM_MAPPED_IO_RANGE_8192CE                0x4000
+ #define RTL_MEM_MAPPED_IO_RANGE_8192DE                0x4000
+ #define RTL_PCI_REVISION_ID_8190PCI           0x00
+ #define RTL_PCI_REVISION_ID_8192PCIE          0x01
+ #define RTL_PCI_REVISION_ID_8192SE            0x10
+ #define RTL_PCI_REVISION_ID_8192CE            0x1
+ #define RTL_PCI_REVISION_ID_8192DE            0x0
+ #define RTL_DEFAULT_HARDWARE_TYPE     HARDWARE_TYPE_RTL8192CE
+ enum pci_bridge_vendor {
+       PCI_BRIDGE_VENDOR_INTEL = 0x0,  /*0b'0000,0001 */
+       PCI_BRIDGE_VENDOR_ATI,          /*0b'0000,0010*/
+       PCI_BRIDGE_VENDOR_AMD,          /*0b'0000,0100*/
+       PCI_BRIDGE_VENDOR_SIS,          /*0b'0000,1000*/
+       PCI_BRIDGE_VENDOR_UNKNOWN,      /*0b'0100,0000*/
+       PCI_BRIDGE_VENDOR_MAX,
+ };
+ struct rtl_pci_capabilities_header {
+       u8 capability_id;
+       u8 next;
+ };
+ /* In new TRX flow, Buffer_desc is new concept
+  * But TX wifi info == TX descriptor in old flow
+  * RX wifi info == RX descriptor in old flow
+  */
+ struct rtl_tx_buffer_desc {
+ #if (RTL8192EE_SEG_NUM == 2)
+       u32 dword[2*(DMA_IS_64BIT + 1)*8]; /*seg = 8*/
+ #elif (RTL8192EE_SEG_NUM == 1)
+       u32 dword[2*(DMA_IS_64BIT + 1)*4]; /*seg = 4*/
+ #elif (RTL8192EE_SEG_NUM == 0)
+       u32 dword[2*(DMA_IS_64BIT + 1)*2]; /*seg = 2*/
+ #endif
+ } __packed;
+ struct rtl_tx_desc {
+       u32 dword[16];
+ } __packed;
+ struct rtl_rx_buffer_desc { /*rx buffer desc*/
+       u32 dword[2];
+ } __packed;
+ struct rtl_rx_desc { /*old: rx desc new: rx wifi info*/
+       u32 dword[8];
+ } __packed;
+ struct rtl_tx_cmd_desc {
+       u32 dword[16];
+ } __packed;
+ struct rtl8192_tx_ring {
+       struct rtl_tx_desc *desc;
+       dma_addr_t dma;
+       unsigned int idx;
+       unsigned int entries;
+       struct sk_buff_head queue;
+       /*add for new trx flow*/
+       struct rtl_tx_buffer_desc *buffer_desc; /*tx buffer descriptor*/
+       dma_addr_t buffer_desc_dma; /*tx bufferd desc dma memory*/
+       u16 avl_desc; /* available_desc_to_write */
+       u16 cur_tx_wp; /* current_tx_write_point */
+       u16 cur_tx_rp; /* current_tx_read_point */
+ };
+ struct rtl8192_rx_ring {
+       struct rtl_rx_desc *desc;
+       dma_addr_t dma;
+       unsigned int idx;
+       struct sk_buff *rx_buf[RTL_PCI_MAX_RX_COUNT];
+       /*add for new trx flow*/
+       struct rtl_rx_buffer_desc *buffer_desc; /*rx buffer descriptor*/
+       u16 next_rx_rp; /* next_rx_read_point */
+ };
+ struct rtl_pci {
+       struct pci_dev *pdev;
+       bool irq_enabled;
+       bool driver_is_goingto_unload;
+       bool up_first_time;
+       bool first_init;
+       bool being_init_adapter;
+       bool init_ready;
+       /*Tx */
+       struct rtl8192_tx_ring tx_ring[RTL_PCI_MAX_TX_QUEUE_COUNT];
+       int txringcount[RTL_PCI_MAX_TX_QUEUE_COUNT];
+       u32 transmit_config;
+       /*Rx */
+       struct rtl8192_rx_ring rx_ring[RTL_PCI_MAX_RX_QUEUE];
+       int rxringcount;
+       u16 rxbuffersize;
+       u32 receive_config;
+       /*irq */
+       u8 irq_alloc;
+       u32 irq_mask[2];
+       u32 sys_irq_mask;
+       /*Bcn control register setting */
+       u32 reg_bcn_ctrl_val;
+        /*ASPM*/ u8 const_pci_aspm;
+       u8 const_amdpci_aspm;
+       u8 const_hwsw_rfoff_d3;
+       u8 const_support_pciaspm;
+       /*pci-e bridge */
+       u8 const_hostpci_aspm_setting;
+       /*pci-e device */
+       u8 const_devicepci_aspm_setting;
+       /*If it supports ASPM, Offset[560h] = 0x40,
+          otherwise Offset[560h] = 0x00. */
+       bool support_aspm;
+       bool support_backdoor;
+       /*QOS & EDCA */
+       enum acm_method acm_method;
+       u16 shortretry_limit;
+       u16 longretry_limit;
+       /* MSI support */
+       bool msi_support;
+       bool using_msi;
++      /* interrupt clear before set */
++      bool int_clear;
+ };
+ struct mp_adapter {
+       u8 linkctrl_reg;
+       u8 busnumber;
+       u8 devnumber;
+       u8 funcnumber;
+       u8 pcibridge_busnum;
+       u8 pcibridge_devnum;
+       u8 pcibridge_funcnum;
+       u8 pcibridge_vendor;
+       u16 pcibridge_vendorid;
+       u16 pcibridge_deviceid;
+       u8 num4bytes;
+       u8 pcibridge_pciehdr_offset;
+       u8 pcibridge_linkctrlreg;
+       bool amd_l1_patch;
+ };
+ struct rtl_pci_priv {
+       struct rtl_pci dev;
+       struct mp_adapter ndis_adapter;
+       struct rtl_led_ctl ledctl;
+       struct bt_coexist_info bt_coexist;
+ };
+ #define rtl_pcipriv(hw)               (((struct rtl_pci_priv *)(rtl_priv(hw))->priv))
+ #define rtl_pcidev(pcipriv)   (&((pcipriv)->dev))
+ int rtl_pci_reset_trx_ring(struct ieee80211_hw *hw);
+ extern struct rtl_intf_ops rtl_pci_ops;
+ int rtl_pci_probe(struct pci_dev *pdev,
+                           const struct pci_device_id *id);
+ void rtl_pci_disconnect(struct pci_dev *pdev);
+ #ifdef CONFIG_PM_SLEEP
+ int rtl_pci_suspend(struct device *dev);
+ int rtl_pci_resume(struct device *dev);
+ #endif /* CONFIG_PM_SLEEP */
+ static inline u8 pci_read8_sync(struct rtl_priv *rtlpriv, u32 addr)
+ {
+       return readb((u8 __iomem *) rtlpriv->io.pci_mem_start + addr);
+ }
+ static inline u16 pci_read16_sync(struct rtl_priv *rtlpriv, u32 addr)
+ {
+       return readw((u8 __iomem *) rtlpriv->io.pci_mem_start + addr);
+ }
+ static inline u32 pci_read32_sync(struct rtl_priv *rtlpriv, u32 addr)
+ {
+       return readl((u8 __iomem *) rtlpriv->io.pci_mem_start + addr);
+ }
+ static inline void pci_write8_async(struct rtl_priv *rtlpriv, u32 addr, u8 val)
+ {
+       writeb(val, (u8 __iomem *) rtlpriv->io.pci_mem_start + addr);
+ }
+ static inline void pci_write16_async(struct rtl_priv *rtlpriv,
+                                    u32 addr, u16 val)
+ {
+       writew(val, (u8 __iomem *) rtlpriv->io.pci_mem_start + addr);
+ }
+ static inline void pci_write32_async(struct rtl_priv *rtlpriv,
+                                    u32 addr, u32 val)
+ {
+       writel(val, (u8 __iomem *) rtlpriv->io.pci_mem_start + addr);
+ }
+ static inline u16 calc_fifo_space(u16 rp, u16 wp)
+ {
+       if (rp <= wp)
+               return RTL_PCI_MAX_RX_COUNT - 1 + rp - wp;
+       return rp - wp - 1;
+ }
+ #endif
index 0000000000000000000000000000000000000000,b7f18e2155eb18358cf4d4f9f3f82774f9b6f522..6e9418ed90c289bee5b7f2dfc478f847dfc7ca68
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,4199 +1,4216 @@@
+ /******************************************************************************
+  *
+  * Copyright(c) 2009-2010  Realtek Corporation.
+  *
+  * 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>
+  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
+  * Hsinchu 300, Taiwan.
+  *
+  * Larry Finger <Larry.Finger@lwfinger.net>
+  *
+  *****************************************************************************/
+ #include "../wifi.h"
+ #include "../efuse.h"
+ #include "../base.h"
+ #include "../regd.h"
+ #include "../cam.h"
+ #include "../ps.h"
+ #include "../pci.h"
+ #include "reg.h"
+ #include "def.h"
+ #include "phy.h"
+ #include "dm.h"
+ #include "fw.h"
+ #include "led.h"
+ #include "hw.h"
+ #include "../pwrseqcmd.h"
+ #include "pwrseq.h"
+ #include "../btcoexist/rtl_btc.h"
+ #define LLT_CONFIG    5
+ static void _rtl8821ae_return_beacon_queue_skb(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[BEACON_QUEUE];
+       unsigned long flags;
+       spin_lock_irqsave(&rtlpriv->locks.irq_th_lock, flags);
+       while (skb_queue_len(&ring->queue)) {
+               struct rtl_tx_desc *entry = &ring->desc[ring->idx];
+               struct sk_buff *skb = __skb_dequeue(&ring->queue);
+               pci_unmap_single(rtlpci->pdev,
+                                rtlpriv->cfg->ops->get_desc(
+                                (u8 *)entry, true, HW_DESC_TXBUFF_ADDR),
+                                skb->len, PCI_DMA_TODEVICE);
+               kfree_skb(skb);
+               ring->idx = (ring->idx + 1) % ring->entries;
+       }
+       spin_unlock_irqrestore(&rtlpriv->locks.irq_th_lock, flags);
+ }
+ static void _rtl8821ae_set_bcn_ctrl_reg(struct ieee80211_hw *hw,
+                                       u8 set_bits, u8 clear_bits)
+ {
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       rtlpci->reg_bcn_ctrl_val |= set_bits;
+       rtlpci->reg_bcn_ctrl_val &= ~clear_bits;
+       rtl_write_byte(rtlpriv, REG_BCN_CTRL, (u8)rtlpci->reg_bcn_ctrl_val);
+ }
+ void _rtl8821ae_stop_tx_beacon(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u8 tmp1byte;
+       tmp1byte = rtl_read_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2);
+       rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, tmp1byte & (~BIT(6)));
+       rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0x64);
+       tmp1byte = rtl_read_byte(rtlpriv, REG_TBTT_PROHIBIT + 2);
+       tmp1byte &= ~(BIT(0));
+       rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 2, tmp1byte);
+ }
+ void _rtl8821ae_resume_tx_beacon(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u8 tmp1byte;
+       tmp1byte = rtl_read_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2);
+       rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, tmp1byte | BIT(6));
+       rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0xff);
+       tmp1byte = rtl_read_byte(rtlpriv, REG_TBTT_PROHIBIT + 2);
+       tmp1byte |= BIT(0);
+       rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 2, tmp1byte);
+ }
+ static void _rtl8821ae_enable_bcn_sub_func(struct ieee80211_hw *hw)
+ {
+       _rtl8821ae_set_bcn_ctrl_reg(hw, 0, BIT(1));
+ }
+ static void _rtl8821ae_disable_bcn_sub_func(struct ieee80211_hw *hw)
+ {
+       _rtl8821ae_set_bcn_ctrl_reg(hw, BIT(1), 0);
+ }
+ static void _rtl8821ae_set_fw_clock_on(struct ieee80211_hw *hw,
+                                      u8 rpwm_val, bool b_need_turn_off_ckk)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       bool b_support_remote_wake_up;
+       u32 count = 0, isr_regaddr, content;
+       bool b_schedule_timer = b_need_turn_off_ckk;
+       rtlpriv->cfg->ops->get_hw_reg(hw, HAL_DEF_WOWLAN,
+                                       (u8 *)(&b_support_remote_wake_up));
+       if (!rtlhal->fw_ready)
+               return;
+       if (!rtlpriv->psc.fw_current_inpsmode)
+               return;
+       while (1) {
+               spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
+               if (rtlhal->fw_clk_change_in_progress) {
+                       while (rtlhal->fw_clk_change_in_progress) {
+                               spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
+                               count++;
+                               udelay(100);
+                               if (count > 1000)
+                                       goto change_done;
+                               spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
+                       }
+                       spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
+               } else {
+                       rtlhal->fw_clk_change_in_progress = false;
+                       spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
+                       goto change_done;
+               }
+       }
+ change_done:
+       if (IS_IN_LOW_POWER_STATE_8821AE(rtlhal->fw_ps_state)) {
+               rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_SET_RPWM,
+                                       (u8 *)(&rpwm_val));
+               if (FW_PS_IS_ACK(rpwm_val)) {
+                       isr_regaddr = REG_HISR;
+                       content = rtl_read_dword(rtlpriv, isr_regaddr);
+                       while (!(content & IMR_CPWM) && (count < 500)) {
+                               udelay(50);
+                               count++;
+                               content = rtl_read_dword(rtlpriv, isr_regaddr);
+                       }
+                       if (content & IMR_CPWM) {
+                               rtl_write_word(rtlpriv, isr_regaddr, 0x0100);
+                               rtlhal->fw_ps_state = FW_PS_STATE_RF_ON_8821AE;
+                               RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
+                                        "Receive CPWM INT!!! Set rtlhal->FwPSState = %X\n",
+                                        rtlhal->fw_ps_state);
+                       }
+               }
+               spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
+               rtlhal->fw_clk_change_in_progress = false;
+               spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
+               if (b_schedule_timer)
+                       mod_timer(&rtlpriv->works.fw_clockoff_timer,
+                                 jiffies + MSECS(10));
+       } else  {
+               spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
+               rtlhal->fw_clk_change_in_progress = false;
+               spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
+       }
+ }
+ static void _rtl8821ae_set_fw_clock_off(struct ieee80211_hw *hw,
+                                       u8 rpwm_val)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       struct rtl8192_tx_ring *ring;
+       enum rf_pwrstate rtstate;
+       bool b_schedule_timer = false;
+       u8 queue;
+       if (!rtlhal->fw_ready)
+               return;
+       if (!rtlpriv->psc.fw_current_inpsmode)
+               return;
+       if (!rtlhal->allow_sw_to_change_hwclc)
+               return;
+       rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_RF_STATE, (u8 *)(&rtstate));
+       if (rtstate == ERFOFF || rtlpriv->psc.inactive_pwrstate == ERFOFF)
+               return;
+       for (queue = 0; queue < RTL_PCI_MAX_TX_QUEUE_COUNT; queue++) {
+               ring = &rtlpci->tx_ring[queue];
+               if (skb_queue_len(&ring->queue)) {
+                       b_schedule_timer = true;
+                       break;
+               }
+       }
+       if (b_schedule_timer) {
+               mod_timer(&rtlpriv->works.fw_clockoff_timer,
+                         jiffies + MSECS(10));
+               return;
+       }
+       if (FW_PS_STATE(rtlhal->fw_ps_state) !=
+               FW_PS_STATE_RF_OFF_LOW_PWR_8821AE) {
+               spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
+               if (!rtlhal->fw_clk_change_in_progress) {
+                       rtlhal->fw_clk_change_in_progress = true;
+                       spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
+                       rtlhal->fw_ps_state = FW_PS_STATE(rpwm_val);
+                       rtl_write_word(rtlpriv, REG_HISR, 0x0100);
+                       rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SET_RPWM,
+                                                     (u8 *)(&rpwm_val));
+                       spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
+                       rtlhal->fw_clk_change_in_progress = false;
+                       spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
+               } else {
+                       spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
+                       mod_timer(&rtlpriv->works.fw_clockoff_timer,
+                                 jiffies + MSECS(10));
+               }
+       }
+ }
+ static void _rtl8821ae_set_fw_ps_rf_on(struct ieee80211_hw *hw)
+ {
+       u8 rpwm_val = 0;
+       rpwm_val |= (FW_PS_STATE_RF_OFF_8821AE | FW_PS_ACK);
+       _rtl8821ae_set_fw_clock_on(hw, rpwm_val, true);
+ }
+ static void _rtl8821ae_fwlps_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));
+       bool fw_current_inps = false;
+       u8 rpwm_val = 0, fw_pwrmode = FW_PS_ACTIVE_MODE;
+       if (ppsc->low_power_enable) {
+               rpwm_val = (FW_PS_STATE_ALL_ON_8821AE|FW_PS_ACK);/* RF on */
+               _rtl8821ae_set_fw_clock_on(hw, rpwm_val, false);
+               rtlhal->allow_sw_to_change_hwclc = false;
+               rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_H2C_FW_PWRMODE,
+                               (u8 *)(&fw_pwrmode));
+               rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_FW_PSMODE_STATUS,
+                               (u8 *)(&fw_current_inps));
+       } else {
+               rpwm_val = FW_PS_STATE_ALL_ON_8821AE;   /* RF on */
+               rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SET_RPWM,
+                               (u8 *)(&rpwm_val));
+               rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_H2C_FW_PWRMODE,
+                               (u8 *)(&fw_pwrmode));
+               rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_FW_PSMODE_STATUS,
+                               (u8 *)(&fw_current_inps));
+       }
+ }
+ static void _rtl8821ae_fwlps_enter(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));
+       bool fw_current_inps = true;
+       u8 rpwm_val;
+       if (ppsc->low_power_enable) {
+               rpwm_val = FW_PS_STATE_RF_OFF_LOW_PWR_8821AE;   /* RF off */
+               rtlpriv->cfg->ops->set_hw_reg(hw,
+                               HW_VAR_FW_PSMODE_STATUS,
+                               (u8 *)(&fw_current_inps));
+               rtlpriv->cfg->ops->set_hw_reg(hw,
+                               HW_VAR_H2C_FW_PWRMODE,
+                               (u8 *)(&ppsc->fwctrl_psmode));
+               rtlhal->allow_sw_to_change_hwclc = true;
+               _rtl8821ae_set_fw_clock_off(hw, rpwm_val);
+       } else {
+               rpwm_val = FW_PS_STATE_RF_OFF_8821AE;   /* RF off */
+               rtlpriv->cfg->ops->set_hw_reg(hw,
+                               HW_VAR_FW_PSMODE_STATUS,
+                               (u8 *)(&fw_current_inps));
+               rtlpriv->cfg->ops->set_hw_reg(hw,
+                               HW_VAR_H2C_FW_PWRMODE,
+                               (u8 *)(&ppsc->fwctrl_psmode));
+               rtlpriv->cfg->ops->set_hw_reg(hw,
+                               HW_VAR_SET_RPWM,
+                               (u8 *)(&rpwm_val));
+       }
+ }
+ static void _rtl8821ae_download_rsvd_page(struct ieee80211_hw *hw,
+                                         bool dl_whole_packets)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
+       u8 tmp_regcr, tmp_reg422, bcnvalid_reg;
+       u8 count = 0, dlbcn_count = 0;
+       bool send_beacon = false;
+       tmp_regcr = rtl_read_byte(rtlpriv, REG_CR + 1);
+       rtl_write_byte(rtlpriv, REG_CR + 1, (tmp_regcr | BIT(0)));
+       _rtl8821ae_set_bcn_ctrl_reg(hw, 0, BIT(3));
+       _rtl8821ae_set_bcn_ctrl_reg(hw, BIT(4), 0);
+       tmp_reg422 = rtl_read_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2);
+       rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2,
+                      tmp_reg422 & (~BIT(6)));
+       if (tmp_reg422 & BIT(6))
+               send_beacon = true;
+       do {
+               bcnvalid_reg = rtl_read_byte(rtlpriv, REG_TDECTRL + 2);
+               rtl_write_byte(rtlpriv, REG_TDECTRL + 2,
+                              (bcnvalid_reg | BIT(0)));
+               _rtl8821ae_return_beacon_queue_skb(hw);
+               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE)
+                       rtl8812ae_set_fw_rsvdpagepkt(hw, false,
+                                                    dl_whole_packets);
+               else
+                       rtl8821ae_set_fw_rsvdpagepkt(hw, false,
+                                                    dl_whole_packets);
+               bcnvalid_reg = rtl_read_byte(rtlpriv, REG_TDECTRL + 2);
+               count = 0;
+               while (!(bcnvalid_reg & BIT(0)) && count < 20) {
+                       count++;
+                       udelay(10);
+                       bcnvalid_reg = rtl_read_byte(rtlpriv, REG_TDECTRL + 2);
+               }
+               dlbcn_count++;
+       } while (!(bcnvalid_reg & BIT(0)) && dlbcn_count < 5);
+       if (!(bcnvalid_reg & BIT(0)))
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Download RSVD page failed!\n");
+       if (bcnvalid_reg & BIT(0) && rtlhal->enter_pnp_sleep) {
+               rtl_write_byte(rtlpriv, REG_TDECTRL + 2, bcnvalid_reg | BIT(0));
+               _rtl8821ae_return_beacon_queue_skb(hw);
+               if (send_beacon) {
+                       dlbcn_count = 0;
+                       do {
+                               rtl_write_byte(rtlpriv, REG_TDECTRL + 2,
+                                              bcnvalid_reg | BIT(0));
+                               _rtl8821ae_return_beacon_queue_skb(hw);
+                               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE)
+                                       rtl8812ae_set_fw_rsvdpagepkt(hw, true,
+                                                                    false);
+                               else
+                                       rtl8821ae_set_fw_rsvdpagepkt(hw, true,
+                                                                    false);
+                               /* check rsvd page download OK. */
+                               bcnvalid_reg = rtl_read_byte(rtlpriv,
+                                                            REG_TDECTRL + 2);
+                               count = 0;
+                               while (!(bcnvalid_reg & BIT(0)) && count < 20) {
+                                       count++;
+                                       udelay(10);
+                                       bcnvalid_reg =
+                                         rtl_read_byte(rtlpriv,
+                                                       REG_TDECTRL + 2);
+                               }
+                               dlbcn_count++;
+                       } while (!(bcnvalid_reg & BIT(0)) && dlbcn_count < 5);
+                       if (!(bcnvalid_reg & BIT(0)))
+                               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                                        "2 Download RSVD page failed!\n");
+               }
+       }
+       if (bcnvalid_reg & BIT(0))
+               rtl_write_byte(rtlpriv, REG_TDECTRL + 2, BIT(0));
+       _rtl8821ae_set_bcn_ctrl_reg(hw, BIT(3), 0);
+       _rtl8821ae_set_bcn_ctrl_reg(hw, 0, BIT(4));
+       if (send_beacon)
+               rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, tmp_reg422);
+       if (!rtlhal->enter_pnp_sleep) {
+               tmp_regcr = rtl_read_byte(rtlpriv, REG_CR + 1);
+               rtl_write_byte(rtlpriv, REG_CR + 1, (tmp_regcr & ~(BIT(0))));
+       }
+ }
+ void rtl8821ae_get_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       switch (variable) {
+       case HW_VAR_ETHER_ADDR:
+               *((u32 *)(val)) = rtl_read_dword(rtlpriv, REG_MACID);
+               *((u16 *)(val+4)) = rtl_read_word(rtlpriv, REG_MACID + 4);
+               break;
+       case HW_VAR_BSSID:
+               *((u32 *)(val)) = rtl_read_dword(rtlpriv, REG_BSSID);
+               *((u16 *)(val+4)) = rtl_read_word(rtlpriv, REG_BSSID+4);
+               break;
+       case HW_VAR_MEDIA_STATUS:
+               val[0] = rtl_read_byte(rtlpriv, MSR) & 0x3;
+               break;
+       case HW_VAR_SLOT_TIME:
+               *((u8 *)(val)) = mac->slot_time;
+               break;
+       case HW_VAR_BEACON_INTERVAL:
+               *((u16 *)(val)) = rtl_read_word(rtlpriv, REG_BCN_INTERVAL);
+               break;
+       case HW_VAR_ATIM_WINDOW:
+               *((u16 *)(val)) =  rtl_read_word(rtlpriv, REG_ATIMWND);
+               break;
+       case HW_VAR_RCR:
+               *((u32 *)(val)) = rtlpci->receive_config;
+               break;
+       case HW_VAR_RF_STATE:
+               *((enum rf_pwrstate *)(val)) = ppsc->rfpwr_state;
+               break;
+       case HW_VAR_FWLPS_RF_ON:{
+               enum rf_pwrstate rfstate;
+               u32 val_rcr;
+               rtlpriv->cfg->ops->get_hw_reg(hw,
+                                             HW_VAR_RF_STATE,
+                                             (u8 *)(&rfstate));
+               if (rfstate == ERFOFF) {
+                       *((bool *)(val)) = true;
+               } else {
+                       val_rcr = rtl_read_dword(rtlpriv, REG_RCR);
+                       val_rcr &= 0x00070000;
+                       if (val_rcr)
+                               *((bool *)(val)) = false;
+                       else
+                               *((bool *)(val)) = true;
+               }
+               break; }
+       case HW_VAR_FW_PSMODE_STATUS:
+               *((bool *)(val)) = ppsc->fw_current_inpsmode;
+               break;
+       case HW_VAR_CORRECT_TSF:{
+               u64 tsf;
+               u32 *ptsf_low = (u32 *)&tsf;
+               u32 *ptsf_high = ((u32 *)&tsf) + 1;
+               *ptsf_high = rtl_read_dword(rtlpriv, (REG_TSFTR + 4));
+               *ptsf_low = rtl_read_dword(rtlpriv, REG_TSFTR);
+               *((u64 *)(val)) = tsf;
+               break; }
+       case HAL_DEF_WOWLAN:
+               if (ppsc->wo_wlan_mode)
+                       *((bool *)(val)) = true;
+               else
+                       *((bool *)(val)) = false;
+               break;
+       default:
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_LOUD,
+                        "switch case not process %x\n", variable);
+               break;
+       }
+ }
+ void rtl8821ae_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
+       struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       u8 idx;
+       switch (variable) {
+       case HW_VAR_ETHER_ADDR:{
+                       for (idx = 0; idx < ETH_ALEN; idx++) {
+                               rtl_write_byte(rtlpriv, (REG_MACID + idx),
+                                              val[idx]);
+                       }
+                       break;
+               }
+       case HW_VAR_BASIC_RATE:{
+                       u16 b_rate_cfg = ((u16 *)val)[0];
+                       b_rate_cfg = b_rate_cfg & 0x15f;
+                       rtl_write_word(rtlpriv, REG_RRSR, b_rate_cfg);
+                       break;
+               }
+       case HW_VAR_BSSID:{
+                       for (idx = 0; idx < ETH_ALEN; idx++) {
+                               rtl_write_byte(rtlpriv, (REG_BSSID + idx),
+                                              val[idx]);
+                       }
+                       break;
+               }
+       case HW_VAR_SIFS:
+               rtl_write_byte(rtlpriv, REG_SIFS_CTX + 1, val[0]);
+               rtl_write_byte(rtlpriv, REG_SIFS_TRX + 1, val[0]);
+               rtl_write_byte(rtlpriv, REG_SPEC_SIFS + 1, val[0]);
+               rtl_write_byte(rtlpriv, REG_MAC_SPEC_SIFS + 1, val[0]);
+               rtl_write_byte(rtlpriv, REG_RESP_SIFS_OFDM + 1, val[0]);
+               rtl_write_byte(rtlpriv, REG_RESP_SIFS_OFDM, val[0]);
+               break;
+       case HW_VAR_R2T_SIFS:
+               rtl_write_byte(rtlpriv, REG_RESP_SIFS_OFDM + 1, val[0]);
+               break;
+       case HW_VAR_SLOT_TIME:{
+               u8 e_aci;
+               RT_TRACE(rtlpriv, COMP_MLME, DBG_LOUD,
+                        "HW_VAR_SLOT_TIME %x\n", val[0]);
+               rtl_write_byte(rtlpriv, REG_SLOT, val[0]);
+               for (e_aci = 0; e_aci < AC_MAX; e_aci++) {
+                       rtlpriv->cfg->ops->set_hw_reg(hw,
+                                                     HW_VAR_AC_PARAM,
+                                                     (u8 *)(&e_aci));
+               }
+               break; }
+       case HW_VAR_ACK_PREAMBLE:{
+               u8 reg_tmp;
+               u8 short_preamble = (bool)(*(u8 *)val);
+               reg_tmp = rtl_read_byte(rtlpriv, REG_TRXPTCL_CTL+2);
+               if (short_preamble) {
+                       reg_tmp |= BIT(1);
+                       rtl_write_byte(rtlpriv, REG_TRXPTCL_CTL + 2,
+                                      reg_tmp);
+               } else {
+                       reg_tmp &= (~BIT(1));
+                       rtl_write_byte(rtlpriv,
+                               REG_TRXPTCL_CTL + 2,
+                               reg_tmp);
+               }
+               break; }
+       case HW_VAR_WPA_CONFIG:
+               rtl_write_byte(rtlpriv, REG_SECCFG, *((u8 *)val));
+               break;
+       case HW_VAR_AMPDU_MIN_SPACE:{
+               u8 min_spacing_to_set;
+               u8 sec_min_space;
+               min_spacing_to_set = *((u8 *)val);
+               if (min_spacing_to_set <= 7) {
+                       sec_min_space = 0;
+                       if (min_spacing_to_set < sec_min_space)
+                               min_spacing_to_set = sec_min_space;
+                       mac->min_space_cfg = ((mac->min_space_cfg &
+                                              0xf8) |
+                                             min_spacing_to_set);
+                       *val = min_spacing_to_set;
+                       RT_TRACE(rtlpriv, COMP_MLME, DBG_LOUD,
+                                "Set HW_VAR_AMPDU_MIN_SPACE: %#x\n",
+                                 mac->min_space_cfg);
+                       rtl_write_byte(rtlpriv, REG_AMPDU_MIN_SPACE,
+                                      mac->min_space_cfg);
+               }
+               break; }
+       case HW_VAR_SHORTGI_DENSITY:{
+               u8 density_to_set;
+               density_to_set = *((u8 *)val);
+               mac->min_space_cfg |= (density_to_set << 3);
+               RT_TRACE(rtlpriv, COMP_MLME, DBG_LOUD,
+                        "Set HW_VAR_SHORTGI_DENSITY: %#x\n",
+                         mac->min_space_cfg);
+               rtl_write_byte(rtlpriv, REG_AMPDU_MIN_SPACE,
+                              mac->min_space_cfg);
+               break; }
+       case HW_VAR_AMPDU_FACTOR:{
+               u32     ampdu_len =  (*((u8 *)val));
+               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
+                       if (ampdu_len < VHT_AGG_SIZE_128K)
+                               ampdu_len =
+                                       (0x2000 << (*((u8 *)val))) - 1;
+                       else
+                               ampdu_len = 0x1ffff;
+               } else if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+                       if (ampdu_len < HT_AGG_SIZE_64K)
+                               ampdu_len =
+                                       (0x2000 << (*((u8 *)val))) - 1;
+                       else
+                               ampdu_len = 0xffff;
+               }
+               ampdu_len |= BIT(31);
+               rtl_write_dword(rtlpriv,
+                       REG_AMPDU_MAX_LENGTH_8812, ampdu_len);
+               break; }
+       case HW_VAR_AC_PARAM:{
+               u8 e_aci = *((u8 *)val);
+               rtl8821ae_dm_init_edca_turbo(hw);
+               if (rtlpci->acm_method != EACMWAY2_SW)
+                       rtlpriv->cfg->ops->set_hw_reg(hw,
+                                                     HW_VAR_ACM_CTRL,
+                                                     (u8 *)(&e_aci));
+               break; }
+       case HW_VAR_ACM_CTRL:{
+               u8 e_aci = *((u8 *)val);
+               union aci_aifsn *p_aci_aifsn =
+                   (union aci_aifsn *)(&mac->ac[0].aifs);
+               u8 acm = p_aci_aifsn->f.acm;
+               u8 acm_ctrl = rtl_read_byte(rtlpriv, REG_ACMHWCTRL);
+               acm_ctrl =
+                   acm_ctrl | ((rtlpci->acm_method == 2) ? 0x0 : 0x1);
+               if (acm) {
+                       switch (e_aci) {
+                       case AC0_BE:
+                               acm_ctrl |= ACMHW_BEQEN;
+                               break;
+                       case AC2_VI:
+                               acm_ctrl |= ACMHW_VIQEN;
+                               break;
+                       case AC3_VO:
+                               acm_ctrl |= ACMHW_VOQEN;
+                               break;
+                       default:
+                               RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
+                                        "HW_VAR_ACM_CTRL acm set failed: eACI is %d\n",
+                                        acm);
+                               break;
+                       }
+               } else {
+                       switch (e_aci) {
+                       case AC0_BE:
+                               acm_ctrl &= (~ACMHW_BEQEN);
+                               break;
+                       case AC2_VI:
+                               acm_ctrl &= (~ACMHW_VIQEN);
+                               break;
+                       case AC3_VO:
+                               acm_ctrl &= (~ACMHW_VOQEN);
+                               break;
+                       default:
+                               RT_TRACE(rtlpriv, COMP_ERR, DBG_LOUD,
+                                        "switch case not process\n");
+                               break;
+                       }
+               }
+               RT_TRACE(rtlpriv, COMP_QOS, DBG_TRACE,
+                        "SetHwReg8190pci(): [HW_VAR_ACM_CTRL] Write 0x%X\n",
+                        acm_ctrl);
+               rtl_write_byte(rtlpriv, REG_ACMHWCTRL, acm_ctrl);
+               break; }
+       case HW_VAR_RCR:
+               rtl_write_dword(rtlpriv, REG_RCR, ((u32 *)(val))[0]);
+               rtlpci->receive_config = ((u32 *)(val))[0];
+               break;
+       case HW_VAR_RETRY_LIMIT:{
+               u8 retry_limit = ((u8 *)(val))[0];
+               rtl_write_word(rtlpriv, REG_RL,
+                              retry_limit << RETRY_LIMIT_SHORT_SHIFT |
+                              retry_limit << RETRY_LIMIT_LONG_SHIFT);
+               break; }
+       case HW_VAR_DUAL_TSF_RST:
+               rtl_write_byte(rtlpriv, REG_DUAL_TSF_RST, (BIT(0) | BIT(1)));
+               break;
+       case HW_VAR_EFUSE_BYTES:
+               rtlefuse->efuse_usedbytes = *((u16 *)val);
+               break;
+       case HW_VAR_EFUSE_USAGE:
+               rtlefuse->efuse_usedpercentage = *((u8 *)val);
+               break;
+       case HW_VAR_IO_CMD:
+               rtl8821ae_phy_set_io_cmd(hw, (*(enum io_type *)val));
+               break;
+       case HW_VAR_SET_RPWM:{
+               u8 rpwm_val;
+               rpwm_val = rtl_read_byte(rtlpriv, REG_PCIE_HRPWM);
+               udelay(1);
+               if (rpwm_val & BIT(7)) {
+                       rtl_write_byte(rtlpriv, REG_PCIE_HRPWM,
+                                      (*(u8 *)val));
+               } else {
+                       rtl_write_byte(rtlpriv, REG_PCIE_HRPWM,
+                                      ((*(u8 *)val) | BIT(7)));
+               }
+               break; }
+       case HW_VAR_H2C_FW_PWRMODE:
+               rtl8821ae_set_fw_pwrmode_cmd(hw, (*(u8 *)val));
+               break;
+       case HW_VAR_FW_PSMODE_STATUS:
+               ppsc->fw_current_inpsmode = *((bool *)val);
+               break;
+       case HW_VAR_INIT_RTS_RATE:
+               break;
+       case HW_VAR_RESUME_CLK_ON:
+               _rtl8821ae_set_fw_ps_rf_on(hw);
+               break;
+       case HW_VAR_FW_LPS_ACTION:{
+               bool b_enter_fwlps = *((bool *)val);
+               if (b_enter_fwlps)
+                       _rtl8821ae_fwlps_enter(hw);
+                else
+                       _rtl8821ae_fwlps_leave(hw);
+                break; }
+       case HW_VAR_H2C_FW_JOINBSSRPT:{
+               u8 mstatus = (*(u8 *)val);
+               if (mstatus == RT_MEDIA_CONNECT) {
+                       rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_AID,
+                                                     NULL);
+                       _rtl8821ae_download_rsvd_page(hw, false);
+               }
+               rtl8821ae_set_fw_media_status_rpt_cmd(hw, mstatus);
+               break; }
+       case HW_VAR_H2C_FW_P2P_PS_OFFLOAD:
+               rtl8821ae_set_p2p_ps_offload_cmd(hw, (*(u8 *)val));
+               break;
+       case HW_VAR_AID:{
+               u16 u2btmp;
+               u2btmp = rtl_read_word(rtlpriv, REG_BCN_PSR_RPT);
+               u2btmp &= 0xC000;
+               rtl_write_word(rtlpriv, REG_BCN_PSR_RPT, (u2btmp |
+                              mac->assoc_id));
+               break; }
+       case HW_VAR_CORRECT_TSF:{
+               u8 btype_ibss = ((u8 *)(val))[0];
+               if (btype_ibss)
+                       _rtl8821ae_stop_tx_beacon(hw);
+               _rtl8821ae_set_bcn_ctrl_reg(hw, 0, BIT(3));
+               rtl_write_dword(rtlpriv, REG_TSFTR,
+                               (u32)(mac->tsf & 0xffffffff));
+               rtl_write_dword(rtlpriv, REG_TSFTR + 4,
+                               (u32)((mac->tsf >> 32) & 0xffffffff));
+               _rtl8821ae_set_bcn_ctrl_reg(hw, BIT(3), 0);
+               if (btype_ibss)
+                       _rtl8821ae_resume_tx_beacon(hw);
+               break; }
+       case HW_VAR_NAV_UPPER: {
+               u32     us_nav_upper = ((u32)*val);
+               if (us_nav_upper > HAL_92C_NAV_UPPER_UNIT * 0xFF) {
+                       RT_TRACE(rtlpriv, COMP_INIT , DBG_WARNING,
+                                "The setting value (0x%08X us) of NAV_UPPER is larger than (%d * 0xFF)!!!\n",
+                                us_nav_upper, HAL_92C_NAV_UPPER_UNIT);
+                       break;
+               }
+               rtl_write_byte(rtlpriv, REG_NAV_UPPER,
+                              ((u8)((us_nav_upper +
+                               HAL_92C_NAV_UPPER_UNIT - 1) /
+                               HAL_92C_NAV_UPPER_UNIT)));
+               break; }
+       case HW_VAR_KEEP_ALIVE: {
+               u8 array[2];
+               array[0] = 0xff;
+               array[1] = *((u8 *)val);
+               rtl8821ae_fill_h2c_cmd(hw, H2C_8821AE_KEEP_ALIVE_CTRL, 2,
+                                      array);
+               break; }
+       default:
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_LOUD,
+                        "switch case not process %x\n", variable);
+               break;
+       }
+ }
+ static bool _rtl8821ae_llt_write(struct ieee80211_hw *hw, u32 address, u32 data)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       bool status = true;
+       long count = 0;
+       u32 value = _LLT_INIT_ADDR(address) | _LLT_INIT_DATA(data) |
+                   _LLT_OP(_LLT_WRITE_ACCESS);
+       rtl_write_dword(rtlpriv, REG_LLT_INIT, value);
+       do {
+               value = rtl_read_dword(rtlpriv, REG_LLT_INIT);
+               if (_LLT_NO_ACTIVE == _LLT_OP_VALUE(value))
+                       break;
+               if (count > POLLING_LLT_THRESHOLD) {
+                       RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                                "Failed to polling write LLT done at address %d!\n",
+                                address);
+                       status = false;
+                       break;
+               }
+       } while (++count);
+       return status;
+ }
+ static bool _rtl8821ae_llt_table_init(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       unsigned short i;
+       u8 txpktbuf_bndy;
+       u32 rqpn;
+       u8 maxpage;
+       bool status;
+       maxpage = 255;
+       txpktbuf_bndy = 0xF8;
+       rqpn = 0x80e70808;
+       if (rtlpriv->rtlhal.hw_type == HARDWARE_TYPE_RTL8812AE) {
+               txpktbuf_bndy = 0xFA;
+               rqpn = 0x80e90808;
+       }
+       rtl_write_byte(rtlpriv, REG_TRXFF_BNDY, txpktbuf_bndy);
+       rtl_write_word(rtlpriv, REG_TRXFF_BNDY + 2, MAX_RX_DMA_BUFFER_SIZE - 1);
+       rtl_write_byte(rtlpriv, REG_TDECTRL + 1, txpktbuf_bndy);
+       rtl_write_byte(rtlpriv, REG_TXPKTBUF_BCNQ_BDNY, txpktbuf_bndy);
+       rtl_write_byte(rtlpriv, REG_TXPKTBUF_MGQ_BDNY, txpktbuf_bndy);
+       rtl_write_byte(rtlpriv, REG_PBP, 0x31);
+       rtl_write_byte(rtlpriv, REG_RX_DRVINFO_SZ, 0x4);
+       for (i = 0; i < (txpktbuf_bndy - 1); i++) {
+               status = _rtl8821ae_llt_write(hw, i, i + 1);
+               if (!status)
+                       return status;
+       }
+       status = _rtl8821ae_llt_write(hw, (txpktbuf_bndy - 1), 0xFF);
+       if (!status)
+               return status;
+       for (i = txpktbuf_bndy; i < maxpage; i++) {
+               status = _rtl8821ae_llt_write(hw, i, (i + 1));
+               if (!status)
+                       return status;
+       }
+       status = _rtl8821ae_llt_write(hw, maxpage, txpktbuf_bndy);
+       if (!status)
+               return status;
+       rtl_write_dword(rtlpriv, REG_RQPN, rqpn);
+       rtl_write_byte(rtlpriv, REG_RQPN_NPQ, 0x00);
+       return true;
+ }
+ static void _rtl8821ae_gen_refresh_led_state(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci_priv *pcipriv = rtl_pcipriv(hw);
+       struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
+       struct rtl_led *pled0 = &pcipriv->ledctl.sw_led0;
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       if (rtlpriv->rtlhal.up_first_time)
+               return;
+       if (ppsc->rfoff_reason == RF_CHANGE_BY_IPS)
+               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE)
+                       rtl8812ae_sw_led_on(hw, pled0);
+               else
+                       rtl8821ae_sw_led_on(hw, pled0);
+       else if (ppsc->rfoff_reason == RF_CHANGE_BY_INIT)
+               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE)
+                       rtl8812ae_sw_led_on(hw, pled0);
+               else
+                       rtl8821ae_sw_led_on(hw, pled0);
+       else
+               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE)
+                       rtl8812ae_sw_led_off(hw, pled0);
+               else
+                       rtl8821ae_sw_led_off(hw, pled0);
+ }
+ static bool _rtl8821ae_init_mac(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       u8 bytetmp = 0;
+       u16 wordtmp = 0;
+       bool mac_func_enable = rtlhal->mac_func_enable;
+       rtl_write_byte(rtlpriv, REG_RSV_CTRL, 0x00);
+       /*Auto Power Down to CHIP-off State*/
+       bytetmp = rtl_read_byte(rtlpriv, REG_APS_FSMCO + 1) & (~BIT(7));
+       rtl_write_byte(rtlpriv, REG_APS_FSMCO + 1, bytetmp);
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
+               /* HW Power on sequence*/
+               if (!rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK,
+                                             PWR_FAB_ALL_MSK, PWR_INTF_PCI_MSK,
+                                             RTL8812_NIC_ENABLE_FLOW)) {
+                               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                                        "init 8812 MAC Fail as power on failure\n");
+                               return false;
+               }
+       } else {
+               /* HW Power on sequence */
+               if (!rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_A_MSK,
+                                             PWR_FAB_ALL_MSK, PWR_INTF_PCI_MSK,
+                                             RTL8821A_NIC_ENABLE_FLOW)){
+                       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                               "init 8821 MAC Fail as power on failure\n");
+                       return false;
+               }
+       }
+       bytetmp = rtl_read_byte(rtlpriv, REG_APS_FSMCO) | BIT(4);
+       rtl_write_byte(rtlpriv, REG_APS_FSMCO, bytetmp);
+       bytetmp = rtl_read_byte(rtlpriv, REG_CR);
+       bytetmp = 0xff;
+       rtl_write_byte(rtlpriv, REG_CR, bytetmp);
+       mdelay(2);
+       bytetmp = 0xff;
+       rtl_write_byte(rtlpriv, REG_HWSEQ_CTRL, bytetmp);
+       mdelay(2);
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+               bytetmp = rtl_read_byte(rtlpriv, REG_SYS_CFG + 3);
+               if (bytetmp & BIT(0)) {
+                       bytetmp = rtl_read_byte(rtlpriv, 0x7c);
+                       bytetmp |= BIT(6);
+                       rtl_write_byte(rtlpriv, 0x7c, bytetmp);
+               }
+       }
+       bytetmp = rtl_read_byte(rtlpriv, REG_GPIO_MUXCFG + 1);
+       bytetmp &= ~BIT(4);
+       rtl_write_byte(rtlpriv, REG_GPIO_MUXCFG + 1, bytetmp);
+       rtl_write_word(rtlpriv, REG_CR, 0x2ff);
+       if (!mac_func_enable) {
+               if (!_rtl8821ae_llt_table_init(hw))
+                       return false;
+       }
+       rtl_write_dword(rtlpriv, REG_HISR, 0xffffffff);
+       rtl_write_dword(rtlpriv, REG_HISRE, 0xffffffff);
+       /* Enable FW Beamformer Interrupt */
+       bytetmp = rtl_read_byte(rtlpriv, REG_FWIMR + 3);
+       rtl_write_byte(rtlpriv, REG_FWIMR + 3, bytetmp | BIT(6));
+       wordtmp = rtl_read_word(rtlpriv, REG_TRXDMA_CTRL);
+       wordtmp &= 0xf;
+       wordtmp |= 0xF5B1;
+       rtl_write_word(rtlpriv, REG_TRXDMA_CTRL, wordtmp);
+       rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 1, 0x1F);
+       rtl_write_dword(rtlpriv, REG_RCR, rtlpci->receive_config);
+       rtl_write_word(rtlpriv, REG_RXFLTMAP2, 0xFFFF);
+       /*low address*/
+       rtl_write_dword(rtlpriv, REG_BCNQ_DESA,
+                       rtlpci->tx_ring[BEACON_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_MGQ_DESA,
+                       rtlpci->tx_ring[MGNT_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_VOQ_DESA,
+                       rtlpci->tx_ring[VO_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_VIQ_DESA,
+                       rtlpci->tx_ring[VI_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_BEQ_DESA,
+                       rtlpci->tx_ring[BE_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_BKQ_DESA,
+                       rtlpci->tx_ring[BK_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_HQ_DESA,
+                       rtlpci->tx_ring[HIGH_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_RX_DESA,
+                       rtlpci->rx_ring[RX_MPDU_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 3, 0x77);
+       rtl_write_dword(rtlpriv, REG_INT_MIG, 0);
+       rtl_write_dword(rtlpriv, REG_MCUTST_1, 0);
+       rtl_write_byte(rtlpriv, REG_SECONDARY_CCA_CTRL, 0x3);
+       _rtl8821ae_gen_refresh_led_state(hw);
+       return true;
+ }
+ static void _rtl8821ae_hw_configure(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       u32 reg_rrsr;
+       reg_rrsr = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
+       rtl_write_dword(rtlpriv, REG_RRSR, reg_rrsr);
+       /* ARFB table 9 for 11ac 5G 2SS */
+       rtl_write_dword(rtlpriv, REG_ARFR0 + 4, 0xfffff000);
+       /* ARFB table 10 for 11ac 5G 1SS */
+       rtl_write_dword(rtlpriv, REG_ARFR1 + 4, 0x003ff000);
+       /* ARFB table 11 for 11ac 24G 1SS */
+       rtl_write_dword(rtlpriv, REG_ARFR2, 0x00000015);
+       rtl_write_dword(rtlpriv, REG_ARFR2 + 4, 0x003ff000);
+       /* ARFB table 12 for 11ac 24G 1SS */
+       rtl_write_dword(rtlpriv, REG_ARFR3, 0x00000015);
+       rtl_write_dword(rtlpriv, REG_ARFR3 + 4, 0xffcff000);
+       /* 0x420[7] = 0 , enable retry AMPDU in new AMPD not singal MPDU. */
+       rtl_write_word(rtlpriv, REG_FWHW_TXQ_CTRL, 0x1F00);
+       rtl_write_byte(rtlpriv, REG_AMPDU_MAX_TIME, 0x70);
+       /*Set retry limit*/
+       rtl_write_word(rtlpriv, REG_RL, 0x0707);
+       /* Set Data / Response auto rate fallack retry count*/
+       rtl_write_dword(rtlpriv, REG_DARFRC, 0x01000000);
+       rtl_write_dword(rtlpriv, REG_DARFRC + 4, 0x07060504);
+       rtl_write_dword(rtlpriv, REG_RARFRC, 0x01000000);
+       rtl_write_dword(rtlpriv, REG_RARFRC + 4, 0x07060504);
+       rtlpci->reg_bcn_ctrl_val = 0x1d;
+       rtl_write_byte(rtlpriv, REG_BCN_CTRL, rtlpci->reg_bcn_ctrl_val);
+       /* TBTT prohibit hold time. Suggested by designer TimChen. */
+       rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0xff);
+       /* AGGR_BK_TIME Reg51A 0x16 */
+       rtl_write_word(rtlpriv, REG_NAV_PROT_LEN, 0x0040);
+       /*For Rx TP. Suggested by SD1 Richard. Added by tynli. 2010.04.12.*/
+       rtl_write_dword(rtlpriv, REG_FAST_EDCA_CTRL, 0x03086666);
+       rtl_write_byte(rtlpriv, REG_HT_SINGLE_AMPDU, 0x80);
+       rtl_write_byte(rtlpriv, REG_RX_PKT_LIMIT, 0x20);
+       rtl_write_word(rtlpriv, REG_MAX_AGGR_NUM, 0x1F1F);
+ }
+ static u16 _rtl8821ae_mdio_read(struct rtl_priv *rtlpriv, u8 addr)
+ {
+       u16 ret = 0;
+       u8 tmp = 0, count = 0;
+       rtl_write_byte(rtlpriv, REG_MDIO_CTL, addr | BIT(6));
+       tmp = rtl_read_byte(rtlpriv, REG_MDIO_CTL) & BIT(6);
+       count = 0;
+       while (tmp && count < 20) {
+               udelay(10);
+               tmp = rtl_read_byte(rtlpriv, REG_MDIO_CTL) & BIT(6);
+               count++;
+       }
+       if (0 == tmp)
+               ret = rtl_read_word(rtlpriv, REG_MDIO_RDATA);
+       return ret;
+ }
+ static void _rtl8821ae_mdio_write(struct rtl_priv *rtlpriv, u8 addr, u16 data)
+ {
+       u8 tmp = 0, count = 0;
+       rtl_write_word(rtlpriv, REG_MDIO_WDATA, data);
+       rtl_write_byte(rtlpriv, REG_MDIO_CTL, addr | BIT(5));
+       tmp = rtl_read_byte(rtlpriv, REG_MDIO_CTL) & BIT(5);
+       count = 0;
+       while (tmp && count < 20) {
+               udelay(10);
+               tmp = rtl_read_byte(rtlpriv, REG_MDIO_CTL) & BIT(5);
+               count++;
+       }
+ }
+ static u8 _rtl8821ae_dbi_read(struct rtl_priv *rtlpriv, u16 addr)
+ {
+       u16 read_addr = addr & 0xfffc;
+       u8 tmp = 0, count = 0, ret = 0;
+       rtl_write_word(rtlpriv, REG_DBI_ADDR, read_addr);
+       rtl_write_byte(rtlpriv, REG_DBI_FLAG, 0x2);
+       tmp = rtl_read_byte(rtlpriv, REG_DBI_FLAG);
+       count = 0;
+       while (tmp && count < 20) {
+               udelay(10);
+               tmp = rtl_read_byte(rtlpriv, REG_DBI_FLAG);
+               count++;
+       }
+       if (0 == tmp) {
+               read_addr = REG_DBI_RDATA + addr % 4;
+               ret = rtl_read_word(rtlpriv, read_addr);
+       }
+       return ret;
+ }
+ static void _rtl8821ae_dbi_write(struct rtl_priv *rtlpriv, u16 addr, u8 data)
+ {
+       u8 tmp = 0, count = 0;
+       u16 wrtie_addr, remainder = addr % 4;
+       wrtie_addr = REG_DBI_WDATA + remainder;
+       rtl_write_byte(rtlpriv, wrtie_addr, data);
+       wrtie_addr = (addr & 0xfffc) | (BIT(0) << (remainder + 12));
+       rtl_write_word(rtlpriv, REG_DBI_ADDR, wrtie_addr);
+       rtl_write_byte(rtlpriv, REG_DBI_FLAG, 0x1);
+       tmp = rtl_read_byte(rtlpriv, REG_DBI_FLAG);
+       count = 0;
+       while (tmp && count < 20) {
+               udelay(10);
+               tmp = rtl_read_byte(rtlpriv, REG_DBI_FLAG);
+               count++;
+       }
+ }
+ static void _rtl8821ae_enable_aspm_back_door(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       u8 tmp;
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+               if (_rtl8821ae_mdio_read(rtlpriv, 0x04) != 0x8544)
+                       _rtl8821ae_mdio_write(rtlpriv, 0x04, 0x8544);
+               if (_rtl8821ae_mdio_read(rtlpriv, 0x0b) != 0x0070)
+                       _rtl8821ae_mdio_write(rtlpriv, 0x0b, 0x0070);
+       }
+       tmp = _rtl8821ae_dbi_read(rtlpriv, 0x70f);
+       _rtl8821ae_dbi_write(rtlpriv, 0x70f, tmp | BIT(7));
+       tmp = _rtl8821ae_dbi_read(rtlpriv, 0x719);
+       _rtl8821ae_dbi_write(rtlpriv, 0x719, tmp | BIT(3) | BIT(4));
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
+               tmp  = _rtl8821ae_dbi_read(rtlpriv, 0x718);
+               _rtl8821ae_dbi_write(rtlpriv, 0x718, tmp|BIT(4));
+       }
+ }
+ void rtl8821ae_enable_hw_security_config(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u8 sec_reg_value;
+       u8 tmp;
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
+                "PairwiseEncAlgorithm = %d GroupEncAlgorithm = %d\n",
+                 rtlpriv->sec.pairwise_enc_algorithm,
+                 rtlpriv->sec.group_enc_algorithm);
+       if (rtlpriv->cfg->mod_params->sw_crypto || rtlpriv->sec.use_sw_sec) {
+               RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
+                        "not open hw encryption\n");
+               return;
+       }
+       sec_reg_value = SCR_TXENCENABLE | SCR_RXDECENABLE;
+       if (rtlpriv->sec.use_defaultkey) {
+               sec_reg_value |= SCR_TXUSEDK;
+               sec_reg_value |= SCR_RXUSEDK;
+       }
+       sec_reg_value |= (SCR_RXBCUSEDK | SCR_TXBCUSEDK);
+       tmp = rtl_read_byte(rtlpriv, REG_CR + 1);
+       rtl_write_byte(rtlpriv, REG_CR + 1, tmp | BIT(1));
+       RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
+                "The SECR-value %x\n", sec_reg_value);
+       rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_WPA_CONFIG, &sec_reg_value);
+ }
+ /* Static MacID Mapping (cf. Used in MacIdDoStaticMapping) ---------- */
+ #define MAC_ID_STATIC_FOR_DEFAULT_PORT                                0
+ #define MAC_ID_STATIC_FOR_BROADCAST_MULTICAST         1
+ #define MAC_ID_STATIC_FOR_BT_CLIENT_START                             2
+ #define MAC_ID_STATIC_FOR_BT_CLIENT_END                               3
+ /* ----------------------------------------------------------- */
+ static void rtl8821ae_macid_initialize_mediastatus(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u8      media_rpt[4] = {RT_MEDIA_CONNECT, 1,
+               MAC_ID_STATIC_FOR_BROADCAST_MULTICAST,
+               MAC_ID_STATIC_FOR_BT_CLIENT_END};
+       rtlpriv->cfg->ops->set_hw_reg(hw,
+               HW_VAR_H2C_FW_MEDIASTATUSRPT, media_rpt);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "Initialize MacId media status: from %d to %d\n",
+                MAC_ID_STATIC_FOR_BROADCAST_MULTICAST,
+                MAC_ID_STATIC_FOR_BT_CLIENT_END);
+ }
+ static bool _rtl8821ae_check_pcie_dma_hang(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u8 tmp;
+       /* write reg 0x350 Bit[26]=1. Enable debug port. */
+       tmp = rtl_read_byte(rtlpriv, REG_DBI_CTRL + 3);
+       if (!(tmp & BIT(2))) {
+               rtl_write_byte(rtlpriv, REG_DBI_CTRL + 3, (tmp | BIT(2)));
+               mdelay(100);
+       }
+       /* read reg 0x350 Bit[25] if 1 : RX hang */
+       /* read reg 0x350 Bit[24] if 1 : TX hang */
+       tmp = rtl_read_byte(rtlpriv, REG_DBI_CTRL + 3);
+       if ((tmp & BIT(0)) || (tmp & BIT(1))) {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "CheckPcieDMAHang8821AE(): true! Reset PCIE DMA!\n");
+               return true;
+       } else {
+               return false;
+       }
+ }
+ static bool _rtl8821ae_reset_pcie_interface_dma(struct ieee80211_hw *hw,
+                                        bool mac_power_on,
+                                        bool in_watchdog)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       u8 tmp;
+       bool release_mac_rx_pause;
+       u8 backup_pcie_dma_pause;
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "\n");
+       /* 1. Disable register write lock. 0x1c[1] = 0 */
+       tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL);
+       tmp &= ~(BIT(1));
+       rtl_write_byte(rtlpriv, REG_RSV_CTRL, tmp);
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+               /* write 0xCC bit[2] = 1'b1 */
+               tmp = rtl_read_byte(rtlpriv, REG_PMC_DBG_CTRL2);
+               tmp |= BIT(2);
+               rtl_write_byte(rtlpriv, REG_PMC_DBG_CTRL2, tmp);
+       }
+       /* 2. Check and pause TRX DMA */
+       /* write 0x284 bit[18] = 1'b1 */
+       /* write 0x301 = 0xFF */
+       tmp = rtl_read_byte(rtlpriv, REG_RXDMA_CONTROL);
+       if (tmp & BIT(2)) {
+               /* Already pause before the function for another purpose. */
+               release_mac_rx_pause = false;
+       } else {
+               rtl_write_byte(rtlpriv, REG_RXDMA_CONTROL, (tmp | BIT(2)));
+               release_mac_rx_pause = true;
+       }
+       backup_pcie_dma_pause = rtl_read_byte(rtlpriv, REG_PCIE_CTRL_REG + 1);
+       if (backup_pcie_dma_pause != 0xFF)
+               rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 1, 0xFF);
+       if (mac_power_on) {
+               /* 3. reset TRX function */
+               /* write 0x100 = 0x00 */
+               rtl_write_byte(rtlpriv, REG_CR, 0);
+       }
+       /* 4. Reset PCIe DMA. 0x3[0] = 0 */
+       tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
+       tmp &= ~(BIT(0));
+       rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, tmp);
+       /* 5. Enable PCIe DMA. 0x3[0] = 1 */
+       tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
+       tmp |= BIT(0);
+       rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, tmp);
+       if (mac_power_on) {
+               /* 6. enable TRX function */
+               /* write 0x100 = 0xFF */
+               rtl_write_byte(rtlpriv, REG_CR, 0xFF);
+               /* We should init LLT & RQPN and
+                * prepare Tx/Rx descrptor address later
+                * because MAC function is reset.*/
+       }
+       /* 7. Restore PCIe autoload down bit */
+       /* 8812AE does not has the defination. */
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+               /* write 0xF8 bit[17] = 1'b1 */
+               tmp = rtl_read_byte(rtlpriv, REG_MAC_PHY_CTRL_NORMAL + 2);
+               tmp |= BIT(1);
+               rtl_write_byte(rtlpriv, REG_MAC_PHY_CTRL_NORMAL + 2, tmp);
+       }
+       /* In MAC power on state, BB and RF maybe in ON state,
+        * if we release TRx DMA here.
+        * it will cause packets to be started to Tx/Rx,
+        * so we release Tx/Rx DMA later.*/
+       if (!mac_power_on/* || in_watchdog*/) {
+               /* 8. release TRX DMA */
+               /* write 0x284 bit[18] = 1'b0 */
+               /* write 0x301 = 0x00 */
+               if (release_mac_rx_pause) {
+                       tmp = rtl_read_byte(rtlpriv, REG_RXDMA_CONTROL);
+                       rtl_write_byte(rtlpriv, REG_RXDMA_CONTROL,
+                                      tmp & (~BIT(2)));
+               }
+               rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 1,
+                              backup_pcie_dma_pause);
+       }
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+               /* 9. lock system register */
+               /* write 0xCC bit[2] = 1'b0 */
+               tmp = rtl_read_byte(rtlpriv, REG_PMC_DBG_CTRL2);
+               tmp &= ~(BIT(2));
+               rtl_write_byte(rtlpriv, REG_PMC_DBG_CTRL2, tmp);
+       }
+       return true;
+ }
+ static void _rtl8821ae_get_wakeup_reason(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
+       u8 fw_reason = 0;
+       struct timeval ts;
+       fw_reason = rtl_read_byte(rtlpriv, REG_MCUTST_WOWLAN);
+       RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, "WOL Read 0x1c7 = %02X\n",
+                fw_reason);
+       ppsc->wakeup_reason = 0;
+       rtlhal->last_suspend_sec = ts.tv_sec;
+       switch (fw_reason) {
+       case FW_WOW_V2_PTK_UPDATE_EVENT:
+               ppsc->wakeup_reason = WOL_REASON_PTK_UPDATE;
+               do_gettimeofday(&ts);
+               ppsc->last_wakeup_time = ts.tv_sec*1000 + ts.tv_usec/1000;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's a WOL PTK Key update event!\n");
+               break;
+       case FW_WOW_V2_GTK_UPDATE_EVENT:
+               ppsc->wakeup_reason = WOL_REASON_GTK_UPDATE;
+               do_gettimeofday(&ts);
+               ppsc->last_wakeup_time = ts.tv_sec*1000 + ts.tv_usec/1000;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's a WOL GTK Key update event!\n");
+               break;
+       case FW_WOW_V2_DISASSOC_EVENT:
+               ppsc->wakeup_reason = WOL_REASON_DISASSOC;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's a disassociation event!\n");
+               break;
+       case FW_WOW_V2_DEAUTH_EVENT:
+               ppsc->wakeup_reason = WOL_REASON_DEAUTH;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's a deauth event!\n");
+               break;
+       case FW_WOW_V2_FW_DISCONNECT_EVENT:
+               ppsc->wakeup_reason = WOL_REASON_AP_LOST;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's a Fw disconnect decision (AP lost) event!\n");
+       break;
+       case FW_WOW_V2_MAGIC_PKT_EVENT:
+               ppsc->wakeup_reason = WOL_REASON_MAGIC_PKT;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's a magic packet event!\n");
+               break;
+       case FW_WOW_V2_UNICAST_PKT_EVENT:
+               ppsc->wakeup_reason = WOL_REASON_UNICAST_PKT;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's an unicast packet event!\n");
+               break;
+       case FW_WOW_V2_PATTERN_PKT_EVENT:
+               ppsc->wakeup_reason = WOL_REASON_PATTERN_PKT;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's a pattern match event!\n");
+               break;
+       case FW_WOW_V2_RTD3_SSID_MATCH_EVENT:
+               ppsc->wakeup_reason = WOL_REASON_RTD3_SSID_MATCH;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's an RTD3 Ssid match event!\n");
+               break;
+       case FW_WOW_V2_REALWOW_V2_WAKEUPPKT:
+               ppsc->wakeup_reason = WOL_REASON_REALWOW_V2_WAKEUPPKT;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's an RealWoW wake packet event!\n");
+               break;
+       case FW_WOW_V2_REALWOW_V2_ACKLOST:
+               ppsc->wakeup_reason = WOL_REASON_REALWOW_V2_ACKLOST;
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "It's an RealWoW ack lost event!\n");
+               break;
+       default:
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_DMESG,
+                        "WOL Read 0x1c7 = %02X, Unknown reason!\n",
+                         fw_reason);
+               break;
+       }
+ }
+ static void _rtl8821ae_init_trx_desc_hw_address(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       /*low address*/
+       rtl_write_dword(rtlpriv, REG_BCNQ_DESA,
+                       rtlpci->tx_ring[BEACON_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_MGQ_DESA,
+                       rtlpci->tx_ring[MGNT_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_VOQ_DESA,
+                       rtlpci->tx_ring[VO_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_VIQ_DESA,
+                       rtlpci->tx_ring[VI_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_BEQ_DESA,
+                       rtlpci->tx_ring[BE_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_BKQ_DESA,
+                       rtlpci->tx_ring[BK_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_HQ_DESA,
+                       rtlpci->tx_ring[HIGH_QUEUE].dma & DMA_BIT_MASK(32));
+       rtl_write_dword(rtlpriv, REG_RX_DESA,
+                       rtlpci->rx_ring[RX_MPDU_QUEUE].dma & DMA_BIT_MASK(32));
+ }
+ static bool _rtl8821ae_init_llt_table(struct ieee80211_hw *hw, u32 boundary)
+ {
+       bool status = true;
+       u32 i;
+       u32 txpktbuf_bndy = boundary;
+       u32 last_entry_of_txpktbuf = LAST_ENTRY_OF_TX_PKT_BUFFER;
+       for (i = 0 ; i < (txpktbuf_bndy - 1) ; i++) {
+               status = _rtl8821ae_llt_write(hw, i , i + 1);
+               if (!status)
+                       return status;
+       }
+       status = _rtl8821ae_llt_write(hw, (txpktbuf_bndy - 1), 0xFF);
+       if (!status)
+               return status;
+       for (i = txpktbuf_bndy ; i < last_entry_of_txpktbuf ; i++) {
+               status = _rtl8821ae_llt_write(hw, i, (i + 1));
+               if (!status)
+                       return status;
+       }
+       status = _rtl8821ae_llt_write(hw, last_entry_of_txpktbuf,
+                                     txpktbuf_bndy);
+       if (!status)
+               return status;
+       return status;
+ }
+ static bool _rtl8821ae_dynamic_rqpn(struct ieee80211_hw *hw, u32 boundary,
+                            u16 npq_rqpn_value, u32 rqpn_val)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u8 tmp;
+       bool ret = true;
+       u16 count = 0, tmp16;
+       bool support_remote_wakeup;
+       rtlpriv->cfg->ops->get_hw_reg(hw, HAL_DEF_WOWLAN,
+                                     (u8 *)(&support_remote_wakeup));
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "boundary=%#X, NPQ_RQPNValue=%#X, RQPNValue=%#X\n",
+                 boundary, npq_rqpn_value, rqpn_val);
+       /* stop PCIe DMA
+        * 1. 0x301[7:0] = 0xFE */
+       rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 1, 0xFE);
+       /* wait TXFF empty
+        * 2. polling till 0x41A[15:0]=0x07FF */
+       tmp16 = rtl_read_word(rtlpriv, REG_TXPKT_EMPTY);
+       while ((tmp16 & 0x07FF) != 0x07FF) {
+               udelay(100);
+               tmp16 = rtl_read_word(rtlpriv, REG_TXPKT_EMPTY);
+               count++;
+               if ((count % 200) == 0) {
+                       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                                "Tx queue is not empty for 20ms!\n");
+               }
+               if (count >= 1000) {
+                       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                                "Wait for Tx FIFO empty timeout!\n");
+                       break;
+               }
+       }
+       /* TX pause
+        * 3. reg 0x522=0xFF */
+       rtl_write_byte(rtlpriv, REG_TXPAUSE, 0xFF);
+       /* Wait TX State Machine OK
+        * 4. polling till reg 0x5FB~0x5F8 = 0x00000000 for 50ms */
+       count = 0;
+       while (rtl_read_byte(rtlpriv, REG_SCH_TXCMD) != 0) {
+               udelay(100);
+               count++;
+               if (count >= 500) {
+                       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                                "Wait for TX State Machine ready timeout !!\n");
+                       break;
+               }
+       }
+       /* stop RX DMA path
+        * 5.   0x284[18] = 1
+        * 6.   wait till 0x284[17] == 1
+        * wait RX DMA idle */
+       count = 0;
+       tmp = rtl_read_byte(rtlpriv, REG_RXDMA_CONTROL);
+       rtl_write_byte(rtlpriv, REG_RXDMA_CONTROL, (tmp | BIT(2)));
+       do {
+               tmp = rtl_read_byte(rtlpriv, REG_RXDMA_CONTROL);
+               udelay(10);
+               count++;
+       } while (!(tmp & BIT(1)) && count < 100);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "Wait until Rx DMA Idle. count=%d REG[0x286]=0x%x\n",
+                 count, tmp);
+       /* reset BB
+        * 7.   0x02 [0] = 0 */
+       tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN);
+       tmp &= ~(BIT(0));
+       rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN, tmp);
+       /* Reset TRX MAC
+        * 8.    0x100 = 0x00
+        * Delay (1ms) */
+       rtl_write_byte(rtlpriv, REG_CR, 0x00);
+       udelay(1000);
+       /* Disable MAC Security Engine
+        * 9.   0x100 bit[9]=0 */
+       tmp = rtl_read_byte(rtlpriv, REG_CR + 1);
+       tmp &= ~(BIT(1));
+       rtl_write_byte(rtlpriv, REG_CR + 1, tmp);
+       /* To avoid DD-Tim Circuit hang
+        * 10.  0x553 bit[5]=1 */
+       tmp = rtl_read_byte(rtlpriv, REG_DUAL_TSF_RST);
+       rtl_write_byte(rtlpriv, REG_DUAL_TSF_RST, (tmp | BIT(5)));
+       /* Enable MAC Security Engine
+        * 11.  0x100 bit[9]=1 */
+       tmp = rtl_read_byte(rtlpriv, REG_CR + 1);
+       rtl_write_byte(rtlpriv, REG_CR + 1, (tmp | BIT(1)));
+       /* Enable TRX MAC
+        * 12.   0x100 = 0xFF
+        *      Delay (1ms) */
+       rtl_write_byte(rtlpriv, REG_CR, 0xFF);
+       udelay(1000);
+       /* Enable BB
+        * 13.  0x02 [0] = 1 */
+       tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN);
+       rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN, (tmp | BIT(0)));
+       /* beacon setting
+        * 14,15. set beacon head page (reg 0x209 and 0x424) */
+       rtl_write_byte(rtlpriv, REG_TDECTRL + 1, (u8)boundary);
+       rtl_write_byte(rtlpriv, REG_TXPKTBUF_BCNQ_BDNY, (u8)boundary);
+       rtl_write_byte(rtlpriv, REG_TXPKTBUF_MGQ_BDNY, (u8)boundary);
+       /* 16.  WMAC_LBK_BF_HD 0x45D[7:0]
+        * WMAC_LBK_BF_HD */
+       rtl_write_byte(rtlpriv, REG_TXPKTBUF_WMAC_LBK_BF_HD,
+                      (u8)boundary);
+       rtl_write_word(rtlpriv, REG_TRXFF_BNDY, boundary);
+       /* init LLT
+        * 17. init LLT */
+       if (!_rtl8821ae_init_llt_table(hw, boundary)) {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_WARNING,
+                        "Failed to init LLT table!\n");
+               return false;
+       }
+       /* reallocate RQPN
+        * 18. reallocate RQPN and init LLT */
+       rtl_write_word(rtlpriv, REG_RQPN_NPQ, npq_rqpn_value);
+       rtl_write_dword(rtlpriv, REG_RQPN, rqpn_val);
+       /* release Tx pause
+        * 19. 0x522=0x00 */
+       rtl_write_byte(rtlpriv, REG_TXPAUSE, 0x00);
+       /* enable PCIE DMA
+        * 20. 0x301[7:0] = 0x00
+        * 21. 0x284[18] = 0 */
+       rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 1, 0x00);
+       tmp = rtl_read_byte(rtlpriv, REG_RXDMA_CONTROL);
+       rtl_write_byte(rtlpriv, REG_RXDMA_CONTROL, (tmp&~BIT(2)));
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "End.\n");
+       return ret;
+ }
+ static void _rtl8821ae_simple_initialize_adapter(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
+       struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
+ #if (USE_SPECIFIC_FW_TO_SUPPORT_WOWLAN == 1)
+       /* Re-download normal Fw. */
+       rtl8821ae_set_fw_related_for_wowlan(hw, false);
+ #endif
+       /* Re-Initialize LLT table. */
+       if (rtlhal->re_init_llt_table) {
+               u32 rqpn = 0x80e70808;
+               u8 rqpn_npq = 0, boundary = 0xF8;
+               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
+                       rqpn = 0x80e90808;
+                       boundary = 0xFA;
+               }
+               if (_rtl8821ae_dynamic_rqpn(hw, boundary, rqpn_npq, rqpn))
+                       rtlhal->re_init_llt_table = false;
+       }
+       ppsc->rfpwr_state = ERFON;
+ }
+ static void _rtl8821ae_enable_l1off(struct ieee80211_hw *hw)
+ {
+       u8 tmp  = 0;
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "--->\n");
+       tmp = _rtl8821ae_dbi_read(rtlpriv, 0x160);
+       if (!(tmp & (BIT(2) | BIT(3)))) {
+               RT_TRACE(rtlpriv, COMP_POWER | COMP_INIT, DBG_LOUD,
+                        "0x160(%#x)return!!\n", tmp);
+               return;
+       }
+       tmp = _rtl8821ae_mdio_read(rtlpriv, 0x1b);
+       _rtl8821ae_mdio_write(rtlpriv, 0x1b, (tmp | BIT(4)));
+       tmp = _rtl8821ae_dbi_read(rtlpriv, 0x718);
+       _rtl8821ae_dbi_write(rtlpriv, 0x718, tmp | BIT(5));
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "<---\n");
+ }
+ static void _rtl8821ae_enable_ltr(struct ieee80211_hw *hw)
+ {
+       u8 tmp  = 0;
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "--->\n");
+       /* Check 0x98[10] */
+       tmp = _rtl8821ae_dbi_read(rtlpriv, 0x99);
+       if (!(tmp & BIT(2))) {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "<---0x99(%#x) return!!\n", tmp);
+               return;
+       }
+       /* LTR idle latency, 0x90 for 144us */
+       rtl_write_dword(rtlpriv, 0x798, 0x88908890);
+       /* LTR active latency, 0x3c for 60us */
+       rtl_write_dword(rtlpriv, 0x79c, 0x883c883c);
+       tmp = rtl_read_byte(rtlpriv, 0x7a4);
+       rtl_write_byte(rtlpriv, 0x7a4, (tmp | BIT(4)));
+       tmp = rtl_read_byte(rtlpriv, 0x7a4);
+       rtl_write_byte(rtlpriv, 0x7a4, (tmp & (~BIT(0))));
+       rtl_write_byte(rtlpriv, 0x7a4, (tmp | BIT(0)));
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "<---\n");
+ }
+ static bool _rtl8821ae_wowlan_initialize_adapter(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
+       bool init_finished = true;
+       u8 tmp = 0;
+       /* Get Fw wake up reason. */
+       _rtl8821ae_get_wakeup_reason(hw);
+       /* Patch Pcie Rx DMA hang after S3/S4 several times.
+        * The root cause has not be found. */
+       if (_rtl8821ae_check_pcie_dma_hang(hw))
+               _rtl8821ae_reset_pcie_interface_dma(hw, true, false);
+       /* Prepare Tx/Rx Desc Hw address. */
+       _rtl8821ae_init_trx_desc_hw_address(hw);
+       /* Release Pcie Interface Rx DMA to allow wake packet DMA. */
+       rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 1, 0xFE);
+       RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, "Enable PCIE Rx DMA.\n");
+       /* Check wake up event.
+        * We should check wake packet bit before disable wowlan by H2C or
+        * Fw will clear the bit. */
+       tmp = rtl_read_byte(rtlpriv, REG_FTISR + 3);
+       RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
+                "Read REG_FTISR 0x13f = %#X\n", tmp);
+       /* Set the WoWLAN related function control disable. */
+       rtl8821ae_set_fw_wowlan_mode(hw, false);
+       rtl8821ae_set_fw_remote_wake_ctrl_cmd(hw, 0);
+       if (rtlhal->hw_rof_enable) {
+               tmp = rtl_read_byte(rtlpriv, REG_HSISR + 3);
+               if (tmp & BIT(1)) {
+                       /* Clear GPIO9 ISR */
+                       rtl_write_byte(rtlpriv, REG_HSISR + 3, tmp | BIT(1));
+                       init_finished = false;
+               } else {
+                       init_finished = true;
+               }
+       }
+       if (init_finished) {
+               _rtl8821ae_simple_initialize_adapter(hw);
+               /* Release Pcie Interface Tx DMA. */
+               rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 1, 0x00);
+               /* Release Pcie RX DMA */
+               rtl_write_byte(rtlpriv, REG_RXDMA_CONTROL, 0x02);
+               tmp = rtl_read_byte(rtlpriv, REG_CR + 1);
+               rtl_write_byte(rtlpriv, REG_CR + 1, (tmp & (~BIT(0))));
+               _rtl8821ae_enable_l1off(hw);
+               _rtl8821ae_enable_ltr(hw);
+       }
+       return init_finished;
+ }
+ static void _rtl8812ae_bb8812_config_1t(struct ieee80211_hw *hw)
+ {
+       /* BB OFDM RX Path_A */
+       rtl_set_bbreg(hw, 0x808, 0xff, 0x11);
+       /* BB OFDM TX Path_A */
+       rtl_set_bbreg(hw, 0x80c, MASKLWORD, 0x1111);
+       /* BB CCK R/Rx Path_A */
+       rtl_set_bbreg(hw, 0xa04, 0x0c000000, 0x0);
+       /* MCS support */
+       rtl_set_bbreg(hw, 0x8bc, 0xc0000060, 0x4);
+       /* RF Path_B HSSI OFF */
+       rtl_set_bbreg(hw, 0xe00, 0xf, 0x4);
+       /* RF Path_B Power Down */
+       rtl_set_bbreg(hw, 0xe90, MASKDWORD, 0);
+       /* ADDA Path_B OFF */
+       rtl_set_bbreg(hw, 0xe60, MASKDWORD, 0);
+       rtl_set_bbreg(hw, 0xe64, MASKDWORD, 0);
+ }
+ static void _rtl8821ae_poweroff_adapter(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       u8 u1b_tmp;
+       rtlhal->mac_func_enable = false;
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+               /* Combo (PCIe + USB) Card and PCIe-MF Card */
+               /* 1. Run LPS WL RFOFF flow */
+               /* RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+               "=====>CardDisableRTL8812E,RTL8821A_NIC_LPS_ENTER_FLOW\n");
+               */
+               rtl_hal_pwrseqcmdparsing(rtlpriv,
+                       PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
+                       PWR_INTF_PCI_MSK, RTL8821A_NIC_LPS_ENTER_FLOW);
+       }
+       /* 2. 0x1F[7:0] = 0 */
+       /* turn off RF */
+       /* rtl_write_byte(rtlpriv, REG_RF_CTRL, 0x00); */
+       if ((rtl_read_byte(rtlpriv, REG_MCUFWDL) & BIT(7)) &&
+               rtlhal->fw_ready) {
+               rtl8821ae_firmware_selfreset(hw);
+       }
+       /* Reset MCU. Suggested by Filen. */
+       u1b_tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN+1);
+       rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN+1, (u1b_tmp & (~BIT(2))));
+       /* g.   MCUFWDL 0x80[1:0]=0      */
+       /* reset MCU ready status */
+       rtl_write_byte(rtlpriv, REG_MCUFWDL, 0x00);
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+               /* HW card disable configuration. */
+               rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
+                       PWR_INTF_PCI_MSK, RTL8821A_NIC_DISABLE_FLOW);
+       } else {
+               /* HW card disable configuration. */
+               rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
+                       PWR_INTF_PCI_MSK, RTL8812_NIC_DISABLE_FLOW);
+       }
+       /* Reset MCU IO Wrapper */
+       u1b_tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL + 1);
+       rtl_write_byte(rtlpriv, REG_RSV_CTRL + 1, (u1b_tmp & (~BIT(0))));
+       u1b_tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL + 1);
+       rtl_write_byte(rtlpriv, REG_RSV_CTRL + 1, u1b_tmp | BIT(0));
+       /* 7. RSV_CTRL 0x1C[7:0] = 0x0E */
+       /* lock ISO/CLK/Power control register */
+       rtl_write_byte(rtlpriv, REG_RSV_CTRL, 0x0e);
+ }
+ int rtl8821ae_hw_init(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
+       bool rtstatus = true;
+       int err;
+       u8 tmp_u1b;
+       bool support_remote_wakeup;
+       u32 nav_upper = WIFI_NAV_UPPER_US;
+       rtlhal->being_init_adapter = true;
+       rtlpriv->cfg->ops->get_hw_reg(hw, HAL_DEF_WOWLAN,
+                                     (u8 *)(&support_remote_wakeup));
+       rtlpriv->intf_ops->disable_aspm(hw);
+       /*YP wowlan not considered*/
+       tmp_u1b = rtl_read_byte(rtlpriv, REG_CR);
+       if (tmp_u1b != 0 && tmp_u1b != 0xEA) {
+               rtlhal->mac_func_enable = true;
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "MAC has already power on.\n");
+       } else {
+               rtlhal->mac_func_enable = false;
+               rtlhal->fw_ps_state = FW_PS_STATE_ALL_ON_8821AE;
+       }
+       if (support_remote_wakeup &&
+               rtlhal->wake_from_pnp_sleep &&
+               rtlhal->mac_func_enable) {
+               if (_rtl8821ae_wowlan_initialize_adapter(hw)) {
+                       rtlhal->being_init_adapter = false;
+                       return 0;
+               }
+       }
+       if (_rtl8821ae_check_pcie_dma_hang(hw)) {
+               _rtl8821ae_reset_pcie_interface_dma(hw,
+                                                   rtlhal->mac_func_enable,
+                                                   false);
+               rtlhal->mac_func_enable = false;
+       }
+       /* Reset MAC/BB/RF status if it is not powered off
+        * before calling initialize Hw flow to prevent
+        * from interface and MAC status mismatch.
+        * 2013.06.21, by tynli. Suggested by SD1 JackieLau. */
+       if (rtlhal->mac_func_enable) {
+               _rtl8821ae_poweroff_adapter(hw);
+               rtlhal->mac_func_enable = false;
+       }
+       rtstatus = _rtl8821ae_init_mac(hw);
+       if (rtstatus != true) {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Init MAC failed\n");
+               err = 1;
+               return err;
+       }
+       tmp_u1b = rtl_read_byte(rtlpriv, REG_SYS_CFG);
+       tmp_u1b &= 0x7F;
+       rtl_write_byte(rtlpriv, REG_SYS_CFG, tmp_u1b);
+       err = rtl8821ae_download_fw(hw, false);
+       if (err) {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
+                        "Failed to download FW. Init HW without FW now\n");
+               err = 1;
+               rtlhal->fw_ready = false;
+               return err;
+       } else {
+               rtlhal->fw_ready = true;
+       }
+       ppsc->fw_current_inpsmode = false;
+       rtlhal->fw_ps_state = FW_PS_STATE_ALL_ON_8821AE;
+       rtlhal->fw_clk_change_in_progress = false;
+       rtlhal->allow_sw_to_change_hwclc = false;
+       rtlhal->last_hmeboxnum = 0;
+       /*SIC_Init(Adapter);
+       if(rtlhal->AMPDUBurstMode)
+               rtl_write_byte(rtlpriv,REG_AMPDU_BURST_MODE_8812,  0x7F);*/
+       rtl8821ae_phy_mac_config(hw);
+       /* because last function modify RCR, so we update
+        * rcr var here, or TP will unstable for receive_config
+        * is wrong, RX RCR_ACRC32 will cause TP unstabel & Rx
+        * RCR_APP_ICV will cause mac80211 unassoc for cisco 1252
+       rtlpci->receive_config = rtl_read_dword(rtlpriv, REG_RCR);
+       rtlpci->receive_config &= ~(RCR_ACRC32 | RCR_AICV);
+       rtl_write_dword(rtlpriv, REG_RCR, rtlpci->receive_config);*/
+       rtl8821ae_phy_bb_config(hw);
+       rtl8821ae_phy_rf_config(hw);
+       if (rtlpriv->phy.rf_type == RF_1T1R &&
+               rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE)
+               _rtl8812ae_bb8812_config_1t(hw);
+       _rtl8821ae_hw_configure(hw);
+       rtl8821ae_phy_switch_wirelessband(hw, BAND_ON_2_4G);
+       /*set wireless mode*/
+       rtlhal->mac_func_enable = true;
+       rtl_cam_reset_all_entry(hw);
+       rtl8821ae_enable_hw_security_config(hw);
+       ppsc->rfpwr_state = ERFON;
+       rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_ETHER_ADDR, mac->mac_addr);
+       _rtl8821ae_enable_aspm_back_door(hw);
+       rtlpriv->intf_ops->enable_aspm(hw);
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE &&
+           (rtlhal->rfe_type == 1 || rtlhal->rfe_type == 5))
+               rtl_set_bbreg(hw, 0x900, 0x00000303, 0x0302);
+       rtl8821ae_bt_hw_init(hw);
+       rtlpriv->rtlhal.being_init_adapter = false;
+       rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_NAV_UPPER, (u8 *)&nav_upper);
+       /* rtl8821ae_dm_check_txpower_tracking(hw); */
+       /* rtl8821ae_phy_lc_calibrate(hw); */
+       if (support_remote_wakeup)
+               rtl_write_byte(rtlpriv, REG_WOW_CTRL, 0);
+       /* Release Rx DMA*/
+       tmp_u1b = rtl_read_byte(rtlpriv, REG_RXDMA_CONTROL);
+       if (tmp_u1b & BIT(2)) {
+               /* Release Rx DMA if needed*/
+               tmp_u1b &= ~BIT(2);
+               rtl_write_byte(rtlpriv, REG_RXDMA_CONTROL, tmp_u1b);
+       }
+       /* Release Tx/Rx PCIE DMA if*/
+       rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 1, 0);
+       rtl8821ae_dm_init(hw);
+       rtl8821ae_macid_initialize_mediastatus(hw);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "rtl8821ae_hw_init() <====\n");
+       return err;
+ }
+ static enum version_8821ae _rtl8821ae_read_chip_version(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_phy *rtlphy = &rtlpriv->phy;
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       enum version_8821ae version = VERSION_UNKNOWN;
+       u32 value32;
+       value32 = rtl_read_dword(rtlpriv, REG_SYS_CFG);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "ReadChipVersion8812A 0xF0 = 0x%x\n", value32);
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE)
+               rtlphy->rf_type = RF_2T2R;
+       else if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE)
+               rtlphy->rf_type = RF_1T1R;
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "RF_Type is %x!!\n", rtlphy->rf_type);
+       if (value32 & TRP_VAUX_EN) {
+               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
+                       if (rtlphy->rf_type == RF_2T2R)
+                               version = VERSION_TEST_CHIP_2T2R_8812;
+                       else
+                               version = VERSION_TEST_CHIP_1T1R_8812;
+               } else
+                       version = VERSION_TEST_CHIP_8821;
+       } else {
+               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
+                       u32 rtl_id = ((value32 & CHIP_VER_RTL_MASK) >> 12) + 1;
+                       if (rtlphy->rf_type == RF_2T2R)
+                               version =
+                                       (enum version_8821ae)(CHIP_8812
+                                       | NORMAL_CHIP |
+                                       RF_TYPE_2T2R);
+                       else
+                               version = (enum version_8821ae)(CHIP_8812
+                                       | NORMAL_CHIP);
+                       version = (enum version_8821ae)(version | (rtl_id << 12));
+               } else if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+                       u32 rtl_id = value32 & CHIP_VER_RTL_MASK;
+                       version = (enum version_8821ae)(CHIP_8821
+                               | NORMAL_CHIP | rtl_id);
+               }
+       }
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) {
+               /*WL_HWROF_EN.*/
+               value32 = rtl_read_dword(rtlpriv, REG_MULTI_FUNC_CTRL);
+               rtlhal->hw_rof_enable = ((value32 & WL_HWROF_EN) ? 1 : 0);
+       }
+       switch (version) {
+       case VERSION_TEST_CHIP_1T1R_8812:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID: VERSION_TEST_CHIP_1T1R_8812\n");
+               break;
+       case VERSION_TEST_CHIP_2T2R_8812:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID: VERSION_TEST_CHIP_2T2R_8812\n");
+               break;
+       case VERSION_NORMAL_TSMC_CHIP_1T1R_8812:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID:VERSION_NORMAL_TSMC_CHIP_1T1R_8812\n");
+               break;
+       case VERSION_NORMAL_TSMC_CHIP_2T2R_8812:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID: VERSION_NORMAL_TSMC_CHIP_2T2R_8812\n");
+               break;
+       case VERSION_NORMAL_TSMC_CHIP_1T1R_8812_C_CUT:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID: VERSION_NORMAL_TSMC_CHIP_1T1R_8812 C CUT\n");
+               break;
+       case VERSION_NORMAL_TSMC_CHIP_2T2R_8812_C_CUT:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID: VERSION_NORMAL_TSMC_CHIP_2T2R_8812 C CUT\n");
+               break;
+       case VERSION_TEST_CHIP_8821:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID: VERSION_TEST_CHIP_8821\n");
+               break;
+       case VERSION_NORMAL_TSMC_CHIP_8821:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID: VERSION_NORMAL_TSMC_CHIP_8821 A CUT\n");
+               break;
+       case VERSION_NORMAL_TSMC_CHIP_8821_B_CUT:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID: VERSION_NORMAL_TSMC_CHIP_8821 B CUT\n");
+               break;
+       default:
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Chip Version ID: Unknow (0x%X)\n", version);
+               break;
+       }
+       return version;
+ }
+ static int _rtl8821ae_set_media_status(struct ieee80211_hw *hw,
+                                    enum nl80211_iftype type)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u8 bt_msr = rtl_read_byte(rtlpriv, MSR);
+       enum led_ctl_mode ledaction = LED_CTL_NO_LINK;
+       bt_msr &= 0xfc;
+       rtl_write_dword(rtlpriv, REG_BCN_CTRL, 0);
+       RT_TRACE(rtlpriv, COMP_BEACON, DBG_LOUD,
+               "clear 0x550 when set HW_VAR_MEDIA_STATUS\n");
+       if (type == NL80211_IFTYPE_UNSPECIFIED ||
+           type == NL80211_IFTYPE_STATION) {
+               _rtl8821ae_stop_tx_beacon(hw);
+               _rtl8821ae_enable_bcn_sub_func(hw);
+       } else if (type == NL80211_IFTYPE_ADHOC ||
+               type == NL80211_IFTYPE_AP) {
+               _rtl8821ae_resume_tx_beacon(hw);
+               _rtl8821ae_disable_bcn_sub_func(hw);
+       } else {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
+                        "Set HW_VAR_MEDIA_STATUS: No such media status(%x).\n",
+                        type);
+       }
+       switch (type) {
+       case NL80211_IFTYPE_UNSPECIFIED:
+               bt_msr |= MSR_NOLINK;
+               ledaction = LED_CTL_LINK;
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
+                        "Set Network type to NO LINK!\n");
+               break;
+       case NL80211_IFTYPE_ADHOC:
+               bt_msr |= MSR_ADHOC;
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
+                        "Set Network type to Ad Hoc!\n");
+               break;
+       case NL80211_IFTYPE_STATION:
+               bt_msr |= MSR_INFRA;
+               ledaction = LED_CTL_LINK;
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
+                        "Set Network type to STA!\n");
+               break;
+       case NL80211_IFTYPE_AP:
+               bt_msr |= MSR_AP;
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
+                        "Set Network type to AP!\n");
+               break;
+       default:
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                        "Network type %d not support!\n", type);
+               return 1;
+       }
+       rtl_write_byte(rtlpriv, MSR, bt_msr);
+       rtlpriv->cfg->ops->led_control(hw, ledaction);
+       if ((bt_msr & MSR_MASK) == MSR_AP)
+               rtl_write_byte(rtlpriv, REG_BCNTCFG + 1, 0x00);
+       else
+               rtl_write_byte(rtlpriv, REG_BCNTCFG + 1, 0x66);
+       return 0;
+ }
+ void rtl8821ae_set_check_bssid(struct ieee80211_hw *hw, bool check_bssid)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       u32 reg_rcr = rtlpci->receive_config;
+       if (rtlpriv->psc.rfpwr_state != ERFON)
+               return;
+       if (check_bssid) {
+               reg_rcr |= (RCR_CBSSID_DATA | RCR_CBSSID_BCN);
+               rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_RCR,
+                                             (u8 *)(&reg_rcr));
+               _rtl8821ae_set_bcn_ctrl_reg(hw, 0, BIT(4));
+       } else if (!check_bssid) {
+               reg_rcr &= (~(RCR_CBSSID_DATA | RCR_CBSSID_BCN));
+               _rtl8821ae_set_bcn_ctrl_reg(hw, BIT(4), 0);
+               rtlpriv->cfg->ops->set_hw_reg(hw,
+                       HW_VAR_RCR, (u8 *)(&reg_rcr));
+       }
+ }
+ int rtl8821ae_set_network_type(struct ieee80211_hw *hw, enum nl80211_iftype type)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "rtl8821ae_set_network_type!\n");
+       if (_rtl8821ae_set_media_status(hw, type))
+               return -EOPNOTSUPP;
+       if (rtlpriv->mac80211.link_state == MAC80211_LINKED) {
+               if (type != NL80211_IFTYPE_AP)
+                       rtl8821ae_set_check_bssid(hw, true);
+       } else {
+               rtl8821ae_set_check_bssid(hw, false);
+       }
+       return 0;
+ }
+ /* don't set REG_EDCA_BE_PARAM here because mac80211 will send pkt when scan */
+ void rtl8821ae_set_qos(struct ieee80211_hw *hw, int aci)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       rtl8821ae_dm_init_edca_turbo(hw);
+       switch (aci) {
+       case AC1_BK:
+               rtl_write_dword(rtlpriv, REG_EDCA_BK_PARAM, 0xa44f);
+               break;
+       case AC0_BE:
+               /* rtl_write_dword(rtlpriv, REG_EDCA_BE_PARAM, u4b_ac_param); */
+               break;
+       case AC2_VI:
+               rtl_write_dword(rtlpriv, REG_EDCA_VI_PARAM, 0x5e4322);
+               break;
+       case AC3_VO:
+               rtl_write_dword(rtlpriv, REG_EDCA_VO_PARAM, 0x2f3222);
+               break;
+       default:
+               RT_ASSERT(false, "invalid aci: %d !\n", aci);
+               break;
+       }
+ }
++static void rtl8821ae_clear_interrupt(struct ieee80211_hw *hw)
++{
++      struct rtl_priv *rtlpriv = rtl_priv(hw);
++      u32 tmp = rtl_read_dword(rtlpriv, REG_HISR);
++
++      rtl_write_dword(rtlpriv, REG_HISR, tmp);
++
++      tmp = rtl_read_dword(rtlpriv, REG_HISRE);
++      rtl_write_dword(rtlpriv, REG_HISRE, tmp);
++
++      tmp = rtl_read_dword(rtlpriv, REG_HSISR);
++      rtl_write_dword(rtlpriv, REG_HSISR, tmp);
++}
++
+ void rtl8821ae_enable_interrupt(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
++      if (!rtlpci->int_clear)
++              rtl8821ae_clear_interrupt(hw);/*clear it here first*/
++
+       rtl_write_dword(rtlpriv, REG_HIMR, rtlpci->irq_mask[0] & 0xFFFFFFFF);
+       rtl_write_dword(rtlpriv, REG_HIMRE, rtlpci->irq_mask[1] & 0xFFFFFFFF);
+       rtlpci->irq_enabled = true;
+       /* there are some C2H CMDs have been sent before
+       system interrupt is enabled, e.g., C2H, CPWM.
+       *So we need to clear all C2H events that FW has
+       notified, otherwise FW won't schedule any commands anymore.
+       */
+       /* rtl_write_byte(rtlpriv, REG_C2HEVT_CLEAR, 0); */
+       /*enable system interrupt*/
+       rtl_write_dword(rtlpriv, REG_HSIMR, rtlpci->sys_irq_mask & 0xFFFFFFFF);
+ }
+ void rtl8821ae_disable_interrupt(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       rtl_write_dword(rtlpriv, REG_HIMR, IMR_DISABLED);
+       rtl_write_dword(rtlpriv, REG_HIMRE, IMR_DISABLED);
+       rtlpci->irq_enabled = false;
+       /*synchronize_irq(rtlpci->pdev->irq);*/
+ }
+ static void _rtl8821ae_clear_pci_pme_status(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       u16 cap_hdr;
+       u8 cap_pointer;
+       u8 cap_id = 0xff;
+       u8 pmcs_reg;
+       u8 cnt = 0;
+       /* Get the Capability pointer first,
+        * the Capability Pointer is located at
+        * offset 0x34 from the Function Header */
+       pci_read_config_byte(rtlpci->pdev, 0x34, &cap_pointer);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "PCI configration 0x34 = 0x%2x\n", cap_pointer);
+       do {
+               pci_read_config_word(rtlpci->pdev, cap_pointer, &cap_hdr);
+               cap_id = cap_hdr & 0xFF;
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "in pci configration, cap_pointer%x = %x\n",
+                         cap_pointer, cap_id);
+               if (cap_id == 0x01) {
+                       break;
+               } else {
+                       /* point to next Capability */
+                       cap_pointer = (cap_hdr >> 8) & 0xFF;
+                       /* 0: end of pci capability, 0xff: invalid value */
+                       if (cap_pointer == 0x00 || cap_pointer == 0xff) {
+                               cap_id = 0xff;
+                               break;
+                       }
+               }
+       } while (cnt++ < 200);
+       if (cap_id == 0x01) {
+               /* Get the PM CSR (Control/Status Register),
+                * The PME_Status is located at PM Capatibility offset 5, bit 7
+                */
+               pci_read_config_byte(rtlpci->pdev, cap_pointer + 5, &pmcs_reg);
+               if (pmcs_reg & BIT(7)) {
+                       /* PME event occured, clear the PM_Status by write 1 */
+                       pmcs_reg = pmcs_reg | BIT(7);
+                       pci_write_config_byte(rtlpci->pdev, cap_pointer + 5,
+                                             pmcs_reg);
+                       /* Read it back to check */
+                       pci_read_config_byte(rtlpci->pdev, cap_pointer + 5,
+                                            &pmcs_reg);
+                       RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
+                                "Clear PME status 0x%2x to 0x%2x\n",
+                                 cap_pointer + 5, pmcs_reg);
+               } else {
+                       RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
+                                "PME status(0x%2x) = 0x%2x\n",
+                                 cap_pointer + 5, pmcs_reg);
+               }
+       } else {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_WARNING,
+                        "Cannot find PME Capability\n");
+       }
+ }
+ void rtl8821ae_card_disable(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
+       struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
+       struct rtl_mac *mac = rtl_mac(rtlpriv);
+       enum nl80211_iftype opmode;
+       bool support_remote_wakeup;
+       u8 tmp;
+       u32 count = 0;
+       rtlpriv->cfg->ops->get_hw_reg(hw, HAL_DEF_WOWLAN,
+                                     (u8 *)(&support_remote_wakeup));
+       RT_SET_PS_LEVEL(ppsc, RT_RF_OFF_LEVL_HALT_NIC);
+       if (!(support_remote_wakeup && mac->opmode == NL80211_IFTYPE_STATION)
+           || !rtlhal->enter_pnp_sleep) {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Normal Power off\n");
+               mac->link_state = MAC80211_NOLINK;
+               opmode = NL80211_IFTYPE_UNSPECIFIED;
+               _rtl8821ae_set_media_status(hw, opmode);
+               _rtl8821ae_poweroff_adapter(hw);
+       } else {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Wowlan Supported.\n");
+               /* 3 <1> Prepare for configuring wowlan related infomations */
+               /* Clear Fw WoWLAN event. */
+               rtl_write_byte(rtlpriv, REG_MCUTST_WOWLAN, 0x0);
+ #if (USE_SPECIFIC_FW_TO_SUPPORT_WOWLAN == 1)
+               rtl8821ae_set_fw_related_for_wowlan(hw, true);
+ #endif
+               /* Dynamically adjust Tx packet boundary
+                * for download reserved page packet.
+                * reserve 30 pages for rsvd page */
+               if (_rtl8821ae_dynamic_rqpn(hw, 0xE0, 0x3, 0x80c20d0d))
+                       rtlhal->re_init_llt_table = true;
+               /* 3 <2> Set Fw releted H2C cmd. */
+               /* Set WoWLAN related security information. */
+               rtl8821ae_set_fw_global_info_cmd(hw);
+               _rtl8821ae_download_rsvd_page(hw, true);
+               /* Just enable AOAC related functions when we connect to AP. */
+               printk("mac->link_state = %d\n", mac->link_state);
+               if (mac->link_state >= MAC80211_LINKED &&
+                   mac->opmode == NL80211_IFTYPE_STATION) {
+                       rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_AID, NULL);
+                       rtl8821ae_set_fw_media_status_rpt_cmd(hw,
+                                                             RT_MEDIA_CONNECT);
+                       rtl8821ae_set_fw_wowlan_mode(hw, true);
+                       /* Enable Fw Keep alive mechanism. */
+                       rtl8821ae_set_fw_keep_alive_cmd(hw, true);
+                       /* Enable disconnect decision control. */
+                       rtl8821ae_set_fw_disconnect_decision_ctrl_cmd(hw, true);
+               }
+               /* 3 <3> Hw Configutations */
+               /* Wait untill Rx DMA Finished before host sleep.
+                * FW Pause Rx DMA may happens when received packet doing dma.
+                */
+               rtl_write_byte(rtlpriv, REG_RXDMA_CONTROL, BIT(2));
+               tmp = rtl_read_byte(rtlpriv, REG_RXDMA_CONTROL);
+               count = 0;
+               while (!(tmp & BIT(1)) && (count++ < 100)) {
+                       udelay(10);
+                       tmp = rtl_read_byte(rtlpriv, REG_RXDMA_CONTROL);
+               }
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Wait Rx DMA Finished before host sleep. count=%d\n",
+                         count);
+               /* reset trx ring */
+               rtlpriv->intf_ops->reset_trx_ring(hw);
+               rtl_write_byte(rtlpriv, REG_APS_FSMCO + 1, 0x0);
+               _rtl8821ae_clear_pci_pme_status(hw);
+               tmp = rtl_read_byte(rtlpriv, REG_SYS_CLKR);
+               rtl_write_byte(rtlpriv, REG_SYS_CLKR, tmp | BIT(3));
+               /* prevent 8051 to be reset by PERST */
+               rtl_write_byte(rtlpriv, REG_RSV_CTRL, 0x20);
+               rtl_write_byte(rtlpriv, REG_RSV_CTRL, 0x60);
+       }
+       if (rtlpriv->rtlhal.driver_is_goingto_unload ||
+           ppsc->rfoff_reason > RF_CHANGE_BY_PS)
+               rtlpriv->cfg->ops->led_control(hw, LED_CTL_POWER_OFF);
+       /* For wowlan+LPS+32k. */
+       if (support_remote_wakeup && rtlhal->enter_pnp_sleep) {
+               /* Set the WoWLAN related function control enable.
+                * It should be the last H2C cmd in the WoWLAN flow. */
+               rtl8821ae_set_fw_remote_wake_ctrl_cmd(hw, 1);
+               /* Stop Pcie Interface Tx DMA. */
+               rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 1, 0xff);
+               RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, "Stop PCIE Tx DMA.\n");
+               /* Wait for TxDMA idle. */
+               count = 0;
+               do {
+                       tmp = rtl_read_byte(rtlpriv, REG_PCIE_CTRL_REG);
+                       udelay(10);
+                       count++;
+               } while ((tmp != 0) && (count < 100));
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "Wait Tx DMA Finished before host sleep. count=%d\n",
+                         count);
+               if (rtlhal->hw_rof_enable) {
+                       printk("hw_rof_enable\n");
+                       tmp = rtl_read_byte(rtlpriv, REG_HSISR + 3);
+                       rtl_write_byte(rtlpriv, REG_HSISR + 3, tmp | BIT(1));
+               }
+       }
+       /* after power off we should do iqk again */
+       rtlpriv->phy.iqk_initialized = false;
+ }
+ void rtl8821ae_interrupt_recognized(struct ieee80211_hw *hw,
+                                 u32 *p_inta, u32 *p_intb)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       *p_inta = rtl_read_dword(rtlpriv, ISR) & rtlpci->irq_mask[0];
+       rtl_write_dword(rtlpriv, ISR, *p_inta);
+       *p_intb = rtl_read_dword(rtlpriv, REG_HISRE) & rtlpci->irq_mask[1];
+       rtl_write_dword(rtlpriv, REG_HISRE, *p_intb);
+ }
+ void rtl8821ae_set_beacon_related_registers(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       u16 bcn_interval, atim_window;
+       bcn_interval = mac->beacon_interval;
+       atim_window = 2;        /*FIX MERGE */
+       rtl8821ae_disable_interrupt(hw);
+       rtl_write_word(rtlpriv, REG_ATIMWND, atim_window);
+       rtl_write_word(rtlpriv, REG_BCN_INTERVAL, bcn_interval);
+       rtl_write_word(rtlpriv, REG_BCNTCFG, 0x660f);
+       rtl_write_byte(rtlpriv, REG_RXTSF_OFFSET_CCK, 0x18);
+       rtl_write_byte(rtlpriv, REG_RXTSF_OFFSET_OFDM, 0x18);
+       rtl_write_byte(rtlpriv, 0x606, 0x30);
+       rtlpci->reg_bcn_ctrl_val |= BIT(3);
+       rtl_write_byte(rtlpriv, REG_BCN_CTRL, (u8)rtlpci->reg_bcn_ctrl_val);
+       rtl8821ae_enable_interrupt(hw);
+ }
+ void rtl8821ae_set_beacon_interval(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       u16 bcn_interval = mac->beacon_interval;
+       RT_TRACE(rtlpriv, COMP_BEACON, DBG_DMESG,
+                "beacon_interval:%d\n", bcn_interval);
+       rtl8821ae_disable_interrupt(hw);
+       rtl_write_word(rtlpriv, REG_BCN_INTERVAL, bcn_interval);
+       rtl8821ae_enable_interrupt(hw);
+ }
+ void rtl8821ae_update_interrupt_mask(struct ieee80211_hw *hw,
+                                  u32 add_msr, u32 rm_msr)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       RT_TRACE(rtlpriv, COMP_INTR, DBG_LOUD,
+                "add_msr:%x, rm_msr:%x\n", add_msr, rm_msr);
+       if (add_msr)
+               rtlpci->irq_mask[0] |= add_msr;
+       if (rm_msr)
+               rtlpci->irq_mask[0] &= (~rm_msr);
+       rtl8821ae_disable_interrupt(hw);
+       rtl8821ae_enable_interrupt(hw);
+ }
+ static u8 _rtl8821ae_get_chnl_group(u8 chnl)
+ {
+       u8 group = 0;
+       if (chnl <= 14) {
+               if (1 <= chnl && chnl <= 2)
+                       group = 0;
+       else if (3 <= chnl && chnl <= 5)
+                       group = 1;
+       else if (6 <= chnl && chnl <= 8)
+                       group = 2;
+       else if (9 <= chnl && chnl <= 11)
+                       group = 3;
+       else /*if (12 <= chnl && chnl <= 14)*/
+                       group = 4;
+       } else {
+               if (36 <= chnl && chnl <= 42)
+                       group = 0;
+       else if (44 <= chnl && chnl <= 48)
+                       group = 1;
+       else if (50 <= chnl && chnl <= 58)
+                       group = 2;
+       else if (60 <= chnl && chnl <= 64)
+                       group = 3;
+       else if (100 <= chnl && chnl <= 106)
+                       group = 4;
+       else if (108 <= chnl && chnl <= 114)
+                       group = 5;
+       else if (116 <= chnl && chnl <= 122)
+                       group = 6;
+       else if (124 <= chnl && chnl <= 130)
+                       group = 7;
+       else if (132 <= chnl && chnl <= 138)
+                       group = 8;
+       else if (140 <= chnl && chnl <= 144)
+                       group = 9;
+       else if (149 <= chnl && chnl <= 155)
+                       group = 10;
+       else if (157 <= chnl && chnl <= 161)
+                       group = 11;
+       else if (165 <= chnl && chnl <= 171)
+                       group = 12;
+       else if (173 <= chnl && chnl <= 177)
+                       group = 13;
+               else
+                       /*RT_TRACE(rtlpriv, COMP_EFUSE,DBG_LOUD,
+                               "5G, Channel %d in Group not found\n",chnl);*/
+                       RT_ASSERT(!COMP_EFUSE,
+                               "5G, Channel %d in Group not found\n", chnl);
+       }
+       return group;
+ }
+ static void _rtl8821ae_read_power_value_fromprom(struct ieee80211_hw *hw,
+       struct txpower_info_2g *pwrinfo24g,
+       struct txpower_info_5g *pwrinfo5g,
+       bool autoload_fail,
+       u8 *hwinfo)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u32 rfPath, eeAddr = EEPROM_TX_PWR_INX, group, TxCount = 0;
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "hal_ReadPowerValueFromPROM8821ae(): hwinfo[0x%x]=0x%x\n",
+                (eeAddr+1), hwinfo[eeAddr+1]);
+       if (0xFF == hwinfo[eeAddr+1])  /*YJ,add,120316*/
+               autoload_fail = true;
+       if (autoload_fail) {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                        "auto load fail : Use Default value!\n");
+               for (rfPath = 0 ; rfPath < MAX_RF_PATH ; rfPath++) {
+                       /*2.4G default value*/
+                       for (group = 0 ; group < MAX_CHNL_GROUP_24G; group++) {
+                               pwrinfo24g->index_cck_base[rfPath][group] =     0x2D;
+                               pwrinfo24g->index_bw40_base[rfPath][group] = 0x2D;
+                       }
+                       for (TxCount = 0; TxCount < MAX_TX_COUNT; TxCount++) {
+                               if (TxCount == 0) {
+                                       pwrinfo24g->bw20_diff[rfPath][0] = 0x02;
+                                       pwrinfo24g->ofdm_diff[rfPath][0] = 0x04;
+                               } else {
+                                       pwrinfo24g->bw20_diff[rfPath][TxCount] = 0xFE;
+                                       pwrinfo24g->bw40_diff[rfPath][TxCount] = 0xFE;
+                                       pwrinfo24g->cck_diff[rfPath][TxCount] = 0xFE;
+                                       pwrinfo24g->ofdm_diff[rfPath][TxCount] = 0xFE;
+                               }
+                       }
+                       /*5G default value*/
+                       for (group = 0 ; group < MAX_CHNL_GROUP_5G; group++)
+                               pwrinfo5g->index_bw40_base[rfPath][group] = 0x2A;
+                       for (TxCount = 0; TxCount < MAX_TX_COUNT; TxCount++) {
+                               if (TxCount == 0) {
+                                       pwrinfo5g->ofdm_diff[rfPath][0] = 0x04;
+                                       pwrinfo5g->bw20_diff[rfPath][0] = 0x00;
+                                       pwrinfo5g->bw80_diff[rfPath][0] = 0xFE;
+                                       pwrinfo5g->bw160_diff[rfPath][0] = 0xFE;
+                               } else {
+                                       pwrinfo5g->ofdm_diff[rfPath][0] = 0xFE;
+                                       pwrinfo5g->bw20_diff[rfPath][0] = 0xFE;
+                                       pwrinfo5g->bw40_diff[rfPath][0] = 0xFE;
+                                       pwrinfo5g->bw80_diff[rfPath][0] = 0xFE;
+                                       pwrinfo5g->bw160_diff[rfPath][0] = 0xFE;
+                               }
+                       }
+               }
+               return;
+       }
+       rtl_priv(hw)->efuse.txpwr_fromeprom = true;
+       for (rfPath = 0 ; rfPath < MAX_RF_PATH ; rfPath++) {
+               /*2.4G default value*/
+               for (group = 0 ; group < MAX_CHNL_GROUP_24G; group++) {
+                       pwrinfo24g->index_cck_base[rfPath][group] = hwinfo[eeAddr++];
+                       if (pwrinfo24g->index_cck_base[rfPath][group] == 0xFF)
+                               pwrinfo24g->index_cck_base[rfPath][group] = 0x2D;
+               }
+               for (group = 0 ; group < MAX_CHNL_GROUP_24G - 1; group++) {
+                       pwrinfo24g->index_bw40_base[rfPath][group] = hwinfo[eeAddr++];
+                       if (pwrinfo24g->index_bw40_base[rfPath][group] == 0xFF)
+                               pwrinfo24g->index_bw40_base[rfPath][group] = 0x2D;
+               }
+               for (TxCount = 0; TxCount < MAX_TX_COUNT; TxCount++) {
+                       if (TxCount == 0) {
+                               pwrinfo24g->bw40_diff[rfPath][TxCount] = 0;
+                               /*bit sign number to 8 bit sign number*/
+                               pwrinfo24g->bw20_diff[rfPath][TxCount] = (hwinfo[eeAddr] & 0xf0) >> 4;
+                               if (pwrinfo24g->bw20_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo24g->bw20_diff[rfPath][TxCount] |= 0xF0;
+                               /*bit sign number to 8 bit sign number*/
+                               pwrinfo24g->ofdm_diff[rfPath][TxCount] = (hwinfo[eeAddr] & 0x0f);
+                               if (pwrinfo24g->ofdm_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo24g->ofdm_diff[rfPath][TxCount] |= 0xF0;
+                               pwrinfo24g->cck_diff[rfPath][TxCount] = 0;
+                               eeAddr++;
+                       } else {
+                               pwrinfo24g->bw40_diff[rfPath][TxCount] = (hwinfo[eeAddr]&0xf0) >> 4;
+                               if (pwrinfo24g->bw40_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo24g->bw40_diff[rfPath][TxCount] |= 0xF0;
+                               pwrinfo24g->bw20_diff[rfPath][TxCount] = (hwinfo[eeAddr] & 0x0f);
+                               if (pwrinfo24g->bw20_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo24g->bw20_diff[rfPath][TxCount] |= 0xF0;
+                               eeAddr++;
+                               pwrinfo24g->ofdm_diff[rfPath][TxCount] = (hwinfo[eeAddr] & 0xf0) >> 4;
+                               if (pwrinfo24g->ofdm_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo24g->ofdm_diff[rfPath][TxCount] |= 0xF0;
+                               pwrinfo24g->cck_diff[rfPath][TxCount] = (hwinfo[eeAddr] & 0x0f);
+                               if (pwrinfo24g->cck_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo24g->cck_diff[rfPath][TxCount] |= 0xF0;
+                               eeAddr++;
+                       }
+               }
+               /*5G default value*/
+               for (group = 0 ; group < MAX_CHNL_GROUP_5G; group++) {
+                       pwrinfo5g->index_bw40_base[rfPath][group] = hwinfo[eeAddr++];
+                       if (pwrinfo5g->index_bw40_base[rfPath][group] == 0xFF)
+                               pwrinfo5g->index_bw40_base[rfPath][group] = 0xFE;
+               }
+               for (TxCount = 0; TxCount < MAX_TX_COUNT; TxCount++) {
+                       if (TxCount == 0) {
+                               pwrinfo5g->bw40_diff[rfPath][TxCount] = 0;
+                               pwrinfo5g->bw20_diff[rfPath][0] = (hwinfo[eeAddr] & 0xf0) >> 4;
+                               if (pwrinfo5g->bw20_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo5g->bw20_diff[rfPath][TxCount] |= 0xF0;
+                               pwrinfo5g->ofdm_diff[rfPath][0] = (hwinfo[eeAddr] & 0x0f);
+                               if (pwrinfo5g->ofdm_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo5g->ofdm_diff[rfPath][TxCount] |= 0xF0;
+                               eeAddr++;
+                       } else {
+                               pwrinfo5g->bw40_diff[rfPath][TxCount] = (hwinfo[eeAddr] & 0xf0) >> 4;
+                               if (pwrinfo5g->bw40_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo5g->bw40_diff[rfPath][TxCount] |= 0xF0;
+                               pwrinfo5g->bw20_diff[rfPath][TxCount] = (hwinfo[eeAddr] & 0x0f);
+                               if (pwrinfo5g->bw20_diff[rfPath][TxCount] & BIT(3))
+                                       pwrinfo5g->bw20_diff[rfPath][TxCount] |= 0xF0;
+                               eeAddr++;
+                       }
+               }
+               pwrinfo5g->ofdm_diff[rfPath][1] =       (hwinfo[eeAddr] & 0xf0) >> 4;
+               pwrinfo5g->ofdm_diff[rfPath][2] =       (hwinfo[eeAddr] & 0x0f);
+               eeAddr++;
+               pwrinfo5g->ofdm_diff[rfPath][3] = (hwinfo[eeAddr] & 0x0f);
+               eeAddr++;
+               for (TxCount = 1; TxCount < MAX_TX_COUNT; TxCount++) {
+                       if (pwrinfo5g->ofdm_diff[rfPath][TxCount] & BIT(3))
+                               pwrinfo5g->ofdm_diff[rfPath][TxCount] |= 0xF0;
+               }
+               for (TxCount = 0; TxCount < MAX_TX_COUNT; TxCount++) {
+                       pwrinfo5g->bw80_diff[rfPath][TxCount] = (hwinfo[eeAddr] & 0xf0) >> 4;
+                       /* 4bit sign number to 8 bit sign number */
+                       if (pwrinfo5g->bw80_diff[rfPath][TxCount] & BIT(3))
+                               pwrinfo5g->bw80_diff[rfPath][TxCount] |= 0xF0;
+                       /* 4bit sign number to 8 bit sign number */
+                       pwrinfo5g->bw160_diff[rfPath][TxCount] = (hwinfo[eeAddr] & 0x0f);
+                       if (pwrinfo5g->bw160_diff[rfPath][TxCount] & BIT(3))
+                               pwrinfo5g->bw160_diff[rfPath][TxCount] |= 0xF0;
+                       eeAddr++;
+               }
+       }
+ }
+ #if 0
+ static void _rtl8812ae_read_txpower_info_from_hwpg(struct ieee80211_hw *hw,
+                                                bool autoload_fail,
+                                                u8 *hwinfo)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
+       struct txpower_info_2g pwrinfo24g;
+       struct txpower_info_5g pwrinfo5g;
+       u8 channel5g[CHANNEL_MAX_NUMBER_5G] = {
+               36, 38, 40, 42, 44, 46, 48, 50, 52, 54,
+               56, 58, 60, 62, 64, 100, 102, 104, 106,
+               108, 110, 112, 114, 116, 118, 120, 122,
+               124, 126, 128, 130, 132, 134, 136, 138,
+               140, 142, 144, 149, 151, 153, 155, 157,
+               159, 161, 163, 165, 167, 168, 169, 171, 173, 175, 177};
+       u8 channel5g_80m[CHANNEL_MAX_NUMBER_5G_80M] = {42, 58, 106, 122, 138, 155, 171};
+       u8 rf_path, index;
+       u8 i;
+       _rtl8821ae_read_power_value_fromprom(hw, &pwrinfo24g,
+                                       &pwrinfo5g, autoload_fail, hwinfo);
+       for (rf_path = 0; rf_path < 2; rf_path++) {
+               for (i = 0; i < CHANNEL_MAX_NUMBER_2G; i++) {
+                       index = _rtl8821ae_get_chnl_group(i + 1);
+                       if (i == CHANNEL_MAX_NUMBER_2G - 1) {
+                               rtlefuse->txpwrlevel_cck[rf_path][i] =
+                                       pwrinfo24g.index_cck_base[rf_path][5];
+                               rtlefuse->txpwrlevel_ht40_1s[rf_path][i] =
+                                       pwrinfo24g.index_bw40_base[rf_path][index];
+                       } else {
+                               rtlefuse->txpwrlevel_cck[rf_path][i] =
+                                       pwrinfo24g.index_cck_base[rf_path][index];
+                               rtlefuse->txpwrlevel_ht40_1s[rf_path][i] =
+                                       pwrinfo24g.index_bw40_base[rf_path][index];
+                       }
+               }
+               for (i = 0; i < CHANNEL_MAX_NUMBER_5G; i++) {
+                       index = _rtl8821ae_get_chnl_group(channel5g[i]);
+                       rtlefuse->txpwr_5g_bw40base[rf_path][i] =
+                                       pwrinfo5g.index_bw40_base[rf_path][index];
+               }
+               for (i = 0; i < CHANNEL_MAX_NUMBER_5G_80M; i++) {
+                       u8 upper, lower;
+                       index = _rtl8821ae_get_chnl_group(channel5g_80m[i]);
+                       upper = pwrinfo5g.index_bw40_base[rf_path][index];
+                       lower = pwrinfo5g.index_bw40_base[rf_path][index + 1];
+                       rtlefuse->txpwr_5g_bw80base[rf_path][i] = (upper + lower) / 2;
+               }
+               for (i = 0; i < MAX_TX_COUNT; i++) {
+                       rtlefuse->txpwr_cckdiff[rf_path][i] =
+                               pwrinfo24g.cck_diff[rf_path][i];
+                       rtlefuse->txpwr_legacyhtdiff[rf_path][i] =
+                               pwrinfo24g.ofdm_diff[rf_path][i];
+                       rtlefuse->txpwr_ht20diff[rf_path][i] =
+                               pwrinfo24g.bw20_diff[rf_path][i];
+                       rtlefuse->txpwr_ht40diff[rf_path][i] =
+                               pwrinfo24g.bw40_diff[rf_path][i];
+                       rtlefuse->txpwr_5g_ofdmdiff[rf_path][i] =
+                               pwrinfo5g.ofdm_diff[rf_path][i];
+                       rtlefuse->txpwr_5g_bw20diff[rf_path][i] =
+                               pwrinfo5g.bw20_diff[rf_path][i];
+                       rtlefuse->txpwr_5g_bw40diff[rf_path][i] =
+                               pwrinfo5g.bw40_diff[rf_path][i];
+                       rtlefuse->txpwr_5g_bw80diff[rf_path][i] =
+                               pwrinfo5g.bw80_diff[rf_path][i];
+               }
+       }
+       if (!autoload_fail) {
+               rtlefuse->eeprom_regulatory =
+                       hwinfo[EEPROM_RF_BOARD_OPTION] & 0x07;/*bit0~2*/
+               if (hwinfo[EEPROM_RF_BOARD_OPTION] == 0xFF)
+                       rtlefuse->eeprom_regulatory = 0;
+       } else {
+               rtlefuse->eeprom_regulatory = 0;
+       }
+       RTPRINT(rtlpriv, FINIT, INIT_TXPOWER,
+       "eeprom_regulatory = 0x%x\n", rtlefuse->eeprom_regulatory);
+ }
+ #endif
+ static void _rtl8821ae_read_txpower_info_from_hwpg(struct ieee80211_hw *hw,
+                                                bool autoload_fail,
+                                                u8 *hwinfo)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
+       struct txpower_info_2g pwrinfo24g;
+       struct txpower_info_5g pwrinfo5g;
+       u8 channel5g[CHANNEL_MAX_NUMBER_5G] = {
+               36, 38, 40, 42, 44, 46, 48, 50, 52, 54,
+               56, 58, 60, 62, 64, 100, 102, 104, 106,
+               108, 110, 112, 114, 116, 118, 120, 122,
+               124, 126, 128, 130, 132, 134, 136, 138,
+               140, 142, 144, 149, 151, 153, 155, 157,
+               159, 161, 163, 165, 167, 168, 169, 171,
+               173, 175, 177};
+       u8 channel5g_80m[CHANNEL_MAX_NUMBER_5G_80M] = {
+               42, 58, 106, 122, 138, 155, 171};
+       u8 rf_path, index;
+       u8 i;
+       _rtl8821ae_read_power_value_fromprom(hw, &pwrinfo24g,
+               &pwrinfo5g, autoload_fail, hwinfo);
+       for (rf_path = 0; rf_path < 2; rf_path++) {
+               for (i = 0; i < CHANNEL_MAX_NUMBER_2G; i++) {
+                       index = _rtl8821ae_get_chnl_group(i + 1);
+                       if (i == CHANNEL_MAX_NUMBER_2G - 1) {
+                               rtlefuse->txpwrlevel_cck[rf_path][i] =
+                                       pwrinfo24g.index_cck_base[rf_path][5];
+                               rtlefuse->txpwrlevel_ht40_1s[rf_path][i] =
+                                       pwrinfo24g.index_bw40_base[rf_path][index];
+                       } else {
+                               rtlefuse->txpwrlevel_cck[rf_path][i] =
+                                       pwrinfo24g.index_cck_base[rf_path][index];
+                               rtlefuse->txpwrlevel_ht40_1s[rf_path][i] =
+                                       pwrinfo24g.index_bw40_base[rf_path][index];
+                       }
+               }
+               for (i = 0; i < CHANNEL_MAX_NUMBER_5G; i++) {
+                       index = _rtl8821ae_get_chnl_group(channel5g[i]);
+                       rtlefuse->txpwr_5g_bw40base[rf_path][i] =
+                               pwrinfo5g.index_bw40_base[rf_path][index];
+               }
+               for (i = 0; i < CHANNEL_MAX_NUMBER_5G_80M; i++) {
+                       u8 upper, lower;
+                       index = _rtl8821ae_get_chnl_group(channel5g_80m[i]);
+                       upper = pwrinfo5g.index_bw40_base[rf_path][index];
+                       lower = pwrinfo5g.index_bw40_base[rf_path][index + 1];
+                       rtlefuse->txpwr_5g_bw80base[rf_path][i] = (upper + lower) / 2;
+               }
+               for (i = 0; i < MAX_TX_COUNT; i++) {
+                       rtlefuse->txpwr_cckdiff[rf_path][i] =
+                               pwrinfo24g.cck_diff[rf_path][i];
+                       rtlefuse->txpwr_legacyhtdiff[rf_path][i] =
+                               pwrinfo24g.ofdm_diff[rf_path][i];
+                       rtlefuse->txpwr_ht20diff[rf_path][i] =
+                               pwrinfo24g.bw20_diff[rf_path][i];
+                       rtlefuse->txpwr_ht40diff[rf_path][i] =
+                               pwrinfo24g.bw40_diff[rf_path][i];
+                       rtlefuse->txpwr_5g_ofdmdiff[rf_path][i] =
+                               pwrinfo5g.ofdm_diff[rf_path][i];
+                       rtlefuse->txpwr_5g_bw20diff[rf_path][i] =
+                               pwrinfo5g.bw20_diff[rf_path][i];
+                       rtlefuse->txpwr_5g_bw40diff[rf_path][i] =
+                               pwrinfo5g.bw40_diff[rf_path][i];
+                       rtlefuse->txpwr_5g_bw80diff[rf_path][i] =
+                               pwrinfo5g.bw80_diff[rf_path][i];
+               }
+       }
+       /*bit0~2*/
+       if (!autoload_fail) {
+               rtlefuse->eeprom_regulatory = hwinfo[EEPROM_RF_BOARD_OPTION] & 0x07;
+               if (hwinfo[EEPROM_RF_BOARD_OPTION] == 0xFF)
+                       rtlefuse->eeprom_regulatory = 0;
+       } else {
+               rtlefuse->eeprom_regulatory = 0;
+       }
+       RTPRINT(rtlpriv, FINIT, INIT_TXPOWER,
+       "eeprom_regulatory = 0x%x\n", rtlefuse->eeprom_regulatory);
+ }
+ static void _rtl8812ae_read_pa_type(struct ieee80211_hw *hw, u8 *hwinfo,
+                                   bool autoload_fail)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
+       if (!autoload_fail) {
+               rtlhal->pa_type_2g = hwinfo[0xBC];
+               rtlhal->lna_type_2g = hwinfo[0xBD];
+               if (rtlhal->pa_type_2g == 0xFF && rtlhal->lna_type_2g == 0xFF) {
+                       rtlhal->pa_type_2g = 0;
+                       rtlhal->lna_type_2g = 0;
+               }
+               rtlhal->external_pa_2g = ((rtlhal->pa_type_2g & BIT(5)) &&
+                                         (rtlhal->pa_type_2g & BIT(4))) ?
+                                        1 : 0;
+               rtlhal->external_lna_2g = ((rtlhal->lna_type_2g & BIT(7)) &&
+                                          (rtlhal->lna_type_2g & BIT(3))) ?
+                                         1 : 0;
+               rtlhal->pa_type_5g = hwinfo[0xBC];
+               rtlhal->lna_type_5g = hwinfo[0xBF];
+               if (rtlhal->pa_type_5g == 0xFF && rtlhal->lna_type_5g == 0xFF) {
+                       rtlhal->pa_type_5g = 0;
+                       rtlhal->lna_type_5g = 0;
+               }
+               rtlhal->external_pa_5g = ((rtlhal->pa_type_5g & BIT(1)) &&
+                                         (rtlhal->pa_type_5g & BIT(0))) ?
+                                        1 : 0;
+               rtlhal->external_lna_5g = ((rtlhal->lna_type_5g & BIT(7)) &&
+                                          (rtlhal->lna_type_5g & BIT(3))) ?
+                                         1 : 0;
+       } else {
+               rtlhal->external_pa_2g  = 0;
+               rtlhal->external_lna_2g = 0;
+               rtlhal->external_pa_5g  = 0;
+               rtlhal->external_lna_5g = 0;
+       }
+ }
+ static void _rtl8821ae_read_pa_type(struct ieee80211_hw *hw, u8 *hwinfo,
+                                   bool autoload_fail)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
+       if (!autoload_fail) {
+               rtlhal->pa_type_2g = hwinfo[0xBC];
+               rtlhal->lna_type_2g = hwinfo[0xBD];
+               if (rtlhal->pa_type_2g == 0xFF && rtlhal->lna_type_2g == 0xFF) {
+                       rtlhal->pa_type_2g = 0;
+                       rtlhal->lna_type_2g = 0;
+               }
+               rtlhal->external_pa_2g = (rtlhal->pa_type_2g & BIT(5)) ? 1 : 0;
+               rtlhal->external_lna_2g = (rtlhal->lna_type_2g & BIT(7)) ? 1 : 0;
+               rtlhal->pa_type_5g = hwinfo[0xBC];
+               rtlhal->lna_type_5g = hwinfo[0xBF];
+               if (rtlhal->pa_type_5g == 0xFF && rtlhal->lna_type_5g == 0xFF) {
+                       rtlhal->pa_type_5g = 0;
+                       rtlhal->lna_type_5g = 0;
+               }
+               rtlhal->external_pa_5g = (rtlhal->pa_type_5g & BIT(1)) ? 1 : 0;
+               rtlhal->external_lna_5g = (rtlhal->lna_type_5g & BIT(7)) ? 1 : 0;
+       } else {
+               rtlhal->external_pa_2g  = 0;
+               rtlhal->external_lna_2g = 0;
+               rtlhal->external_pa_5g  = 0;
+               rtlhal->external_lna_5g = 0;
+       }
+ }
+ static void _rtl8821ae_read_rfe_type(struct ieee80211_hw *hw, u8 *hwinfo,
+                             bool autoload_fail)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
+       if (!autoload_fail) {
+               if (hwinfo[EEPROM_RFE_OPTION] & BIT(7)) {
+                       if (rtlhal->external_lna_5g) {
+                               if (rtlhal->external_pa_5g) {
+                                       if (rtlhal->external_lna_2g &&
+                                           rtlhal->external_pa_2g)
+                                               rtlhal->rfe_type = 3;
+                                       else
+                                               rtlhal->rfe_type = 0;
+                               } else {
+                                       rtlhal->rfe_type = 2;
+                               }
+                       } else {
+                               rtlhal->rfe_type = 4;
+                       }
+               } else {
+                       rtlhal->rfe_type = hwinfo[EEPROM_RFE_OPTION] & 0x3F;
+                       if (rtlhal->rfe_type == 4 &&
+                           (rtlhal->external_pa_5g ||
+                            rtlhal->external_pa_2g ||
+                            rtlhal->external_lna_5g ||
+                            rtlhal->external_lna_2g)) {
+                               if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE)
+                                       rtlhal->rfe_type = 2;
+                       }
+               }
+       } else {
+               rtlhal->rfe_type = 0x04;
+       }
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "RFE Type: 0x%2x\n", rtlhal->rfe_type);
+ }
+ static void _rtl8812ae_read_bt_coexist_info_from_hwpg(struct ieee80211_hw *hw,
+                                             bool auto_load_fail, u8 *hwinfo)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u8 value;
+       if (!auto_load_fail) {
+               value = *(u8 *)&hwinfo[EEPROM_RF_BOARD_OPTION];
+               if (((value & 0xe0) >> 5) == 0x1)
+                       rtlpriv->btcoexist.btc_info.btcoexist = 1;
+               else
+                       rtlpriv->btcoexist.btc_info.btcoexist = 0;
+               rtlpriv->btcoexist.btc_info.bt_type = BT_RTL8812A;
+               value = hwinfo[EEPROM_RF_BT_SETTING];
+               rtlpriv->btcoexist.btc_info.ant_num = (value & 0x1);
+       } else {
+               rtlpriv->btcoexist.btc_info.btcoexist = 0;
+               rtlpriv->btcoexist.btc_info.bt_type = BT_RTL8812A;
+               rtlpriv->btcoexist.btc_info.ant_num = ANT_X2;
+       }
+       /*move BT_InitHalVars() to init_sw_vars*/
+ }
+ static void _rtl8821ae_read_bt_coexist_info_from_hwpg(struct ieee80211_hw *hw,
+                                             bool auto_load_fail, u8 *hwinfo)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u8 value;
+       u32 tmpu_32;
+       if (!auto_load_fail) {
+               tmpu_32 = rtl_read_dword(rtlpriv, REG_MULTI_FUNC_CTRL);
+               if (tmpu_32 & BIT(18))
+                       rtlpriv->btcoexist.btc_info.btcoexist = 1;
+               else
+                       rtlpriv->btcoexist.btc_info.btcoexist = 0;
+               rtlpriv->btcoexist.btc_info.bt_type = BT_RTL8821A;
+               value = hwinfo[EEPROM_RF_BT_SETTING];
+               rtlpriv->btcoexist.btc_info.ant_num = (value & 0x1);
+       } else {
+               rtlpriv->btcoexist.btc_info.btcoexist = 0;
+               rtlpriv->btcoexist.btc_info.bt_type = BT_RTL8821A;
+               rtlpriv->btcoexist.btc_info.ant_num = ANT_X2;
+       }
+       /*move BT_InitHalVars() to init_sw_vars*/
+ }
+ static void _rtl8821ae_read_adapter_info(struct ieee80211_hw *hw, bool b_pseudo_test)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       struct rtl_pci_priv *pcipriv = rtl_pcipriv(hw);
+       u16 i, usvalue;
+       u8 hwinfo[HWSET_MAX_SIZE];
+       u16 eeprom_id;
+       if (b_pseudo_test) {
+               ;/* need add */
+       }
+       if (rtlefuse->epromtype == EEPROM_BOOT_EFUSE) {
+               rtl_efuse_shadow_map_update(hw);
+               memcpy(hwinfo, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
+                      HWSET_MAX_SIZE);
+       } else if (rtlefuse->epromtype == EEPROM_93C46) {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                        "RTL819X Not boot from eeprom, check it !!");
+       }
+       RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_DMESG, "MAP\n",
+                     hwinfo, HWSET_MAX_SIZE);
+       eeprom_id = *((u16 *)&hwinfo[0]);
+       if (eeprom_id != RTL_EEPROM_ID) {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
+                        "EEPROM ID(%#x) is invalid!!\n", eeprom_id);
+               rtlefuse->autoload_failflag = true;
+       } else {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
+               rtlefuse->autoload_failflag = false;
+       }
+       if (rtlefuse->autoload_failflag) {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                        "RTL8812AE autoload_failflag, check it !!");
+               return;
+       }
+       rtlefuse->eeprom_version = *(u8 *)&hwinfo[EEPROM_VERSION];
+       if (rtlefuse->eeprom_version == 0xff)
+                       rtlefuse->eeprom_version = 0;
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "EEPROM version: 0x%2x\n", rtlefuse->eeprom_version);
+       rtlefuse->eeprom_vid = *(u16 *)&hwinfo[EEPROM_VID];
+       rtlefuse->eeprom_did = *(u16 *)&hwinfo[EEPROM_DID];
+       rtlefuse->eeprom_svid = *(u16 *)&hwinfo[EEPROM_SVID];
+       rtlefuse->eeprom_smid = *(u16 *)&hwinfo[EEPROM_SMID];
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "EEPROMId = 0x%4x\n", eeprom_id);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "EEPROM VID = 0x%4x\n", rtlefuse->eeprom_vid);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "EEPROM DID = 0x%4x\n", rtlefuse->eeprom_did);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "EEPROM SVID = 0x%4x\n", rtlefuse->eeprom_svid);
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "EEPROM SMID = 0x%4x\n", rtlefuse->eeprom_smid);
+       /*customer ID*/
+       rtlefuse->eeprom_oemid = *(u8 *)&hwinfo[EEPROM_CUSTOMER_ID];
+       if (rtlefuse->eeprom_oemid == 0xFF)
+               rtlefuse->eeprom_oemid = 0;
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "EEPROM Customer ID: 0x%2x\n", rtlefuse->eeprom_oemid);
+       for (i = 0; i < 6; i += 2) {
+               usvalue = *(u16 *)&hwinfo[EEPROM_MAC_ADDR + i];
+               *((u16 *)(&rtlefuse->dev_addr[i])) = usvalue;
+       }
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
+                "dev_addr: %pM\n", rtlefuse->dev_addr);
+       _rtl8821ae_read_txpower_info_from_hwpg(hw, rtlefuse->autoload_failflag,
+                                              hwinfo);
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
+               _rtl8812ae_read_pa_type(hw, hwinfo, rtlefuse->autoload_failflag);
+               _rtl8812ae_read_bt_coexist_info_from_hwpg(hw,
+                               rtlefuse->autoload_failflag, hwinfo);
+       } else {
+               _rtl8821ae_read_pa_type(hw, hwinfo, rtlefuse->autoload_failflag);
+               _rtl8821ae_read_bt_coexist_info_from_hwpg(hw,
+                               rtlefuse->autoload_failflag, hwinfo);
+       }
+       _rtl8821ae_read_rfe_type(hw, hwinfo, rtlefuse->autoload_failflag);
+       /*board type*/
+       rtlefuse->board_type = ODM_BOARD_DEFAULT;
+       if (rtlhal->external_lna_2g != 0)
+               rtlefuse->board_type |= ODM_BOARD_EXT_LNA;
+       if (rtlhal->external_lna_5g != 0)
+               rtlefuse->board_type |= ODM_BOARD_EXT_LNA_5G;
+       if (rtlhal->external_pa_2g != 0)
+               rtlefuse->board_type |= ODM_BOARD_EXT_PA;
+       if (rtlhal->external_pa_5g != 0)
+               rtlefuse->board_type |= ODM_BOARD_EXT_PA_5G;
+       if (rtlpriv->btcoexist.btc_info.btcoexist == 1)
+               rtlefuse->board_type |= ODM_BOARD_BT;
+       rtlhal->board_type = rtlefuse->board_type;
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "board_type = 0x%x\n", rtlefuse->board_type);
+       rtlefuse->eeprom_channelplan = *(u8 *)&hwinfo[EEPROM_CHANNELPLAN];
+       if (rtlefuse->eeprom_channelplan == 0xff)
+               rtlefuse->eeprom_channelplan = 0x7F;
+       /* set channel plan from efuse */
+       rtlefuse->channel_plan = rtlefuse->eeprom_channelplan;
+       /*parse xtal*/
+       rtlefuse->crystalcap = hwinfo[EEPROM_XTAL_8821AE];
+       if (rtlefuse->crystalcap == 0xFF)
+               rtlefuse->crystalcap = 0x20;
+       rtlefuse->eeprom_thermalmeter = *(u8 *)&hwinfo[EEPROM_THERMAL_METER];
+       if ((rtlefuse->eeprom_thermalmeter == 0xff) ||
+           rtlefuse->autoload_failflag) {
+               rtlefuse->apk_thermalmeterignore = true;
+               rtlefuse->eeprom_thermalmeter = 0xff;
+       }
+       rtlefuse->thermalmeter[0] = rtlefuse->eeprom_thermalmeter;
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                "thermalmeter = 0x%x\n", rtlefuse->eeprom_thermalmeter);
+       if (!rtlefuse->autoload_failflag) {
+               rtlefuse->antenna_div_cfg =
+                 (hwinfo[EEPROM_RF_BOARD_OPTION] & 0x18) >> 3;
+               if (hwinfo[EEPROM_RF_BOARD_OPTION] == 0xff)
+                       rtlefuse->antenna_div_cfg = 0;
+               if (rtlpriv->btcoexist.btc_info.btcoexist == 1 &&
+                   rtlpriv->btcoexist.btc_info.ant_num == ANT_X1)
+                       rtlefuse->antenna_div_cfg = 0;
+               rtlefuse->antenna_div_type = hwinfo[EEPROM_RF_ANTENNA_OPT_88E];
+               if (rtlefuse->antenna_div_type == 0xff)
+                       rtlefuse->antenna_div_type = FIXED_HW_ANTDIV;
+       } else {
+               rtlefuse->antenna_div_cfg = 0;
+               rtlefuse->antenna_div_type = 0;
+       }
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+               "SWAS: bHwAntDiv = %x, TRxAntDivType = %x\n",
+               rtlefuse->antenna_div_cfg, rtlefuse->antenna_div_type);
+       pcipriv->ledctl.led_opendrain = true;
+       if (rtlhal->oem_id == RT_CID_DEFAULT) {
+               switch (rtlefuse->eeprom_oemid) {
+               case RT_CID_DEFAULT:
+                       break;
+               case EEPROM_CID_TOSHIBA:
+                       rtlhal->oem_id = RT_CID_TOSHIBA;
+                       break;
+               case EEPROM_CID_CCX:
+                       rtlhal->oem_id = RT_CID_CCX;
+                       break;
+               case EEPROM_CID_QMI:
+                       rtlhal->oem_id = RT_CID_819X_QMI;
+                       break;
+               case EEPROM_CID_WHQL:
+                       break;
+               default:
+                       break;
+               }
+       }
+ }
+ /*static void _rtl8821ae_hal_customized_behavior(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci_priv *pcipriv = rtl_pcipriv(hw);
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       pcipriv->ledctl.led_opendrain = true;
+       switch (rtlhal->oem_id) {
+       case RT_CID_819X_HP:
+               pcipriv->ledctl.led_opendrain = true;
+               break;
+       case RT_CID_819X_LENOVO:
+       case RT_CID_DEFAULT:
+       case RT_CID_TOSHIBA:
+       case RT_CID_CCX:
+       case RT_CID_819X_ACER:
+       case RT_CID_WHQL:
+       default:
+               break;
+       }
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
+                "RT Customized ID: 0x%02X\n", rtlhal->oem_id);
+ }*/
+ void rtl8821ae_read_eeprom_info(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
+       struct rtl_phy *rtlphy = &rtlpriv->phy;
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       u8 tmp_u1b;
+       rtlhal->version = _rtl8821ae_read_chip_version(hw);
+       if (get_rf_type(rtlphy) == RF_1T1R)
+               rtlpriv->dm.rfpath_rxenable[0] = true;
+       else
+               rtlpriv->dm.rfpath_rxenable[0] =
+                   rtlpriv->dm.rfpath_rxenable[1] = true;
+       RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "VersionID = 0x%4x\n",
+                                               rtlhal->version);
+       tmp_u1b = rtl_read_byte(rtlpriv, REG_9346CR);
+       if (tmp_u1b & BIT(4)) {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Boot from EEPROM\n");
+               rtlefuse->epromtype = EEPROM_93C46;
+       } else {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Boot from EFUSE\n");
+               rtlefuse->epromtype = EEPROM_BOOT_EFUSE;
+       }
+       if (tmp_u1b & BIT(5)) {
+               RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
+               rtlefuse->autoload_failflag = false;
+               _rtl8821ae_read_adapter_info(hw, false);
+       } else {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Autoload ERR!!\n");
+       }
+       /*hal_ReadRFType_8812A()*/
+       /* _rtl8821ae_hal_customized_behavior(hw); */
+ }
+ static void rtl8821ae_update_hal_rate_table(struct ieee80211_hw *hw,
+               struct ieee80211_sta *sta)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_phy *rtlphy = &rtlpriv->phy;
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       u32 ratr_value;
+       u8 ratr_index = 0;
+       u8 b_nmode = mac->ht_enable;
+       u8 mimo_ps = IEEE80211_SMPS_OFF;
+       u16 shortgi_rate;
+       u32 tmp_ratr_value;
+       u8 curtxbw_40mhz = mac->bw_40;
+       u8 b_curshortgi_40mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40) ?
+                               1 : 0;
+       u8 b_curshortgi_20mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) ?
+                               1 : 0;
+       enum wireless_mode wirelessmode = mac->mode;
+       if (rtlhal->current_bandtype == BAND_ON_5G)
+               ratr_value = sta->supp_rates[1] << 4;
+       else
+               ratr_value = sta->supp_rates[0];
+       if (mac->opmode == NL80211_IFTYPE_ADHOC)
+               ratr_value = 0xfff;
+       ratr_value |= (sta->ht_cap.mcs.rx_mask[1] << 20 |
+                       sta->ht_cap.mcs.rx_mask[0] << 12);
+       switch (wirelessmode) {
+       case WIRELESS_MODE_B:
+               if (ratr_value & 0x0000000c)
+                       ratr_value &= 0x0000000d;
+               else
+                       ratr_value &= 0x0000000f;
+               break;
+       case WIRELESS_MODE_G:
+               ratr_value &= 0x00000FF5;
+               break;
+       case WIRELESS_MODE_N_24G:
+       case WIRELESS_MODE_N_5G:
+               b_nmode = 1;
+               if (mimo_ps == IEEE80211_SMPS_STATIC) {
+                       ratr_value &= 0x0007F005;
+               } else {
+                       u32 ratr_mask;
+                       if (get_rf_type(rtlphy) == RF_1T2R ||
+                           get_rf_type(rtlphy) == RF_1T1R)
+                               ratr_mask = 0x000ff005;
+                       else
+                               ratr_mask = 0x0f0ff005;
+                       ratr_value &= ratr_mask;
+               }
+               break;
+       default:
+               if (rtlphy->rf_type == RF_1T2R)
+                       ratr_value &= 0x000ff0ff;
+               else
+                       ratr_value &= 0x0f0ff0ff;
+               break;
+       }
+       if ((rtlpriv->btcoexist.bt_coexistence) &&
+            (rtlpriv->btcoexist.bt_coexist_type == BT_CSR_BC4) &&
+            (rtlpriv->btcoexist.bt_cur_state) &&
+            (rtlpriv->btcoexist.bt_ant_isolation) &&
+            ((rtlpriv->btcoexist.bt_service == BT_SCO) ||
+            (rtlpriv->btcoexist.bt_service == BT_BUSY)))
+               ratr_value &= 0x0fffcfc0;
+       else
+               ratr_value &= 0x0FFFFFFF;
+       if (b_nmode && ((curtxbw_40mhz &&
+                        b_curshortgi_40mhz) || (!curtxbw_40mhz &&
+                                                b_curshortgi_20mhz))) {
+               ratr_value |= 0x10000000;
+               tmp_ratr_value = (ratr_value >> 12);
+               for (shortgi_rate = 15; shortgi_rate > 0; shortgi_rate--) {
+                       if ((1 << shortgi_rate) & tmp_ratr_value)
+                               break;
+               }
+               shortgi_rate = (shortgi_rate << 12) | (shortgi_rate << 8) |
+                   (shortgi_rate << 4) | (shortgi_rate);
+       }
+       rtl_write_dword(rtlpriv, REG_ARFR0 + ratr_index * 4, ratr_value);
+       RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG,
+                "%x\n", rtl_read_dword(rtlpriv, REG_ARFR0));
+ }
+ static u8 _rtl8821ae_mrate_idx_to_arfr_id(
+       struct ieee80211_hw *hw, u8 rate_index,
+       enum wireless_mode wirelessmode)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_phy *rtlphy = &rtlpriv->phy;
+       u8 ret = 0;
+       switch (rate_index) {
+       case RATR_INX_WIRELESS_NGB:
+               if (rtlphy->rf_type == RF_1T1R)
+                       ret = 1;
+               else
+                       ret = 0;
+               ; break;
+       case RATR_INX_WIRELESS_N:
+       case RATR_INX_WIRELESS_NG:
+               if (rtlphy->rf_type == RF_1T1R)
+                       ret = 5;
+               else
+                       ret = 4;
+               ; break;
+       case RATR_INX_WIRELESS_NB:
+               if (rtlphy->rf_type == RF_1T1R)
+                       ret = 3;
+               else
+                       ret = 2;
+               ; break;
+       case RATR_INX_WIRELESS_GB:
+               ret = 6;
+               break;
+       case RATR_INX_WIRELESS_G:
+               ret = 7;
+               break;
+       case RATR_INX_WIRELESS_B:
+               ret = 8;
+               break;
+       case RATR_INX_WIRELESS_MC:
+               if ((wirelessmode == WIRELESS_MODE_B)
+                       || (wirelessmode == WIRELESS_MODE_G)
+                       || (wirelessmode == WIRELESS_MODE_N_24G)
+                       || (wirelessmode == WIRELESS_MODE_AC_24G))
+                       ret = 6;
+               else
+                       ret = 7;
+       case RATR_INX_WIRELESS_AC_5N:
+               if (rtlphy->rf_type == RF_1T1R)
+                       ret = 10;
+               else
+                       ret = 9;
+               break;
+       case RATR_INX_WIRELESS_AC_24N:
+               if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_80) {
+                       if (rtlphy->rf_type == RF_1T1R)
+                               ret = 10;
+                       else
+                               ret = 9;
+               } else {
+                       if (rtlphy->rf_type == RF_1T1R)
+                               ret = 11;
+                       else
+                               ret = 12;
+               }
+               break;
+       default:
+               ret = 0; break;
+       }
+       return ret;
+ }
+ static u32 _rtl8821ae_rate_to_bitmap_2ssvht(__le16 vht_rate)
+ {
+       u8 i, j, tmp_rate;
+       u32 rate_bitmap = 0;
+       for (i = j = 0; i < 4; i += 2, j += 10) {
+               tmp_rate = (le16_to_cpu(vht_rate) >> i) & 3;
+               switch (tmp_rate) {
+               case 2:
+                       rate_bitmap = rate_bitmap | (0x03ff << j);
+                       break;
+               case 1:
+                       rate_bitmap = rate_bitmap | (0x01ff << j);
+                       break;
+               case 0:
+                       rate_bitmap = rate_bitmap | (0x00ff << j);
+                       break;
+               default:
+                       break;
+               }
+       }
+       return rate_bitmap;
+ }
+ static u32 _rtl8821ae_set_ra_vht_ratr_bitmap(struct ieee80211_hw *hw,
+                                            enum wireless_mode wirelessmode,
+                                            u32 ratr_bitmap)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_phy *rtlphy = &rtlpriv->phy;
+       u32 ret_bitmap = ratr_bitmap;
+       if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_20_40
+               || rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_80)
+               ret_bitmap = ratr_bitmap;
+       else if (wirelessmode == WIRELESS_MODE_AC_5G
+               || wirelessmode == WIRELESS_MODE_AC_24G) {
+               if (rtlphy->rf_type == RF_1T1R)
+                       ret_bitmap = ratr_bitmap & (~BIT21);
+               else
+                       ret_bitmap = ratr_bitmap & (~(BIT31|BIT21));
+       }
+       return ret_bitmap;
+ }
+ static u8 _rtl8821ae_get_vht_eni(enum wireless_mode wirelessmode,
+                       u32 ratr_bitmap)
+ {
+       u8 ret = 0;
+       if (wirelessmode < WIRELESS_MODE_N_24G)
+               ret =  0;
+       else if (wirelessmode == WIRELESS_MODE_AC_24G) {
+               if (ratr_bitmap & 0xfff00000)   /* Mix , 2SS */
+                       ret = 3;
+               else                                    /* Mix, 1SS */
+                       ret = 2;
+       } else if (wirelessmode == WIRELESS_MODE_AC_5G) {
+                       ret = 1;
+       } /* VHT */
+       return ret << 4;
+ }
+ static u8 _rtl8821ae_get_ra_ldpc(struct ieee80211_hw *hw,
+                            u8 mac_id, struct rtl_sta_info *sta_entry,
+                            enum wireless_mode wirelessmode)
+ {
+       u8 b_ldpc = 0;
+       /*not support ldpc, do not open*/
+       return b_ldpc << 2;
+ }
+ static u8 _rtl8821ae_get_ra_rftype(struct ieee80211_hw *hw,
+                         enum wireless_mode wirelessmode,
+                         u32 ratr_bitmap)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_phy *rtlphy = &rtlpriv->phy;
+       u8 rf_type = RF_1T1R;
+       if (rtlphy->rf_type == RF_1T1R)
+               rf_type = RF_1T1R;
+       else if (wirelessmode == WIRELESS_MODE_AC_5G
+               || wirelessmode == WIRELESS_MODE_AC_24G
+               || wirelessmode == WIRELESS_MODE_AC_ONLY) {
+               if (ratr_bitmap & 0xffc00000)
+                       rf_type = RF_2T2R;
+       } else if (wirelessmode == WIRELESS_MODE_N_5G
+               || wirelessmode == WIRELESS_MODE_N_24G) {
+               if (ratr_bitmap & 0xfff00000)
+                       rf_type = RF_2T2R;
+       }
+       return rf_type;
+ }
+ static bool _rtl8821ae_get_ra_shortgi(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
+                             u8 mac_id)
+ {
+       bool b_short_gi = false;
+       u8 b_curshortgi_40mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40) ?
+                               1 : 0;
+       u8 b_curshortgi_20mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) ?
+                               1 : 0;
+       u8 b_curshortgi_80mhz = 0;
+       b_curshortgi_80mhz = (sta->vht_cap.cap &
+                             IEEE80211_VHT_CAP_SHORT_GI_80) ? 1 : 0;
+       if (mac_id == MAC_ID_STATIC_FOR_BROADCAST_MULTICAST)
+                       b_short_gi = false;
+       if (b_curshortgi_40mhz || b_curshortgi_80mhz
+               || b_curshortgi_20mhz)
+               b_short_gi = true;
+       return b_short_gi;
+ }
+ static void rtl8821ae_update_hal_rate_mask(struct ieee80211_hw *hw,
+               struct ieee80211_sta *sta, u8 rssi_level)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_phy *rtlphy = &rtlpriv->phy;
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       struct rtl_sta_info *sta_entry = NULL;
+       u32 ratr_bitmap;
+       u8 ratr_index;
+       enum wireless_mode wirelessmode = 0;
+       u8 curtxbw_40mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)
+                               ? 1 : 0;
+       bool b_shortgi = false;
+       u8 rate_mask[7];
+       u8 macid = 0;
+       u8 mimo_ps = IEEE80211_SMPS_OFF;
+       u8 rf_type;
+       sta_entry = (struct rtl_sta_info *)sta->drv_priv;
+       wirelessmode = sta_entry->wireless_mode;
+       RT_TRACE(rtlpriv, COMP_RATR, DBG_LOUD,
+                "wireless mode = 0x%x\n", wirelessmode);
+       if (mac->opmode == NL80211_IFTYPE_STATION ||
+               mac->opmode == NL80211_IFTYPE_MESH_POINT) {
+               curtxbw_40mhz = mac->bw_40;
+       } else if (mac->opmode == NL80211_IFTYPE_AP ||
+               mac->opmode == NL80211_IFTYPE_ADHOC)
+               macid = sta->aid + 1;
+       if (wirelessmode == WIRELESS_MODE_N_5G ||
+           wirelessmode == WIRELESS_MODE_AC_5G ||
+           wirelessmode == WIRELESS_MODE_A)
+               ratr_bitmap = sta->supp_rates[NL80211_BAND_5GHZ] << 4;
+       else
+               ratr_bitmap = sta->supp_rates[NL80211_BAND_2GHZ];
+       if (mac->opmode == NL80211_IFTYPE_ADHOC)
+               ratr_bitmap = 0xfff;
+       if (wirelessmode == WIRELESS_MODE_N_24G
+               || wirelessmode == WIRELESS_MODE_N_5G)
+               ratr_bitmap |= (sta->ht_cap.mcs.rx_mask[1] << 20 |
+                               sta->ht_cap.mcs.rx_mask[0] << 12);
+       else if (wirelessmode == WIRELESS_MODE_AC_24G
+               || wirelessmode == WIRELESS_MODE_AC_5G
+               || wirelessmode == WIRELESS_MODE_AC_ONLY)
+               ratr_bitmap |= _rtl8821ae_rate_to_bitmap_2ssvht(
+                               sta->vht_cap.vht_mcs.rx_mcs_map) << 12;
+       b_shortgi = _rtl8821ae_get_ra_shortgi(hw, sta, macid);
+       rf_type = _rtl8821ae_get_ra_rftype(hw, wirelessmode, ratr_bitmap);
+ /*mac id owner*/
+       switch (wirelessmode) {
+       case WIRELESS_MODE_B:
+               ratr_index = RATR_INX_WIRELESS_B;
+               if (ratr_bitmap & 0x0000000c)
+                       ratr_bitmap &= 0x0000000d;
+               else
+                       ratr_bitmap &= 0x0000000f;
+               break;
+       case WIRELESS_MODE_G:
+               ratr_index = RATR_INX_WIRELESS_GB;
+               if (rssi_level == 1)
+                       ratr_bitmap &= 0x00000f00;
+               else if (rssi_level == 2)
+                       ratr_bitmap &= 0x00000ff0;
+               else
+                       ratr_bitmap &= 0x00000ff5;
+               break;
+       case WIRELESS_MODE_A:
+               ratr_index = RATR_INX_WIRELESS_G;
+               ratr_bitmap &= 0x00000ff0;
+               break;
+       case WIRELESS_MODE_N_24G:
+       case WIRELESS_MODE_N_5G:
+               if (wirelessmode == WIRELESS_MODE_N_24G)
+                       ratr_index = RATR_INX_WIRELESS_NGB;
+               else
+                       ratr_index = RATR_INX_WIRELESS_NG;
+               if (mimo_ps == IEEE80211_SMPS_STATIC
+                       || mimo_ps == IEEE80211_SMPS_DYNAMIC) {
+                       if (rssi_level == 1)
+                               ratr_bitmap &= 0x000f0000;
+                       else if (rssi_level == 2)
+                               ratr_bitmap &= 0x000ff000;
+                       else
+                               ratr_bitmap &= 0x000ff005;
+               } else {
+                       if (rf_type == RF_1T1R) {
+                               if (curtxbw_40mhz) {
+                                       if (rssi_level == 1)
+                                               ratr_bitmap &= 0x000f0000;
+                                       else if (rssi_level == 2)
+                                               ratr_bitmap &= 0x000ff000;
+                                       else
+                                               ratr_bitmap &= 0x000ff015;
+                               } else {
+                                       if (rssi_level == 1)
+                                               ratr_bitmap &= 0x000f0000;
+                                       else if (rssi_level == 2)
+                                               ratr_bitmap &= 0x000ff000;
+                                       else
+                                               ratr_bitmap &= 0x000ff005;
+                               }
+                       } else {
+                               if (curtxbw_40mhz) {
+                                       if (rssi_level == 1)
+                                               ratr_bitmap &= 0x0fff0000;
+                                       else if (rssi_level == 2)
+                                               ratr_bitmap &= 0x0ffff000;
+                                       else
+                                               ratr_bitmap &= 0x0ffff015;
+                               } else {
+                                       if (rssi_level == 1)
+                                               ratr_bitmap &= 0x0fff0000;
+                                       else if (rssi_level == 2)
+                                               ratr_bitmap &= 0x0ffff000;
+                                       else
+                                               ratr_bitmap &= 0x0ffff005;
+                               }
+                       }
+               }
+               break;
+       case WIRELESS_MODE_AC_24G:
+               ratr_index = RATR_INX_WIRELESS_AC_24N;
+               if (rssi_level == 1)
+                       ratr_bitmap &= 0xfc3f0000;
+               else if (rssi_level == 2)
+                       ratr_bitmap &= 0xfffff000;
+               else
+                       ratr_bitmap &= 0xffffffff;
+               break;
+       case WIRELESS_MODE_AC_5G:
+               ratr_index = RATR_INX_WIRELESS_AC_5N;
+               if (rf_type == RF_1T1R) {
+                       if (rssi_level == 1)    /*add by Gary for ac-series*/
+                               ratr_bitmap &= 0x003f8000;
+                       else if (rssi_level == 2)
+                               ratr_bitmap &= 0x003ff000;
+                       else
+                               ratr_bitmap &= 0x003ff010;
+               } else {
+                       if (rssi_level == 1)
+                               ratr_bitmap &= 0xfe3f8000;
+                       else if (rssi_level == 2)
+                               ratr_bitmap &= 0xfffff000;
+                       else
+                               ratr_bitmap &= 0xfffff010;
+               }
+               break;
+       default:
+               ratr_index = RATR_INX_WIRELESS_NGB;
+               if (rf_type == RF_1T2R)
+                       ratr_bitmap &= 0x000ff0ff;
+               else
+                       ratr_bitmap &= 0x0f8ff0ff;
+               break;
+       }
+       ratr_index = _rtl8821ae_mrate_idx_to_arfr_id(hw, ratr_index, wirelessmode);
+       sta_entry->ratr_index = ratr_index;
+       ratr_bitmap = _rtl8821ae_set_ra_vht_ratr_bitmap(hw, wirelessmode,
+                                                       ratr_bitmap);
+       RT_TRACE(rtlpriv, COMP_RATR, DBG_LOUD,
+                "ratr_bitmap :%x\n", ratr_bitmap);
+       /* *(u32 *)& rate_mask = EF4BYTE((ratr_bitmap & 0x0fffffff) |
+                                      (ratr_index << 28)); */
+       rate_mask[0] = macid;
+       rate_mask[1] = ratr_index | (b_shortgi ? 0x80 : 0x00);
+       rate_mask[2] = rtlphy->current_chan_bw
+                          | _rtl8821ae_get_vht_eni(wirelessmode, ratr_bitmap)
+                          | _rtl8821ae_get_ra_ldpc(hw, macid, sta_entry, wirelessmode);
+       rate_mask[3] = (u8)(ratr_bitmap & 0x000000ff);
+       rate_mask[4] = (u8)((ratr_bitmap & 0x0000ff00) >> 8);
+       rate_mask[5] = (u8)((ratr_bitmap & 0x00ff0000) >> 16);
+       rate_mask[6] = (u8)((ratr_bitmap & 0xff000000) >> 24);
+       RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG,
+                "Rate_index:%x, ratr_val:%x, %x:%x:%x:%x:%x:%x:%x\n",
+                ratr_index, ratr_bitmap,
+                rate_mask[0], rate_mask[1],
+                rate_mask[2], rate_mask[3],
+                rate_mask[4], rate_mask[5],
+                rate_mask[6]);
+       rtl8821ae_fill_h2c_cmd(hw, H2C_8821AE_RA_MASK, 7, rate_mask);
+       _rtl8821ae_set_bcn_ctrl_reg(hw, BIT(3), 0);
+ }
+ void rtl8821ae_update_hal_rate_tbl(struct ieee80211_hw *hw,
+               struct ieee80211_sta *sta, u8 rssi_level)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       if (rtlpriv->dm.useramask)
+               rtl8821ae_update_hal_rate_mask(hw, sta, rssi_level);
+       else
+               /*RT_TRACE(rtlpriv, COMP_RATR,DBG_LOUD,
+                          "rtl8821ae_update_hal_rate_tbl() Error! 8821ae FW RA Only");*/
+               rtl8821ae_update_hal_rate_table(hw, sta);
+ }
+ void rtl8821ae_update_channel_access_setting(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       u8 wireless_mode = mac->mode;
+       u8 sifs_timer, r2t_sifs;
+       rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SLOT_TIME,
+                                     (u8 *)&mac->slot_time);
+       if (wireless_mode == WIRELESS_MODE_G)
+               sifs_timer = 0x0a;
+       else
+               sifs_timer = 0x0e;
+       rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SIFS, (u8 *)&sifs_timer);
+       r2t_sifs = 0xa;
+       if (wireless_mode == WIRELESS_MODE_AC_5G &&
+           (mac->vht_ldpc_cap & LDPC_VHT_ENABLE_RX) &&
+           (mac->vht_stbc_cap & STBC_VHT_ENABLE_RX)) {
+               if (mac->vendor == PEER_ATH)
+                       r2t_sifs = 0x8;
+               else
+                       r2t_sifs = 0xa;
+       } else if (wireless_mode == WIRELESS_MODE_AC_5G) {
+               r2t_sifs = 0xa;
+       }
+       rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_R2T_SIFS, (u8 *)&r2t_sifs);
+ }
+ bool rtl8821ae_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
+       struct rtl_phy *rtlphy = &rtlpriv->phy;
+       enum rf_pwrstate e_rfpowerstate_toset, cur_rfstate;
+       u8 u1tmp = 0;
+       bool b_actuallyset = false;
+       if (rtlpriv->rtlhal.being_init_adapter)
+               return false;
+       if (ppsc->swrf_processing)
+               return false;
+       spin_lock(&rtlpriv->locks.rf_ps_lock);
+       if (ppsc->rfchange_inprogress) {
+               spin_unlock(&rtlpriv->locks.rf_ps_lock);
+               return false;
+       } else {
+               ppsc->rfchange_inprogress = true;
+               spin_unlock(&rtlpriv->locks.rf_ps_lock);
+       }
+       cur_rfstate = ppsc->rfpwr_state;
+       rtl_write_byte(rtlpriv, REG_GPIO_IO_SEL_2,
+                       rtl_read_byte(rtlpriv,
+                                       REG_GPIO_IO_SEL_2) & ~(BIT(1)));
+       u1tmp = rtl_read_byte(rtlpriv, REG_GPIO_PIN_CTRL_2);
+       if (rtlphy->polarity_ctl)
+               e_rfpowerstate_toset = (u1tmp & BIT(1)) ? ERFOFF : ERFON;
+       else
+               e_rfpowerstate_toset = (u1tmp & BIT(1)) ? ERFON : ERFOFF;
+       if ((ppsc->hwradiooff) && (e_rfpowerstate_toset == ERFON)) {
+               RT_TRACE(rtlpriv, COMP_RF, DBG_DMESG,
+                        "GPIOChangeRF  - HW Radio ON, RF ON\n");
+               e_rfpowerstate_toset = ERFON;
+               ppsc->hwradiooff = false;
+               b_actuallyset = true;
+       } else if ((!ppsc->hwradiooff)
+                  && (e_rfpowerstate_toset == ERFOFF)) {
+               RT_TRACE(rtlpriv, COMP_RF, DBG_DMESG,
+                        "GPIOChangeRF  - HW Radio OFF, RF OFF\n");
+               e_rfpowerstate_toset = ERFOFF;
+               ppsc->hwradiooff = true;
+               b_actuallyset = true;
+       }
+       if (b_actuallyset) {
+               spin_lock(&rtlpriv->locks.rf_ps_lock);
+               ppsc->rfchange_inprogress = false;
+               spin_unlock(&rtlpriv->locks.rf_ps_lock);
+       } else {
+               if (ppsc->reg_rfps_level & RT_RF_OFF_LEVL_HALT_NIC)
+                       RT_SET_PS_LEVEL(ppsc, RT_RF_OFF_LEVL_HALT_NIC);
+               spin_lock(&rtlpriv->locks.rf_ps_lock);
+               ppsc->rfchange_inprogress = false;
+               spin_unlock(&rtlpriv->locks.rf_ps_lock);
+       }
+       *valid = 1;
+       return !ppsc->hwradiooff;
+ }
+ void rtl8821ae_set_key(struct ieee80211_hw *hw, u32 key_index,
+                    u8 *p_macaddr, bool is_group, u8 enc_algo,
+                    bool is_wepkey, bool clear_all)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
+       u8 *macaddr = p_macaddr;
+       u32 entry_id = 0;
+       bool is_pairwise = false;
+       static u8 cam_const_addr[4][6] = {
+               {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+               {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
+               {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
+               {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}
+       };
+       static u8 cam_const_broad[] = {
+               0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+       };
+       if (clear_all) {
+               u8 idx = 0;
+               u8 cam_offset = 0;
+               u8 clear_number = 5;
+               RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "clear_all\n");
+               for (idx = 0; idx < clear_number; idx++) {
+                       rtl_cam_mark_invalid(hw, cam_offset + idx);
+                       rtl_cam_empty_entry(hw, cam_offset + idx);
+                       if (idx < 5) {
+                               memset(rtlpriv->sec.key_buf[idx], 0,
+                                      MAX_KEY_LEN);
+                               rtlpriv->sec.key_len[idx] = 0;
+                       }
+               }
+       } else {
+               switch (enc_algo) {
+               case WEP40_ENCRYPTION:
+                       enc_algo = CAM_WEP40;
+                       break;
+               case WEP104_ENCRYPTION:
+                       enc_algo = CAM_WEP104;
+                       break;
+               case TKIP_ENCRYPTION:
+                       enc_algo = CAM_TKIP;
+                       break;
+               case AESCCMP_ENCRYPTION:
+                       enc_algo = CAM_AES;
+                       break;
+               default:
+                       RT_TRACE(rtlpriv, COMP_ERR, DBG_LOUD,
+                                "switch case not process\n");
+                       enc_algo = CAM_TKIP;
+                       break;
+               }
+               if (is_wepkey || rtlpriv->sec.use_defaultkey) {
+                       macaddr = cam_const_addr[key_index];
+                       entry_id = key_index;
+               } else {
+                       if (is_group) {
+                               macaddr = cam_const_broad;
+                               entry_id = key_index;
+                       } else {
+                               if (mac->opmode == NL80211_IFTYPE_AP) {
+                                       entry_id = rtl_cam_get_free_entry(hw, p_macaddr);
+                                       if (entry_id >=  TOTAL_CAM_ENTRY) {
+                                               RT_TRACE(rtlpriv, COMP_SEC, DBG_EMERG,
+                                                        "Can not find free hwsecurity cam entry\n");
+                                               return;
+                                       }
+                               } else {
+                                       entry_id = CAM_PAIRWISE_KEY_POSITION;
+                               }
+                               key_index = PAIRWISE_KEYIDX;
+                               is_pairwise = true;
+                       }
+               }
+               if (rtlpriv->sec.key_len[key_index] == 0) {
+                       RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
+                                "delete one entry, entry_id is %d\n",
+                                entry_id);
+                       if (mac->opmode == NL80211_IFTYPE_AP)
+                               rtl_cam_del_entry(hw, p_macaddr);
+                       rtl_cam_delete_one_entry(hw, p_macaddr, entry_id);
+               } else {
+                       RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
+                                "add one entry\n");
+                       if (is_pairwise) {
+                               RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
+                                        "set Pairwise key\n");
+                               rtl_cam_add_one_entry(hw, macaddr, key_index,
+                                                     entry_id, enc_algo,
+                                                     CAM_CONFIG_NO_USEDK,
+                                                     rtlpriv->sec.key_buf[key_index]);
+                       } else {
+                               RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
+                                        "set group key\n");
+                               if (mac->opmode == NL80211_IFTYPE_ADHOC) {
+                                       rtl_cam_add_one_entry(hw,
+                                                       rtlefuse->dev_addr,
+                                                       PAIRWISE_KEYIDX,
+                                                       CAM_PAIRWISE_KEY_POSITION,
+                                                       enc_algo,
+                                                       CAM_CONFIG_NO_USEDK,
+                                                       rtlpriv->sec.key_buf
+                                                       [entry_id]);
+                               }
+                               rtl_cam_add_one_entry(hw, macaddr, key_index,
+                                               entry_id, enc_algo,
+                                               CAM_CONFIG_NO_USEDK,
+                                               rtlpriv->sec.key_buf[entry_id]);
+                       }
+               }
+       }
+ }
+ void rtl8821ae_bt_reg_init(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       /* 0:Low, 1:High, 2:From Efuse. */
+       rtlpriv->btcoexist.reg_bt_iso = 2;
+       /* 0:Idle, 1:None-SCO, 2:SCO, 3:From Counter. */
+       rtlpriv->btcoexist.reg_bt_sco = 3;
+       /* 0:Disable BT control A-MPDU, 1:Enable BT control A-MPDU. */
+       rtlpriv->btcoexist.reg_bt_sco = 0;
+ }
+ void rtl8821ae_bt_hw_init(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       if (rtlpriv->cfg->ops->get_btc_status())
+               rtlpriv->btcoexist.btc_ops->btc_init_hw_config(rtlpriv);
+ }
+ void rtl8821ae_suspend(struct ieee80211_hw *hw)
+ {
+ }
+ void rtl8821ae_resume(struct ieee80211_hw *hw)
+ {
+ }
+ /* Turn on AAP (RCR:bit 0) for promicuous mode. */
+ void rtl8821ae_allow_all_destaddr(struct ieee80211_hw *hw,
+       bool allow_all_da, bool write_into_reg)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       if (allow_all_da) /* Set BIT0 */
+               rtlpci->receive_config |= RCR_AAP;
+       else /* Clear BIT0 */
+               rtlpci->receive_config &= ~RCR_AAP;
+       if (write_into_reg)
+               rtl_write_dword(rtlpriv, REG_RCR, rtlpci->receive_config);
+       RT_TRACE(rtlpriv, COMP_TURBO | COMP_INIT, DBG_LOUD,
+               "receive_config=0x%08X, write_into_reg=%d\n",
+               rtlpci->receive_config, write_into_reg);
+ }
+ /* WKFMCAMAddAllEntry8812 */
+ void rtl8821ae_add_wowlan_pattern(struct ieee80211_hw *hw,
+                                 struct rtl_wow_pattern *rtl_pattern,
+                                 u8 index)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       u32 cam = 0;
+       u8 addr = 0;
+       u16 rxbuf_addr;
+       u8 tmp, count = 0;
+       u16 cam_start;
+       u16 offset;
+       /* Count the WFCAM entry start offset. */
+       /* RX page size = 128 byte */
+       offset = MAX_RX_DMA_BUFFER_SIZE_8812 / 128;
+       /* We should start from the boundry */
+       cam_start = offset * 128;
+       /* Enable Rx packet buffer access. */
+       rtl_write_byte(rtlpriv, REG_PKT_BUFF_ACCESS_CTRL, RXPKT_BUF_SELECT);
+       for (addr = 0; addr < WKFMCAM_ADDR_NUM; addr++) {
+               /* Set Rx packet buffer offset.
+                * RxBufer pointer increases 1,
+                * we can access 8 bytes in Rx packet buffer.
+                * CAM start offset (unit: 1 byte) =  index*WKFMCAM_SIZE
+                * RxBufer addr = (CAM start offset +
+                *                 per entry offset of a WKFM CAM)/8
+                *      * index: The index of the wake up frame mask
+                *      * WKFMCAM_SIZE: the total size of one WKFM CAM
+                *      * per entry offset of a WKFM CAM: Addr*4 bytes
+                */
+               rxbuf_addr = (cam_start + index * WKFMCAM_SIZE + addr * 4) >> 3;
+               /* Set R/W start offset */
+               rtl_write_word(rtlpriv, REG_PKTBUF_DBG_CTRL, rxbuf_addr);
+               if (addr == 0) {
+                       cam = BIT(31) | rtl_pattern->crc;
+                       if (rtl_pattern->type == UNICAST_PATTERN)
+                               cam |= BIT(24);
+                       else if (rtl_pattern->type == MULTICAST_PATTERN)
+                               cam |= BIT(25);
+                       else if (rtl_pattern->type == BROADCAST_PATTERN)
+                               cam |= BIT(26);
+                       rtl_write_dword(rtlpriv, REG_PKTBUF_DBG_DATA_L, cam);
+                       RT_TRACE(rtlpriv, COMP_POWER, DBG_TRACE,
+                                "WRITE entry[%d] 0x%x: %x\n", addr,
+                                 REG_PKTBUF_DBG_DATA_L, cam);
+                       /* Write to Rx packet buffer. */
+                       rtl_write_word(rtlpriv, REG_RXPKTBUF_CTRL, 0x0f01);
+               } else if (addr == 2 || addr == 4) {/* WKFM[127:0] */
+                       cam = rtl_pattern->mask[addr - 2];
+                       rtl_write_dword(rtlpriv, REG_PKTBUF_DBG_DATA_L, cam);
+                       RT_TRACE(rtlpriv, COMP_POWER, DBG_TRACE,
+                                "WRITE entry[%d] 0x%x: %x\n", addr,
+                                 REG_PKTBUF_DBG_DATA_L, cam);
+                       rtl_write_word(rtlpriv, REG_RXPKTBUF_CTRL, 0x0f01);
+               } else if (addr == 3 || addr == 5) {/* WKFM[127:0] */
+                       cam = rtl_pattern->mask[addr - 2];
+                       rtl_write_dword(rtlpriv, REG_PKTBUF_DBG_DATA_H, cam);
+                       RT_TRACE(rtlpriv, COMP_POWER, DBG_TRACE,
+                                "WRITE entry[%d] 0x%x: %x\n", addr,
+                                 REG_PKTBUF_DBG_DATA_H, cam);
+                       rtl_write_word(rtlpriv, REG_RXPKTBUF_CTRL, 0xf001);
+               }
+               count = 0;
+               do {
+                       tmp = rtl_read_byte(rtlpriv, REG_RXPKTBUF_CTRL);
+                       udelay(2);
+                       count++;
+               } while (tmp && count < 100);
+               RT_ASSERT((count < 100),
+                         "Write wake up frame mask FAIL %d value!\n", tmp);
+       }
+       /* Disable Rx packet buffer access. */
+       rtl_write_byte(rtlpriv, REG_PKT_BUFF_ACCESS_CTRL,
+                      DISABLE_TRXPKT_BUF_ACCESS);
+ }
index 0000000000000000000000000000000000000000,a4988121e1ab6a20bad5ad9b5934c166a41f36d6..8ee141a55bc5cc6b566e79dde58cdb05583e7fdf
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,458 +1,463 @@@
+ /******************************************************************************
+  *
+  * Copyright(c) 2009-2010  Realtek Corporation.
+  *
+  * 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>
+  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
+  * Hsinchu 300, Taiwan.
+  *
+  * Larry Finger <Larry.Finger@lwfinger.net>
+  *
+  *****************************************************************************/
+ #include "../wifi.h"
+ #include "../core.h"
+ #include "../pci.h"
+ #include "reg.h"
+ #include "def.h"
+ #include "phy.h"
+ #include "dm.h"
+ #include "hw.h"
+ #include "fw.h"
+ #include "sw.h"
+ #include "trx.h"
+ #include "led.h"
+ #include "table.h"
+ #include "../btcoexist/rtl_btc.h"
+ #include <linux/vmalloc.h>
+ #include <linux/module.h>
+ static void rtl8821ae_init_aspm_vars(struct ieee80211_hw *hw)
+ {
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       /*close ASPM for AMD defaultly */
+       rtlpci->const_amdpci_aspm = 0;
+       /**
+        * ASPM PS mode.
+        * 0 - Disable ASPM,
+        * 1 - Enable ASPM without Clock Req,
+        * 2 - Enable ASPM with Clock Req,
+        * 3 - Alwyas Enable ASPM with Clock Req,
+        * 4 - Always Enable ASPM without Clock Req.
+        * set defult to RTL8192CE:3 RTL8192E:2
+        */
+       rtlpci->const_pci_aspm = 3;
+       /*Setting for PCI-E device */
+       rtlpci->const_devicepci_aspm_setting = 0x03;
+       /*Setting for PCI-E bridge */
+       rtlpci->const_hostpci_aspm_setting = 0x02;
+       /**
+        * In Hw/Sw Radio Off situation.
+        * 0 - Default,
+        * 1 - From ASPM setting without low Mac Pwr,
+        * 2 - From ASPM setting with low Mac Pwr,
+        * 3 - Bus D3
+        * set default to RTL8192CE:0 RTL8192SE:2
+        */
+       rtlpci->const_hwsw_rfoff_d3 = 0;
+       /**
+        * This setting works for those device with
+        * backdoor ASPM setting such as EPHY setting.
+        * 0 - Not support ASPM,
+        * 1 - Support ASPM,
+        * 2 - According to chipset.
+        */
+       rtlpci->const_support_pciaspm = 1;
+ }
+ /*InitializeVariables8812E*/
+ int rtl8821ae_init_sw_vars(struct ieee80211_hw *hw)
+ {
+       int err = 0;
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
+       rtl8821ae_bt_reg_init(hw);
+       rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support;
++      rtlpci->int_clear = rtlpriv->cfg->mod_params->int_clear;
+       rtlpriv->btcoexist.btc_ops = rtl_btc_get_ops_pointer();
+       rtlpriv->dm.dm_initialgain_enable = 1;
+       rtlpriv->dm.dm_flag = 0;
+       rtlpriv->dm.disable_framebursting = 0;
+       rtlpriv->dm.thermalvalue = 0;
+       rtlpci->transmit_config = CFENDFORM | BIT(15) | BIT(24) | BIT(25);
+       mac->ht_enable = true;
+       mac->ht_cur_stbc = 0;
+       mac->ht_stbc_cap = 0;
+       mac->vht_cur_ldpc = 0;
+       mac->vht_ldpc_cap = 0;
+       mac->vht_cur_stbc = 0;
+       mac->vht_stbc_cap = 0;
+       rtlpriv->rtlhal.current_bandtype = BAND_ON_2_4G;
+       /*following 2 is for register 5G band, refer to _rtl_init_mac80211()*/
+       rtlpriv->rtlhal.bandset = BAND_ON_BOTH;
+       rtlpriv->rtlhal.macphymode = SINGLEMAC_SINGLEPHY;
+       rtlpci->receive_config = (RCR_APPFCS    |
+                               RCR_APP_MIC             |
+                               RCR_APP_ICV             |
+                               RCR_APP_PHYST_RXFF      |
+                               RCR_NONQOS_VHT          |
+                               RCR_HTC_LOC_CTRL        |
+                               RCR_AMF                 |
+                               RCR_ACF                 |
+                       /*This bit controls the PS-Poll packet filter.*/
+                               RCR_ADF                 |
+                               RCR_AICV                |
+                               RCR_ACRC32              |
+                               RCR_AB                  |
+                               RCR_AM                  |
+                               RCR_APM                 |
+                               0);
+       rtlpci->irq_mask[0] =
+            (u32)(IMR_PSTIMEOUT                        |
+                               IMR_GTINT3              |
+                               IMR_HSISR_IND_ON_INT    |
+                               IMR_C2HCMD              |
+                               IMR_HIGHDOK             |
+                               IMR_MGNTDOK             |
+                               IMR_BKDOK               |
+                               IMR_BEDOK               |
+                               IMR_VIDOK               |
+                               IMR_VODOK               |
+                               IMR_RDU                 |
+                               IMR_ROK                 |
+                               0);
+       rtlpci->irq_mask[1]     =
+                (u32)(IMR_RXFOVW |
+                               IMR_TXFOVW |
+                               0);
+       rtlpci->sys_irq_mask = (u32)(HSIMR_PDN_INT_EN   |
+                                     HSIMR_RON_INT_EN  |
+                                     0);
+       /* for WOWLAN */
+       rtlpriv->psc.wo_wlan_mode = WAKE_ON_MAGIC_PACKET |
+                                   WAKE_ON_PATTERN_MATCH;
+       /* for debug level */
+       rtlpriv->dbg.global_debuglevel = rtlpriv->cfg->mod_params->debug;
+       /* for LPS & IPS */
+       rtlpriv->psc.inactiveps = rtlpriv->cfg->mod_params->inactiveps;
+       rtlpriv->psc.swctrl_lps = rtlpriv->cfg->mod_params->swctrl_lps;
+       rtlpriv->psc.fwctrl_lps = rtlpriv->cfg->mod_params->fwctrl_lps;
+       rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support;
++      rtlpci->msi_support = rtlpriv->cfg->mod_params->int_clear;
+       if (rtlpriv->cfg->mod_params->disable_watchdog)
+               pr_info("watchdog disabled\n");
+       rtlpriv->psc.reg_fwctrl_lps = 3;
+       rtlpriv->psc.reg_max_lps_awakeintvl = 5;
+       rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support;
+       /* for ASPM, you can close aspm through
+        * set const_support_pciaspm = 0
+        */
+       rtl8821ae_init_aspm_vars(hw);
+       if (rtlpriv->psc.reg_fwctrl_lps == 1)
+               rtlpriv->psc.fwctrl_psmode = FW_PS_MIN_MODE;
+       else if (rtlpriv->psc.reg_fwctrl_lps == 2)
+               rtlpriv->psc.fwctrl_psmode = FW_PS_MAX_MODE;
+       else if (rtlpriv->psc.reg_fwctrl_lps == 3)
+               rtlpriv->psc.fwctrl_psmode = FW_PS_DTIM_MODE;
+       /* for firmware buf */
+       rtlpriv->rtlhal.pfirmware = vzalloc(0x8000);
+       if (!rtlpriv->rtlhal.pfirmware) {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                        "Can't alloc buffer for fw.\n");
+               return 1;
+       }
+       rtlpriv->rtlhal.wowlan_firmware = vzalloc(0x8000);
+       if (!rtlpriv->rtlhal.wowlan_firmware) {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                        "Can't alloc buffer for wowlan fw.\n");
+               return 1;
+       }
+       if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE) {
+               rtlpriv->cfg->fw_name = "rtlwifi/rtl8812aefw.bin";
+               rtlpriv->cfg->wowlan_fw_name = "rtlwifi/rtl8812aefw_wowlan.bin";
+       } else {
+               rtlpriv->cfg->fw_name = "rtlwifi/rtl8821aefw.bin";
+               rtlpriv->cfg->wowlan_fw_name = "rtlwifi/rtl8821aefw_wowlan.bin";
+       }
+       rtlpriv->max_fw_size = 0x8000;
+       /*load normal firmware*/
+       pr_info("Using firmware %s\n", rtlpriv->cfg->fw_name);
+       err = request_firmware_nowait(THIS_MODULE, 1, rtlpriv->cfg->fw_name,
+                                     rtlpriv->io.dev, GFP_KERNEL, hw,
+                                     rtl_fw_cb);
+       if (err) {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                        "Failed to request normal firmware!\n");
+               return 1;
+       }
+       /*load wowlan firmware*/
+       pr_info("Using firmware %s\n", rtlpriv->cfg->wowlan_fw_name);
+       err = request_firmware_nowait(THIS_MODULE, 1,
+                                     rtlpriv->cfg->wowlan_fw_name,
+                                     rtlpriv->io.dev, GFP_KERNEL, hw,
+                                     rtl_wowlan_fw_cb);
+       if (err) {
+               RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
+                        "Failed to request wowlan firmware!\n");
+               return 1;
+       }
+       return 0;
+ }
+ void rtl8821ae_deinit_sw_vars(struct ieee80211_hw *hw)
+ {
+       struct rtl_priv *rtlpriv = rtl_priv(hw);
+       if (rtlpriv->rtlhal.pfirmware) {
+               vfree(rtlpriv->rtlhal.pfirmware);
+               rtlpriv->rtlhal.pfirmware = NULL;
+       }
+ #if (USE_SPECIFIC_FW_TO_SUPPORT_WOWLAN == 1)
+       if (rtlpriv->rtlhal.wowlan_firmware) {
+               vfree(rtlpriv->rtlhal.wowlan_firmware);
+               rtlpriv->rtlhal.wowlan_firmware = NULL;
+       }
+ #endif
+ }
+ /* get bt coexist status */
+ bool rtl8821ae_get_btc_status(void)
+ {
+       return true;
+ }
+ static struct rtl_hal_ops rtl8821ae_hal_ops = {
+       .init_sw_vars = rtl8821ae_init_sw_vars,
+       .deinit_sw_vars = rtl8821ae_deinit_sw_vars,
+       .read_eeprom_info = rtl8821ae_read_eeprom_info,
+       .interrupt_recognized = rtl8821ae_interrupt_recognized,
+       .hw_init = rtl8821ae_hw_init,
+       .hw_disable = rtl8821ae_card_disable,
+       .hw_suspend = rtl8821ae_suspend,
+       .hw_resume = rtl8821ae_resume,
+       .enable_interrupt = rtl8821ae_enable_interrupt,
+       .disable_interrupt = rtl8821ae_disable_interrupt,
+       .set_network_type = rtl8821ae_set_network_type,
+       .set_chk_bssid = rtl8821ae_set_check_bssid,
+       .set_qos = rtl8821ae_set_qos,
+       .set_bcn_reg = rtl8821ae_set_beacon_related_registers,
+       .set_bcn_intv = rtl8821ae_set_beacon_interval,
+       .update_interrupt_mask = rtl8821ae_update_interrupt_mask,
+       .get_hw_reg = rtl8821ae_get_hw_reg,
+       .set_hw_reg = rtl8821ae_set_hw_reg,
+       .update_rate_tbl = rtl8821ae_update_hal_rate_tbl,
+       .fill_tx_desc = rtl8821ae_tx_fill_desc,
+       .fill_tx_cmddesc = rtl8821ae_tx_fill_cmddesc,
+       .query_rx_desc = rtl8821ae_rx_query_desc,
+       .set_channel_access = rtl8821ae_update_channel_access_setting,
+       .radio_onoff_checking = rtl8821ae_gpio_radio_on_off_checking,
+       .set_bw_mode = rtl8821ae_phy_set_bw_mode,
+       .switch_channel = rtl8821ae_phy_sw_chnl,
+       .dm_watchdog = rtl8821ae_dm_watchdog,
+       .scan_operation_backup = rtl8821ae_phy_scan_operation_backup,
+       .set_rf_power_state = rtl8821ae_phy_set_rf_power_state,
+       .led_control = rtl8821ae_led_control,
+       .set_desc = rtl8821ae_set_desc,
+       .get_desc = rtl8821ae_get_desc,
+       .is_tx_desc_closed = rtl8821ae_is_tx_desc_closed,
+       .tx_polling = rtl8821ae_tx_polling,
+       .enable_hw_sec = rtl8821ae_enable_hw_security_config,
+       .set_key = rtl8821ae_set_key,
+       .init_sw_leds = rtl8821ae_init_sw_leds,
+       .get_bbreg = rtl8821ae_phy_query_bb_reg,
+       .set_bbreg = rtl8821ae_phy_set_bb_reg,
+       .get_rfreg = rtl8821ae_phy_query_rf_reg,
+       .set_rfreg = rtl8821ae_phy_set_rf_reg,
+       .fill_h2c_cmd = rtl8821ae_fill_h2c_cmd,
+       .get_btc_status = rtl8821ae_get_btc_status,
+       .rx_command_packet = rtl8821ae_rx_command_packet,
+       .add_wowlan_pattern = rtl8821ae_add_wowlan_pattern,
+ };
+ static struct rtl_mod_params rtl8821ae_mod_params = {
+       .sw_crypto = false,
+       .inactiveps = true,
+       .swctrl_lps = false,
+       .fwctrl_lps = true,
+       .msi_support = true,
++      .int_clear = true,
+       .debug = DBG_EMERG,
+       .disable_watchdog = 0,
+ };
+ static struct rtl_hal_cfg rtl8821ae_hal_cfg = {
+       .bar_id = 2,
+       .write_readback = true,
+       .name = "rtl8821ae_pci",
+       .fw_name = "rtlwifi/rtl8821aefw.bin",
+       .ops = &rtl8821ae_hal_ops,
+       .mod_params = &rtl8821ae_mod_params,
+       .maps[SYS_ISO_CTRL] = REG_SYS_ISO_CTRL,
+       .maps[SYS_FUNC_EN] = REG_SYS_FUNC_EN,
+       .maps[SYS_CLK] = REG_SYS_CLKR,
+       .maps[MAC_RCR_AM] = AM,
+       .maps[MAC_RCR_AB] = AB,
+       .maps[MAC_RCR_ACRC32] = ACRC32,
+       .maps[MAC_RCR_ACF] = ACF,
+       .maps[MAC_RCR_AAP] = AAP,
+       .maps[MAC_HIMR] = REG_HIMR,
+       .maps[MAC_HIMRE] = REG_HIMRE,
+       .maps[EFUSE_ACCESS] = REG_EFUSE_ACCESS,
+       .maps[EFUSE_TEST] = REG_EFUSE_TEST,
+       .maps[EFUSE_CTRL] = REG_EFUSE_CTRL,
+       .maps[EFUSE_CLK] = 0,
+       .maps[EFUSE_CLK_CTRL] = REG_EFUSE_CTRL,
+       .maps[EFUSE_PWC_EV12V] = PWC_EV12V,
+       .maps[EFUSE_FEN_ELDR] = FEN_ELDR,
+       .maps[EFUSE_LOADER_CLK_EN] = LOADER_CLK_EN,
+       .maps[EFUSE_ANA8M] = ANA8M,
+       .maps[EFUSE_HWSET_MAX_SIZE] = HWSET_MAX_SIZE,
+       .maps[EFUSE_MAX_SECTION_MAP] = EFUSE_MAX_SECTION,
+       .maps[EFUSE_REAL_CONTENT_SIZE] = EFUSE_REAL_CONTENT_LEN,
+       .maps[EFUSE_OOB_PROTECT_BYTES_LEN] = EFUSE_OOB_PROTECT_BYTES,
+       .maps[RWCAM] = REG_CAMCMD,
+       .maps[WCAMI] = REG_CAMWRITE,
+       .maps[RCAMO] = REG_CAMREAD,
+       .maps[CAMDBG] = REG_CAMDBG,
+       .maps[SECR] = REG_SECCFG,
+       .maps[SEC_CAM_NONE] = CAM_NONE,
+       .maps[SEC_CAM_WEP40] = CAM_WEP40,
+       .maps[SEC_CAM_TKIP] = CAM_TKIP,
+       .maps[SEC_CAM_AES] = CAM_AES,
+       .maps[SEC_CAM_WEP104] = CAM_WEP104,
+       .maps[RTL_IMR_BCNDMAINT6] = IMR_BCNDMAINT6,
+       .maps[RTL_IMR_BCNDMAINT5] = IMR_BCNDMAINT5,
+       .maps[RTL_IMR_BCNDMAINT4] = IMR_BCNDMAINT4,
+       .maps[RTL_IMR_BCNDMAINT3] = IMR_BCNDMAINT3,
+       .maps[RTL_IMR_BCNDMAINT2] = IMR_BCNDMAINT2,
+       .maps[RTL_IMR_BCNDMAINT1] = IMR_BCNDMAINT1,
+ /*    .maps[RTL_IMR_BCNDOK8] = IMR_BCNDOK8,     */   /*need check*/
+       .maps[RTL_IMR_BCNDOK7] = IMR_BCNDOK7,
+       .maps[RTL_IMR_BCNDOK6] = IMR_BCNDOK6,
+       .maps[RTL_IMR_BCNDOK5] = IMR_BCNDOK5,
+       .maps[RTL_IMR_BCNDOK4] = IMR_BCNDOK4,
+       .maps[RTL_IMR_BCNDOK3] = IMR_BCNDOK3,
+       .maps[RTL_IMR_BCNDOK2] = IMR_BCNDOK2,
+       .maps[RTL_IMR_BCNDOK1] = IMR_BCNDOK1,
+ /*    .maps[RTL_IMR_TIMEOUT2] = IMR_TIMEOUT2,*/
+ /*    .maps[RTL_IMR_TIMEOUT1] = IMR_TIMEOUT1,*/
+       .maps[RTL_IMR_TXFOVW] = IMR_TXFOVW,
+       .maps[RTL_IMR_PSTIMEOUT] = IMR_PSTIMEOUT,
+       .maps[RTL_IMR_BCNINT] = IMR_BCNDMAINT0,
+       .maps[RTL_IMR_RXFOVW] = IMR_RXFOVW,
+       .maps[RTL_IMR_RDU] = IMR_RDU,
+       .maps[RTL_IMR_ATIMEND] = IMR_ATIMEND,
+       .maps[RTL_IMR_BDOK] = IMR_BCNDOK0,
+       .maps[RTL_IMR_MGNTDOK] = IMR_MGNTDOK,
+       .maps[RTL_IMR_TBDER] = IMR_TBDER,
+       .maps[RTL_IMR_HIGHDOK] = IMR_HIGHDOK,
+       .maps[RTL_IMR_TBDOK] = IMR_TBDOK,
+       .maps[RTL_IMR_BKDOK] = IMR_BKDOK,
+       .maps[RTL_IMR_BEDOK] = IMR_BEDOK,
+       .maps[RTL_IMR_VIDOK] = IMR_VIDOK,
+       .maps[RTL_IMR_VODOK] = IMR_VODOK,
+       .maps[RTL_IMR_ROK] = IMR_ROK,
+       .maps[RTL_IBSS_INT_MASKS] = (IMR_BCNDMAINT0 | IMR_TBDOK | IMR_TBDER),
+       .maps[RTL_RC_CCK_RATE1M] = DESC_RATE1M,
+       .maps[RTL_RC_CCK_RATE2M] =  DESC_RATE2M,
+       .maps[RTL_RC_CCK_RATE5_5M] =  DESC_RATE5_5M,
+       .maps[RTL_RC_CCK_RATE11M] =  DESC_RATE11M,
+       .maps[RTL_RC_OFDM_RATE6M] =  DESC_RATE6M,
+       .maps[RTL_RC_OFDM_RATE9M] =  DESC_RATE9M,
+       .maps[RTL_RC_OFDM_RATE12M] =  DESC_RATE12M,
+       .maps[RTL_RC_OFDM_RATE18M] =  DESC_RATE18M,
+       .maps[RTL_RC_OFDM_RATE24M] =  DESC_RATE24M,
+       .maps[RTL_RC_OFDM_RATE36M] =  DESC_RATE36M,
+       .maps[RTL_RC_OFDM_RATE48M] =  DESC_RATE48M,
+       .maps[RTL_RC_OFDM_RATE54M] =  DESC_RATE54M,
+       .maps[RTL_RC_HT_RATEMCS7] =  DESC_RATEMCS7,
+       .maps[RTL_RC_HT_RATEMCS15] =  DESC_RATEMCS15,
+       /*VHT hightest rate*/
+       .maps[RTL_RC_VHT_RATE_1SS_MCS7] = DESC_RATEVHT1SS_MCS7,
+       .maps[RTL_RC_VHT_RATE_1SS_MCS8] = DESC_RATEVHT1SS_MCS8,
+       .maps[RTL_RC_VHT_RATE_1SS_MCS9] = DESC_RATEVHT1SS_MCS9,
+       .maps[RTL_RC_VHT_RATE_2SS_MCS7] = DESC_RATEVHT2SS_MCS7,
+       .maps[RTL_RC_VHT_RATE_2SS_MCS8] = DESC_RATEVHT2SS_MCS8,
+       .maps[RTL_RC_VHT_RATE_2SS_MCS9] = DESC_RATEVHT2SS_MCS9,
+ };
+ static struct pci_device_id rtl8821ae_pci_ids[] = {
+       {RTL_PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x8812, rtl8821ae_hal_cfg)},
+       {RTL_PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x8821, rtl8821ae_hal_cfg)},
+       {},
+ };
+ MODULE_DEVICE_TABLE(pci, rtl8821ae_pci_ids);
+ MODULE_AUTHOR("Realtek WlanFAE        <wlanfae@realtek.com>");
+ MODULE_LICENSE("GPL");
+ MODULE_DESCRIPTION("Realtek 8821ae 802.11ac PCI wireless");
+ MODULE_FIRMWARE("rtlwifi/rtl8821aefw.bin");
+ module_param_named(swenc, rtl8821ae_mod_params.sw_crypto, bool, 0444);
+ module_param_named(debug, rtl8821ae_mod_params.debug, int, 0444);
+ module_param_named(ips, rtl8821ae_mod_params.inactiveps, bool, 0444);
+ module_param_named(swlps, rtl8821ae_mod_params.swctrl_lps, bool, 0444);
+ module_param_named(fwlps, rtl8821ae_mod_params.fwctrl_lps, bool, 0444);
+ module_param_named(msi, rtl8821ae_mod_params.msi_support, bool, 0444);
+ module_param_named(disable_watchdog, rtl8821ae_mod_params.disable_watchdog,
+                  bool, 0444);
++module_param_named(int_clear, rtl8821ae_mod_params.int_clear, bool, 0444);
+ MODULE_PARM_DESC(swenc, "Set to 1 for software crypto (default 0)\n");
+ MODULE_PARM_DESC(ips, "Set to 0 to not use link power save (default 1)\n");
+ MODULE_PARM_DESC(swlps, "Set to 1 to use SW control power save (default 0)\n");
+ MODULE_PARM_DESC(fwlps, "Set to 1 to use FW control power save (default 1)\n");
+ MODULE_PARM_DESC(msi, "Set to 1 to use MSI interrupts mode (default 1)\n");
+ MODULE_PARM_DESC(debug, "Set debug level (0-5) (default 0)");
+ MODULE_PARM_DESC(disable_watchdog, "Set to 1 to disable the watchdog (default 0)\n");
++MODULE_PARM_DESC(int_clear, "Set to 1 to disable interrupt clear before set (default 0)\n");
+ static SIMPLE_DEV_PM_OPS(rtlwifi_pm_ops, rtl_pci_suspend, rtl_pci_resume);
+ static struct pci_driver rtl8821ae_driver = {
+       .name = KBUILD_MODNAME,
+       .id_table = rtl8821ae_pci_ids,
+       .probe = rtl_pci_probe,
+       .remove = rtl_pci_disconnect,
+       .driver.pm = &rtlwifi_pm_ops,
+ };
+ module_pci_driver(rtl8821ae_driver);
index 0000000000000000000000000000000000000000,b90ca618b123209a1724bc808c4fdfe8ea330a69..4544752a2ba83ca173f7cb4f14abc72538b73beb
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,3032 +1,3035 @@@
+ /******************************************************************************
+  *
+  * Copyright(c) 2009-2012  Realtek Corporation.
+  *
+  * 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>
+  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
+  * Hsinchu 300, Taiwan.
+  *
+  * Larry Finger <Larry.Finger@lwfinger.net>
+  *
+  *****************************************************************************/
+ #ifndef __RTL_WIFI_H__
+ #define __RTL_WIFI_H__
+ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+ #include <linux/sched.h>
+ #include <linux/firmware.h>
+ #include <linux/etherdevice.h>
+ #include <linux/vmalloc.h>
+ #include <linux/usb.h>
+ #include <net/mac80211.h>
+ #include <linux/completion.h>
+ #include "debug.h"
+ #define       MASKBYTE0                               0xff
+ #define       MASKBYTE1                               0xff00
+ #define       MASKBYTE2                               0xff0000
+ #define       MASKBYTE3                               0xff000000
+ #define       MASKHWORD                               0xffff0000
+ #define       MASKLWORD                               0x0000ffff
+ #define       MASKDWORD                               0xffffffff
+ #define       MASK12BITS                              0xfff
+ #define       MASKH4BITS                              0xf0000000
+ #define MASKOFDM_D                            0xffc00000
+ #define       MASKCCK                                 0x3f3f3f3f
+ #define       MASK4BITS                               0x0f
+ #define       MASK20BITS                              0xfffff
+ #define RFREG_OFFSET_MASK                     0xfffff
+ #define       MASKBYTE0                               0xff
+ #define       MASKBYTE1                               0xff00
+ #define       MASKBYTE2                               0xff0000
+ #define       MASKBYTE3                               0xff000000
+ #define       MASKHWORD                               0xffff0000
+ #define       MASKLWORD                               0x0000ffff
+ #define       MASKDWORD                               0xffffffff
+ #define       MASK12BITS                              0xfff
+ #define       MASKH4BITS                              0xf0000000
+ #define MASKOFDM_D                            0xffc00000
+ #define       MASKCCK                                 0x3f3f3f3f
+ #define       MASK4BITS                               0x0f
+ #define       MASK20BITS                              0xfffff
+ #define RFREG_OFFSET_MASK                     0xfffff
+ #define RF_CHANGE_BY_INIT                     0
+ #define RF_CHANGE_BY_IPS                      BIT(28)
+ #define RF_CHANGE_BY_PS                               BIT(29)
+ #define RF_CHANGE_BY_HW                               BIT(30)
+ #define RF_CHANGE_BY_SW                               BIT(31)
+ #define IQK_ADDA_REG_NUM                      16
+ #define IQK_MAC_REG_NUM                               4
+ #define IQK_THRESHOLD                         8
+ #define MAX_KEY_LEN                           61
+ #define KEY_BUF_SIZE                          5
+ /* QoS related. */
+ /*aci: 0x00   Best Effort*/
+ /*aci: 0x01   Background*/
+ /*aci: 0x10   Video*/
+ /*aci: 0x11   Voice*/
+ /*Max: define total number.*/
+ #define AC0_BE                                        0
+ #define AC1_BK                                        1
+ #define AC2_VI                                        2
+ #define AC3_VO                                        3
+ #define AC_MAX                                        4
+ #define QOS_QUEUE_NUM                         4
+ #define RTL_MAC80211_NUM_QUEUE                        5
+ #define REALTEK_USB_VENQT_MAX_BUF_SIZE                254
+ #define RTL_USB_MAX_RX_COUNT                  100
+ #define QBSS_LOAD_SIZE                                5
+ #define MAX_WMMELE_LENGTH                     64
+ #define TOTAL_CAM_ENTRY                               32
+ /*slot time for 11g. */
+ #define RTL_SLOT_TIME_9                               9
+ #define RTL_SLOT_TIME_20                      20
+ /*related to tcp/ip. */
+ #define SNAP_SIZE             6
+ #define PROTOC_TYPE_SIZE      2
+ /*related with 802.11 frame*/
+ #define MAC80211_3ADDR_LEN                    24
+ #define MAC80211_4ADDR_LEN                    30
+ #define CHANNEL_MAX_NUMBER    (14 + 24 + 21)  /* 14 is the max channel no */
+ #define CHANNEL_MAX_NUMBER_2G         14
+ #define CHANNEL_MAX_NUMBER_5G         54 /* Please refer to
+                                           *"phy_GetChnlGroup8812A" and
+                                           * "Hal_ReadTxPowerInfo8812A"
+                                           */
+ #define CHANNEL_MAX_NUMBER_5G_80M     7
+ #define CHANNEL_GROUP_MAX     (3 + 9) /*  ch1~3, 4~9, 10~14 = three groups */
+ #define CHANNEL_MAX_NUMBER_5G         54 /* Please refer to
+                                           *"phy_GetChnlGroup8812A" and
+                                           * "Hal_ReadTxPowerInfo8812A"
+                                           */
+ #define CHANNEL_MAX_NUMBER_5G_80M     7
+ #define MAX_PG_GROUP                  13
+ #define       CHANNEL_GROUP_MAX_2G            3
+ #define       CHANNEL_GROUP_IDX_5GL           3
+ #define       CHANNEL_GROUP_IDX_5GM           6
+ #define       CHANNEL_GROUP_IDX_5GH           9
+ #define       CHANNEL_GROUP_MAX_5G            9
+ #define CHANNEL_MAX_NUMBER_2G         14
+ #define AVG_THERMAL_NUM                       8
+ #define AVG_THERMAL_NUM_88E           4
+ #define AVG_THERMAL_NUM_8723BE                4
+ #define MAX_TID_COUNT                 9
+ /* for early mode */
+ #define FCS_LEN                               4
+ #define EM_HDR_LEN                    8
+ enum rtl8192c_h2c_cmd {
+       H2C_AP_OFFLOAD = 0,
+       H2C_SETPWRMODE = 1,
+       H2C_JOINBSSRPT = 2,
+       H2C_RSVDPAGE = 3,
+       H2C_RSSI_REPORT = 5,
+       H2C_RA_MASK = 6,
+       H2C_MACID_PS_MODE = 7,
+       H2C_P2P_PS_OFFLOAD = 8,
+       H2C_MAC_MODE_SEL = 9,
+       H2C_PWRM = 15,
+       H2C_P2P_PS_CTW_CMD = 24,
+       MAX_H2CCMD
+ };
+ #define MAX_TX_COUNT                  4
+ #define MAX_REGULATION_NUM            4
+ #define MAX_RF_PATH_NUM                       4
+ #define MAX_RATE_SECTION_NUM          6
+ #define MAX_2_4G_BANDWITH_NUM         4
+ #define MAX_5G_BANDWITH_NUM           4
+ #define       MAX_RF_PATH                     4
+ #define       MAX_CHNL_GROUP_24G              6
+ #define       MAX_CHNL_GROUP_5G               14
+ #define TX_PWR_BY_RATE_NUM_BAND               2
+ #define TX_PWR_BY_RATE_NUM_RF         4
+ #define TX_PWR_BY_RATE_NUM_SECTION    12
+ #define MAX_BASE_NUM_IN_PHY_REG_PG_24G  6
+ #define MAX_BASE_NUM_IN_PHY_REG_PG_5G 5
+ #define RTL8192EE_SEG_NUM             1 /* 0:2 seg, 1: 4 seg, 2: 8 seg */
+ #define DEL_SW_IDX_SZ         30
+ #define BAND_NUM                      3
+ /* For now, it's just for 8192ee
+  * but not OK yet, keep it 0
+  */
+ #define DMA_IS_64BIT 0
+ #define RTL8192EE_SEG_NUM             1 /* 0:2 seg, 1: 4 seg, 2: 8 seg */
+ enum rf_tx_num {
+       RF_1TX = 0,
+       RF_2TX,
+       RF_MAX_TX_NUM,
+       RF_TX_NUM_NONIMPLEMENT,
+ };
+ #define PACKET_NORMAL                 0
+ #define PACKET_DHCP                   1
+ #define PACKET_ARP                    2
+ #define PACKET_EAPOL                  3
+ #define       MAX_SUPPORT_WOL_PATTERN_NUM     16
+ #define       RSVD_WOL_PATTERN_NUM            1
+ #define       WKFMCAM_ADDR_NUM                6
+ #define       WKFMCAM_SIZE                    24
+ #define       MAX_WOL_BIT_MASK_SIZE           16
+ /* MIN LEN keeps 13 here */
+ #define       MIN_WOL_PATTERN_SIZE            13
+ #define       MAX_WOL_PATTERN_SIZE            128
+ #define       WAKE_ON_MAGIC_PACKET            BIT(0)
+ #define       WAKE_ON_PATTERN_MATCH           BIT(1)
+ #define       WOL_REASON_PTK_UPDATE           BIT(0)
+ #define       WOL_REASON_GTK_UPDATE           BIT(1)
+ #define       WOL_REASON_DISASSOC             BIT(2)
+ #define       WOL_REASON_DEAUTH               BIT(3)
+ #define       WOL_REASON_AP_LOST              BIT(4)
+ #define       WOL_REASON_MAGIC_PKT            BIT(5)
+ #define       WOL_REASON_UNICAST_PKT          BIT(6)
+ #define       WOL_REASON_PATTERN_PKT          BIT(7)
+ #define       WOL_REASON_RTD3_SSID_MATCH      BIT(8)
+ #define       WOL_REASON_REALWOW_V2_WAKEUPPKT BIT(9)
+ #define       WOL_REASON_REALWOW_V2_ACKLOST   BIT(10)
+ struct rtlwifi_firmware_header {
+       __le16 signature;
+       u8 category;
+       u8 function;
+       __le16 version;
+       u8 subversion;
+       u8 rsvd1;
+       u8 month;
+       u8 date;
+       u8 hour;
+       u8 minute;
+       __le16 ramcodeSize;
+       __le16 rsvd2;
+       __le32 svnindex;
+       __le32 rsvd3;
+       __le32 rsvd4;
+       __le32 rsvd5;
+ };
+ struct txpower_info_2g {
+       u8 index_cck_base[MAX_RF_PATH][MAX_CHNL_GROUP_24G];
+       u8 index_bw40_base[MAX_RF_PATH][MAX_CHNL_GROUP_24G];
+       /*If only one tx, only BW20 and OFDM are used.*/
+       u8 cck_diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 ofdm_diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 bw20_diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 bw40_diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 bw80_diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 bw160_diff[MAX_RF_PATH][MAX_TX_COUNT];
+ };
+ struct txpower_info_5g {
+       u8 index_bw40_base[MAX_RF_PATH][MAX_CHNL_GROUP_5G];
+       /*If only one tx, only BW20, OFDM, BW80 and BW160 are used.*/
+       u8 ofdm_diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 bw20_diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 bw40_diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 bw80_diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 bw160_diff[MAX_RF_PATH][MAX_TX_COUNT];
+ };
+ enum rate_section {
+       CCK = 0,
+       OFDM,
+       HT_MCS0_MCS7,
+       HT_MCS8_MCS15,
+       VHT_1SSMCS0_1SSMCS9,
+       VHT_2SSMCS0_2SSMCS9,
+ };
+ enum intf_type {
+       INTF_PCI = 0,
+       INTF_USB = 1,
+ };
+ enum radio_path {
+       RF90_PATH_A = 0,
+       RF90_PATH_B = 1,
+       RF90_PATH_C = 2,
+       RF90_PATH_D = 3,
+ };
+ enum regulation_txpwr_lmt {
+       TXPWR_LMT_FCC = 0,
+       TXPWR_LMT_MKK = 1,
+       TXPWR_LMT_ETSI = 2,
+       TXPWR_LMT_WW = 3,
+       TXPWR_LMT_MAX_REGULATION_NUM = 4
+ };
+ enum rt_eeprom_type {
+       EEPROM_93C46,
+       EEPROM_93C56,
+       EEPROM_BOOT_EFUSE,
+ };
+ enum ttl_status {
+       RTL_STATUS_INTERFACE_START = 0,
+ };
+ enum hardware_type {
+       HARDWARE_TYPE_RTL8192E,
+       HARDWARE_TYPE_RTL8192U,
+       HARDWARE_TYPE_RTL8192SE,
+       HARDWARE_TYPE_RTL8192SU,
+       HARDWARE_TYPE_RTL8192CE,
+       HARDWARE_TYPE_RTL8192CU,
+       HARDWARE_TYPE_RTL8192DE,
+       HARDWARE_TYPE_RTL8192DU,
+       HARDWARE_TYPE_RTL8723AE,
+       HARDWARE_TYPE_RTL8723U,
+       HARDWARE_TYPE_RTL8188EE,
+       HARDWARE_TYPE_RTL8723BE,
+       HARDWARE_TYPE_RTL8192EE,
+       HARDWARE_TYPE_RTL8821AE,
+       HARDWARE_TYPE_RTL8812AE,
+       /* keep it last */
+       HARDWARE_TYPE_NUM
+ };
+ #define IS_HARDWARE_TYPE_8192SU(rtlhal)                       \
+       (rtlhal->hw_type == HARDWARE_TYPE_RTL8192SU)
+ #define IS_HARDWARE_TYPE_8192SE(rtlhal)                       \
+       (rtlhal->hw_type == HARDWARE_TYPE_RTL8192SE)
+ #define IS_HARDWARE_TYPE_8192CE(rtlhal)                       \
+       (rtlhal->hw_type == HARDWARE_TYPE_RTL8192CE)
+ #define IS_HARDWARE_TYPE_8192CU(rtlhal)                       \
+       (rtlhal->hw_type == HARDWARE_TYPE_RTL8192CU)
+ #define IS_HARDWARE_TYPE_8192DE(rtlhal)                       \
+       (rtlhal->hw_type == HARDWARE_TYPE_RTL8192DE)
+ #define IS_HARDWARE_TYPE_8192DU(rtlhal)                       \
+       (rtlhal->hw_type == HARDWARE_TYPE_RTL8192DU)
+ #define IS_HARDWARE_TYPE_8723E(rtlhal)                        \
+       (rtlhal->hw_type == HARDWARE_TYPE_RTL8723E)
+ #define IS_HARDWARE_TYPE_8723U(rtlhal)                        \
+       (rtlhal->hw_type == HARDWARE_TYPE_RTL8723U)
+ #define       IS_HARDWARE_TYPE_8192S(rtlhal)                  \
+ (IS_HARDWARE_TYPE_8192SE(rtlhal) || IS_HARDWARE_TYPE_8192SU(rtlhal))
+ #define       IS_HARDWARE_TYPE_8192C(rtlhal)                  \
+ (IS_HARDWARE_TYPE_8192CE(rtlhal) || IS_HARDWARE_TYPE_8192CU(rtlhal))
+ #define       IS_HARDWARE_TYPE_8192D(rtlhal)                  \
+ (IS_HARDWARE_TYPE_8192DE(rtlhal) || IS_HARDWARE_TYPE_8192DU(rtlhal))
+ #define       IS_HARDWARE_TYPE_8723(rtlhal)                   \
+ (IS_HARDWARE_TYPE_8723E(rtlhal) || IS_HARDWARE_TYPE_8723U(rtlhal))
+ #define RX_HAL_IS_CCK_RATE(rxmcs)                     \
+       ((rxmcs) == DESC_RATE1M ||                      \
+        (rxmcs) == DESC_RATE2M ||                      \
+        (rxmcs) == DESC_RATE5_5M ||                    \
+        (rxmcs) == DESC_RATE11M)
+ enum scan_operation_backup_opt {
+       SCAN_OPT_BACKUP = 0,
+       SCAN_OPT_BACKUP_BAND0 = 0,
+       SCAN_OPT_BACKUP_BAND1,
+       SCAN_OPT_RESTORE,
+       SCAN_OPT_MAX
+ };
+ /*RF state.*/
+ enum rf_pwrstate {
+       ERFON,
+       ERFSLEEP,
+       ERFOFF
+ };
+ struct bb_reg_def {
+       u32 rfintfs;
+       u32 rfintfi;
+       u32 rfintfo;
+       u32 rfintfe;
+       u32 rf3wire_offset;
+       u32 rflssi_select;
+       u32 rftxgain_stage;
+       u32 rfhssi_para1;
+       u32 rfhssi_para2;
+       u32 rfsw_ctrl;
+       u32 rfagc_control1;
+       u32 rfagc_control2;
+       u32 rfrxiq_imbal;
+       u32 rfrx_afe;
+       u32 rftxiq_imbal;
+       u32 rftx_afe;
+       u32 rf_rb;              /* rflssi_readback */
+       u32 rf_rbpi;            /* rflssi_readbackpi */
+ };
+ enum io_type {
+       IO_CMD_PAUSE_DM_BY_SCAN = 0,
+       IO_CMD_PAUSE_BAND0_DM_BY_SCAN = 0,
+       IO_CMD_PAUSE_BAND1_DM_BY_SCAN = 1,
+       IO_CMD_RESUME_DM_BY_SCAN = 2,
+ };
+ enum hw_variables {
+       HW_VAR_ETHER_ADDR,
+       HW_VAR_MULTICAST_REG,
+       HW_VAR_BASIC_RATE,
+       HW_VAR_BSSID,
+       HW_VAR_MEDIA_STATUS,
+       HW_VAR_SECURITY_CONF,
+       HW_VAR_BEACON_INTERVAL,
+       HW_VAR_ATIM_WINDOW,
+       HW_VAR_LISTEN_INTERVAL,
+       HW_VAR_CS_COUNTER,
+       HW_VAR_DEFAULTKEY0,
+       HW_VAR_DEFAULTKEY1,
+       HW_VAR_DEFAULTKEY2,
+       HW_VAR_DEFAULTKEY3,
+       HW_VAR_SIFS,
+       HW_VAR_R2T_SIFS,
+       HW_VAR_DIFS,
+       HW_VAR_EIFS,
+       HW_VAR_SLOT_TIME,
+       HW_VAR_ACK_PREAMBLE,
+       HW_VAR_CW_CONFIG,
+       HW_VAR_CW_VALUES,
+       HW_VAR_RATE_FALLBACK_CONTROL,
+       HW_VAR_CONTENTION_WINDOW,
+       HW_VAR_RETRY_COUNT,
+       HW_VAR_TR_SWITCH,
+       HW_VAR_COMMAND,
+       HW_VAR_WPA_CONFIG,
+       HW_VAR_AMPDU_MIN_SPACE,
+       HW_VAR_SHORTGI_DENSITY,
+       HW_VAR_AMPDU_FACTOR,
+       HW_VAR_MCS_RATE_AVAILABLE,
+       HW_VAR_AC_PARAM,
+       HW_VAR_ACM_CTRL,
+       HW_VAR_DIS_Req_Qsize,
+       HW_VAR_CCX_CHNL_LOAD,
+       HW_VAR_CCX_NOISE_HISTOGRAM,
+       HW_VAR_CCX_CLM_NHM,
+       HW_VAR_TxOPLimit,
+       HW_VAR_TURBO_MODE,
+       HW_VAR_RF_STATE,
+       HW_VAR_RF_OFF_BY_HW,
+       HW_VAR_BUS_SPEED,
+       HW_VAR_SET_DEV_POWER,
+       HW_VAR_RCR,
+       HW_VAR_RATR_0,
+       HW_VAR_RRSR,
+       HW_VAR_CPU_RST,
+       HW_VAR_CHECK_BSSID,
+       HW_VAR_LBK_MODE,
+       HW_VAR_AES_11N_FIX,
+       HW_VAR_USB_RX_AGGR,
+       HW_VAR_USER_CONTROL_TURBO_MODE,
+       HW_VAR_RETRY_LIMIT,
+       HW_VAR_INIT_TX_RATE,
+       HW_VAR_TX_RATE_REG,
+       HW_VAR_EFUSE_USAGE,
+       HW_VAR_EFUSE_BYTES,
+       HW_VAR_AUTOLOAD_STATUS,
+       HW_VAR_RF_2R_DISABLE,
+       HW_VAR_SET_RPWM,
+       HW_VAR_H2C_FW_PWRMODE,
+       HW_VAR_H2C_FW_JOINBSSRPT,
+       HW_VAR_H2C_FW_MEDIASTATUSRPT,
+       HW_VAR_H2C_FW_P2P_PS_OFFLOAD,
+       HW_VAR_FW_PSMODE_STATUS,
+       HW_VAR_INIT_RTS_RATE,
+       HW_VAR_RESUME_CLK_ON,
+       HW_VAR_FW_LPS_ACTION,
+       HW_VAR_1X1_RECV_COMBINE,
+       HW_VAR_STOP_SEND_BEACON,
+       HW_VAR_TSF_TIMER,
+       HW_VAR_IO_CMD,
+       HW_VAR_RF_RECOVERY,
+       HW_VAR_H2C_FW_UPDATE_GTK,
+       HW_VAR_WF_MASK,
+       HW_VAR_WF_CRC,
+       HW_VAR_WF_IS_MAC_ADDR,
+       HW_VAR_H2C_FW_OFFLOAD,
+       HW_VAR_RESET_WFCRC,
+       HW_VAR_HANDLE_FW_C2H,
+       HW_VAR_DL_FW_RSVD_PAGE,
+       HW_VAR_AID,
+       HW_VAR_HW_SEQ_ENABLE,
+       HW_VAR_CORRECT_TSF,
+       HW_VAR_BCN_VALID,
+       HW_VAR_FWLPS_RF_ON,
+       HW_VAR_DUAL_TSF_RST,
+       HW_VAR_SWITCH_EPHY_WoWLAN,
+       HW_VAR_INT_MIGRATION,
+       HW_VAR_INT_AC,
+       HW_VAR_RF_TIMING,
+       HAL_DEF_WOWLAN,
+       HW_VAR_MRC,
+       HW_VAR_KEEP_ALIVE,
+       HW_VAR_NAV_UPPER,
+       HW_VAR_MGT_FILTER,
+       HW_VAR_CTRL_FILTER,
+       HW_VAR_DATA_FILTER,
+ };
+ enum rt_media_status {
+       RT_MEDIA_DISCONNECT = 0,
+       RT_MEDIA_CONNECT = 1
+ };
+ enum rt_oem_id {
+       RT_CID_DEFAULT = 0,
+       RT_CID_8187_ALPHA0 = 1,
+       RT_CID_8187_SERCOMM_PS = 2,
+       RT_CID_8187_HW_LED = 3,
+       RT_CID_8187_NETGEAR = 4,
+       RT_CID_WHQL = 5,
+       RT_CID_819X_CAMEO = 6,
+       RT_CID_819X_RUNTOP = 7,
+       RT_CID_819X_SENAO = 8,
+       RT_CID_TOSHIBA = 9,
+       RT_CID_819X_NETCORE = 10,
+       RT_CID_NETTRONIX = 11,
+       RT_CID_DLINK = 12,
+       RT_CID_PRONET = 13,
+       RT_CID_COREGA = 14,
+       RT_CID_819X_ALPHA = 15,
+       RT_CID_819X_SITECOM = 16,
+       RT_CID_CCX = 17,
+       RT_CID_819X_LENOVO = 18,
+       RT_CID_819X_QMI = 19,
+       RT_CID_819X_EDIMAX_BELKIN = 20,
+       RT_CID_819X_SERCOMM_BELKIN = 21,
+       RT_CID_819X_CAMEO1 = 22,
+       RT_CID_819X_MSI = 23,
+       RT_CID_819X_ACER = 24,
+       RT_CID_819X_HP = 27,
+       RT_CID_819X_CLEVO = 28,
+       RT_CID_819X_ARCADYAN_BELKIN = 29,
+       RT_CID_819X_SAMSUNG = 30,
+       RT_CID_819X_WNC_COREGA = 31,
+       RT_CID_819X_FOXCOON = 32,
+       RT_CID_819X_DELL = 33,
+       RT_CID_819X_PRONETS = 34,
+       RT_CID_819X_EDIMAX_ASUS = 35,
+       RT_CID_NETGEAR = 36,
+       RT_CID_PLANEX = 37,
+       RT_CID_CC_C = 38,
+ };
+ enum hw_descs {
+       HW_DESC_OWN,
+       HW_DESC_RXOWN,
+       HW_DESC_TX_NEXTDESC_ADDR,
+       HW_DESC_TXBUFF_ADDR,
+       HW_DESC_RXBUFF_ADDR,
+       HW_DESC_RXPKT_LEN,
+       HW_DESC_RXERO,
+       HW_DESC_RX_PREPARE,
+ };
+ enum prime_sc {
+       PRIME_CHNL_OFFSET_DONT_CARE = 0,
+       PRIME_CHNL_OFFSET_LOWER = 1,
+       PRIME_CHNL_OFFSET_UPPER = 2,
+ };
+ enum rf_type {
+       RF_1T1R = 0,
+       RF_1T2R = 1,
+       RF_2T2R = 2,
+       RF_2T2R_GREEN = 3,
+ };
+ enum ht_channel_width {
+       HT_CHANNEL_WIDTH_20 = 0,
+       HT_CHANNEL_WIDTH_20_40 = 1,
+       HT_CHANNEL_WIDTH_80 = 2,
+ };
+ /* Ref: 802.11i sepc D10.0 7.3.2.25.1
+ Cipher Suites Encryption Algorithms */
+ enum rt_enc_alg {
+       NO_ENCRYPTION = 0,
+       WEP40_ENCRYPTION = 1,
+       TKIP_ENCRYPTION = 2,
+       RSERVED_ENCRYPTION = 3,
+       AESCCMP_ENCRYPTION = 4,
+       WEP104_ENCRYPTION = 5,
+       AESCMAC_ENCRYPTION = 6, /*IEEE802.11w */
+ };
+ enum rtl_hal_state {
+       _HAL_STATE_STOP = 0,
+       _HAL_STATE_START = 1,
+ };
+ enum rtl_desc92_rate {
+       DESC_RATE1M = 0x00,
+       DESC_RATE2M = 0x01,
+       DESC_RATE5_5M = 0x02,
+       DESC_RATE11M = 0x03,
+       DESC_RATE6M = 0x04,
+       DESC_RATE9M = 0x05,
+       DESC_RATE12M = 0x06,
+       DESC_RATE18M = 0x07,
+       DESC_RATE24M = 0x08,
+       DESC_RATE36M = 0x09,
+       DESC_RATE48M = 0x0a,
+       DESC_RATE54M = 0x0b,
+       DESC_RATEMCS0 = 0x0c,
+       DESC_RATEMCS1 = 0x0d,
+       DESC_RATEMCS2 = 0x0e,
+       DESC_RATEMCS3 = 0x0f,
+       DESC_RATEMCS4 = 0x10,
+       DESC_RATEMCS5 = 0x11,
+       DESC_RATEMCS6 = 0x12,
+       DESC_RATEMCS7 = 0x13,
+       DESC_RATEMCS8 = 0x14,
+       DESC_RATEMCS9 = 0x15,
+       DESC_RATEMCS10 = 0x16,
+       DESC_RATEMCS11 = 0x17,
+       DESC_RATEMCS12 = 0x18,
+       DESC_RATEMCS13 = 0x19,
+       DESC_RATEMCS14 = 0x1a,
+       DESC_RATEMCS15 = 0x1b,
+       DESC_RATEMCS15_SG = 0x1c,
+       DESC_RATEMCS32 = 0x20,
+       DESC_RATEVHT1SS_MCS0 = 0x2c,
+       DESC_RATEVHT1SS_MCS1 = 0x2d,
+       DESC_RATEVHT1SS_MCS2 = 0x2e,
+       DESC_RATEVHT1SS_MCS3 = 0x2f,
+       DESC_RATEVHT1SS_MCS4 = 0x30,
+       DESC_RATEVHT1SS_MCS5 = 0x31,
+       DESC_RATEVHT1SS_MCS6 = 0x32,
+       DESC_RATEVHT1SS_MCS7 = 0x33,
+       DESC_RATEVHT1SS_MCS8 = 0x34,
+       DESC_RATEVHT1SS_MCS9 = 0x35,
+       DESC_RATEVHT2SS_MCS0 = 0x36,
+       DESC_RATEVHT2SS_MCS1 = 0x37,
+       DESC_RATEVHT2SS_MCS2 = 0x38,
+       DESC_RATEVHT2SS_MCS3 = 0x39,
+       DESC_RATEVHT2SS_MCS4 = 0x3a,
+       DESC_RATEVHT2SS_MCS5 = 0x3b,
+       DESC_RATEVHT2SS_MCS6 = 0x3c,
+       DESC_RATEVHT2SS_MCS7 = 0x3d,
+       DESC_RATEVHT2SS_MCS8 = 0x3e,
+       DESC_RATEVHT2SS_MCS9 = 0x3f,
+ };
+ enum rtl_var_map {
+       /*reg map */
+       SYS_ISO_CTRL = 0,
+       SYS_FUNC_EN,
+       SYS_CLK,
+       MAC_RCR_AM,
+       MAC_RCR_AB,
+       MAC_RCR_ACRC32,
+       MAC_RCR_ACF,
+       MAC_RCR_AAP,
+       MAC_HIMR,
+       MAC_HIMRE,
+       MAC_HSISR,
+       /*efuse map */
+       EFUSE_TEST,
+       EFUSE_CTRL,
+       EFUSE_CLK,
+       EFUSE_CLK_CTRL,
+       EFUSE_PWC_EV12V,
+       EFUSE_FEN_ELDR,
+       EFUSE_LOADER_CLK_EN,
+       EFUSE_ANA8M,
+       EFUSE_HWSET_MAX_SIZE,
+       EFUSE_MAX_SECTION_MAP,
+       EFUSE_REAL_CONTENT_SIZE,
+       EFUSE_OOB_PROTECT_BYTES_LEN,
+       EFUSE_ACCESS,
+       /*CAM map */
+       RWCAM,
+       WCAMI,
+       RCAMO,
+       CAMDBG,
+       SECR,
+       SEC_CAM_NONE,
+       SEC_CAM_WEP40,
+       SEC_CAM_TKIP,
+       SEC_CAM_AES,
+       SEC_CAM_WEP104,
+       /*IMR map */
+       RTL_IMR_BCNDMAINT6,     /*Beacon DMA Interrupt 6 */
+       RTL_IMR_BCNDMAINT5,     /*Beacon DMA Interrupt 5 */
+       RTL_IMR_BCNDMAINT4,     /*Beacon DMA Interrupt 4 */
+       RTL_IMR_BCNDMAINT3,     /*Beacon DMA Interrupt 3 */
+       RTL_IMR_BCNDMAINT2,     /*Beacon DMA Interrupt 2 */
+       RTL_IMR_BCNDMAINT1,     /*Beacon DMA Interrupt 1 */
+       RTL_IMR_BCNDOK8,        /*Beacon Queue DMA OK Interrup 8 */
+       RTL_IMR_BCNDOK7,        /*Beacon Queue DMA OK Interrup 7 */
+       RTL_IMR_BCNDOK6,        /*Beacon Queue DMA OK Interrup 6 */
+       RTL_IMR_BCNDOK5,        /*Beacon Queue DMA OK Interrup 5 */
+       RTL_IMR_BCNDOK4,        /*Beacon Queue DMA OK Interrup 4 */
+       RTL_IMR_BCNDOK3,        /*Beacon Queue DMA OK Interrup 3 */
+       RTL_IMR_BCNDOK2,        /*Beacon Queue DMA OK Interrup 2 */
+       RTL_IMR_BCNDOK1,        /*Beacon Queue DMA OK Interrup 1 */
+       RTL_IMR_TIMEOUT2,       /*Timeout interrupt 2 */
+       RTL_IMR_TIMEOUT1,       /*Timeout interrupt 1 */
+       RTL_IMR_TXFOVW,         /*Transmit FIFO Overflow */
+       RTL_IMR_PSTIMEOUT,      /*Power save time out interrupt */
+       RTL_IMR_BCNINT,         /*Beacon DMA Interrupt 0 */
+       RTL_IMR_RXFOVW,         /*Receive FIFO Overflow */
+       RTL_IMR_RDU,            /*Receive Descriptor Unavailable */
+       RTL_IMR_ATIMEND,        /*For 92C,ATIM Window End Interrupt */
+       RTL_IMR_BDOK,           /*Beacon Queue DMA OK Interrup */
+       RTL_IMR_HIGHDOK,        /*High Queue DMA OK Interrupt */
+       RTL_IMR_COMDOK,         /*Command Queue DMA OK Interrupt*/
+       RTL_IMR_TBDOK,          /*Transmit Beacon OK interrup */
+       RTL_IMR_MGNTDOK,        /*Management Queue DMA OK Interrupt */
+       RTL_IMR_TBDER,          /*For 92C,Transmit Beacon Error Interrupt */
+       RTL_IMR_BKDOK,          /*AC_BK DMA OK Interrupt */
+       RTL_IMR_BEDOK,          /*AC_BE DMA OK Interrupt */
+       RTL_IMR_VIDOK,          /*AC_VI DMA OK Interrupt */
+       RTL_IMR_VODOK,          /*AC_VO DMA Interrupt */
+       RTL_IMR_ROK,            /*Receive DMA OK Interrupt */
+       RTL_IMR_HSISR_IND,      /*HSISR Interrupt*/
+       RTL_IBSS_INT_MASKS,     /*(RTL_IMR_BCNINT | RTL_IMR_TBDOK |
+                                * RTL_IMR_TBDER) */
+       RTL_IMR_C2HCMD,         /*fw interrupt*/
+       /*CCK Rates, TxHT = 0 */
+       RTL_RC_CCK_RATE1M,
+       RTL_RC_CCK_RATE2M,
+       RTL_RC_CCK_RATE5_5M,
+       RTL_RC_CCK_RATE11M,
+       /*OFDM Rates, TxHT = 0 */
+       RTL_RC_OFDM_RATE6M,
+       RTL_RC_OFDM_RATE9M,
+       RTL_RC_OFDM_RATE12M,
+       RTL_RC_OFDM_RATE18M,
+       RTL_RC_OFDM_RATE24M,
+       RTL_RC_OFDM_RATE36M,
+       RTL_RC_OFDM_RATE48M,
+       RTL_RC_OFDM_RATE54M,
+       RTL_RC_HT_RATEMCS7,
+       RTL_RC_HT_RATEMCS15,
+       RTL_RC_VHT_RATE_1SS_MCS7,
+       RTL_RC_VHT_RATE_1SS_MCS8,
+       RTL_RC_VHT_RATE_1SS_MCS9,
+       RTL_RC_VHT_RATE_2SS_MCS7,
+       RTL_RC_VHT_RATE_2SS_MCS8,
+       RTL_RC_VHT_RATE_2SS_MCS9,
+       /*keep it last */
+       RTL_VAR_MAP_MAX,
+ };
+ /*Firmware PS mode for control LPS.*/
+ enum _fw_ps_mode {
+       FW_PS_ACTIVE_MODE = 0,
+       FW_PS_MIN_MODE = 1,
+       FW_PS_MAX_MODE = 2,
+       FW_PS_DTIM_MODE = 3,
+       FW_PS_VOIP_MODE = 4,
+       FW_PS_UAPSD_WMM_MODE = 5,
+       FW_PS_UAPSD_MODE = 6,
+       FW_PS_IBSS_MODE = 7,
+       FW_PS_WWLAN_MODE = 8,
+       FW_PS_PM_Radio_Off = 9,
+       FW_PS_PM_Card_Disable = 10,
+ };
+ enum rt_psmode {
+       EACTIVE,                /*Active/Continuous access. */
+       EMAXPS,                 /*Max power save mode. */
+       EFASTPS,                /*Fast power save mode. */
+       EAUTOPS,                /*Auto power save mode. */
+ };
+ /*LED related.*/
+ enum led_ctl_mode {
+       LED_CTL_POWER_ON = 1,
+       LED_CTL_LINK = 2,
+       LED_CTL_NO_LINK = 3,
+       LED_CTL_TX = 4,
+       LED_CTL_RX = 5,
+       LED_CTL_SITE_SURVEY = 6,
+       LED_CTL_POWER_OFF = 7,
+       LED_CTL_START_TO_LINK = 8,
+       LED_CTL_START_WPS = 9,
+       LED_CTL_STOP_WPS = 10,
+ };
+ enum rtl_led_pin {
+       LED_PIN_GPIO0,
+       LED_PIN_LED0,
+       LED_PIN_LED1,
+       LED_PIN_LED2
+ };
+ /*QoS related.*/
+ /*acm implementation method.*/
+ enum acm_method {
+       eAcmWay0_SwAndHw = 0,
+       eAcmWay1_HW = 1,
+       EACMWAY2_SW = 2,
+ };
+ enum macphy_mode {
+       SINGLEMAC_SINGLEPHY = 0,
+       DUALMAC_DUALPHY,
+       DUALMAC_SINGLEPHY,
+ };
+ enum band_type {
+       BAND_ON_2_4G = 0,
+       BAND_ON_5G,
+       BAND_ON_BOTH,
+       BANDMAX
+ };
+ /*aci/aifsn Field.
+ Ref: WMM spec 2.2.2: WME Parameter Element, p.12.*/
+ union aci_aifsn {
+       u8 char_data;
+       struct {
+               u8 aifsn:4;
+               u8 acm:1;
+               u8 aci:2;
+               u8 reserved:1;
+       } f;                    /* Field */
+ };
+ /*mlme related.*/
+ enum wireless_mode {
+       WIRELESS_MODE_UNKNOWN = 0x00,
+       WIRELESS_MODE_A = 0x01,
+       WIRELESS_MODE_B = 0x02,
+       WIRELESS_MODE_G = 0x04,
+       WIRELESS_MODE_AUTO = 0x08,
+       WIRELESS_MODE_N_24G = 0x10,
+       WIRELESS_MODE_N_5G = 0x20,
+       WIRELESS_MODE_AC_5G = 0x40,
+       WIRELESS_MODE_AC_24G  = 0x80,
+       WIRELESS_MODE_AC_ONLY = 0x100,
+       WIRELESS_MODE_MAX = 0x800
+ };
+ #define IS_WIRELESS_MODE_A(wirelessmode)      \
+       (wirelessmode == WIRELESS_MODE_A)
+ #define IS_WIRELESS_MODE_B(wirelessmode)      \
+       (wirelessmode == WIRELESS_MODE_B)
+ #define IS_WIRELESS_MODE_G(wirelessmode)      \
+       (wirelessmode == WIRELESS_MODE_G)
+ #define IS_WIRELESS_MODE_N_24G(wirelessmode)  \
+       (wirelessmode == WIRELESS_MODE_N_24G)
+ #define IS_WIRELESS_MODE_N_5G(wirelessmode)   \
+       (wirelessmode == WIRELESS_MODE_N_5G)
+ enum ratr_table_mode {
+       RATR_INX_WIRELESS_NGB = 0,
+       RATR_INX_WIRELESS_NG = 1,
+       RATR_INX_WIRELESS_NB = 2,
+       RATR_INX_WIRELESS_N = 3,
+       RATR_INX_WIRELESS_GB = 4,
+       RATR_INX_WIRELESS_G = 5,
+       RATR_INX_WIRELESS_B = 6,
+       RATR_INX_WIRELESS_MC = 7,
+       RATR_INX_WIRELESS_A = 8,
+       RATR_INX_WIRELESS_AC_5N = 8,
+       RATR_INX_WIRELESS_AC_24N = 9,
+ };
+ enum rtl_link_state {
+       MAC80211_NOLINK = 0,
+       MAC80211_LINKING = 1,
+       MAC80211_LINKED = 2,
+       MAC80211_LINKED_SCANNING = 3,
+ };
+ enum act_category {
+       ACT_CAT_QOS = 1,
+       ACT_CAT_DLS = 2,
+       ACT_CAT_BA = 3,
+       ACT_CAT_HT = 7,
+       ACT_CAT_WMM = 17,
+ };
+ enum ba_action {
+       ACT_ADDBAREQ = 0,
+       ACT_ADDBARSP = 1,
+       ACT_DELBA = 2,
+ };
+ enum rt_polarity_ctl {
+       RT_POLARITY_LOW_ACT = 0,
+       RT_POLARITY_HIGH_ACT = 1,
+ };
+ /* After 8188E, we use V2 reason define. 88C/8723A use V1 reason. */
+ enum fw_wow_reason_v2 {
+       FW_WOW_V2_PTK_UPDATE_EVENT = 0x01,
+       FW_WOW_V2_GTK_UPDATE_EVENT = 0x02,
+       FW_WOW_V2_DISASSOC_EVENT = 0x04,
+       FW_WOW_V2_DEAUTH_EVENT = 0x08,
+       FW_WOW_V2_FW_DISCONNECT_EVENT = 0x10,
+       FW_WOW_V2_MAGIC_PKT_EVENT = 0x21,
+       FW_WOW_V2_UNICAST_PKT_EVENT = 0x22,
+       FW_WOW_V2_PATTERN_PKT_EVENT = 0x23,
+       FW_WOW_V2_RTD3_SSID_MATCH_EVENT = 0x24,
+       FW_WOW_V2_REALWOW_V2_WAKEUPPKT = 0x30,
+       FW_WOW_V2_REALWOW_V2_ACKLOST = 0x31,
+       FW_WOW_V2_REASON_MAX = 0xff,
+ };
+ enum wolpattern_type {
+       UNICAST_PATTERN = 0,
+       MULTICAST_PATTERN = 1,
+       BROADCAST_PATTERN = 2,
+       DONT_CARE_DA = 3,
+       UNKNOWN_TYPE = 4,
+ };
+ struct octet_string {
+       u8 *octet;
+       u16 length;
+ };
+ struct rtl_hdr_3addr {
+       __le16 frame_ctl;
+       __le16 duration_id;
+       u8 addr1[ETH_ALEN];
+       u8 addr2[ETH_ALEN];
+       u8 addr3[ETH_ALEN];
+       __le16 seq_ctl;
+       u8 payload[0];
+ } __packed;
+ struct rtl_info_element {
+       u8 id;
+       u8 len;
+       u8 data[0];
+ } __packed;
+ struct rtl_probe_rsp {
+       struct rtl_hdr_3addr header;
+       u32 time_stamp[2];
+       __le16 beacon_interval;
+       __le16 capability;
+       /*SSID, supported rates, FH params, DS params,
+          CF params, IBSS params, TIM (if beacon), RSN */
+       struct rtl_info_element info_element[0];
+ } __packed;
+ /*LED related.*/
+ /*ledpin Identify how to implement this SW led.*/
+ struct rtl_led {
+       void *hw;
+       enum rtl_led_pin ledpin;
+       bool ledon;
+ };
+ struct rtl_led_ctl {
+       bool led_opendrain;
+       struct rtl_led sw_led0;
+       struct rtl_led sw_led1;
+ };
+ struct rtl_qos_parameters {
+       __le16 cw_min;
+       __le16 cw_max;
+       u8 aifs;
+       u8 flag;
+       __le16 tx_op;
+ } __packed;
+ struct rt_smooth_data {
+       u32 elements[100];      /*array to store values */
+       u32 index;              /*index to current array to store */
+       u32 total_num;          /*num of valid elements */
+       u32 total_val;          /*sum of valid elements */
+ };
+ struct false_alarm_statistics {
+       u32 cnt_parity_fail;
+       u32 cnt_rate_illegal;
+       u32 cnt_crc8_fail;
+       u32 cnt_mcs_fail;
+       u32 cnt_fast_fsync_fail;
+       u32 cnt_sb_search_fail;
+       u32 cnt_ofdm_fail;
+       u32 cnt_cck_fail;
+       u32 cnt_all;
+       u32 cnt_ofdm_cca;
+       u32 cnt_cck_cca;
+       u32 cnt_cca_all;
+       u32 cnt_bw_usc;
+       u32 cnt_bw_lsc;
+ };
+ struct init_gain {
+       u8 xaagccore1;
+       u8 xbagccore1;
+       u8 xcagccore1;
+       u8 xdagccore1;
+       u8 cca;
+ };
+ struct wireless_stats {
+       unsigned long txbytesunicast;
+       unsigned long txbytesmulticast;
+       unsigned long txbytesbroadcast;
+       unsigned long rxbytesunicast;
+       long rx_snr_db[4];
+       /*Correct smoothed ss in Dbm, only used
+          in driver to report real power now. */
+       long recv_signal_power;
+       long signal_quality;
+       long last_sigstrength_inpercent;
+       u32 rssi_calculate_cnt;
+       u32 pwdb_all_cnt;
+       /*Transformed, in dbm. Beautified signal
+          strength for UI, not correct. */
+       long signal_strength;
+       u8 rx_rssi_percentage[4];
+       u8 rx_evm_dbm[4];
+       u8 rx_evm_percentage[2];
+       u16 rx_cfo_short[4];
+       u16 rx_cfo_tail[4];
+       struct rt_smooth_data ui_rssi;
+       struct rt_smooth_data ui_link_quality;
+ };
+ struct rate_adaptive {
+       u8 rate_adaptive_disabled;
+       u8 ratr_state;
+       u16 reserve;
+       u32 high_rssi_thresh_for_ra;
+       u32 high2low_rssi_thresh_for_ra;
+       u8 low2high_rssi_thresh_for_ra40m;
+       u32 low_rssi_thresh_for_ra40m;
+       u8 low2high_rssi_thresh_for_ra20m;
+       u32 low_rssi_thresh_for_ra20m;
+       u32 upper_rssi_threshold_ratr;
+       u32 middleupper_rssi_threshold_ratr;
+       u32 middle_rssi_threshold_ratr;
+       u32 middlelow_rssi_threshold_ratr;
+       u32 low_rssi_threshold_ratr;
+       u32 ultralow_rssi_threshold_ratr;
+       u32 low_rssi_threshold_ratr_40m;
+       u32 low_rssi_threshold_ratr_20m;
+       u8 ping_rssi_enable;
+       u32 ping_rssi_ratr;
+       u32 ping_rssi_thresh_for_ra;
+       u32 last_ratr;
+       u8 pre_ratr_state;
+       u8 ldpc_thres;
+       bool use_ldpc;
+       bool lower_rts_rate;
+       bool is_special_data;
+ };
+ struct regd_pair_mapping {
+       u16 reg_dmnenum;
+       u16 reg_5ghz_ctl;
+       u16 reg_2ghz_ctl;
+ };
+ struct dynamic_primary_cca {
+       u8 pricca_flag;
+       u8 intf_flag;
+       u8 intf_type;
+       u8 dup_rts_flag;
+       u8 monitor_flag;
+       u8 ch_offset;
+       u8 mf_state;
+ };
+ struct rtl_regulatory {
+       char alpha2[2];
+       u16 country_code;
+       u16 max_power_level;
+       u32 tp_scale;
+       u16 current_rd;
+       u16 current_rd_ext;
+       int16_t power_limit;
+       struct regd_pair_mapping *regpair;
+ };
+ struct rtl_rfkill {
+       bool rfkill_state;      /*0 is off, 1 is on */
+ };
+ /*for P2P PS**/
+ #define       P2P_MAX_NOA_NUM         2
+ enum p2p_role {
+       P2P_ROLE_DISABLE = 0,
+       P2P_ROLE_DEVICE = 1,
+       P2P_ROLE_CLIENT = 2,
+       P2P_ROLE_GO = 3
+ };
+ enum p2p_ps_state {
+       P2P_PS_DISABLE = 0,
+       P2P_PS_ENABLE = 1,
+       P2P_PS_SCAN = 2,
+       P2P_PS_SCAN_DONE = 3,
+       P2P_PS_ALLSTASLEEP = 4, /* for P2P GO */
+ };
+ enum p2p_ps_mode {
+       P2P_PS_NONE = 0,
+       P2P_PS_CTWINDOW = 1,
+       P2P_PS_NOA       = 2,
+       P2P_PS_MIX = 3, /* CTWindow and NoA */
+ };
+ struct rtl_p2p_ps_info {
+       enum p2p_ps_mode p2p_ps_mode; /* indicate p2p ps mode */
+       enum p2p_ps_state p2p_ps_state; /*  indicate p2p ps state */
+       u8 noa_index; /*  Identifies instance of Notice of Absence timing. */
+       /*  Client traffic window. A period of time in TU after TBTT. */
+       u8 ctwindow;
+       u8 opp_ps; /*  opportunistic power save. */
+       u8 noa_num; /*  number of NoA descriptor in P2P IE. */
+       /*  Count for owner, Type of client. */
+       u8 noa_count_type[P2P_MAX_NOA_NUM];
+       /*  Max duration for owner, preferred or min acceptable duration
+        * for client.
+        */
+       u32 noa_duration[P2P_MAX_NOA_NUM];
+       /*  Length of interval for owner, preferred or max acceptable intervali
+        * of client.
+        */
+       u32 noa_interval[P2P_MAX_NOA_NUM];
+       /*  schedule in terms of the lower 4 bytes of the TSF timer. */
+       u32 noa_start_time[P2P_MAX_NOA_NUM];
+ };
+ struct p2p_ps_offload_t {
+       u8 offload_en:1;
+       u8 role:1; /* 1: Owner, 0: Client */
+       u8 ctwindow_en:1;
+       u8 noa0_en:1;
+       u8 noa1_en:1;
+       u8 allstasleep:1;
+       u8 discovery:1;
+       u8 reserved:1;
+ };
+ #define IQK_MATRIX_REG_NUM    8
+ #define IQK_MATRIX_SETTINGS_NUM       (1 + 24 + 21)
+ struct iqk_matrix_regs {
+       bool iqk_done;
+       long value[1][IQK_MATRIX_REG_NUM];
+ };
+ struct phy_parameters {
+       u16 length;
+       u32 *pdata;
+ };
+ enum hw_param_tab_index {
+       PHY_REG_2T,
+       PHY_REG_1T,
+       PHY_REG_PG,
+       RADIOA_2T,
+       RADIOB_2T,
+       RADIOA_1T,
+       RADIOB_1T,
+       MAC_REG,
+       AGCTAB_2T,
+       AGCTAB_1T,
+       MAX_TAB
+ };
+ struct rtl_phy {
+       struct bb_reg_def phyreg_def[4];        /*Radio A/B/C/D */
+       struct init_gain initgain_backup;
+       enum io_type current_io_type;
+       u8 rf_mode;
+       u8 rf_type;
+       u8 current_chan_bw;
+       u8 set_bwmode_inprogress;
+       u8 sw_chnl_inprogress;
+       u8 sw_chnl_stage;
+       u8 sw_chnl_step;
+       u8 current_channel;
+       u8 h2c_box_num;
+       u8 set_io_inprogress;
+       u8 lck_inprogress;
+       /* record for power tracking */
+       s32 reg_e94;
+       s32 reg_e9c;
+       s32 reg_ea4;
+       s32 reg_eac;
+       s32 reg_eb4;
+       s32 reg_ebc;
+       s32 reg_ec4;
+       s32 reg_ecc;
+       u8 rfpienable;
+       u8 reserve_0;
+       u16 reserve_1;
+       u32 reg_c04, reg_c08, reg_874;
+       u32 adda_backup[16];
+       u32 iqk_mac_backup[IQK_MAC_REG_NUM];
+       u32 iqk_bb_backup[10];
+       bool iqk_initialized;
+       bool rfpath_rx_enable[MAX_RF_PATH];
+       u8 reg_837;
+       /* Dual mac */
+       bool need_iqk;
+       struct iqk_matrix_regs iqk_matrix[IQK_MATRIX_SETTINGS_NUM];
+       bool rfpi_enable;
+       bool iqk_in_progress;
+       u8 pwrgroup_cnt;
+       u8 cck_high_power;
+       /* this is for 88E & 8723A */
+       u32 mcs_txpwrlevel_origoffset[MAX_PG_GROUP][16];
+       /* MAX_PG_GROUP groups of pwr diff by rates */
+       u32 mcs_offset[MAX_PG_GROUP][16];
+       u32 tx_power_by_rate_offset[TX_PWR_BY_RATE_NUM_BAND]
+                                  [TX_PWR_BY_RATE_NUM_RF]
+                                  [TX_PWR_BY_RATE_NUM_RF]
+                                  [TX_PWR_BY_RATE_NUM_SECTION];
+       u8 txpwr_by_rate_base_24g[TX_PWR_BY_RATE_NUM_RF]
+                                [TX_PWR_BY_RATE_NUM_RF]
+                                [MAX_BASE_NUM_IN_PHY_REG_PG_24G];
+       u8 txpwr_by_rate_base_5g[TX_PWR_BY_RATE_NUM_RF]
+                               [TX_PWR_BY_RATE_NUM_RF]
+                               [MAX_BASE_NUM_IN_PHY_REG_PG_5G];
+       u8 default_initialgain[4];
+       /* the current Tx power level */
+       u8 cur_cck_txpwridx;
+       u8 cur_ofdm24g_txpwridx;
+       u8 cur_bw20_txpwridx;
+       u8 cur_bw40_txpwridx;
+       char txpwr_limit_2_4g[MAX_REGULATION_NUM]
+                            [MAX_2_4G_BANDWITH_NUM]
+                            [MAX_RATE_SECTION_NUM]
+                            [CHANNEL_MAX_NUMBER_2G]
+                            [MAX_RF_PATH_NUM];
+       char txpwr_limit_5g[MAX_REGULATION_NUM]
+                          [MAX_5G_BANDWITH_NUM]
+                          [MAX_RATE_SECTION_NUM]
+                          [CHANNEL_MAX_NUMBER_5G]
+                          [MAX_RF_PATH_NUM];
+       u32 rfreg_chnlval[2];
+       bool apk_done;
+       u32 reg_rf3c[2];        /* pathA / pathB  */
+       u32 backup_rf_0x1a;/*92ee*/
+       /* bfsync */
+       u8 framesync;
+       u32 framesync_c34;
+       u8 num_total_rfpath;
+       struct phy_parameters hwparam_tables[MAX_TAB];
+       u16 rf_pathmap;
+       u8 hw_rof_enable; /*Enable GPIO[9] as WL RF HW PDn source*/
+       enum rt_polarity_ctl polarity_ctl;
+ };
+ #define MAX_TID_COUNT                         9
+ #define RTL_AGG_STOP                          0
+ #define RTL_AGG_PROGRESS                      1
+ #define RTL_AGG_START                         2
+ #define RTL_AGG_OPERATIONAL                   3
+ #define RTL_AGG_OFF                           0
+ #define RTL_AGG_ON                            1
+ #define RTL_RX_AGG_START                      1
+ #define RTL_RX_AGG_STOP                               0
+ #define RTL_AGG_EMPTYING_HW_QUEUE_ADDBA               2
+ #define RTL_AGG_EMPTYING_HW_QUEUE_DELBA               3
+ struct rtl_ht_agg {
+       u16 txq_id;
+       u16 wait_for_ba;
+       u16 start_idx;
+       u64 bitmap;
+       u32 rate_n_flags;
+       u8 agg_state;
+       u8 rx_agg_state;
+ };
+ struct rssi_sta {
+       long undec_sm_pwdb;
+       long undec_sm_cck;
+ };
+ struct rtl_tid_data {
+       u16 seq_number;
+       struct rtl_ht_agg agg;
+ };
+ struct rtl_sta_info {
+       struct list_head list;
+       u8 ratr_index;
+       u8 wireless_mode;
+       u8 mimo_ps;
+       u8 mac_addr[ETH_ALEN];
+       struct rtl_tid_data tids[MAX_TID_COUNT];
+       /* just used for ap adhoc or mesh*/
+       struct rssi_sta rssi_stat;
+ } __packed;
+ struct rtl_priv;
+ struct rtl_io {
+       struct device *dev;
+       struct mutex bb_mutex;
+       /*PCI MEM map */
+       unsigned long pci_mem_end;      /*shared mem end        */
+       unsigned long pci_mem_start;    /*shared mem start */
+       /*PCI IO map */
+       unsigned long pci_base_addr;    /*device I/O address */
+       void (*write8_async) (struct rtl_priv *rtlpriv, u32 addr, u8 val);
+       void (*write16_async) (struct rtl_priv *rtlpriv, u32 addr, u16 val);
+       void (*write32_async) (struct rtl_priv *rtlpriv, u32 addr, u32 val);
+       void (*writeN_sync) (struct rtl_priv *rtlpriv, u32 addr, void *buf,
+                            u16 len);
+       u8(*read8_sync) (struct rtl_priv *rtlpriv, u32 addr);
+       u16(*read16_sync) (struct rtl_priv *rtlpriv, u32 addr);
+       u32(*read32_sync) (struct rtl_priv *rtlpriv, u32 addr);
+ };
+ struct rtl_mac {
+       u8 mac_addr[ETH_ALEN];
+       u8 mac80211_registered;
+       u8 beacon_enabled;
+       u32 tx_ss_num;
+       u32 rx_ss_num;
+       struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
+       struct ieee80211_hw *hw;
+       struct ieee80211_vif *vif;
+       enum nl80211_iftype opmode;
+       /*Probe Beacon management */
+       struct rtl_tid_data tids[MAX_TID_COUNT];
+       enum rtl_link_state link_state;
+       int n_channels;
+       int n_bitrates;
+       bool offchan_delay;
+       u8 p2p; /*using p2p role*/
+       bool p2p_in_use;
+       /*filters */
+       u32 rx_conf;
+       u16 rx_mgt_filter;
+       u16 rx_ctrl_filter;
+       u16 rx_data_filter;
+       bool act_scanning;
+       u8 cnt_after_linked;
+       bool skip_scan;
+       /* early mode */
+       /* skb wait queue */
+       struct sk_buff_head skb_waitq[MAX_TID_COUNT];
+       u8 ht_stbc_cap;
+       u8 ht_cur_stbc;
+       /*vht support*/
+       u8 vht_enable;
+       u8 bw_80;
+       u8 vht_cur_ldpc;
+       u8 vht_cur_stbc;
+       u8 vht_stbc_cap;
+       u8 vht_ldpc_cap;
+       /*RDG*/
+       bool rdg_en;
+       /*AP*/
+       u8 bssid[ETH_ALEN] __aligned(2);
+       u32 vendor;
+       u8 mcs[16];     /* 16 bytes mcs for HT rates. */
+       u32 basic_rates; /* b/g rates */
+       u8 ht_enable;
+       u8 sgi_40;
+       u8 sgi_20;
+       u8 bw_40;
+       u16 mode;               /* wireless mode */
+       u8 slot_time;
+       u8 short_preamble;
+       u8 use_cts_protect;
+       u8 cur_40_prime_sc;
+       u8 cur_40_prime_sc_bk;
+       u8 cur_80_prime_sc;
+       u64 tsf;
+       u8 retry_short;
+       u8 retry_long;
+       u16 assoc_id;
+       bool hiddenssid;
+       /*IBSS*/
+       int beacon_interval;
+       /*AMPDU*/
+       u8 min_space_cfg;       /*For Min spacing configurations */
+       u8 max_mss_density;
+       u8 current_ampdu_factor;
+       u8 current_ampdu_density;
+       /*QOS & EDCA */
+       struct ieee80211_tx_queue_params edca_param[RTL_MAC80211_NUM_QUEUE];
+       struct rtl_qos_parameters ac[AC_MAX];
+       /* counters */
+       u64 last_txok_cnt;
+       u64 last_rxok_cnt;
+       u32 last_bt_edca_ul;
+       u32 last_bt_edca_dl;
+ };
+ struct btdm_8723 {
+       bool all_off;
+       bool agc_table_en;
+       bool adc_back_off_on;
+       bool b2_ant_hid_en;
+       bool low_penalty_rate_adaptive;
+       bool rf_rx_lpf_shrink;
+       bool reject_aggre_pkt;
+       bool tra_tdma_on;
+       u8 tra_tdma_nav;
+       u8 tra_tdma_ant;
+       bool tdma_on;
+       u8 tdma_ant;
+       u8 tdma_nav;
+       u8 tdma_dac_swing;
+       u8 fw_dac_swing_lvl;
+       bool ps_tdma_on;
+       u8 ps_tdma_byte[5];
+       bool pta_on;
+       u32 val_0x6c0;
+       u32 val_0x6c8;
+       u32 val_0x6cc;
+       bool sw_dac_swing_on;
+       u32 sw_dac_swing_lvl;
+       u32 wlan_act_hi;
+       u32 wlan_act_lo;
+       u32 bt_retry_index;
+       bool dec_bt_pwr;
+       bool ignore_wlan_act;
+ };
+ struct bt_coexist_8723 {
+       u32 high_priority_tx;
+       u32 high_priority_rx;
+       u32 low_priority_tx;
+       u32 low_priority_rx;
+       u8 c2h_bt_info;
+       bool c2h_bt_info_req_sent;
+       bool c2h_bt_inquiry_page;
+       u32 bt_inq_page_start_time;
+       u8 bt_retry_cnt;
+       u8 c2h_bt_info_original;
+       u8 bt_inquiry_page_cnt;
+       struct btdm_8723 btdm;
+ };
+ struct rtl_hal {
+       struct ieee80211_hw *hw;
+       bool driver_is_goingto_unload;
+       bool up_first_time;
+       bool first_init;
+       bool being_init_adapter;
+       bool bbrf_ready;
+       bool mac_func_enable;
+       bool pre_edcca_enable;
+       struct bt_coexist_8723 hal_coex_8723;
+       enum intf_type interface;
+       u16 hw_type;            /*92c or 92d or 92s and so on */
+       u8 ic_class;
+       u8 oem_id;
+       u32 version;            /*version of chip */
+       u8 state;               /*stop 0, start 1 */
+       u8 board_type;
+       u8 external_pa;
+       u8 pa_mode;
+       u8 pa_type_2g;
+       u8 pa_type_5g;
+       u8 lna_type_2g;
+       u8 lna_type_5g;
+       u8 external_pa_2g;
+       u8 external_lna_2g;
+       u8 external_pa_5g;
+       u8 external_lna_5g;
+       u8 rfe_type;
+       /*firmware */
+       u32 fwsize;
+       u8 *pfirmware;
+       u16 fw_version;
+       u16 fw_subversion;
+       bool h2c_setinprogress;
+       u8 last_hmeboxnum;
+       bool fw_ready;
+       /*Reserve page start offset except beacon in TxQ. */
+       u8 fw_rsvdpage_startoffset;
+       u8 h2c_txcmd_seq;
+       u8 current_ra_rate;
+       /* FW Cmd IO related */
+       u16 fwcmd_iomap;
+       u32 fwcmd_ioparam;
+       bool set_fwcmd_inprogress;
+       u8 current_fwcmd_io;
+       struct p2p_ps_offload_t p2p_ps_offload;
+       bool fw_clk_change_in_progress;
+       bool allow_sw_to_change_hwclc;
+       u8 fw_ps_state;
+       /**/
+       bool driver_going2unload;
+       /*AMPDU init min space*/
+       u8 minspace_cfg;        /*For Min spacing configurations */
+       /* Dual mac */
+       enum macphy_mode macphymode;
+       enum band_type current_bandtype;        /* 0:2.4G, 1:5G */
+       enum band_type current_bandtypebackup;
+       enum band_type bandset;
+       /* dual MAC 0--Mac0 1--Mac1 */
+       u32 interfaceindex;
+       /* just for DualMac S3S4 */
+       u8 macphyctl_reg;
+       bool earlymode_enable;
+       u8 max_earlymode_num;
+       /* Dual mac*/
+       bool during_mac0init_radiob;
+       bool during_mac1init_radioa;
+       bool reloadtxpowerindex;
+       /* True if IMR or IQK  have done
+       for 2.4G in scan progress */
+       bool load_imrandiqk_setting_for2g;
+       bool disable_amsdu_8k;
+       bool master_of_dmsp;
+       bool slave_of_dmsp;
+       u16 rx_tag;/*for 92ee*/
+       u8 rts_en;
+       /*for wowlan*/
+       bool wow_enable;
+       bool enter_pnp_sleep;
+       bool wake_from_pnp_sleep;
+       bool wow_enabled;
+       __kernel_time_t last_suspend_sec;
+       u32 wowlan_fwsize;
+       u8 *wowlan_firmware;
+       u8 hw_rof_enable; /*Enable GPIO[9] as WL RF HW PDn source*/
+       bool real_wow_v2_enable;
+       bool re_init_llt_table;
+ };
+ struct rtl_security {
+       /*default 0 */
+       bool use_sw_sec;
+       bool being_setkey;
+       bool use_defaultkey;
+       /*Encryption Algorithm for Unicast Packet */
+       enum rt_enc_alg pairwise_enc_algorithm;
+       /*Encryption Algorithm for Brocast/Multicast */
+       enum rt_enc_alg group_enc_algorithm;
+       /*Cam Entry Bitmap */
+       u32 hwsec_cam_bitmap;
+       u8 hwsec_cam_sta_addr[TOTAL_CAM_ENTRY][ETH_ALEN];
+       /*local Key buffer, indx 0 is for
+          pairwise key 1-4 is for agoup key. */
+       u8 key_buf[KEY_BUF_SIZE][MAX_KEY_LEN];
+       u8 key_len[KEY_BUF_SIZE];
+       /*The pointer of Pairwise Key,
+          it always points to KeyBuf[4] */
+       u8 *pairwise_key;
+ };
+ #define ASSOCIATE_ENTRY_NUM   33
+ struct fast_ant_training {
+       u8      bssid[6];
+       u8      antsel_rx_keep_0;
+       u8      antsel_rx_keep_1;
+       u8      antsel_rx_keep_2;
+       u32     ant_sum[7];
+       u32     ant_cnt[7];
+       u32     ant_ave[7];
+       u8      fat_state;
+       u32     train_idx;
+       u8      antsel_a[ASSOCIATE_ENTRY_NUM];
+       u8      antsel_b[ASSOCIATE_ENTRY_NUM];
+       u8      antsel_c[ASSOCIATE_ENTRY_NUM];
+       u32     main_ant_sum[ASSOCIATE_ENTRY_NUM];
+       u32     aux_ant_sum[ASSOCIATE_ENTRY_NUM];
+       u32     main_ant_cnt[ASSOCIATE_ENTRY_NUM];
+       u32     aux_ant_cnt[ASSOCIATE_ENTRY_NUM];
+       u8      rx_idle_ant;
+       bool    becomelinked;
+ };
+ struct dm_phy_dbg_info {
+       char rx_snrdb[4];
+       u64 num_qry_phy_status;
+       u64 num_qry_phy_status_cck;
+       u64 num_qry_phy_status_ofdm;
+       u16 num_qry_beacon_pkt;
+       u16 num_non_be_pkt;
+       s32 rx_evm[4];
+ };
+ struct rtl_dm {
+       /*PHY status for Dynamic Management */
+       long entry_min_undec_sm_pwdb;
+       long undec_sm_cck;
+       long undec_sm_pwdb;     /*out dm */
+       long entry_max_undec_sm_pwdb;
+       s32 ofdm_pkt_cnt;
+       bool dm_initialgain_enable;
+       bool dynamic_txpower_enable;
+       bool current_turbo_edca;
+       bool is_any_nonbepkts;  /*out dm */
+       bool is_cur_rdlstate;
+       bool txpower_trackinginit;
+       bool disable_framebursting;
+       bool cck_inch14;
+       bool txpower_tracking;
+       bool useramask;
+       bool rfpath_rxenable[4];
+       bool inform_fw_driverctrldm;
+       bool current_mrc_switch;
+       u8 txpowercount;
+       u8 powerindex_backup[6];
+       u8 thermalvalue_rxgain;
+       u8 thermalvalue_iqk;
+       u8 thermalvalue_lck;
+       u8 thermalvalue;
+       u8 last_dtp_lvl;
+       u8 thermalvalue_avg[AVG_THERMAL_NUM];
+       u8 thermalvalue_avg_index;
+       u8 tm_trigger;
+       bool done_txpower;
+       u8 dynamic_txhighpower_lvl;     /*Tx high power level */
+       u8 dm_flag;             /*Indicate each dynamic mechanism's status. */
+       u8 dm_flag_tmp;
+       u8 dm_type;
+       u8 dm_rssi_sel;
+       u8 txpower_track_control;
+       bool interrupt_migration;
+       bool disable_tx_int;
+       char ofdm_index[MAX_RF_PATH];
+       u8 default_ofdm_index;
+       u8 default_cck_index;
+       char cck_index;
+       char delta_power_index[MAX_RF_PATH];
+       char delta_power_index_last[MAX_RF_PATH];
+       char power_index_offset[MAX_RF_PATH];
+       char absolute_ofdm_swing_idx[MAX_RF_PATH];
+       char remnant_ofdm_swing_idx[MAX_RF_PATH];
+       char remnant_cck_idx;
+       bool modify_txagc_flag_path_a;
+       bool modify_txagc_flag_path_b;
+       bool one_entry_only;
+       struct dm_phy_dbg_info dbginfo;
+       /* Dynamic ATC switch */
+       bool atc_status;
+       bool large_cfo_hit;
+       bool is_freeze;
+       int cfo_tail[2];
+       int cfo_ave_pre;
+       int crystal_cap;
+       u8 cfo_threshold;
+       u32 packet_count;
+       u32 packet_count_pre;
+       u8 tx_rate;
+       /*88e tx power tracking*/
+       u8      swing_idx_ofdm[MAX_RF_PATH];
+       u8      swing_idx_ofdm_cur;
+       u8      swing_idx_ofdm_base[MAX_RF_PATH];
+       bool    swing_flag_ofdm;
+       u8      swing_idx_cck;
+       u8      swing_idx_cck_cur;
+       u8      swing_idx_cck_base;
+       bool    swing_flag_cck;
+       char    swing_diff_2g;
+       char    swing_diff_5g;
+       u8 delta_swing_table_idx_24gccka_p[DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_24gccka_n[DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_24gcckb_p[DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_24gcckb_n[DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_24ga_p[DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_24ga_n[DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_24gb_p[DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_24gb_n[DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_5ga_p[BAND_NUM][DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_5ga_n[BAND_NUM][DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_5gb_p[BAND_NUM][DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_5gb_n[BAND_NUM][DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_24ga_p_8188e[DEL_SW_IDX_SZ];
+       u8 delta_swing_table_idx_24ga_n_8188e[DEL_SW_IDX_SZ];
+       /* DMSP */
+       bool supp_phymode_switch;
+       /* DulMac */
+       struct fast_ant_training fat_table;
+       u8      resp_tx_path;
+       u8      path_sel;
+       u32     patha_sum;
+       u32     pathb_sum;
+       u32     patha_cnt;
+       u32     pathb_cnt;
+       u8 pre_channel;
+       u8 *p_channel;
+       u8 linked_interval;
+       u64 last_tx_ok_cnt;
+       u64 last_rx_ok_cnt;
+ };
+ #define       EFUSE_MAX_LOGICAL_SIZE                  512
+ struct rtl_efuse {
+       bool autoLoad_ok;
+       bool bootfromefuse;
+       u16 max_physical_size;
+       u8 efuse_map[2][EFUSE_MAX_LOGICAL_SIZE];
+       u16 efuse_usedbytes;
+       u8 efuse_usedpercentage;
+ #ifdef EFUSE_REPG_WORKAROUND
+       bool efuse_re_pg_sec1flag;
+       u8 efuse_re_pg_data[8];
+ #endif
+       u8 autoload_failflag;
+       u8 autoload_status;
+       short epromtype;
+       u16 eeprom_vid;
+       u16 eeprom_did;
+       u16 eeprom_svid;
+       u16 eeprom_smid;
+       u8 eeprom_oemid;
+       u16 eeprom_channelplan;
+       u8 eeprom_version;
+       u8 board_type;
+       u8 external_pa;
+       u8 dev_addr[6];
+       u8 wowlan_enable;
+       u8 antenna_div_cfg;
+       u8 antenna_div_type;
+       bool txpwr_fromeprom;
+       u8 eeprom_crystalcap;
+       u8 eeprom_tssi[2];
+       u8 eeprom_tssi_5g[3][2]; /* for 5GL/5GM/5GH band. */
+       u8 eeprom_pwrlimit_ht20[CHANNEL_GROUP_MAX];
+       u8 eeprom_pwrlimit_ht40[CHANNEL_GROUP_MAX];
+       u8 eeprom_chnlarea_txpwr_cck[MAX_RF_PATH][CHANNEL_GROUP_MAX_2G];
+       u8 eeprom_chnlarea_txpwr_ht40_1s[MAX_RF_PATH][CHANNEL_GROUP_MAX];
+       u8 eprom_chnl_txpwr_ht40_2sdf[MAX_RF_PATH][CHANNEL_GROUP_MAX];
+       u8 internal_pa_5g[2];   /* pathA / pathB */
+       u8 eeprom_c9;
+       u8 eeprom_cc;
+       /*For power group */
+       u8 eeprom_pwrgroup[2][3];
+       u8 pwrgroup_ht20[2][CHANNEL_MAX_NUMBER];
+       u8 pwrgroup_ht40[2][CHANNEL_MAX_NUMBER];
+       u8 txpwrlevel_cck[MAX_RF_PATH][CHANNEL_MAX_NUMBER_2G];
+       /*For HT 40MHZ pwr */
+       u8 txpwrlevel_ht40_1s[MAX_RF_PATH][CHANNEL_MAX_NUMBER];
+       /*For HT 40MHZ pwr */
+       u8 txpwrlevel_ht40_2s[MAX_RF_PATH][CHANNEL_MAX_NUMBER];
+       /*--------------------------------------------------------*
+        * 8192CE\8192SE\8192DE\8723AE use the following 4 arrays,
+        * other ICs (8188EE\8723BE\8192EE\8812AE...)
+        * define new arrays in Windows code.
+        * BUT, in linux code, we use the same array for all ICs.
+        *
+        * The Correspondance relation between two arrays is:
+        * txpwr_cckdiff[][] == CCK_24G_Diff[][]
+        * txpwr_ht20diff[][] == BW20_24G_Diff[][]
+        * txpwr_ht40diff[][] == BW40_24G_Diff[][]
+        * txpwr_legacyhtdiff[][] == OFDM_24G_Diff[][]
+        *
+        * Sizes of these arrays are decided by the larger ones.
+        */
+       char txpwr_cckdiff[MAX_RF_PATH][CHANNEL_MAX_NUMBER];
+       char txpwr_ht20diff[MAX_RF_PATH][CHANNEL_MAX_NUMBER];
+       char txpwr_ht40diff[MAX_RF_PATH][CHANNEL_MAX_NUMBER];
+       char txpwr_legacyhtdiff[MAX_RF_PATH][CHANNEL_MAX_NUMBER];
+       u8 txpwr_5g_bw40base[MAX_RF_PATH][CHANNEL_MAX_NUMBER];
+       u8 txpwr_5g_bw80base[MAX_RF_PATH][CHANNEL_MAX_NUMBER_5G_80M];
+       char txpwr_5g_ofdmdiff[MAX_RF_PATH][MAX_TX_COUNT];
+       char txpwr_5g_bw20diff[MAX_RF_PATH][MAX_TX_COUNT];
+       char txpwr_5g_bw40diff[MAX_RF_PATH][MAX_TX_COUNT];
+       char txpwr_5g_bw80diff[MAX_RF_PATH][MAX_TX_COUNT];
+       u8 txpwr_safetyflag;                    /* Band edge enable flag */
+       u16 eeprom_txpowerdiff;
+       u8 legacy_httxpowerdiff;        /* Legacy to HT rate power diff */
+       u8 antenna_txpwdiff[3];
+       u8 eeprom_regulatory;
+       u8 eeprom_thermalmeter;
+       u8 thermalmeter[2]; /*ThermalMeter, index 0 for RFIC0, 1 for RFIC1 */
+       u16 tssi_13dbm;
+       u8 crystalcap;          /* CrystalCap. */
+       u8 delta_iqk;
+       u8 delta_lck;
+       u8 legacy_ht_txpowerdiff;       /*Legacy to HT rate power diff */
+       bool apk_thermalmeterignore;
+       bool b1x1_recvcombine;
+       bool b1ss_support;
+       /*channel plan */
+       u8 channel_plan;
+ };
+ struct rtl_ps_ctl {
+       bool pwrdomain_protect;
+       bool in_powersavemode;
+       bool rfchange_inprogress;
+       bool swrf_processing;
+       bool hwradiooff;
+       /*
+        * just for PCIE ASPM
+        * If it supports ASPM, Offset[560h] = 0x40,
+        * otherwise Offset[560h] = 0x00.
+        * */
+       bool support_aspm;
+       bool support_backdoor;
+       /*for LPS */
+       enum rt_psmode dot11_psmode;    /*Power save mode configured. */
+       bool swctrl_lps;
+       bool leisure_ps;
+       bool fwctrl_lps;
+       u8 fwctrl_psmode;
+       /*For Fw control LPS mode */
+       u8 reg_fwctrl_lps;
+       /*Record Fw PS mode status. */
+       bool fw_current_inpsmode;
+       u8 reg_max_lps_awakeintvl;
+       bool report_linked;
+       bool low_power_enable;/*for 32k*/
+       /*for IPS */
+       bool inactiveps;
+       u32 rfoff_reason;
+       /*RF OFF Level */
+       u32 cur_ps_level;
+       u32 reg_rfps_level;
+       /*just for PCIE ASPM */
+       u8 const_amdpci_aspm;
+       bool pwrdown_mode;
+       enum rf_pwrstate inactive_pwrstate;
+       enum rf_pwrstate rfpwr_state;   /*cur power state */
+       /* for SW LPS*/
+       bool sw_ps_enabled;
+       bool state;
+       bool state_inap;
+       bool multi_buffered;
+       u16 nullfunc_seq;
+       unsigned int dtim_counter;
+       unsigned int sleep_ms;
+       unsigned long last_sleep_jiffies;
+       unsigned long last_awake_jiffies;
+       unsigned long last_delaylps_stamp_jiffies;
+       unsigned long last_dtim;
+       unsigned long last_beacon;
+       unsigned long last_action;
+       unsigned long last_slept;
+       /*For P2P PS */
+       struct rtl_p2p_ps_info p2p_ps_info;
+       u8 pwr_mode;
+       u8 smart_ps;
+       /* wake up on line */
+       u8 wo_wlan_mode;
+       u8 arp_offload_enable;
+       u8 gtk_offload_enable;
+       /* Used for WOL, indicates the reason for waking event.*/
+       u32 wakeup_reason;
+       /* Record the last waking time for comparison with setting key. */
+       u64 last_wakeup_time;
+ };
+ struct rtl_stats {
+       u8 psaddr[ETH_ALEN];
+       u32 mac_time[2];
+       s8 rssi;
+       u8 signal;
+       u8 noise;
+       u8 rate;                /* hw desc rate */
+       u8 received_channel;
+       u8 control;
+       u8 mask;
+       u8 freq;
+       u16 len;
+       u64 tsf;
+       u32 beacon_time;
+       u8 nic_type;
+       u16 length;
+       u8 signalquality;       /*in 0-100 index. */
+       /*
+        * Real power in dBm for this packet,
+        * no beautification and aggregation.
+        * */
+       s32 recvsignalpower;
+       s8 rxpower;             /*in dBm Translate from PWdB */
+       u8 signalstrength;      /*in 0-100 index. */
+       u16 hwerror:1;
+       u16 crc:1;
+       u16 icv:1;
+       u16 shortpreamble:1;
+       u16 antenna:1;
+       u16 decrypted:1;
+       u16 wakeup:1;
+       u32 timestamp_low;
+       u32 timestamp_high;
+       bool shift;
+       u8 rx_drvinfo_size;
+       u8 rx_bufshift;
+       bool isampdu;
+       bool isfirst_ampdu;
+       bool rx_is40Mhzpacket;
+       u8 rx_packet_bw;
+       u32 rx_pwdb_all;
+       u8 rx_mimo_signalstrength[4];   /*in 0~100 index */
+       s8 rx_mimo_signalquality[4];
+       u8 rx_mimo_evm_dbm[4];
+       u16 cfo_short[4];               /* per-path's Cfo_short */
+       u16 cfo_tail[4];
+       s8 rx_mimo_sig_qual[4];
+       u8 rx_pwr[4]; /* per-path's pwdb */
+       u8 rx_snr[4]; /* per-path's SNR */
+       u8 bandwidth;
+       u8 bt_coex_pwr_adjust;
+       bool packet_matchbssid;
+       bool is_cck;
+       bool is_ht;
+       bool packet_toself;
+       bool packet_beacon;     /*for rssi */
+       char cck_adc_pwdb[4];   /*for rx path selection */
+       bool is_vht;
+       bool is_short_gi;
+       u8 vht_nss;
+       u8 packet_report_type;
+       u32 macid;
+       u8 wake_match;
+       u32 bt_rx_rssi_percentage;
+       u32 macid_valid_entry[2];
+ };
+ struct rt_link_detect {
+       /* count for roaming */
+       u32 bcn_rx_inperiod;
+       u32 roam_times;
+       u32 num_tx_in4period[4];
+       u32 num_rx_in4period[4];
+       u32 num_tx_inperiod;
+       u32 num_rx_inperiod;
+       bool busytraffic;
+       bool tx_busy_traffic;
+       bool rx_busy_traffic;
+       bool higher_busytraffic;
+       bool higher_busyrxtraffic;
+       u32 tidtx_in4period[MAX_TID_COUNT][4];
+       u32 tidtx_inperiod[MAX_TID_COUNT];
+       bool higher_busytxtraffic[MAX_TID_COUNT];
+ };
+ struct rtl_tcb_desc {
+       u8 packet_bw:2;
+       u8 multicast:1;
+       u8 broadcast:1;
+       u8 rts_stbc:1;
+       u8 rts_enable:1;
+       u8 cts_enable:1;
+       u8 rts_use_shortpreamble:1;
+       u8 rts_use_shortgi:1;
+       u8 rts_sc:1;
+       u8 rts_bw:1;
+       u8 rts_rate;
+       u8 use_shortgi:1;
+       u8 use_shortpreamble:1;
+       u8 use_driver_rate:1;
+       u8 disable_ratefallback:1;
+       u8 ratr_index;
+       u8 mac_id;
+       u8 hw_rate;
+       u8 last_inipkt:1;
+       u8 cmd_or_init:1;
+       u8 queue_index;
+       /* early mode */
+       u8 empkt_num;
+       /* The max value by HW */
+       u32 empkt_len[10];
+       bool tx_enable_sw_calc_duration;
+ };
+ struct rtl_wow_pattern {
+       u8 type;
+       u16 crc;
+       u32 mask[4];
+ };
+ struct rtl_hal_ops {
+       int (*init_sw_vars) (struct ieee80211_hw *hw);
+       void (*deinit_sw_vars) (struct ieee80211_hw *hw);
+       void (*read_chip_version)(struct ieee80211_hw *hw);
+       void (*read_eeprom_info) (struct ieee80211_hw *hw);
+       void (*interrupt_recognized) (struct ieee80211_hw *hw,
+                                     u32 *p_inta, u32 *p_intb);
+       int (*hw_init) (struct ieee80211_hw *hw);
+       void (*hw_disable) (struct ieee80211_hw *hw);
+       void (*hw_suspend) (struct ieee80211_hw *hw);
+       void (*hw_resume) (struct ieee80211_hw *hw);
+       void (*enable_interrupt) (struct ieee80211_hw *hw);
+       void (*disable_interrupt) (struct ieee80211_hw *hw);
+       int (*set_network_type) (struct ieee80211_hw *hw,
+                                enum nl80211_iftype type);
+       void (*set_chk_bssid)(struct ieee80211_hw *hw,
+                               bool check_bssid);
+       void (*set_bw_mode) (struct ieee80211_hw *hw,
+                            enum nl80211_channel_type ch_type);
+        u8(*switch_channel) (struct ieee80211_hw *hw);
+       void (*set_qos) (struct ieee80211_hw *hw, int aci);
+       void (*set_bcn_reg) (struct ieee80211_hw *hw);
+       void (*set_bcn_intv) (struct ieee80211_hw *hw);
+       void (*update_interrupt_mask) (struct ieee80211_hw *hw,
+                                      u32 add_msr, u32 rm_msr);
+       void (*get_hw_reg) (struct ieee80211_hw *hw, u8 variable, u8 *val);
+       void (*set_hw_reg) (struct ieee80211_hw *hw, u8 variable, u8 *val);
+       void (*update_rate_tbl) (struct ieee80211_hw *hw,
+                             struct ieee80211_sta *sta, u8 rssi_level);
+       void (*pre_fill_tx_bd_desc)(struct ieee80211_hw *hw, u8 *tx_bd_desc,
+                                   u8 *desc, u8 queue_index,
+                                   struct sk_buff *skb, dma_addr_t addr);
+       void (*update_rate_mask) (struct ieee80211_hw *hw, u8 rssi_level);
+       u16 (*rx_desc_buff_remained_cnt)(struct ieee80211_hw *hw,
+                                        u8 queue_index);
+       void (*rx_check_dma_ok)(struct ieee80211_hw *hw, u8 *header_desc,
+                               u8 queue_index);
+       void (*fill_tx_desc) (struct ieee80211_hw *hw,
+                             struct ieee80211_hdr *hdr, u8 *pdesc_tx,
+                             u8 *pbd_desc_tx,
+                             struct ieee80211_tx_info *info,
+                             struct ieee80211_sta *sta,
+                             struct sk_buff *skb, u8 hw_queue,
+                             struct rtl_tcb_desc *ptcb_desc);
+       void (*fill_fake_txdesc) (struct ieee80211_hw *hw, u8 *pDesc,
+                                 u32 buffer_len, bool bIsPsPoll);
+       void (*fill_tx_cmddesc) (struct ieee80211_hw *hw, u8 *pdesc,
+                                bool firstseg, bool lastseg,
+                                struct sk_buff *skb);
+       bool (*query_rx_desc) (struct ieee80211_hw *hw,
+                              struct rtl_stats *stats,
+                              struct ieee80211_rx_status *rx_status,
+                              u8 *pdesc, struct sk_buff *skb);
+       void (*set_channel_access) (struct ieee80211_hw *hw);
+       bool (*radio_onoff_checking) (struct ieee80211_hw *hw, u8 *valid);
+       void (*dm_watchdog) (struct ieee80211_hw *hw);
+       void (*scan_operation_backup) (struct ieee80211_hw *hw, u8 operation);
+       bool (*set_rf_power_state) (struct ieee80211_hw *hw,
+                                   enum rf_pwrstate rfpwr_state);
+       void (*led_control) (struct ieee80211_hw *hw,
+                            enum led_ctl_mode ledaction);
+       void (*set_desc)(struct ieee80211_hw *hw, u8 *pdesc, bool istx,
+                        u8 desc_name, u8 *val);
+       u32 (*get_desc) (u8 *pdesc, bool istx, u8 desc_name);
+       bool (*is_tx_desc_closed) (struct ieee80211_hw *hw,
+                                  u8 hw_queue, u16 index);
+       void (*tx_polling) (struct ieee80211_hw *hw, u8 hw_queue);
+       void (*enable_hw_sec) (struct ieee80211_hw *hw);
+       void (*set_key) (struct ieee80211_hw *hw, u32 key_index,
+                        u8 *macaddr, bool is_group, u8 enc_algo,
+                        bool is_wepkey, bool clear_all);
+       void (*init_sw_leds) (struct ieee80211_hw *hw);
+       void (*deinit_sw_leds) (struct ieee80211_hw *hw);
+       u32 (*get_bbreg) (struct ieee80211_hw *hw, u32 regaddr, u32 bitmask);
+       void (*set_bbreg) (struct ieee80211_hw *hw, u32 regaddr, u32 bitmask,
+                          u32 data);
+       u32 (*get_rfreg) (struct ieee80211_hw *hw, enum radio_path rfpath,
+                         u32 regaddr, u32 bitmask);
+       void (*set_rfreg) (struct ieee80211_hw *hw, enum radio_path rfpath,
+                          u32 regaddr, u32 bitmask, u32 data);
+       void (*linked_set_reg) (struct ieee80211_hw *hw);
+       void (*chk_switch_dmdp) (struct ieee80211_hw *hw);
+       void (*dualmac_easy_concurrent) (struct ieee80211_hw *hw);
+       void (*dualmac_switch_to_dmdp) (struct ieee80211_hw *hw);
+       bool (*phy_rf6052_config) (struct ieee80211_hw *hw);
+       void (*phy_rf6052_set_cck_txpower) (struct ieee80211_hw *hw,
+                                           u8 *powerlevel);
+       void (*phy_rf6052_set_ofdm_txpower) (struct ieee80211_hw *hw,
+                                            u8 *ppowerlevel, u8 channel);
+       bool (*config_bb_with_headerfile) (struct ieee80211_hw *hw,
+                                          u8 configtype);
+       bool (*config_bb_with_pgheaderfile) (struct ieee80211_hw *hw,
+                                            u8 configtype);
+       void (*phy_lc_calibrate) (struct ieee80211_hw *hw, bool is2t);
+       void (*phy_set_bw_mode_callback) (struct ieee80211_hw *hw);
+       void (*dm_dynamic_txpower) (struct ieee80211_hw *hw);
+       void (*c2h_command_handle) (struct ieee80211_hw *hw);
+       void (*bt_wifi_media_status_notify) (struct ieee80211_hw *hw,
+                                            bool mstate);
+       void (*bt_coex_off_before_lps) (struct ieee80211_hw *hw);
+       void (*fill_h2c_cmd) (struct ieee80211_hw *hw, u8 element_id,
+                             u32 cmd_len, u8 *p_cmdbuffer);
+       bool (*get_btc_status) (void);
+       bool (*is_fw_header)(struct rtlwifi_firmware_header *hdr);
+       u32 (*rx_command_packet)(struct ieee80211_hw *hw,
+                                struct rtl_stats status, struct sk_buff *skb);
+       void (*add_wowlan_pattern)(struct ieee80211_hw *hw,
+                                  struct rtl_wow_pattern *rtl_pattern,
+                                  u8 index);
+       u16 (*get_available_desc)(struct ieee80211_hw *hw, u8 q_idx);
+ };
+ struct rtl_intf_ops {
+       /*com */
+       void (*read_efuse_byte)(struct ieee80211_hw *hw, u16 _offset, u8 *pbuf);
+       int (*adapter_start) (struct ieee80211_hw *hw);
+       void (*adapter_stop) (struct ieee80211_hw *hw);
+       bool (*check_buddy_priv)(struct ieee80211_hw *hw,
+                                struct rtl_priv **buddy_priv);
+       int (*adapter_tx) (struct ieee80211_hw *hw,
+                          struct ieee80211_sta *sta,
+                          struct sk_buff *skb,
+                          struct rtl_tcb_desc *ptcb_desc);
+       void (*flush)(struct ieee80211_hw *hw, u32 queues, bool drop);
+       int (*reset_trx_ring) (struct ieee80211_hw *hw);
+       bool (*waitq_insert) (struct ieee80211_hw *hw,
+                             struct ieee80211_sta *sta,
+                             struct sk_buff *skb);
+       /*pci */
+       void (*disable_aspm) (struct ieee80211_hw *hw);
+       void (*enable_aspm) (struct ieee80211_hw *hw);
+       /*usb */
+ };
+ struct rtl_mod_params {
+       /* default: 0 = using hardware encryption */
+       bool sw_crypto;
+       /* default: 0 = DBG_EMERG (0)*/
+       int debug;
+       /* default: 1 = using no linked power save */
+       bool inactiveps;
+       /* default: 1 = using linked sw power save */
+       bool swctrl_lps;
+       /* default: 1 = using linked fw power save */
+       bool fwctrl_lps;
+       /* default: 0 = not using MSI interrupts mode
+        * submodules should set their own default value
+        */
+       bool msi_support;
+       /* default 0: 1 means disable */
+       bool disable_watchdog;
++
++      /* default 0: 1 means do not disable interrupts */
++      bool int_clear;
+ };
+ struct rtl_hal_usbint_cfg {
+       /* data - rx */
+       u32 in_ep_num;
+       u32 rx_urb_num;
+       u32 rx_max_size;
+       /* op - rx */
+       void (*usb_rx_hdl)(struct ieee80211_hw *, struct sk_buff *);
+       void (*usb_rx_segregate_hdl)(struct ieee80211_hw *, struct sk_buff *,
+                                    struct sk_buff_head *);
+       /* tx */
+       void (*usb_tx_cleanup)(struct ieee80211_hw *, struct sk_buff *);
+       int (*usb_tx_post_hdl)(struct ieee80211_hw *, struct urb *,
+                              struct sk_buff *);
+       struct sk_buff *(*usb_tx_aggregate_hdl)(struct ieee80211_hw *,
+                                               struct sk_buff_head *);
+       /* endpoint mapping */
+       int (*usb_endpoint_mapping)(struct ieee80211_hw *hw);
+       u16 (*usb_mq_to_hwq)(__le16 fc, u16 mac80211_queue_index);
+ };
+ struct rtl_hal_cfg {
+       u8 bar_id;
+       bool write_readback;
+       char *name;
+       char *fw_name;
+       char *alt_fw_name;
+       char *wowlan_fw_name;
+       struct rtl_hal_ops *ops;
+       struct rtl_mod_params *mod_params;
+       struct rtl_hal_usbint_cfg *usb_interface_cfg;
+       /*this map used for some registers or vars
+          defined int HAL but used in MAIN */
+       u32 maps[RTL_VAR_MAP_MAX];
+ };
+ struct rtl_locks {
+       /* mutex */
+       struct mutex conf_mutex;
+       struct mutex ps_mutex;
+       /*spin lock */
+       spinlock_t ips_lock;
+       spinlock_t irq_th_lock;
+       spinlock_t irq_pci_lock;
+       spinlock_t tx_lock;
+       spinlock_t h2c_lock;
+       spinlock_t rf_ps_lock;
+       spinlock_t rf_lock;
+       spinlock_t lps_lock;
+       spinlock_t waitq_lock;
+       spinlock_t entry_list_lock;
+       spinlock_t usb_lock;
+       /*FW clock change */
+       spinlock_t fw_ps_lock;
+       /*Dual mac*/
+       spinlock_t cck_and_rw_pagea_lock;
+       /*Easy concurrent*/
+       spinlock_t check_sendpkt_lock;
+       spinlock_t iqk_lock;
+ };
+ struct rtl_works {
+       struct ieee80211_hw *hw;
+       /*timer */
+       struct timer_list watchdog_timer;
+       struct timer_list dualmac_easyconcurrent_retrytimer;
+       struct timer_list fw_clockoff_timer;
+       struct timer_list fast_antenna_training_timer;
+       /*task */
+       struct tasklet_struct irq_tasklet;
+       struct tasklet_struct irq_prepare_bcn_tasklet;
+       /*work queue */
+       struct workqueue_struct *rtl_wq;
+       struct delayed_work watchdog_wq;
+       struct delayed_work ips_nic_off_wq;
+       /* For SW LPS */
+       struct delayed_work ps_work;
+       struct delayed_work ps_rfon_wq;
+       struct delayed_work fwevt_wq;
+       struct work_struct lps_change_work;
+       struct work_struct fill_h2c_cmd;
+ };
+ struct rtl_debug {
+       u32 dbgp_type[DBGP_TYPE_MAX];
+       int global_debuglevel;
+       u64 global_debugcomponents;
+       /* add for proc debug */
+       struct proc_dir_entry *proc_dir;
+       char proc_name[20];
+ };
+ #define MIMO_PS_STATIC                        0
+ #define MIMO_PS_DYNAMIC                       1
+ #define MIMO_PS_NOLIMIT                       3
+ struct rtl_dualmac_easy_concurrent_ctl {
+       enum band_type currentbandtype_backfordmdp;
+       bool close_bbandrf_for_dmsp;
+       bool change_to_dmdp;
+       bool change_to_dmsp;
+       bool switch_in_process;
+ };
+ struct rtl_dmsp_ctl {
+       bool activescan_for_slaveofdmsp;
+       bool scan_for_anothermac_fordmsp;
+       bool scan_for_itself_fordmsp;
+       bool writedig_for_anothermacofdmsp;
+       u32 curdigvalue_for_anothermacofdmsp;
+       bool changecckpdstate_for_anothermacofdmsp;
+       u8 curcckpdstate_for_anothermacofdmsp;
+       bool changetxhighpowerlvl_for_anothermacofdmsp;
+       u8 curtxhighlvl_for_anothermacofdmsp;
+       long rssivalmin_for_anothermacofdmsp;
+ };
+ struct ps_t {
+       u8 pre_ccastate;
+       u8 cur_ccasate;
+       u8 pre_rfstate;
+       u8 cur_rfstate;
+       u8 initialize;
+       long rssi_val_min;
+ };
+ struct dig_t {
+       u32 rssi_lowthresh;
+       u32 rssi_highthresh;
+       u32 fa_lowthresh;
+       u32 fa_highthresh;
+       long last_min_undec_pwdb_for_dm;
+       long rssi_highpower_lowthresh;
+       long rssi_highpower_highthresh;
+       u32 recover_cnt;
+       u32 pre_igvalue;
+       u32 cur_igvalue;
+       long rssi_val;
+       u8 dig_enable_flag;
+       u8 dig_ext_port_stage;
+       u8 dig_algorithm;
+       u8 dig_twoport_algorithm;
+       u8 dig_dbgmode;
+       u8 dig_slgorithm_switch;
+       u8 cursta_cstate;
+       u8 presta_cstate;
+       u8 curmultista_cstate;
+       u8 stop_dig;
+       char back_val;
+       char back_range_max;
+       char back_range_min;
+       u8 rx_gain_max;
+       u8 rx_gain_min;
+       u8 min_undec_pwdb_for_dm;
+       u8 rssi_val_min;
+       u8 pre_cck_cca_thres;
+       u8 cur_cck_cca_thres;
+       u8 pre_cck_pd_state;
+       u8 cur_cck_pd_state;
+       u8 pre_cck_fa_state;
+       u8 cur_cck_fa_state;
+       u8 pre_ccastate;
+       u8 cur_ccasate;
+       u8 large_fa_hit;
+       u8 forbidden_igi;
+       u8 dig_state;
+       u8 dig_highpwrstate;
+       u8 cur_sta_cstate;
+       u8 pre_sta_cstate;
+       u8 cur_ap_cstate;
+       u8 pre_ap_cstate;
+       u8 cur_pd_thstate;
+       u8 pre_pd_thstate;
+       u8 cur_cs_ratiostate;
+       u8 pre_cs_ratiostate;
+       u8 backoff_enable_flag;
+       char backoffval_range_max;
+       char backoffval_range_min;
+       u8 dig_min_0;
+       u8 dig_min_1;
+       u8 bt30_cur_igi;
+       bool media_connect_0;
+       bool media_connect_1;
+       u32 antdiv_rssi_max;
+       u32 rssi_max;
+ };
+ struct rtl_global_var {
+       /* from this list we can get
+        * other adapter's rtl_priv */
+       struct list_head glb_priv_list;
+       spinlock_t glb_list_lock;
+ };
+ struct rtl_btc_info {
+       u8 bt_type;
+       u8 btcoexist;
+       u8 ant_num;
+ };
+ struct bt_coexist_info {
+       struct rtl_btc_ops *btc_ops;
+       struct rtl_btc_info btc_info;
+       /* EEPROM BT info. */
+       u8 eeprom_bt_coexist;
+       u8 eeprom_bt_type;
+       u8 eeprom_bt_ant_num;
+       u8 eeprom_bt_ant_isol;
+       u8 eeprom_bt_radio_shared;
+       u8 bt_coexistence;
+       u8 bt_ant_num;
+       u8 bt_coexist_type;
+       u8 bt_state;
+       u8 bt_cur_state;        /* 0:on, 1:off */
+       u8 bt_ant_isolation;    /* 0:good, 1:bad */
+       u8 bt_pape_ctrl;        /* 0:SW, 1:SW/HW dynamic */
+       u8 bt_service;
+       u8 bt_radio_shared_type;
+       u8 bt_rfreg_origin_1e;
+       u8 bt_rfreg_origin_1f;
+       u8 bt_rssi_state;
+       u32 ratio_tx;
+       u32 ratio_pri;
+       u32 bt_edca_ul;
+       u32 bt_edca_dl;
+       bool init_set;
+       bool bt_busy_traffic;
+       bool bt_traffic_mode_set;
+       bool bt_non_traffic_mode_set;
+       bool fw_coexist_all_off;
+       bool sw_coexist_all_off;
+       bool hw_coexist_all_off;
+       u32 cstate;
+       u32 previous_state;
+       u32 cstate_h;
+       u32 previous_state_h;
+       u8 bt_pre_rssi_state;
+       u8 bt_pre_rssi_state1;
+       u8 reg_bt_iso;
+       u8 reg_bt_sco;
+       bool balance_on;
+       u8 bt_active_zero_cnt;
+       bool cur_bt_disabled;
+       bool pre_bt_disabled;
+       u8 bt_profile_case;
+       u8 bt_profile_action;
+       bool bt_busy;
+       bool hold_for_bt_operation;
+       u8 lps_counter;
+ };
+ struct rtl_btc_ops {
+       void (*btc_init_variables) (struct rtl_priv *rtlpriv);
+       void (*btc_init_hal_vars) (struct rtl_priv *rtlpriv);
+       void (*btc_init_hw_config) (struct rtl_priv *rtlpriv);
+       void (*btc_ips_notify) (struct rtl_priv *rtlpriv, u8 type);
+       void (*btc_lps_notify)(struct rtl_priv *rtlpriv, u8 type);
+       void (*btc_scan_notify) (struct rtl_priv *rtlpriv, u8 scantype);
+       void (*btc_connect_notify) (struct rtl_priv *rtlpriv, u8 action);
+       void (*btc_mediastatus_notify) (struct rtl_priv *rtlpriv,
+                                       enum rt_media_status mstatus);
+       void (*btc_periodical) (struct rtl_priv *rtlpriv);
+       void (*btc_halt_notify) (void);
+       void (*btc_btinfo_notify) (struct rtl_priv *rtlpriv,
+                                  u8 *tmp_buf, u8 length);
+       bool (*btc_is_limited_dig) (struct rtl_priv *rtlpriv);
+       bool (*btc_is_disable_edca_turbo) (struct rtl_priv *rtlpriv);
+       bool (*btc_is_bt_disabled) (struct rtl_priv *rtlpriv);
+       void (*btc_special_packet_notify)(struct rtl_priv *rtlpriv,
+                                         u8 pkt_type);
+ };
+ struct proxim {
+       bool proxim_on;
+       void *proximity_priv;
+       int (*proxim_rx)(struct ieee80211_hw *hw, struct rtl_stats *status,
+                        struct sk_buff *skb);
+       u8  (*proxim_get_var)(struct ieee80211_hw *hw, u8 type);
+ };
+ struct rtl_priv {
+       struct ieee80211_hw *hw;
+       struct completion firmware_loading_complete;
+       struct list_head list;
+       struct rtl_priv *buddy_priv;
+       struct rtl_global_var *glb_var;
+       struct rtl_dualmac_easy_concurrent_ctl easy_concurrent_ctl;
+       struct rtl_dmsp_ctl dmsp_ctl;
+       struct rtl_locks locks;
+       struct rtl_works works;
+       struct rtl_mac mac80211;
+       struct rtl_hal rtlhal;
+       struct rtl_regulatory regd;
+       struct rtl_rfkill rfkill;
+       struct rtl_io io;
+       struct rtl_phy phy;
+       struct rtl_dm dm;
+       struct rtl_security sec;
+       struct rtl_efuse efuse;
+       struct rtl_ps_ctl psc;
+       struct rate_adaptive ra;
+       struct dynamic_primary_cca primarycca;
+       struct wireless_stats stats;
+       struct rt_link_detect link_info;
+       struct false_alarm_statistics falsealm_cnt;
+       struct rtl_rate_priv *rate_priv;
+       /* sta entry list for ap adhoc or mesh */
+       struct list_head entry_list;
+       struct rtl_debug dbg;
+       int max_fw_size;
+       /*
+        *hal_cfg : for diff cards
+        *intf_ops : for diff interrface usb/pcie
+        */
+       struct rtl_hal_cfg *cfg;
+       struct rtl_intf_ops *intf_ops;
+       /*this var will be set by set_bit,
+          and was used to indicate status of
+          interface or hardware */
+       unsigned long status;
+       /* tables for dm */
+       struct dig_t dm_digtable;
+       struct ps_t dm_pstable;
+       u32 reg_874;
+       u32 reg_c70;
+       u32 reg_85c;
+       u32 reg_a74;
+       bool reg_init;  /* true if regs saved */
+       bool bt_operation_on;
+       __le32 *usb_data;
+       int usb_data_index;
+       bool initialized;
+       bool enter_ps;  /* true when entering PS */
+       u8 rate_mask[5];
+       /* intel Proximity, should be alloc mem
+        * in intel Proximity module and can only
+        * be used in intel Proximity mode
+        */
+       struct proxim proximity;
+       /*for bt coexist use*/
+       struct bt_coexist_info btcoexist;
+       /* separate 92ee from other ICs,
+        * 92ee use new trx flow.
+        */
+       bool use_new_trx_flow;
+ #ifdef CONFIG_PM
+       struct wiphy_wowlan_support wowlan;
+ #endif
+       /*This must be the last item so
+          that it points to the data allocated
+          beyond  this structure like:
+          rtl_pci_priv or rtl_usb_priv */
+       u8 priv[0] __aligned(sizeof(void *));
+ };
+ #define rtl_priv(hw)          (((struct rtl_priv *)(hw)->priv))
+ #define rtl_mac(rtlpriv)      (&((rtlpriv)->mac80211))
+ #define rtl_hal(rtlpriv)      (&((rtlpriv)->rtlhal))
+ #define rtl_efuse(rtlpriv)    (&((rtlpriv)->efuse))
+ #define rtl_psc(rtlpriv)      (&((rtlpriv)->psc))
+ /***************************************
+     Bluetooth Co-existence Related
+ ****************************************/
+ enum bt_ant_num {
+       ANT_X2 = 0,
+       ANT_X1 = 1,
+ };
+ enum bt_co_type {
+       BT_2WIRE = 0,
+       BT_ISSC_3WIRE = 1,
+       BT_ACCEL = 2,
+       BT_CSR_BC4 = 3,
+       BT_CSR_BC8 = 4,
+       BT_RTL8756 = 5,
+       BT_RTL8723A = 6,
+       BT_RTL8821A = 7,
+       BT_RTL8723B = 8,
+       BT_RTL8192E = 9,
+       BT_RTL8812A = 11,
+ };
+ enum bt_total_ant_num {
+       ANT_TOTAL_X2 = 0,
+       ANT_TOTAL_X1 = 1
+ };
+ enum bt_cur_state {
+       BT_OFF = 0,
+       BT_ON = 1,
+ };
+ enum bt_service_type {
+       BT_SCO = 0,
+       BT_A2DP = 1,
+       BT_HID = 2,
+       BT_HID_IDLE = 3,
+       BT_SCAN = 4,
+       BT_IDLE = 5,
+       BT_OTHER_ACTION = 6,
+       BT_BUSY = 7,
+       BT_OTHERBUSY = 8,
+       BT_PAN = 9,
+ };
+ enum bt_radio_shared {
+       BT_RADIO_SHARED = 0,
+       BT_RADIO_INDIVIDUAL = 1,
+ };
+ /****************************************
+       mem access macro define start
+       Call endian free function when
+       1. Read/write packet content.
+       2. Before write integer to IO.
+       3. After read integer from IO.
+ ****************************************/
+ /* Convert little data endian to host ordering */
+ #define EF1BYTE(_val)         \
+       ((u8)(_val))
+ #define EF2BYTE(_val)         \
+       (le16_to_cpu(_val))
+ #define EF4BYTE(_val)         \
+       (le32_to_cpu(_val))
+ /* Read data from memory */
+ #define READEF1BYTE(_ptr)     \
+       EF1BYTE(*((u8 *)(_ptr)))
+ /* Read le16 data from memory and convert to host ordering */
+ #define READEF2BYTE(_ptr)     \
+       EF2BYTE(*(_ptr))
+ #define READEF4BYTE(_ptr)     \
+       EF4BYTE(*(_ptr))
+ /* Write data to memory */
+ #define WRITEEF1BYTE(_ptr, _val)      \
+       (*((u8 *)(_ptr))) = EF1BYTE(_val)
+ /* Write le16 data to memory in host ordering */
+ #define WRITEEF2BYTE(_ptr, _val)      \
+       (*((u16 *)(_ptr))) = EF2BYTE(_val)
+ #define WRITEEF4BYTE(_ptr, _val)      \
+       (*((u32 *)(_ptr))) = EF2BYTE(_val)
+ /* Create a bit mask
+  * Examples:
+  * BIT_LEN_MASK_32(0) => 0x00000000
+  * BIT_LEN_MASK_32(1) => 0x00000001
+  * BIT_LEN_MASK_32(2) => 0x00000003
+  * BIT_LEN_MASK_32(32) => 0xFFFFFFFF
+  */
+ #define BIT_LEN_MASK_32(__bitlen)      \
+       (0xFFFFFFFF >> (32 - (__bitlen)))
+ #define BIT_LEN_MASK_16(__bitlen)      \
+       (0xFFFF >> (16 - (__bitlen)))
+ #define BIT_LEN_MASK_8(__bitlen) \
+       (0xFF >> (8 - (__bitlen)))
+ /* Create an offset bit mask
+  * Examples:
+  * BIT_OFFSET_LEN_MASK_32(0, 2) => 0x00000003
+  * BIT_OFFSET_LEN_MASK_32(16, 2) => 0x00030000
+  */
+ #define BIT_OFFSET_LEN_MASK_32(__bitoffset, __bitlen) \
+       (BIT_LEN_MASK_32(__bitlen) << (__bitoffset))
+ #define BIT_OFFSET_LEN_MASK_16(__bitoffset, __bitlen) \
+       (BIT_LEN_MASK_16(__bitlen) << (__bitoffset))
+ #define BIT_OFFSET_LEN_MASK_8(__bitoffset, __bitlen) \
+       (BIT_LEN_MASK_8(__bitlen) << (__bitoffset))
+ /*Description:
+  * Return 4-byte value in host byte ordering from
+  * 4-byte pointer in little-endian system.
+  */
+ #define LE_P4BYTE_TO_HOST_4BYTE(__pstart) \
+       (EF4BYTE(*((__le32 *)(__pstart))))
+ #define LE_P2BYTE_TO_HOST_2BYTE(__pstart) \
+       (EF2BYTE(*((__le16 *)(__pstart))))
+ #define LE_P1BYTE_TO_HOST_1BYTE(__pstart) \
+       (EF1BYTE(*((u8 *)(__pstart))))
+ /*Description:
+ Translate subfield (continuous bits in little-endian) of 4-byte
+ value to host byte ordering.*/
+ #define LE_BITS_TO_4BYTE(__pstart, __bitoffset, __bitlen) \
+       ( \
+               (LE_P4BYTE_TO_HOST_4BYTE(__pstart) >> (__bitoffset))  & \
+               BIT_LEN_MASK_32(__bitlen) \
+       )
+ #define LE_BITS_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
+       ( \
+               (LE_P2BYTE_TO_HOST_2BYTE(__pstart) >> (__bitoffset)) & \
+               BIT_LEN_MASK_16(__bitlen) \
+       )
+ #define LE_BITS_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
+       ( \
+               (LE_P1BYTE_TO_HOST_1BYTE(__pstart) >> (__bitoffset)) & \
+               BIT_LEN_MASK_8(__bitlen) \
+       )
+ /* Description:
+  * Mask subfield (continuous bits in little-endian) of 4-byte value
+  * and return the result in 4-byte value in host byte ordering.
+  */
+ #define LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) \
+       ( \
+               LE_P4BYTE_TO_HOST_4BYTE(__pstart)  & \
+               (~BIT_OFFSET_LEN_MASK_32(__bitoffset, __bitlen)) \
+       )
+ #define LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
+       ( \
+               LE_P2BYTE_TO_HOST_2BYTE(__pstart) & \
+               (~BIT_OFFSET_LEN_MASK_16(__bitoffset, __bitlen)) \
+       )
+ #define LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
+       ( \
+               LE_P1BYTE_TO_HOST_1BYTE(__pstart) & \
+               (~BIT_OFFSET_LEN_MASK_8(__bitoffset, __bitlen)) \
+       )
+ /* Description:
+  * Set subfield of little-endian 4-byte value to specified value.
+  */
+ #define SET_BITS_TO_LE_4BYTE(__pstart, __bitoffset, __bitlen, __val) \
+       *((u32 *)(__pstart)) = \
+       ( \
+               LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) | \
+               ((((u32)__val) & BIT_LEN_MASK_32(__bitlen)) << (__bitoffset)) \
+       );
+ #define SET_BITS_TO_LE_2BYTE(__pstart, __bitoffset, __bitlen, __val) \
+       *((u16 *)(__pstart)) = \
+       ( \
+               LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) | \
+               ((((u16)__val) & BIT_LEN_MASK_16(__bitlen)) << (__bitoffset)) \
+       );
+ #define SET_BITS_TO_LE_1BYTE(__pstart, __bitoffset, __bitlen, __val) \
+       *((u8 *)(__pstart)) = EF1BYTE \
+       ( \
+               LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) | \
+               ((((u8)__val) & BIT_LEN_MASK_8(__bitlen)) << (__bitoffset)) \
+       );
+ #define       N_BYTE_ALIGMENT(__value, __aligment) ((__aligment == 1) ? \
+       (__value) : (((__value + __aligment - 1) / __aligment) * __aligment))
+ /****************************************
+       mem access macro define end
+ ****************************************/
+ #define byte(x, n) ((x >> (8 * n)) & 0xff)
+ #define packet_get_type(_packet) (EF1BYTE((_packet).octet[0]) & 0xFC)
+ #define RTL_WATCH_DOG_TIME    2000
+ #define MSECS(t)              msecs_to_jiffies(t)
+ #define WLAN_FC_GET_VERS(fc)  (le16_to_cpu(fc) & IEEE80211_FCTL_VERS)
+ #define WLAN_FC_GET_TYPE(fc)  (le16_to_cpu(fc) & IEEE80211_FCTL_FTYPE)
+ #define WLAN_FC_GET_STYPE(fc) (le16_to_cpu(fc) & IEEE80211_FCTL_STYPE)
+ #define WLAN_FC_MORE_DATA(fc) (le16_to_cpu(fc) & IEEE80211_FCTL_MOREDATA)
+ #define rtl_dm(rtlpriv)               (&((rtlpriv)->dm))
+ #define       RT_RF_OFF_LEVL_ASPM             BIT(0)  /*PCI ASPM */
+ #define       RT_RF_OFF_LEVL_CLK_REQ          BIT(1)  /*PCI clock request */
+ #define       RT_RF_OFF_LEVL_PCI_D3           BIT(2)  /*PCI D3 mode */
+ /*NIC halt, re-initialize hw parameters*/
+ #define       RT_RF_OFF_LEVL_HALT_NIC         BIT(3)
+ #define       RT_RF_OFF_LEVL_FREE_FW          BIT(4)  /*FW free, re-download the FW */
+ #define       RT_RF_OFF_LEVL_FW_32K           BIT(5)  /*FW in 32k */
+ /*Always enable ASPM and Clock Req in initialization.*/
+ #define       RT_RF_PS_LEVEL_ALWAYS_ASPM      BIT(6)
+ /* no matter RFOFF or SLEEP we set PS_ASPM_LEVL*/
+ #define       RT_PS_LEVEL_ASPM                BIT(7)
+ /*When LPS is on, disable 2R if no packet is received or transmittd.*/
+ #define       RT_RF_LPS_DISALBE_2R            BIT(30)
+ #define       RT_RF_LPS_LEVEL_ASPM            BIT(31) /*LPS with ASPM */
+ #define       RT_IN_PS_LEVEL(ppsc, _ps_flg)           \
+       ((ppsc->cur_ps_level & _ps_flg) ? true : false)
+ #define       RT_CLEAR_PS_LEVEL(ppsc, _ps_flg)        \
+       (ppsc->cur_ps_level &= (~(_ps_flg)))
+ #define       RT_SET_PS_LEVEL(ppsc, _ps_flg)          \
+       (ppsc->cur_ps_level |= _ps_flg)
+ #define container_of_dwork_rtl(x, y, z) \
+       container_of(container_of(x, struct delayed_work, work), y, z)
+ #define FILL_OCTET_STRING(_os, _octet, _len)  \
+               (_os).octet = (u8 *)(_octet);           \
+               (_os).length = (_len);
+ #define CP_MACADDR(des, src)  \
+       ((des)[0] = (src)[0], (des)[1] = (src)[1],\
+       (des)[2] = (src)[2], (des)[3] = (src)[3],\
+       (des)[4] = (src)[4], (des)[5] = (src)[5])
+ #define       LDPC_HT_ENABLE_RX                       BIT(0)
+ #define       LDPC_HT_ENABLE_TX                       BIT(1)
+ #define       LDPC_HT_TEST_TX_ENABLE                  BIT(2)
+ #define       LDPC_HT_CAP_TX                          BIT(3)
+ #define       STBC_HT_ENABLE_RX                       BIT(0)
+ #define       STBC_HT_ENABLE_TX                       BIT(1)
+ #define       STBC_HT_TEST_TX_ENABLE                  BIT(2)
+ #define       STBC_HT_CAP_TX                          BIT(3)
+ #define       LDPC_VHT_ENABLE_RX                      BIT(0)
+ #define       LDPC_VHT_ENABLE_TX                      BIT(1)
+ #define       LDPC_VHT_TEST_TX_ENABLE                 BIT(2)
+ #define       LDPC_VHT_CAP_TX                         BIT(3)
+ #define       STBC_VHT_ENABLE_RX                      BIT(0)
+ #define       STBC_VHT_ENABLE_TX                      BIT(1)
+ #define       STBC_VHT_TEST_TX_ENABLE                 BIT(2)
+ #define       STBC_VHT_CAP_TX                         BIT(3)
+ static inline u8 rtl_read_byte(struct rtl_priv *rtlpriv, u32 addr)
+ {
+       return rtlpriv->io.read8_sync(rtlpriv, addr);
+ }
+ static inline u16 rtl_read_word(struct rtl_priv *rtlpriv, u32 addr)
+ {
+       return rtlpriv->io.read16_sync(rtlpriv, addr);
+ }
+ static inline u32 rtl_read_dword(struct rtl_priv *rtlpriv, u32 addr)
+ {
+       return rtlpriv->io.read32_sync(rtlpriv, addr);
+ }
+ static inline void rtl_write_byte(struct rtl_priv *rtlpriv, u32 addr, u8 val8)
+ {
+       rtlpriv->io.write8_async(rtlpriv, addr, val8);
+       if (rtlpriv->cfg->write_readback)
+               rtlpriv->io.read8_sync(rtlpriv, addr);
+ }
+ static inline void rtl_write_word(struct rtl_priv *rtlpriv, u32 addr, u16 val16)
+ {
+       rtlpriv->io.write16_async(rtlpriv, addr, val16);
+       if (rtlpriv->cfg->write_readback)
+               rtlpriv->io.read16_sync(rtlpriv, addr);
+ }
+ static inline void rtl_write_dword(struct rtl_priv *rtlpriv,
+                                  u32 addr, u32 val32)
+ {
+       rtlpriv->io.write32_async(rtlpriv, addr, val32);
+       if (rtlpriv->cfg->write_readback)
+               rtlpriv->io.read32_sync(rtlpriv, addr);
+ }
+ static inline u32 rtl_get_bbreg(struct ieee80211_hw *hw,
+                               u32 regaddr, u32 bitmask)
+ {
+       struct rtl_priv *rtlpriv = hw->priv;
+       return rtlpriv->cfg->ops->get_bbreg(hw, regaddr, bitmask);
+ }
+ static inline void rtl_set_bbreg(struct ieee80211_hw *hw, u32 regaddr,
+                                u32 bitmask, u32 data)
+ {
+       struct rtl_priv *rtlpriv = hw->priv;
+       rtlpriv->cfg->ops->set_bbreg(hw, regaddr, bitmask, data);
+ }
+ static inline u32 rtl_get_rfreg(struct ieee80211_hw *hw,
+                               enum radio_path rfpath, u32 regaddr,
+                               u32 bitmask)
+ {
+       struct rtl_priv *rtlpriv = hw->priv;
+       return rtlpriv->cfg->ops->get_rfreg(hw, rfpath, regaddr, bitmask);
+ }
+ static inline void rtl_set_rfreg(struct ieee80211_hw *hw,
+                                enum radio_path rfpath, u32 regaddr,
+                                u32 bitmask, u32 data)
+ {
+       struct rtl_priv *rtlpriv = hw->priv;
+       rtlpriv->cfg->ops->set_rfreg(hw, rfpath, regaddr, bitmask, data);
+ }
+ static inline bool is_hal_stop(struct rtl_hal *rtlhal)
+ {
+       return (_HAL_STATE_STOP == rtlhal->state);
+ }
+ static inline void set_hal_start(struct rtl_hal *rtlhal)
+ {
+       rtlhal->state = _HAL_STATE_START;
+ }
+ static inline void set_hal_stop(struct rtl_hal *rtlhal)
+ {
+       rtlhal->state = _HAL_STATE_STOP;
+ }
+ static inline u8 get_rf_type(struct rtl_phy *rtlphy)
+ {
+       return rtlphy->rf_type;
+ }
+ static inline struct ieee80211_hdr *rtl_get_hdr(struct sk_buff *skb)
+ {
+       return (struct ieee80211_hdr *)(skb->data);
+ }
+ static inline __le16 rtl_get_fc(struct sk_buff *skb)
+ {
+       return rtl_get_hdr(skb)->frame_control;
+ }
+ static inline u16 rtl_get_tid_h(struct ieee80211_hdr *hdr)
+ {
+       return (ieee80211_get_qos_ctl(hdr))[0] & IEEE80211_QOS_CTL_TID_MASK;
+ }
+ static inline u16 rtl_get_tid(struct sk_buff *skb)
+ {
+       return rtl_get_tid_h(rtl_get_hdr(skb));
+ }
+ static inline struct ieee80211_sta *get_sta(struct ieee80211_hw *hw,
+                                           struct ieee80211_vif *vif,
+                                           const u8 *bssid)
+ {
+       return ieee80211_find_sta(vif, bssid);
+ }
+ static inline struct ieee80211_sta *rtl_find_sta(struct ieee80211_hw *hw,
+               u8 *mac_addr)
+ {
+       struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
+       return ieee80211_find_sta(mac->vif, mac_addr);
+ }
+ #endif