10770f718SLarry Finger // SPDX-License-Identifier: GPL-2.0 20770f718SLarry Finger /* Copyright(c) 2009-2012 Realtek Corporation.*/ 3f1d2b4d3SLarry Finger 4f1d2b4d3SLarry Finger #include "../wifi.h" 5f1d2b4d3SLarry Finger #include "../efuse.h" 6f1d2b4d3SLarry Finger #include "../base.h" 7f1d2b4d3SLarry Finger #include "../regd.h" 8f1d2b4d3SLarry Finger #include "../cam.h" 9f1d2b4d3SLarry Finger #include "../ps.h" 10f1d2b4d3SLarry Finger #include "../pci.h" 11f1d2b4d3SLarry Finger #include "reg.h" 12f1d2b4d3SLarry Finger #include "def.h" 13f1d2b4d3SLarry Finger #include "phy.h" 14f1d2b4d3SLarry Finger #include "../rtl8192c/dm_common.h" 15f1d2b4d3SLarry Finger #include "../rtl8192c/fw_common.h" 16f1d2b4d3SLarry Finger #include "../rtl8192c/phy_common.h" 17f1d2b4d3SLarry Finger #include "dm.h" 18f1d2b4d3SLarry Finger #include "led.h" 19f1d2b4d3SLarry Finger #include "hw.h" 20f1d2b4d3SLarry Finger 21f1d2b4d3SLarry Finger #define LLT_CONFIG 5 22f1d2b4d3SLarry Finger 23f1d2b4d3SLarry Finger static void _rtl92ce_set_bcn_ctrl_reg(struct ieee80211_hw *hw, 24f1d2b4d3SLarry Finger u8 set_bits, u8 clear_bits) 25f1d2b4d3SLarry Finger { 26f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 27f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 28f1d2b4d3SLarry Finger 29f1d2b4d3SLarry Finger rtlpci->reg_bcn_ctrl_val |= set_bits; 30f1d2b4d3SLarry Finger rtlpci->reg_bcn_ctrl_val &= ~clear_bits; 31f1d2b4d3SLarry Finger 32f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_BCN_CTRL, (u8)rtlpci->reg_bcn_ctrl_val); 33f1d2b4d3SLarry Finger } 34f1d2b4d3SLarry Finger 35f1d2b4d3SLarry Finger static void _rtl92ce_stop_tx_beacon(struct ieee80211_hw *hw) 36f1d2b4d3SLarry Finger { 37f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 38f1d2b4d3SLarry Finger u8 tmp1byte; 39f1d2b4d3SLarry Finger 40f1d2b4d3SLarry Finger tmp1byte = rtl_read_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2); 41f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, tmp1byte & (~BIT(6))); 42f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0x64); 43f1d2b4d3SLarry Finger tmp1byte = rtl_read_byte(rtlpriv, REG_TBTT_PROHIBIT + 2); 44f1d2b4d3SLarry Finger tmp1byte &= ~(BIT(0)); 45f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 2, tmp1byte); 46f1d2b4d3SLarry Finger } 47f1d2b4d3SLarry Finger 48f1d2b4d3SLarry Finger static void _rtl92ce_resume_tx_beacon(struct ieee80211_hw *hw) 49f1d2b4d3SLarry Finger { 50f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 51f1d2b4d3SLarry Finger u8 tmp1byte; 52f1d2b4d3SLarry Finger 53f1d2b4d3SLarry Finger tmp1byte = rtl_read_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2); 54f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, tmp1byte | BIT(6)); 55f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0xff); 56f1d2b4d3SLarry Finger tmp1byte = rtl_read_byte(rtlpriv, REG_TBTT_PROHIBIT + 2); 57f1d2b4d3SLarry Finger tmp1byte |= BIT(0); 58f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 2, tmp1byte); 59f1d2b4d3SLarry Finger } 60f1d2b4d3SLarry Finger 61f1d2b4d3SLarry Finger static void _rtl92ce_enable_bcn_sub_func(struct ieee80211_hw *hw) 62f1d2b4d3SLarry Finger { 63f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, 0, BIT(1)); 64f1d2b4d3SLarry Finger } 65f1d2b4d3SLarry Finger 66f1d2b4d3SLarry Finger static void _rtl92ce_disable_bcn_sub_func(struct ieee80211_hw *hw) 67f1d2b4d3SLarry Finger { 68f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, BIT(1), 0); 69f1d2b4d3SLarry Finger } 70f1d2b4d3SLarry Finger 71f1d2b4d3SLarry Finger void rtl92ce_get_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val) 72f1d2b4d3SLarry Finger { 73f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 74f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 75f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 76f1d2b4d3SLarry Finger 77f1d2b4d3SLarry Finger switch (variable) { 78f1d2b4d3SLarry Finger case HW_VAR_RCR: 79f1d2b4d3SLarry Finger *((u32 *) (val)) = rtlpci->receive_config; 80f1d2b4d3SLarry Finger break; 81f1d2b4d3SLarry Finger case HW_VAR_RF_STATE: 82f1d2b4d3SLarry Finger *((enum rf_pwrstate *)(val)) = ppsc->rfpwr_state; 83f1d2b4d3SLarry Finger break; 84f1d2b4d3SLarry Finger case HW_VAR_FWLPS_RF_ON:{ 85ff970453SLarry Finger enum rf_pwrstate rfstate; 86f1d2b4d3SLarry Finger u32 val_rcr; 87f1d2b4d3SLarry Finger 88f1d2b4d3SLarry Finger rtlpriv->cfg->ops->get_hw_reg(hw, 89f1d2b4d3SLarry Finger HW_VAR_RF_STATE, 90ff970453SLarry Finger (u8 *)(&rfstate)); 91ff970453SLarry Finger if (rfstate == ERFOFF) { 92f1d2b4d3SLarry Finger *((bool *) (val)) = true; 93f1d2b4d3SLarry Finger } else { 94f1d2b4d3SLarry Finger val_rcr = rtl_read_dword(rtlpriv, REG_RCR); 95f1d2b4d3SLarry Finger val_rcr &= 0x00070000; 96f1d2b4d3SLarry Finger if (val_rcr) 97f1d2b4d3SLarry Finger *((bool *) (val)) = false; 98f1d2b4d3SLarry Finger else 99f1d2b4d3SLarry Finger *((bool *) (val)) = true; 100f1d2b4d3SLarry Finger } 101f1d2b4d3SLarry Finger break; 102f1d2b4d3SLarry Finger } 103f1d2b4d3SLarry Finger case HW_VAR_FW_PSMODE_STATUS: 104f1d2b4d3SLarry Finger *((bool *) (val)) = ppsc->fw_current_inpsmode; 105f1d2b4d3SLarry Finger break; 106f1d2b4d3SLarry Finger case HW_VAR_CORRECT_TSF:{ 107f1d2b4d3SLarry Finger u64 tsf; 108f1d2b4d3SLarry Finger u32 *ptsf_low = (u32 *)&tsf; 109f1d2b4d3SLarry Finger u32 *ptsf_high = ((u32 *)&tsf) + 1; 110f1d2b4d3SLarry Finger 111f1d2b4d3SLarry Finger *ptsf_high = rtl_read_dword(rtlpriv, (REG_TSFTR + 4)); 112f1d2b4d3SLarry Finger *ptsf_low = rtl_read_dword(rtlpriv, REG_TSFTR); 113f1d2b4d3SLarry Finger 114f1d2b4d3SLarry Finger *((u64 *) (val)) = tsf; 115f1d2b4d3SLarry Finger 116f1d2b4d3SLarry Finger break; 117f1d2b4d3SLarry Finger } 1181cc49a5bSLarry Finger case HAL_DEF_WOWLAN: 1191cc49a5bSLarry Finger break; 120f1d2b4d3SLarry Finger default: 121e40a0056SLarry Finger pr_err("switch case %#x not processed\n", variable); 122f1d2b4d3SLarry Finger break; 123f1d2b4d3SLarry Finger } 124f1d2b4d3SLarry Finger } 125f1d2b4d3SLarry Finger 126f1d2b4d3SLarry Finger void rtl92ce_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val) 127f1d2b4d3SLarry Finger { 128f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 129f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 130f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 131f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 132f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 133f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 134f1d2b4d3SLarry Finger u8 idx; 135f1d2b4d3SLarry Finger 136f1d2b4d3SLarry Finger switch (variable) { 137f1d2b4d3SLarry Finger case HW_VAR_ETHER_ADDR:{ 138f1d2b4d3SLarry Finger for (idx = 0; idx < ETH_ALEN; idx++) { 139f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, (REG_MACID + idx), 140f1d2b4d3SLarry Finger val[idx]); 141f1d2b4d3SLarry Finger } 142f1d2b4d3SLarry Finger break; 143f1d2b4d3SLarry Finger } 144f1d2b4d3SLarry Finger case HW_VAR_BASIC_RATE:{ 145f1d2b4d3SLarry Finger u16 rate_cfg = ((u16 *) val)[0]; 146f1d2b4d3SLarry Finger u8 rate_index = 0; 1472973af74SLarry Finger 148f1d2b4d3SLarry Finger rate_cfg &= 0x15f; 149f1d2b4d3SLarry Finger rate_cfg |= 0x01; 150f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RRSR, rate_cfg & 0xff); 151f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RRSR + 1, 152f1d2b4d3SLarry Finger (rate_cfg >> 8) & 0xff); 153f1d2b4d3SLarry Finger while (rate_cfg > 0x1) { 154f1d2b4d3SLarry Finger rate_cfg = (rate_cfg >> 1); 155f1d2b4d3SLarry Finger rate_index++; 156f1d2b4d3SLarry Finger } 157f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_INIRTS_RATE_SEL, 158f1d2b4d3SLarry Finger rate_index); 159f1d2b4d3SLarry Finger break; 160f1d2b4d3SLarry Finger } 161f1d2b4d3SLarry Finger case HW_VAR_BSSID:{ 162f1d2b4d3SLarry Finger for (idx = 0; idx < ETH_ALEN; idx++) { 163f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, (REG_BSSID + idx), 164f1d2b4d3SLarry Finger val[idx]); 165f1d2b4d3SLarry Finger } 166f1d2b4d3SLarry Finger break; 167f1d2b4d3SLarry Finger } 168f1d2b4d3SLarry Finger case HW_VAR_SIFS:{ 169f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SIFS_CTX + 1, val[0]); 170f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SIFS_TRX + 1, val[1]); 171f1d2b4d3SLarry Finger 172f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SPEC_SIFS + 1, val[0]); 173f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_MAC_SPEC_SIFS + 1, val[0]); 174f1d2b4d3SLarry Finger 175f1d2b4d3SLarry Finger if (!mac->ht_enable) 176f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_RESP_SIFS_OFDM, 177f1d2b4d3SLarry Finger 0x0e0e); 178f1d2b4d3SLarry Finger else 179f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_RESP_SIFS_OFDM, 180f1d2b4d3SLarry Finger *((u16 *) val)); 181f1d2b4d3SLarry Finger break; 182f1d2b4d3SLarry Finger } 183f1d2b4d3SLarry Finger case HW_VAR_SLOT_TIME:{ 184f1d2b4d3SLarry Finger u8 e_aci; 185f1d2b4d3SLarry Finger 186de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_MLME, DBG_LOUD, 187f1d2b4d3SLarry Finger "HW_VAR_SLOT_TIME %x\n", val[0]); 188f1d2b4d3SLarry Finger 189f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SLOT, val[0]); 190f1d2b4d3SLarry Finger 191f1d2b4d3SLarry Finger for (e_aci = 0; e_aci < AC_MAX; e_aci++) { 192f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 193f1d2b4d3SLarry Finger HW_VAR_AC_PARAM, 194f1d2b4d3SLarry Finger &e_aci); 195f1d2b4d3SLarry Finger } 196f1d2b4d3SLarry Finger break; 197f1d2b4d3SLarry Finger } 198f1d2b4d3SLarry Finger case HW_VAR_ACK_PREAMBLE:{ 199f1d2b4d3SLarry Finger u8 reg_tmp; 200f1d2b4d3SLarry Finger u8 short_preamble = (bool)*val; 2012973af74SLarry Finger 202f1d2b4d3SLarry Finger reg_tmp = (mac->cur_40_prime_sc) << 5; 203f1d2b4d3SLarry Finger if (short_preamble) 204f1d2b4d3SLarry Finger reg_tmp |= 0x80; 205f1d2b4d3SLarry Finger 206f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RRSR + 2, reg_tmp); 207f1d2b4d3SLarry Finger break; 208f1d2b4d3SLarry Finger } 209f1d2b4d3SLarry Finger case HW_VAR_AMPDU_MIN_SPACE:{ 210f1d2b4d3SLarry Finger u8 min_spacing_to_set; 211f1d2b4d3SLarry Finger u8 sec_min_space; 212f1d2b4d3SLarry Finger 213f1d2b4d3SLarry Finger min_spacing_to_set = *val; 214f1d2b4d3SLarry Finger if (min_spacing_to_set <= 7) { 215f1d2b4d3SLarry Finger sec_min_space = 0; 216f1d2b4d3SLarry Finger 217f1d2b4d3SLarry Finger if (min_spacing_to_set < sec_min_space) 218f1d2b4d3SLarry Finger min_spacing_to_set = sec_min_space; 219f1d2b4d3SLarry Finger 220f1d2b4d3SLarry Finger mac->min_space_cfg = ((mac->min_space_cfg & 221f1d2b4d3SLarry Finger 0xf8) | 222f1d2b4d3SLarry Finger min_spacing_to_set); 223f1d2b4d3SLarry Finger 224f1d2b4d3SLarry Finger *val = min_spacing_to_set; 225f1d2b4d3SLarry Finger 226de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_MLME, DBG_LOUD, 227f1d2b4d3SLarry Finger "Set HW_VAR_AMPDU_MIN_SPACE: %#x\n", 228f1d2b4d3SLarry Finger mac->min_space_cfg); 229f1d2b4d3SLarry Finger 230f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_AMPDU_MIN_SPACE, 231f1d2b4d3SLarry Finger mac->min_space_cfg); 232f1d2b4d3SLarry Finger } 233f1d2b4d3SLarry Finger break; 234f1d2b4d3SLarry Finger } 235f1d2b4d3SLarry Finger case HW_VAR_SHORTGI_DENSITY:{ 236f1d2b4d3SLarry Finger u8 density_to_set; 237f1d2b4d3SLarry Finger 238f1d2b4d3SLarry Finger density_to_set = *val; 239f1d2b4d3SLarry Finger mac->min_space_cfg |= (density_to_set << 3); 240f1d2b4d3SLarry Finger 241de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_MLME, DBG_LOUD, 242f1d2b4d3SLarry Finger "Set HW_VAR_SHORTGI_DENSITY: %#x\n", 243f1d2b4d3SLarry Finger mac->min_space_cfg); 244f1d2b4d3SLarry Finger 245f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_AMPDU_MIN_SPACE, 246f1d2b4d3SLarry Finger mac->min_space_cfg); 247f1d2b4d3SLarry Finger 248f1d2b4d3SLarry Finger break; 249f1d2b4d3SLarry Finger } 250f1d2b4d3SLarry Finger case HW_VAR_AMPDU_FACTOR:{ 251f1d2b4d3SLarry Finger u8 regtoset_normal[4] = {0x41, 0xa8, 0x72, 0xb9}; 252f1d2b4d3SLarry Finger u8 regtoset_bt[4] = {0x31, 0x74, 0x42, 0x97}; 253f1d2b4d3SLarry Finger 254f1d2b4d3SLarry Finger u8 factor_toset; 255f1d2b4d3SLarry Finger u8 *p_regtoset = NULL; 256f1d2b4d3SLarry Finger u8 index = 0; 257f1d2b4d3SLarry Finger 258d5efe153SLarry Finger if ((rtlpriv->btcoexist.bt_coexistence) && 259d5efe153SLarry Finger (rtlpriv->btcoexist.bt_coexist_type == 260f1d2b4d3SLarry Finger BT_CSR_BC4)) 261f1d2b4d3SLarry Finger p_regtoset = regtoset_bt; 262f1d2b4d3SLarry Finger else 263f1d2b4d3SLarry Finger p_regtoset = regtoset_normal; 264f1d2b4d3SLarry Finger 265f1d2b4d3SLarry Finger factor_toset = *(val); 266f1d2b4d3SLarry Finger if (factor_toset <= 3) { 267f1d2b4d3SLarry Finger factor_toset = (1 << (factor_toset + 2)); 268f1d2b4d3SLarry Finger if (factor_toset > 0xf) 269f1d2b4d3SLarry Finger factor_toset = 0xf; 270f1d2b4d3SLarry Finger 271f1d2b4d3SLarry Finger for (index = 0; index < 4; index++) { 272f1d2b4d3SLarry Finger if ((p_regtoset[index] & 0xf0) > 273f1d2b4d3SLarry Finger (factor_toset << 4)) 274f1d2b4d3SLarry Finger p_regtoset[index] = 275f1d2b4d3SLarry Finger (p_regtoset[index] & 0x0f) | 276f1d2b4d3SLarry Finger (factor_toset << 4); 277f1d2b4d3SLarry Finger 278f1d2b4d3SLarry Finger if ((p_regtoset[index] & 0x0f) > 279f1d2b4d3SLarry Finger factor_toset) 280f1d2b4d3SLarry Finger p_regtoset[index] = 281f1d2b4d3SLarry Finger (p_regtoset[index] & 0xf0) | 282f1d2b4d3SLarry Finger (factor_toset); 283f1d2b4d3SLarry Finger 284f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 285f1d2b4d3SLarry Finger (REG_AGGLEN_LMT + index), 286f1d2b4d3SLarry Finger p_regtoset[index]); 287f1d2b4d3SLarry Finger 288f1d2b4d3SLarry Finger } 289f1d2b4d3SLarry Finger 290de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_MLME, DBG_LOUD, 291f1d2b4d3SLarry Finger "Set HW_VAR_AMPDU_FACTOR: %#x\n", 292f1d2b4d3SLarry Finger factor_toset); 293f1d2b4d3SLarry Finger } 294f1d2b4d3SLarry Finger break; 295f1d2b4d3SLarry Finger } 296f1d2b4d3SLarry Finger case HW_VAR_AC_PARAM:{ 297f1d2b4d3SLarry Finger u8 e_aci = *(val); 2982973af74SLarry Finger 299f1d2b4d3SLarry Finger rtl92c_dm_init_edca_turbo(hw); 300f1d2b4d3SLarry Finger 301f1d2b4d3SLarry Finger if (rtlpci->acm_method != EACMWAY2_SW) 302f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 303f1d2b4d3SLarry Finger HW_VAR_ACM_CTRL, 304f1d2b4d3SLarry Finger (&e_aci)); 305f1d2b4d3SLarry Finger break; 306f1d2b4d3SLarry Finger } 307f1d2b4d3SLarry Finger case HW_VAR_ACM_CTRL:{ 308f1d2b4d3SLarry Finger u8 e_aci = *(val); 309f1d2b4d3SLarry Finger union aci_aifsn *p_aci_aifsn = 310f1d2b4d3SLarry Finger (union aci_aifsn *)(&(mac->ac[0].aifs)); 311f1d2b4d3SLarry Finger u8 acm = p_aci_aifsn->f.acm; 312f1d2b4d3SLarry Finger u8 acm_ctrl = rtl_read_byte(rtlpriv, REG_ACMHWCTRL); 313f1d2b4d3SLarry Finger 314f1d2b4d3SLarry Finger acm_ctrl = 315f1d2b4d3SLarry Finger acm_ctrl | ((rtlpci->acm_method == 2) ? 0x0 : 0x1); 316f1d2b4d3SLarry Finger 317f1d2b4d3SLarry Finger if (acm) { 318f1d2b4d3SLarry Finger switch (e_aci) { 319f1d2b4d3SLarry Finger case AC0_BE: 320ff970453SLarry Finger acm_ctrl |= ACMHW_BEQEN; 321f1d2b4d3SLarry Finger break; 322f1d2b4d3SLarry Finger case AC2_VI: 323ff970453SLarry Finger acm_ctrl |= ACMHW_VIQEN; 324f1d2b4d3SLarry Finger break; 325f1d2b4d3SLarry Finger case AC3_VO: 326ff970453SLarry Finger acm_ctrl |= ACMHW_VOQEN; 327f1d2b4d3SLarry Finger break; 328f1d2b4d3SLarry Finger default: 329de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING, 330f1d2b4d3SLarry Finger "HW_VAR_ACM_CTRL acm set failed: eACI is %d\n", 331f1d2b4d3SLarry Finger acm); 332f1d2b4d3SLarry Finger break; 333f1d2b4d3SLarry Finger } 334f1d2b4d3SLarry Finger } else { 335f1d2b4d3SLarry Finger switch (e_aci) { 336f1d2b4d3SLarry Finger case AC0_BE: 337ff970453SLarry Finger acm_ctrl &= (~ACMHW_BEQEN); 338f1d2b4d3SLarry Finger break; 339f1d2b4d3SLarry Finger case AC2_VI: 340ff970453SLarry Finger acm_ctrl &= (~ACMHW_VIQEN); 341f1d2b4d3SLarry Finger break; 342f1d2b4d3SLarry Finger case AC3_VO: 343ff970453SLarry Finger acm_ctrl &= (~ACMHW_VOQEN); 344f1d2b4d3SLarry Finger break; 345f1d2b4d3SLarry Finger default: 346e40a0056SLarry Finger pr_err("switch case %#x not processed\n", 347ad574889SJoe Perches e_aci); 348f1d2b4d3SLarry Finger break; 349f1d2b4d3SLarry Finger } 350f1d2b4d3SLarry Finger } 351f1d2b4d3SLarry Finger 352de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_QOS, DBG_TRACE, 353f1d2b4d3SLarry Finger "SetHwReg8190pci(): [HW_VAR_ACM_CTRL] Write 0x%X\n", 354f1d2b4d3SLarry Finger acm_ctrl); 355f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_ACMHWCTRL, acm_ctrl); 356f1d2b4d3SLarry Finger break; 357f1d2b4d3SLarry Finger } 358f1d2b4d3SLarry Finger case HW_VAR_RCR:{ 359f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RCR, ((u32 *) (val))[0]); 360f1d2b4d3SLarry Finger rtlpci->receive_config = ((u32 *) (val))[0]; 361f1d2b4d3SLarry Finger break; 362f1d2b4d3SLarry Finger } 363f1d2b4d3SLarry Finger case HW_VAR_RETRY_LIMIT:{ 364f1d2b4d3SLarry Finger u8 retry_limit = val[0]; 365f1d2b4d3SLarry Finger 366f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_RL, 367f1d2b4d3SLarry Finger retry_limit << RETRY_LIMIT_SHORT_SHIFT | 368f1d2b4d3SLarry Finger retry_limit << RETRY_LIMIT_LONG_SHIFT); 369f1d2b4d3SLarry Finger break; 370f1d2b4d3SLarry Finger } 371f1d2b4d3SLarry Finger case HW_VAR_DUAL_TSF_RST: 372f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_DUAL_TSF_RST, (BIT(0) | BIT(1))); 373f1d2b4d3SLarry Finger break; 374f1d2b4d3SLarry Finger case HW_VAR_EFUSE_BYTES: 375f1d2b4d3SLarry Finger rtlefuse->efuse_usedbytes = *((u16 *) val); 376f1d2b4d3SLarry Finger break; 377f1d2b4d3SLarry Finger case HW_VAR_EFUSE_USAGE: 378f1d2b4d3SLarry Finger rtlefuse->efuse_usedpercentage = *val; 379f1d2b4d3SLarry Finger break; 380f1d2b4d3SLarry Finger case HW_VAR_IO_CMD: 381f1d2b4d3SLarry Finger rtl92c_phy_set_io_cmd(hw, (*(enum io_type *)val)); 382f1d2b4d3SLarry Finger break; 383f1d2b4d3SLarry Finger case HW_VAR_WPA_CONFIG: 384f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SECCFG, *val); 385f1d2b4d3SLarry Finger break; 386f1d2b4d3SLarry Finger case HW_VAR_SET_RPWM:{ 387f1d2b4d3SLarry Finger u8 rpwm_val; 388f1d2b4d3SLarry Finger 389f1d2b4d3SLarry Finger rpwm_val = rtl_read_byte(rtlpriv, REG_PCIE_HRPWM); 390f1d2b4d3SLarry Finger udelay(1); 391f1d2b4d3SLarry Finger 392f1d2b4d3SLarry Finger if (rpwm_val & BIT(7)) { 393f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_PCIE_HRPWM, *val); 394f1d2b4d3SLarry Finger } else { 395f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_PCIE_HRPWM, 396f1d2b4d3SLarry Finger *val | BIT(7)); 397f1d2b4d3SLarry Finger } 398f1d2b4d3SLarry Finger 399f1d2b4d3SLarry Finger break; 400f1d2b4d3SLarry Finger } 401f1d2b4d3SLarry Finger case HW_VAR_H2C_FW_PWRMODE:{ 402f1d2b4d3SLarry Finger u8 psmode = *val; 403f1d2b4d3SLarry Finger 404f1d2b4d3SLarry Finger if ((psmode != FW_PS_ACTIVE_MODE) && 405f1d2b4d3SLarry Finger (!IS_92C_SERIAL(rtlhal->version))) { 406f1d2b4d3SLarry Finger rtl92c_dm_rf_saving(hw, true); 407f1d2b4d3SLarry Finger } 408f1d2b4d3SLarry Finger 409f1d2b4d3SLarry Finger rtl92c_set_fw_pwrmode_cmd(hw, *val); 410f1d2b4d3SLarry Finger break; 411f1d2b4d3SLarry Finger } 412f1d2b4d3SLarry Finger case HW_VAR_FW_PSMODE_STATUS: 413f1d2b4d3SLarry Finger ppsc->fw_current_inpsmode = *((bool *) val); 414f1d2b4d3SLarry Finger break; 415f1d2b4d3SLarry Finger case HW_VAR_H2C_FW_JOINBSSRPT:{ 416f1d2b4d3SLarry Finger u8 mstatus = *val; 417f1d2b4d3SLarry Finger u8 tmp_regcr, tmp_reg422; 418f1d2b4d3SLarry Finger bool recover = false; 419f1d2b4d3SLarry Finger 420f1d2b4d3SLarry Finger if (mstatus == RT_MEDIA_CONNECT) { 421f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_AID, 422f1d2b4d3SLarry Finger NULL); 423f1d2b4d3SLarry Finger 424f1d2b4d3SLarry Finger tmp_regcr = rtl_read_byte(rtlpriv, REG_CR + 1); 425f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_CR + 1, 426f1d2b4d3SLarry Finger (tmp_regcr | BIT(0))); 427f1d2b4d3SLarry Finger 428f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, 0, BIT(3)); 429f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, BIT(4), 0); 430f1d2b4d3SLarry Finger 431f1d2b4d3SLarry Finger tmp_reg422 = 432f1d2b4d3SLarry Finger rtl_read_byte(rtlpriv, 433f1d2b4d3SLarry Finger REG_FWHW_TXQ_CTRL + 2); 434f1d2b4d3SLarry Finger if (tmp_reg422 & BIT(6)) 435f1d2b4d3SLarry Finger recover = true; 436f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, 437f1d2b4d3SLarry Finger tmp_reg422 & (~BIT(6))); 438f1d2b4d3SLarry Finger 439f1d2b4d3SLarry Finger rtl92c_set_fw_rsvdpagepkt(hw, NULL); 440f1d2b4d3SLarry Finger 441f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, BIT(3), 0); 442f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, 0, BIT(4)); 443f1d2b4d3SLarry Finger 444f1d2b4d3SLarry Finger if (recover) { 445f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 446f1d2b4d3SLarry Finger REG_FWHW_TXQ_CTRL + 2, 447f1d2b4d3SLarry Finger tmp_reg422); 448f1d2b4d3SLarry Finger } 449f1d2b4d3SLarry Finger 450f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_CR + 1, 451f1d2b4d3SLarry Finger (tmp_regcr & ~(BIT(0)))); 452f1d2b4d3SLarry Finger } 453f1d2b4d3SLarry Finger rtl92c_set_fw_joinbss_report_cmd(hw, *val); 454f1d2b4d3SLarry Finger 455f1d2b4d3SLarry Finger break; 456f1d2b4d3SLarry Finger } 457f1d2b4d3SLarry Finger case HW_VAR_H2C_FW_P2P_PS_OFFLOAD: 458f1d2b4d3SLarry Finger rtl92c_set_p2p_ps_offload_cmd(hw, *val); 459f1d2b4d3SLarry Finger break; 460f1d2b4d3SLarry Finger case HW_VAR_AID:{ 461f1d2b4d3SLarry Finger u16 u2btmp; 4622973af74SLarry Finger 463f1d2b4d3SLarry Finger u2btmp = rtl_read_word(rtlpriv, REG_BCN_PSR_RPT); 464f1d2b4d3SLarry Finger u2btmp &= 0xC000; 465f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_BCN_PSR_RPT, (u2btmp | 466f1d2b4d3SLarry Finger mac->assoc_id)); 467f1d2b4d3SLarry Finger 468f1d2b4d3SLarry Finger break; 469f1d2b4d3SLarry Finger } 470f1d2b4d3SLarry Finger case HW_VAR_CORRECT_TSF:{ 471f1d2b4d3SLarry Finger u8 btype_ibss = val[0]; 472f1d2b4d3SLarry Finger 473f1d2b4d3SLarry Finger if (btype_ibss) 474f1d2b4d3SLarry Finger _rtl92ce_stop_tx_beacon(hw); 475f1d2b4d3SLarry Finger 476f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, 0, BIT(3)); 477f1d2b4d3SLarry Finger 478f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_TSFTR, 479f1d2b4d3SLarry Finger (u32) (mac->tsf & 0xffffffff)); 480f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_TSFTR + 4, 481f1d2b4d3SLarry Finger (u32) ((mac->tsf >> 32) & 0xffffffff)); 482f1d2b4d3SLarry Finger 483f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, BIT(3), 0); 484f1d2b4d3SLarry Finger 485f1d2b4d3SLarry Finger if (btype_ibss) 486f1d2b4d3SLarry Finger _rtl92ce_resume_tx_beacon(hw); 487f1d2b4d3SLarry Finger 488f1d2b4d3SLarry Finger break; 489f1d2b4d3SLarry Finger 490f1d2b4d3SLarry Finger } 491f1d2b4d3SLarry Finger case HW_VAR_FW_LPS_ACTION: { 492f1d2b4d3SLarry Finger bool enter_fwlps = *((bool *)val); 493f1d2b4d3SLarry Finger u8 rpwm_val, fw_pwrmode; 494f1d2b4d3SLarry Finger bool fw_current_inps; 495f1d2b4d3SLarry Finger 496f1d2b4d3SLarry Finger if (enter_fwlps) { 497f1d2b4d3SLarry Finger rpwm_val = 0x02; /* RF off */ 498f1d2b4d3SLarry Finger fw_current_inps = true; 499f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 500f1d2b4d3SLarry Finger HW_VAR_FW_PSMODE_STATUS, 501f1d2b4d3SLarry Finger (u8 *)(&fw_current_inps)); 502f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 503f1d2b4d3SLarry Finger HW_VAR_H2C_FW_PWRMODE, 504f1d2b4d3SLarry Finger &ppsc->fwctrl_psmode); 505f1d2b4d3SLarry Finger 506f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 507f1d2b4d3SLarry Finger HW_VAR_SET_RPWM, 508f1d2b4d3SLarry Finger &rpwm_val); 509f1d2b4d3SLarry Finger } else { 510f1d2b4d3SLarry Finger rpwm_val = 0x0C; /* RF on */ 511f1d2b4d3SLarry Finger fw_pwrmode = FW_PS_ACTIVE_MODE; 512f1d2b4d3SLarry Finger fw_current_inps = false; 513f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 514f1d2b4d3SLarry Finger HW_VAR_SET_RPWM, 515f1d2b4d3SLarry Finger &rpwm_val); 516f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 517f1d2b4d3SLarry Finger HW_VAR_H2C_FW_PWRMODE, 518f1d2b4d3SLarry Finger &fw_pwrmode); 519f1d2b4d3SLarry Finger 520f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 521f1d2b4d3SLarry Finger HW_VAR_FW_PSMODE_STATUS, 522f1d2b4d3SLarry Finger (u8 *)(&fw_current_inps)); 523f1d2b4d3SLarry Finger } 524f1d2b4d3SLarry Finger break; } 525f1d2b4d3SLarry Finger case HW_VAR_KEEP_ALIVE: { 526f1d2b4d3SLarry Finger u8 array[2]; 527f1d2b4d3SLarry Finger 528f1d2b4d3SLarry Finger array[0] = 0xff; 529f1d2b4d3SLarry Finger array[1] = *((u8 *)val); 530f1d2b4d3SLarry Finger rtl92c_fill_h2c_cmd(hw, H2C_92C_KEEP_ALIVE_CTRL, 2, array); 531f1d2b4d3SLarry Finger break; } 532f1d2b4d3SLarry Finger default: 533e40a0056SLarry Finger pr_err("switch case %d not processed\n", variable); 534f1d2b4d3SLarry Finger break; 535f1d2b4d3SLarry Finger } 536f1d2b4d3SLarry Finger } 537f1d2b4d3SLarry Finger 538f1d2b4d3SLarry Finger static bool _rtl92ce_llt_write(struct ieee80211_hw *hw, u32 address, u32 data) 539f1d2b4d3SLarry Finger { 540f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 541f1d2b4d3SLarry Finger bool status = true; 542f1d2b4d3SLarry Finger long count = 0; 543f1d2b4d3SLarry Finger u32 value = _LLT_INIT_ADDR(address) | 544f1d2b4d3SLarry Finger _LLT_INIT_DATA(data) | _LLT_OP(_LLT_WRITE_ACCESS); 545f1d2b4d3SLarry Finger 546f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_LLT_INIT, value); 547f1d2b4d3SLarry Finger 548f1d2b4d3SLarry Finger do { 549f1d2b4d3SLarry Finger value = rtl_read_dword(rtlpriv, REG_LLT_INIT); 550f1d2b4d3SLarry Finger if (_LLT_NO_ACTIVE == _LLT_OP_VALUE(value)) 551f1d2b4d3SLarry Finger break; 552f1d2b4d3SLarry Finger 553f1d2b4d3SLarry Finger if (count > POLLING_LLT_THRESHOLD) { 554e40a0056SLarry Finger pr_err("Failed to polling write LLT done at address %d!\n", 555f1d2b4d3SLarry Finger address); 556f1d2b4d3SLarry Finger status = false; 557f1d2b4d3SLarry Finger break; 558f1d2b4d3SLarry Finger } 559f1d2b4d3SLarry Finger } while (++count); 560f1d2b4d3SLarry Finger 561f1d2b4d3SLarry Finger return status; 562f1d2b4d3SLarry Finger } 563f1d2b4d3SLarry Finger 564f1d2b4d3SLarry Finger static bool _rtl92ce_llt_table_init(struct ieee80211_hw *hw) 565f1d2b4d3SLarry Finger { 566f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 567f1d2b4d3SLarry Finger unsigned short i; 568f1d2b4d3SLarry Finger u8 txpktbuf_bndy; 569ff970453SLarry Finger u8 maxpage; 570f1d2b4d3SLarry Finger bool status; 571f1d2b4d3SLarry Finger 572f1d2b4d3SLarry Finger #if LLT_CONFIG == 1 573ff970453SLarry Finger maxpage = 255; 574f1d2b4d3SLarry Finger txpktbuf_bndy = 252; 575f1d2b4d3SLarry Finger #elif LLT_CONFIG == 2 576ff970453SLarry Finger maxpage = 127; 577f1d2b4d3SLarry Finger txpktbuf_bndy = 124; 578f1d2b4d3SLarry Finger #elif LLT_CONFIG == 3 579ff970453SLarry Finger maxpage = 255; 580f1d2b4d3SLarry Finger txpktbuf_bndy = 174; 581f1d2b4d3SLarry Finger #elif LLT_CONFIG == 4 582ff970453SLarry Finger maxpage = 255; 583f1d2b4d3SLarry Finger txpktbuf_bndy = 246; 584f1d2b4d3SLarry Finger #elif LLT_CONFIG == 5 585ff970453SLarry Finger maxpage = 255; 586f1d2b4d3SLarry Finger txpktbuf_bndy = 246; 587f1d2b4d3SLarry Finger #endif 588f1d2b4d3SLarry Finger 589f1d2b4d3SLarry Finger #if LLT_CONFIG == 1 590f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RQPN_NPQ, 0x1c); 591f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RQPN, 0x80a71c1c); 592f1d2b4d3SLarry Finger #elif LLT_CONFIG == 2 593f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RQPN, 0x845B1010); 594f1d2b4d3SLarry Finger #elif LLT_CONFIG == 3 595f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RQPN, 0x84838484); 596f1d2b4d3SLarry Finger #elif LLT_CONFIG == 4 597f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RQPN, 0x80bd1c1c); 598f1d2b4d3SLarry Finger #elif LLT_CONFIG == 5 599f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_RQPN_NPQ, 0x0000); 600f1d2b4d3SLarry Finger 601f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RQPN, 0x80b01c29); 602f1d2b4d3SLarry Finger #endif 603f1d2b4d3SLarry Finger 604f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_TRXFF_BNDY, (0x27FF0000 | txpktbuf_bndy)); 605f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TDECTRL + 1, txpktbuf_bndy); 606f1d2b4d3SLarry Finger 607f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TXPKTBUF_BCNQ_BDNY, txpktbuf_bndy); 608f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TXPKTBUF_MGQ_BDNY, txpktbuf_bndy); 609f1d2b4d3SLarry Finger 610f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x45D, txpktbuf_bndy); 611f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_PBP, 0x11); 612f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RX_DRVINFO_SZ, 0x4); 613f1d2b4d3SLarry Finger 614f1d2b4d3SLarry Finger for (i = 0; i < (txpktbuf_bndy - 1); i++) { 615f1d2b4d3SLarry Finger status = _rtl92ce_llt_write(hw, i, i + 1); 616d544707aSZheng Bin if (!status) 617f1d2b4d3SLarry Finger return status; 618f1d2b4d3SLarry Finger } 619f1d2b4d3SLarry Finger 620f1d2b4d3SLarry Finger status = _rtl92ce_llt_write(hw, (txpktbuf_bndy - 1), 0xFF); 621d544707aSZheng Bin if (!status) 622f1d2b4d3SLarry Finger return status; 623f1d2b4d3SLarry Finger 624ff970453SLarry Finger for (i = txpktbuf_bndy; i < maxpage; i++) { 625f1d2b4d3SLarry Finger status = _rtl92ce_llt_write(hw, i, (i + 1)); 626d544707aSZheng Bin if (!status) 627f1d2b4d3SLarry Finger return status; 628f1d2b4d3SLarry Finger } 629f1d2b4d3SLarry Finger 630ff970453SLarry Finger status = _rtl92ce_llt_write(hw, maxpage, txpktbuf_bndy); 631d544707aSZheng Bin if (!status) 632f1d2b4d3SLarry Finger return status; 633f1d2b4d3SLarry Finger 634f1d2b4d3SLarry Finger return true; 635f1d2b4d3SLarry Finger } 636f1d2b4d3SLarry Finger 637f1d2b4d3SLarry Finger static void _rtl92ce_gen_refresh_led_state(struct ieee80211_hw *hw) 638f1d2b4d3SLarry Finger { 639d5efe153SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 640f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 641f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 642d5efe153SLarry Finger struct rtl_led *pled0 = &rtlpriv->ledctl.sw_led0; 643f1d2b4d3SLarry Finger 644f1d2b4d3SLarry Finger if (rtlpci->up_first_time) 645f1d2b4d3SLarry Finger return; 646f1d2b4d3SLarry Finger 647f1d2b4d3SLarry Finger if (ppsc->rfoff_reason == RF_CHANGE_BY_IPS) 648d5efe153SLarry Finger rtl92ce_sw_led_on(hw, pled0); 649f1d2b4d3SLarry Finger else if (ppsc->rfoff_reason == RF_CHANGE_BY_INIT) 650d5efe153SLarry Finger rtl92ce_sw_led_on(hw, pled0); 651f1d2b4d3SLarry Finger else 652d5efe153SLarry Finger rtl92ce_sw_led_off(hw, pled0); 653f1d2b4d3SLarry Finger } 654f1d2b4d3SLarry Finger 655f1d2b4d3SLarry Finger static bool _rtl92ce_init_mac(struct ieee80211_hw *hw) 656f1d2b4d3SLarry Finger { 657f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 658f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 659f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 660f1d2b4d3SLarry Finger 661f1d2b4d3SLarry Finger unsigned char bytetmp; 662f1d2b4d3SLarry Finger unsigned short wordtmp; 663f1d2b4d3SLarry Finger u16 retry; 664f1d2b4d3SLarry Finger 665f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RSV_CTRL, 0x00); 666d5efe153SLarry Finger if (rtlpriv->btcoexist.bt_coexistence) { 667f1d2b4d3SLarry Finger u32 value32; 6682973af74SLarry Finger 669f1d2b4d3SLarry Finger value32 = rtl_read_dword(rtlpriv, REG_APS_FSMCO); 670f1d2b4d3SLarry Finger value32 |= (SOP_ABG | SOP_AMB | XOP_BTCK); 671f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_APS_FSMCO, value32); 672f1d2b4d3SLarry Finger } 673f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SPS0_CTRL, 0x2b); 674f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_AFE_XTAL_CTRL, 0x0F); 675f1d2b4d3SLarry Finger 676d5efe153SLarry Finger if (rtlpriv->btcoexist.bt_coexistence) { 677f1d2b4d3SLarry Finger u32 u4b_tmp = rtl_read_dword(rtlpriv, REG_AFE_XTAL_CTRL); 678f1d2b4d3SLarry Finger 679f1d2b4d3SLarry Finger u4b_tmp &= (~0x00024800); 680f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_AFE_XTAL_CTRL, u4b_tmp); 681f1d2b4d3SLarry Finger } 682f1d2b4d3SLarry Finger 683f1d2b4d3SLarry Finger bytetmp = rtl_read_byte(rtlpriv, REG_APS_FSMCO + 1) | BIT(0); 684f1d2b4d3SLarry Finger udelay(2); 685f1d2b4d3SLarry Finger 686f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_APS_FSMCO + 1, bytetmp); 687f1d2b4d3SLarry Finger udelay(2); 688f1d2b4d3SLarry Finger 689f1d2b4d3SLarry Finger bytetmp = rtl_read_byte(rtlpriv, REG_APS_FSMCO + 1); 690f1d2b4d3SLarry Finger udelay(2); 691f1d2b4d3SLarry Finger 692f1d2b4d3SLarry Finger retry = 0; 693de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "reg0xec:%x:%x\n", 694f1d2b4d3SLarry Finger rtl_read_dword(rtlpriv, 0xEC), bytetmp); 695f1d2b4d3SLarry Finger 696f1d2b4d3SLarry Finger while ((bytetmp & BIT(0)) && retry < 1000) { 697f1d2b4d3SLarry Finger retry++; 698f1d2b4d3SLarry Finger udelay(50); 699f1d2b4d3SLarry Finger bytetmp = rtl_read_byte(rtlpriv, REG_APS_FSMCO + 1); 700de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "reg0xec:%x:%x\n", 701f1d2b4d3SLarry Finger rtl_read_dword(rtlpriv, 0xEC), bytetmp); 702f1d2b4d3SLarry Finger udelay(50); 703f1d2b4d3SLarry Finger } 704f1d2b4d3SLarry Finger 705f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_APS_FSMCO, 0x1012); 706f1d2b4d3SLarry Finger 707f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SYS_ISO_CTRL + 1, 0x82); 708f1d2b4d3SLarry Finger udelay(2); 709f1d2b4d3SLarry Finger 710d5efe153SLarry Finger if (rtlpriv->btcoexist.bt_coexistence) { 711f1d2b4d3SLarry Finger bytetmp = rtl_read_byte(rtlpriv, REG_AFE_XTAL_CTRL+2) & 0xfd; 712f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_AFE_XTAL_CTRL+2, bytetmp); 713f1d2b4d3SLarry Finger } 714f1d2b4d3SLarry Finger 715f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_CR, 0x2ff); 716f1d2b4d3SLarry Finger 717f1d2b4d3SLarry Finger if (!_rtl92ce_llt_table_init(hw)) 718f1d2b4d3SLarry Finger return false; 719f1d2b4d3SLarry Finger 720f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_HISR, 0xffffffff); 721f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_HISRE, 0xff); 722f1d2b4d3SLarry Finger 723f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_TRXFF_BNDY + 2, 0x27ff); 724f1d2b4d3SLarry Finger 725f1d2b4d3SLarry Finger wordtmp = rtl_read_word(rtlpriv, REG_TRXDMA_CTRL); 726f1d2b4d3SLarry Finger wordtmp &= 0xf; 727f1d2b4d3SLarry Finger wordtmp |= 0xF771; 728f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_TRXDMA_CTRL, wordtmp); 729f1d2b4d3SLarry Finger 730f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 1, 0x1F); 731f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RCR, rtlpci->receive_config); 732f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_TCR, rtlpci->transmit_config); 733f1d2b4d3SLarry Finger 734f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x4d0, 0x0); 735f1d2b4d3SLarry Finger 736f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_BCNQ_DESA, 737f1d2b4d3SLarry Finger ((u64) rtlpci->tx_ring[BEACON_QUEUE].dma) & 738f1d2b4d3SLarry Finger DMA_BIT_MASK(32)); 739f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_MGQ_DESA, 740f1d2b4d3SLarry Finger (u64) rtlpci->tx_ring[MGNT_QUEUE].dma & 741f1d2b4d3SLarry Finger DMA_BIT_MASK(32)); 742f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_VOQ_DESA, 743f1d2b4d3SLarry Finger (u64) rtlpci->tx_ring[VO_QUEUE].dma & DMA_BIT_MASK(32)); 744f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_VIQ_DESA, 745f1d2b4d3SLarry Finger (u64) rtlpci->tx_ring[VI_QUEUE].dma & DMA_BIT_MASK(32)); 746f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_BEQ_DESA, 747f1d2b4d3SLarry Finger (u64) rtlpci->tx_ring[BE_QUEUE].dma & DMA_BIT_MASK(32)); 748f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_BKQ_DESA, 749f1d2b4d3SLarry Finger (u64) rtlpci->tx_ring[BK_QUEUE].dma & DMA_BIT_MASK(32)); 750f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_HQ_DESA, 751f1d2b4d3SLarry Finger (u64) rtlpci->tx_ring[HIGH_QUEUE].dma & 752f1d2b4d3SLarry Finger DMA_BIT_MASK(32)); 753f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RX_DESA, 754f1d2b4d3SLarry Finger (u64) rtlpci->rx_ring[RX_MPDU_QUEUE].dma & 755f1d2b4d3SLarry Finger DMA_BIT_MASK(32)); 756f1d2b4d3SLarry Finger 757f1d2b4d3SLarry Finger if (IS_92C_SERIAL(rtlhal->version)) 758f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 3, 0x77); 759f1d2b4d3SLarry Finger else 760f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 3, 0x22); 761f1d2b4d3SLarry Finger 762f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_INT_MIG, 0); 763f1d2b4d3SLarry Finger 764f1d2b4d3SLarry Finger bytetmp = rtl_read_byte(rtlpriv, REG_APSD_CTRL); 765f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_APSD_CTRL, bytetmp & ~BIT(6)); 766f1d2b4d3SLarry Finger do { 767f1d2b4d3SLarry Finger retry++; 768f1d2b4d3SLarry Finger bytetmp = rtl_read_byte(rtlpriv, REG_APSD_CTRL); 769f1d2b4d3SLarry Finger } while ((retry < 200) && (bytetmp & BIT(7))); 770f1d2b4d3SLarry Finger 771f1d2b4d3SLarry Finger _rtl92ce_gen_refresh_led_state(hw); 772f1d2b4d3SLarry Finger 773f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_MCUTST_1, 0x0); 774f1d2b4d3SLarry Finger 775f1d2b4d3SLarry Finger return true; 776f1d2b4d3SLarry Finger } 777f1d2b4d3SLarry Finger 778f1d2b4d3SLarry Finger static void _rtl92ce_hw_configure(struct ieee80211_hw *hw) 779f1d2b4d3SLarry Finger { 780f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 781f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 782f1d2b4d3SLarry Finger u8 reg_bw_opmode; 783f1d2b4d3SLarry Finger u32 reg_prsr; 784f1d2b4d3SLarry Finger 785f1d2b4d3SLarry Finger reg_bw_opmode = BW_OPMODE_20MHZ; 786f1d2b4d3SLarry Finger reg_prsr = RATE_ALL_CCK | RATE_ALL_OFDM_AG; 787f1d2b4d3SLarry Finger 788f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_INIRTS_RATE_SEL, 0x8); 789f1d2b4d3SLarry Finger 790f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_BWOPMODE, reg_bw_opmode); 791f1d2b4d3SLarry Finger 792f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RRSR, reg_prsr); 793f1d2b4d3SLarry Finger 794f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SLOT, 0x09); 795f1d2b4d3SLarry Finger 796f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_AMPDU_MIN_SPACE, 0x0); 797f1d2b4d3SLarry Finger 798f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_FWHW_TXQ_CTRL, 0x1F80); 799f1d2b4d3SLarry Finger 800f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_RL, 0x0707); 801f1d2b4d3SLarry Finger 802f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_BAR_MODE_CTRL, 0x02012802); 803f1d2b4d3SLarry Finger 804f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_HWSEQ_CTRL, 0xFF); 805f1d2b4d3SLarry Finger 806f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_DARFRC, 0x01000000); 807f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_DARFRC + 4, 0x07060504); 808f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RARFRC, 0x01000000); 809f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RARFRC + 4, 0x07060504); 810f1d2b4d3SLarry Finger 811d5efe153SLarry Finger if ((rtlpriv->btcoexist.bt_coexistence) && 812d5efe153SLarry Finger (rtlpriv->btcoexist.bt_coexist_type == BT_CSR_BC4)) 813f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_AGGLEN_LMT, 0x97427431); 814f1d2b4d3SLarry Finger else 815f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_AGGLEN_LMT, 0xb972a841); 816f1d2b4d3SLarry Finger 817f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_ATIMWND, 0x2); 818f1d2b4d3SLarry Finger 819f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_BCN_MAX_ERR, 0xff); 820f1d2b4d3SLarry Finger 821f1d2b4d3SLarry Finger rtlpci->reg_bcn_ctrl_val = 0x1f; 822f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_BCN_CTRL, rtlpci->reg_bcn_ctrl_val); 823f1d2b4d3SLarry Finger 824f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0xff); 825f1d2b4d3SLarry Finger 826f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0xff); 827f1d2b4d3SLarry Finger 828f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_PIFS, 0x1C); 829f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_AGGR_BREAK_TIME, 0x16); 830f1d2b4d3SLarry Finger 831d5efe153SLarry Finger if ((rtlpriv->btcoexist.bt_coexistence) && 832d5efe153SLarry Finger (rtlpriv->btcoexist.bt_coexist_type == BT_CSR_BC4)) { 833f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_NAV_PROT_LEN, 0x0020); 834f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_PROT_MODE_CTRL, 0x0402); 835f1d2b4d3SLarry Finger } else { 836f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_NAV_PROT_LEN, 0x0020); 837f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_NAV_PROT_LEN, 0x0020); 838f1d2b4d3SLarry Finger } 839f1d2b4d3SLarry Finger 840d5efe153SLarry Finger if ((rtlpriv->btcoexist.bt_coexistence) && 841d5efe153SLarry Finger (rtlpriv->btcoexist.bt_coexist_type == BT_CSR_BC4)) 842f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_FAST_EDCA_CTRL, 0x03086666); 843f1d2b4d3SLarry Finger else 844f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_FAST_EDCA_CTRL, 0x086666); 845f1d2b4d3SLarry Finger 846f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_ACKTO, 0x40); 847f1d2b4d3SLarry Finger 848f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_SPEC_SIFS, 0x1010); 849f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_MAC_SPEC_SIFS, 0x1010); 850f1d2b4d3SLarry Finger 851f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_SIFS_CTX, 0x1010); 852f1d2b4d3SLarry Finger 853f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_SIFS_TRX, 0x1010); 854f1d2b4d3SLarry Finger 855f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_MAR, 0xffffffff); 856f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_MAR + 4, 0xffffffff); 857f1d2b4d3SLarry Finger 858f1d2b4d3SLarry Finger } 859f1d2b4d3SLarry Finger 860f1d2b4d3SLarry Finger static void _rtl92ce_enable_aspm_back_door(struct ieee80211_hw *hw) 861f1d2b4d3SLarry Finger { 862f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 863f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 864f1d2b4d3SLarry Finger 865f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x34b, 0x93); 866f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, 0x350, 0x870c); 867f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x352, 0x1); 868f1d2b4d3SLarry Finger 869f1d2b4d3SLarry Finger if (ppsc->support_backdoor) 870f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x349, 0x1b); 871f1d2b4d3SLarry Finger else 872f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x349, 0x03); 873f1d2b4d3SLarry Finger 874f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, 0x350, 0x2718); 875f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x352, 0x1); 876f1d2b4d3SLarry Finger } 877f1d2b4d3SLarry Finger 878f1d2b4d3SLarry Finger void rtl92ce_enable_hw_security_config(struct ieee80211_hw *hw) 879f1d2b4d3SLarry Finger { 880f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 881f1d2b4d3SLarry Finger u8 sec_reg_value; 882f1d2b4d3SLarry Finger 883de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, 8840421dd41SColin Ian King "PairwiseEncAlgorithm = %d GroupEncAlgorithm = %d\n", 885f1d2b4d3SLarry Finger rtlpriv->sec.pairwise_enc_algorithm, 886f1d2b4d3SLarry Finger rtlpriv->sec.group_enc_algorithm); 887f1d2b4d3SLarry Finger 888f1d2b4d3SLarry Finger if (rtlpriv->cfg->mod_params->sw_crypto || rtlpriv->sec.use_sw_sec) { 889de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_SEC, DBG_DMESG, 890f1d2b4d3SLarry Finger "not open hw encryption\n"); 891f1d2b4d3SLarry Finger return; 892f1d2b4d3SLarry Finger } 893f1d2b4d3SLarry Finger 894ff970453SLarry Finger sec_reg_value = SCR_TXENCENABLE | SCR_RXDECENABLE; 895f1d2b4d3SLarry Finger 896f1d2b4d3SLarry Finger if (rtlpriv->sec.use_defaultkey) { 897ff970453SLarry Finger sec_reg_value |= SCR_TXUSEDK; 898ff970453SLarry Finger sec_reg_value |= SCR_RXUSEDK; 899f1d2b4d3SLarry Finger } 900f1d2b4d3SLarry Finger 901f1d2b4d3SLarry Finger sec_reg_value |= (SCR_RXBCUSEDK | SCR_TXBCUSEDK); 902f1d2b4d3SLarry Finger 903f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_CR + 1, 0x02); 904f1d2b4d3SLarry Finger 905de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_SEC, DBG_LOUD, 906f1d2b4d3SLarry Finger "The SECR-value %x\n", sec_reg_value); 907f1d2b4d3SLarry Finger 908f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_WPA_CONFIG, &sec_reg_value); 909f1d2b4d3SLarry Finger 910f1d2b4d3SLarry Finger } 911f1d2b4d3SLarry Finger 912f1d2b4d3SLarry Finger int rtl92ce_hw_init(struct ieee80211_hw *hw) 913f1d2b4d3SLarry Finger { 914f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 915f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 916f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 917f1d2b4d3SLarry Finger struct rtl_phy *rtlphy = &(rtlpriv->phy); 918f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 919f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 920f1d2b4d3SLarry Finger bool rtstatus = true; 921f1d2b4d3SLarry Finger bool is92c; 922f1d2b4d3SLarry Finger int err; 923f1d2b4d3SLarry Finger u8 tmp_u1b; 924f1d2b4d3SLarry Finger unsigned long flags; 925f1d2b4d3SLarry Finger 926f1d2b4d3SLarry Finger rtlpci->being_init_adapter = true; 927f1d2b4d3SLarry Finger 928f1d2b4d3SLarry Finger /* Since this function can take a very long time (up to 350 ms) 929f1d2b4d3SLarry Finger * and can be called with irqs disabled, reenable the irqs 930f1d2b4d3SLarry Finger * to let the other devices continue being serviced. 931f1d2b4d3SLarry Finger * 932f1d2b4d3SLarry Finger * It is safe doing so since our own interrupts will only be enabled 933f1d2b4d3SLarry Finger * in a subsequent step. 934f1d2b4d3SLarry Finger */ 935f1d2b4d3SLarry Finger local_save_flags(flags); 936f1d2b4d3SLarry Finger local_irq_enable(); 937f1d2b4d3SLarry Finger 938f1d2b4d3SLarry Finger rtlhal->fw_ready = false; 939f1d2b4d3SLarry Finger rtlpriv->intf_ops->disable_aspm(hw); 940f1d2b4d3SLarry Finger rtstatus = _rtl92ce_init_mac(hw); 941f1d2b4d3SLarry Finger if (!rtstatus) { 942e40a0056SLarry Finger pr_err("Init MAC failed\n"); 943f1d2b4d3SLarry Finger err = 1; 944f1d2b4d3SLarry Finger goto exit; 945f1d2b4d3SLarry Finger } 946f1d2b4d3SLarry Finger 947f1d2b4d3SLarry Finger err = rtl92c_download_fw(hw); 948f1d2b4d3SLarry Finger if (err) { 949de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING, 950f1d2b4d3SLarry Finger "Failed to download FW. Init HW without FW now..\n"); 951f1d2b4d3SLarry Finger err = 1; 952f1d2b4d3SLarry Finger goto exit; 953f1d2b4d3SLarry Finger } 954f1d2b4d3SLarry Finger 955f1d2b4d3SLarry Finger rtlhal->fw_ready = true; 956f1d2b4d3SLarry Finger rtlhal->last_hmeboxnum = 0; 957f1d2b4d3SLarry Finger rtl92c_phy_mac_config(hw); 958f1d2b4d3SLarry Finger /* because last function modify RCR, so we update 959f1d2b4d3SLarry Finger * rcr var here, or TP will unstable for receive_config 960f1d2b4d3SLarry Finger * is wrong, RX RCR_ACRC32 will cause TP unstabel & Rx 961f1d2b4d3SLarry Finger * RCR_APP_ICV will cause mac80211 unassoc for cisco 1252*/ 962f1d2b4d3SLarry Finger rtlpci->receive_config = rtl_read_dword(rtlpriv, REG_RCR); 963f1d2b4d3SLarry Finger rtlpci->receive_config &= ~(RCR_ACRC32 | RCR_AICV); 964f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_RCR, rtlpci->receive_config); 965f1d2b4d3SLarry Finger rtl92c_phy_bb_config(hw); 966f1d2b4d3SLarry Finger rtlphy->rf_mode = RF_OP_BY_SW_3WIRE; 967f1d2b4d3SLarry Finger rtl92c_phy_rf_config(hw); 968f1d2b4d3SLarry Finger if (IS_VENDOR_UMC_A_CUT(rtlhal->version) && 969f1d2b4d3SLarry Finger !IS_92C_SERIAL(rtlhal->version)) { 970f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, RF_RX_G1, MASKDWORD, 0x30255); 971f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, RF_RX_G2, MASKDWORD, 0x50a00); 972f1d2b4d3SLarry Finger } else if (IS_81XXC_VENDOR_UMC_B_CUT(rtlhal->version)) { 973f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, 0x0C, MASKDWORD, 0x894AE); 974f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, 0x0A, MASKDWORD, 0x1AF31); 975f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, RF_IPA, MASKDWORD, 0x8F425); 976f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, RF_SYN_G2, MASKDWORD, 0x4F200); 977f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, RF_RCK1, MASKDWORD, 0x44053); 978f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, RF_RCK2, MASKDWORD, 0x80201); 979f1d2b4d3SLarry Finger } 980f1d2b4d3SLarry Finger rtlphy->rfreg_chnlval[0] = rtl_get_rfreg(hw, (enum radio_path)0, 981f1d2b4d3SLarry Finger RF_CHNLBW, RFREG_OFFSET_MASK); 982f1d2b4d3SLarry Finger rtlphy->rfreg_chnlval[1] = rtl_get_rfreg(hw, (enum radio_path)1, 983f1d2b4d3SLarry Finger RF_CHNLBW, RFREG_OFFSET_MASK); 984f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RFPGA0_RFMOD, BCCKEN, 0x1); 985f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RFPGA0_RFMOD, BOFDMEN, 0x1); 986f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RFPGA0_ANALOGPARAMETER2, BIT(10), 1); 987f1d2b4d3SLarry Finger _rtl92ce_hw_configure(hw); 988f1d2b4d3SLarry Finger rtl_cam_reset_all_entry(hw); 989f1d2b4d3SLarry Finger rtl92ce_enable_hw_security_config(hw); 990f1d2b4d3SLarry Finger 991f1d2b4d3SLarry Finger ppsc->rfpwr_state = ERFON; 992f1d2b4d3SLarry Finger 993f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_ETHER_ADDR, mac->mac_addr); 994f1d2b4d3SLarry Finger _rtl92ce_enable_aspm_back_door(hw); 995f1d2b4d3SLarry Finger rtlpriv->intf_ops->enable_aspm(hw); 996f1d2b4d3SLarry Finger 997f1d2b4d3SLarry Finger rtl8192ce_bt_hw_init(hw); 998f1d2b4d3SLarry Finger 999f1d2b4d3SLarry Finger if (ppsc->rfpwr_state == ERFON) { 1000f1d2b4d3SLarry Finger rtl92c_phy_set_rfpath_switch(hw, 1); 1001f1d2b4d3SLarry Finger if (rtlphy->iqk_initialized) { 1002f1d2b4d3SLarry Finger rtl92c_phy_iq_calibrate(hw, true); 1003f1d2b4d3SLarry Finger } else { 1004f1d2b4d3SLarry Finger rtl92c_phy_iq_calibrate(hw, false); 1005f1d2b4d3SLarry Finger rtlphy->iqk_initialized = true; 1006f1d2b4d3SLarry Finger } 1007f1d2b4d3SLarry Finger 1008f1d2b4d3SLarry Finger rtl92c_dm_check_txpower_tracking(hw); 1009f1d2b4d3SLarry Finger rtl92c_phy_lc_calibrate(hw); 1010f1d2b4d3SLarry Finger } 1011f1d2b4d3SLarry Finger 1012f1d2b4d3SLarry Finger is92c = IS_92C_SERIAL(rtlhal->version); 1013f1d2b4d3SLarry Finger tmp_u1b = efuse_read_1byte(hw, 0x1FA); 1014f1d2b4d3SLarry Finger if (!(tmp_u1b & BIT(0))) { 1015f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, 0x15, 0x0F, 0x05); 1016de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE, "PA BIAS path A\n"); 1017f1d2b4d3SLarry Finger } 1018f1d2b4d3SLarry Finger 1019f1d2b4d3SLarry Finger if (!(tmp_u1b & BIT(1)) && is92c) { 1020f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_B, 0x15, 0x0F, 0x05); 1021de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE, "PA BIAS path B\n"); 1022f1d2b4d3SLarry Finger } 1023f1d2b4d3SLarry Finger 1024f1d2b4d3SLarry Finger if (!(tmp_u1b & BIT(4))) { 1025f1d2b4d3SLarry Finger tmp_u1b = rtl_read_byte(rtlpriv, 0x16); 1026f1d2b4d3SLarry Finger tmp_u1b &= 0x0F; 1027f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x16, tmp_u1b | 0x80); 1028f1d2b4d3SLarry Finger udelay(10); 1029f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x16, tmp_u1b | 0x90); 1030de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE, "under 1.5V\n"); 1031f1d2b4d3SLarry Finger } 1032f1d2b4d3SLarry Finger rtl92c_dm_init(hw); 1033f1d2b4d3SLarry Finger exit: 1034f1d2b4d3SLarry Finger local_irq_restore(flags); 1035f1d2b4d3SLarry Finger rtlpci->being_init_adapter = false; 1036f1d2b4d3SLarry Finger return err; 1037f1d2b4d3SLarry Finger } 1038f1d2b4d3SLarry Finger 1039f1d2b4d3SLarry Finger static enum version_8192c _rtl92ce_read_chip_version(struct ieee80211_hw *hw) 1040f1d2b4d3SLarry Finger { 1041f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1042f1d2b4d3SLarry Finger struct rtl_phy *rtlphy = &(rtlpriv->phy); 1043f1d2b4d3SLarry Finger enum version_8192c version = VERSION_UNKNOWN; 1044f1d2b4d3SLarry Finger u32 value32; 1045f1d2b4d3SLarry Finger const char *versionid; 1046f1d2b4d3SLarry Finger 1047f1d2b4d3SLarry Finger value32 = rtl_read_dword(rtlpriv, REG_SYS_CFG); 1048f1d2b4d3SLarry Finger if (value32 & TRP_VAUX_EN) { 1049f1d2b4d3SLarry Finger version = (value32 & TYPE_ID) ? VERSION_A_CHIP_92C : 1050f1d2b4d3SLarry Finger VERSION_A_CHIP_88C; 1051f1d2b4d3SLarry Finger } else { 1052f1d2b4d3SLarry Finger version = (enum version_8192c) (CHIP_VER_B | 1053f1d2b4d3SLarry Finger ((value32 & TYPE_ID) ? CHIP_92C_BITMASK : 0) | 1054f1d2b4d3SLarry Finger ((value32 & VENDOR_ID) ? CHIP_VENDOR_UMC : 0)); 1055f1d2b4d3SLarry Finger if ((!IS_CHIP_VENDOR_UMC(version)) && (value32 & 1056f1d2b4d3SLarry Finger CHIP_VER_RTL_MASK)) { 1057f1d2b4d3SLarry Finger version = (enum version_8192c)(version | 1058f1d2b4d3SLarry Finger ((((value32 & CHIP_VER_RTL_MASK) == BIT(12)) 1059f1d2b4d3SLarry Finger ? CHIP_VENDOR_UMC_B_CUT : CHIP_UNKNOWN) | 1060f1d2b4d3SLarry Finger CHIP_VENDOR_UMC)); 1061f1d2b4d3SLarry Finger } 1062f1d2b4d3SLarry Finger if (IS_92C_SERIAL(version)) { 1063f1d2b4d3SLarry Finger value32 = rtl_read_dword(rtlpriv, REG_HPON_FSM); 1064f1d2b4d3SLarry Finger version = (enum version_8192c)(version | 1065f1d2b4d3SLarry Finger ((CHIP_BONDING_IDENTIFIER(value32) 1066f1d2b4d3SLarry Finger == CHIP_BONDING_92C_1T2R) ? 1067f1d2b4d3SLarry Finger RF_TYPE_1T2R : 0)); 1068f1d2b4d3SLarry Finger } 1069f1d2b4d3SLarry Finger } 1070f1d2b4d3SLarry Finger 1071f1d2b4d3SLarry Finger switch (version) { 1072f1d2b4d3SLarry Finger case VERSION_B_CHIP_92C: 1073f1d2b4d3SLarry Finger versionid = "B_CHIP_92C"; 1074f1d2b4d3SLarry Finger break; 1075f1d2b4d3SLarry Finger case VERSION_B_CHIP_88C: 1076f1d2b4d3SLarry Finger versionid = "B_CHIP_88C"; 1077f1d2b4d3SLarry Finger break; 1078f1d2b4d3SLarry Finger case VERSION_A_CHIP_92C: 1079f1d2b4d3SLarry Finger versionid = "A_CHIP_92C"; 1080f1d2b4d3SLarry Finger break; 1081f1d2b4d3SLarry Finger case VERSION_A_CHIP_88C: 1082f1d2b4d3SLarry Finger versionid = "A_CHIP_88C"; 1083f1d2b4d3SLarry Finger break; 1084f1d2b4d3SLarry Finger case VERSION_NORMAL_UMC_CHIP_92C_1T2R_A_CUT: 1085f1d2b4d3SLarry Finger versionid = "A_CUT_92C_1T2R"; 1086f1d2b4d3SLarry Finger break; 1087f1d2b4d3SLarry Finger case VERSION_NORMAL_UMC_CHIP_92C_A_CUT: 1088f1d2b4d3SLarry Finger versionid = "A_CUT_92C"; 1089f1d2b4d3SLarry Finger break; 1090f1d2b4d3SLarry Finger case VERSION_NORMAL_UMC_CHIP_88C_A_CUT: 1091f1d2b4d3SLarry Finger versionid = "A_CUT_88C"; 1092f1d2b4d3SLarry Finger break; 1093f1d2b4d3SLarry Finger case VERSION_NORMAL_UMC_CHIP_92C_1T2R_B_CUT: 1094f1d2b4d3SLarry Finger versionid = "B_CUT_92C_1T2R"; 1095f1d2b4d3SLarry Finger break; 1096f1d2b4d3SLarry Finger case VERSION_NORMAL_UMC_CHIP_92C_B_CUT: 1097f1d2b4d3SLarry Finger versionid = "B_CUT_92C"; 1098f1d2b4d3SLarry Finger break; 1099f1d2b4d3SLarry Finger case VERSION_NORMAL_UMC_CHIP_88C_B_CUT: 1100f1d2b4d3SLarry Finger versionid = "B_CUT_88C"; 1101f1d2b4d3SLarry Finger break; 1102f1d2b4d3SLarry Finger default: 1103f1d2b4d3SLarry Finger versionid = "Unknown. Bug?"; 1104f1d2b4d3SLarry Finger break; 1105f1d2b4d3SLarry Finger } 1106f1d2b4d3SLarry Finger 1107e40a0056SLarry Finger pr_info("Chip Version ID: %s\n", versionid); 1108f1d2b4d3SLarry Finger 1109f1d2b4d3SLarry Finger switch (version & 0x3) { 1110f1d2b4d3SLarry Finger case CHIP_88C: 1111f1d2b4d3SLarry Finger rtlphy->rf_type = RF_1T1R; 1112f1d2b4d3SLarry Finger break; 1113f1d2b4d3SLarry Finger case CHIP_92C: 1114f1d2b4d3SLarry Finger rtlphy->rf_type = RF_2T2R; 1115f1d2b4d3SLarry Finger break; 1116f1d2b4d3SLarry Finger case CHIP_92C_1T2R: 1117f1d2b4d3SLarry Finger rtlphy->rf_type = RF_1T2R; 1118f1d2b4d3SLarry Finger break; 1119f1d2b4d3SLarry Finger default: 1120f1d2b4d3SLarry Finger rtlphy->rf_type = RF_1T1R; 1121e40a0056SLarry Finger pr_err("ERROR RF_Type is set!!\n"); 1122f1d2b4d3SLarry Finger break; 1123f1d2b4d3SLarry Finger } 1124f1d2b4d3SLarry Finger 1125de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "Chip RF Type: %s\n", 1126f1d2b4d3SLarry Finger rtlphy->rf_type == RF_2T2R ? "RF_2T2R" : "RF_1T1R"); 1127f1d2b4d3SLarry Finger 1128f1d2b4d3SLarry Finger return version; 1129f1d2b4d3SLarry Finger } 1130f1d2b4d3SLarry Finger 1131f1d2b4d3SLarry Finger static int _rtl92ce_set_media_status(struct ieee80211_hw *hw, 1132f1d2b4d3SLarry Finger enum nl80211_iftype type) 1133f1d2b4d3SLarry Finger { 1134f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1135f1d2b4d3SLarry Finger u8 bt_msr = rtl_read_byte(rtlpriv, MSR); 1136f1d2b4d3SLarry Finger enum led_ctl_mode ledaction = LED_CTL_NO_LINK; 1137f1d2b4d3SLarry Finger u8 mode = MSR_NOLINK; 1138f1d2b4d3SLarry Finger 1139f1d2b4d3SLarry Finger bt_msr &= 0xfc; 1140f1d2b4d3SLarry Finger 1141f1d2b4d3SLarry Finger switch (type) { 1142f1d2b4d3SLarry Finger case NL80211_IFTYPE_UNSPECIFIED: 1143f1d2b4d3SLarry Finger mode = MSR_NOLINK; 1144de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE, 1145f1d2b4d3SLarry Finger "Set Network type to NO LINK!\n"); 1146f1d2b4d3SLarry Finger break; 1147f1d2b4d3SLarry Finger case NL80211_IFTYPE_ADHOC: 1148f1d2b4d3SLarry Finger mode = MSR_ADHOC; 1149de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE, 1150f1d2b4d3SLarry Finger "Set Network type to Ad Hoc!\n"); 1151f1d2b4d3SLarry Finger break; 1152f1d2b4d3SLarry Finger case NL80211_IFTYPE_STATION: 1153f1d2b4d3SLarry Finger mode = MSR_INFRA; 1154f1d2b4d3SLarry Finger ledaction = LED_CTL_LINK; 1155de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE, 1156f1d2b4d3SLarry Finger "Set Network type to STA!\n"); 1157f1d2b4d3SLarry Finger break; 1158f1d2b4d3SLarry Finger case NL80211_IFTYPE_AP: 1159f1d2b4d3SLarry Finger mode = MSR_AP; 1160f1d2b4d3SLarry Finger ledaction = LED_CTL_LINK; 1161de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE, 1162f1d2b4d3SLarry Finger "Set Network type to AP!\n"); 1163f1d2b4d3SLarry Finger break; 1164f1d2b4d3SLarry Finger case NL80211_IFTYPE_MESH_POINT: 1165f1d2b4d3SLarry Finger mode = MSR_ADHOC; 1166de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE, 1167f1d2b4d3SLarry Finger "Set Network type to Mesh Point!\n"); 1168f1d2b4d3SLarry Finger break; 1169f1d2b4d3SLarry Finger default: 1170e40a0056SLarry Finger pr_err("Network type %d not supported!\n", type); 1171f1d2b4d3SLarry Finger return 1; 1172f1d2b4d3SLarry Finger 1173f1d2b4d3SLarry Finger } 1174f1d2b4d3SLarry Finger 1175f1d2b4d3SLarry Finger /* MSR_INFRA == Link in infrastructure network; 1176f1d2b4d3SLarry Finger * MSR_ADHOC == Link in ad hoc network; 1177f1d2b4d3SLarry Finger * Therefore, check link state is necessary. 1178f1d2b4d3SLarry Finger * 1179f1d2b4d3SLarry Finger * MSR_AP == AP mode; link state does not matter here. 1180f1d2b4d3SLarry Finger */ 1181f1d2b4d3SLarry Finger if (mode != MSR_AP && 1182f1d2b4d3SLarry Finger rtlpriv->mac80211.link_state < MAC80211_LINKED) { 1183f1d2b4d3SLarry Finger mode = MSR_NOLINK; 1184f1d2b4d3SLarry Finger ledaction = LED_CTL_NO_LINK; 1185f1d2b4d3SLarry Finger } 1186f1d2b4d3SLarry Finger if (mode == MSR_NOLINK || mode == MSR_INFRA) { 1187f1d2b4d3SLarry Finger _rtl92ce_stop_tx_beacon(hw); 1188f1d2b4d3SLarry Finger _rtl92ce_enable_bcn_sub_func(hw); 1189f1d2b4d3SLarry Finger } else if (mode == MSR_ADHOC || mode == MSR_AP) { 1190f1d2b4d3SLarry Finger _rtl92ce_resume_tx_beacon(hw); 1191f1d2b4d3SLarry Finger _rtl92ce_disable_bcn_sub_func(hw); 1192f1d2b4d3SLarry Finger } else { 1193de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING, 1194f1d2b4d3SLarry Finger "Set HW_VAR_MEDIA_STATUS: No such media status(%x).\n", 1195f1d2b4d3SLarry Finger mode); 1196f1d2b4d3SLarry Finger } 1197f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, MSR, bt_msr | mode); 1198f1d2b4d3SLarry Finger 1199f1d2b4d3SLarry Finger rtlpriv->cfg->ops->led_control(hw, ledaction); 1200f1d2b4d3SLarry Finger if (mode == MSR_AP) 1201f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_BCNTCFG + 1, 0x00); 1202f1d2b4d3SLarry Finger else 1203f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_BCNTCFG + 1, 0x66); 1204f1d2b4d3SLarry Finger return 0; 1205f1d2b4d3SLarry Finger } 1206f1d2b4d3SLarry Finger 1207f1d2b4d3SLarry Finger void rtl92ce_set_check_bssid(struct ieee80211_hw *hw, bool check_bssid) 1208f1d2b4d3SLarry Finger { 1209f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1210f1d2b4d3SLarry Finger u32 reg_rcr; 1211f1d2b4d3SLarry Finger 1212f1d2b4d3SLarry Finger if (rtlpriv->psc.rfpwr_state != ERFON) 1213f1d2b4d3SLarry Finger return; 1214f1d2b4d3SLarry Finger 1215f1d2b4d3SLarry Finger rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_RCR, (u8 *)(®_rcr)); 1216f1d2b4d3SLarry Finger 1217f1d2b4d3SLarry Finger if (check_bssid) { 1218f1d2b4d3SLarry Finger reg_rcr |= (RCR_CBSSID_DATA | RCR_CBSSID_BCN); 1219f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_RCR, 1220f1d2b4d3SLarry Finger (u8 *) (®_rcr)); 1221f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, 0, BIT(4)); 1222f1d2b4d3SLarry Finger } else if (!check_bssid) { 1223f1d2b4d3SLarry Finger reg_rcr &= (~(RCR_CBSSID_DATA | RCR_CBSSID_BCN)); 1224f1d2b4d3SLarry Finger _rtl92ce_set_bcn_ctrl_reg(hw, BIT(4), 0); 1225f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 1226f1d2b4d3SLarry Finger HW_VAR_RCR, (u8 *) (®_rcr)); 1227f1d2b4d3SLarry Finger } 1228f1d2b4d3SLarry Finger 1229f1d2b4d3SLarry Finger } 1230f1d2b4d3SLarry Finger 1231f1d2b4d3SLarry Finger int rtl92ce_set_network_type(struct ieee80211_hw *hw, enum nl80211_iftype type) 1232f1d2b4d3SLarry Finger { 1233f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1234f1d2b4d3SLarry Finger 1235f1d2b4d3SLarry Finger if (_rtl92ce_set_media_status(hw, type)) 1236f1d2b4d3SLarry Finger return -EOPNOTSUPP; 1237f1d2b4d3SLarry Finger 1238f1d2b4d3SLarry Finger if (rtlpriv->mac80211.link_state == MAC80211_LINKED) { 1239f1d2b4d3SLarry Finger if (type != NL80211_IFTYPE_AP && 1240f1d2b4d3SLarry Finger type != NL80211_IFTYPE_MESH_POINT) 1241f1d2b4d3SLarry Finger rtl92ce_set_check_bssid(hw, true); 1242f1d2b4d3SLarry Finger } else { 1243f1d2b4d3SLarry Finger rtl92ce_set_check_bssid(hw, false); 1244f1d2b4d3SLarry Finger } 1245f1d2b4d3SLarry Finger 1246f1d2b4d3SLarry Finger return 0; 1247f1d2b4d3SLarry Finger } 1248f1d2b4d3SLarry Finger 1249f1d2b4d3SLarry Finger /* don't set REG_EDCA_BE_PARAM here because mac80211 will send pkt when scan */ 1250f1d2b4d3SLarry Finger void rtl92ce_set_qos(struct ieee80211_hw *hw, int aci) 1251f1d2b4d3SLarry Finger { 1252f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 12532973af74SLarry Finger 1254f1d2b4d3SLarry Finger rtl92c_dm_init_edca_turbo(hw); 1255f1d2b4d3SLarry Finger switch (aci) { 1256f1d2b4d3SLarry Finger case AC1_BK: 1257f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_EDCA_BK_PARAM, 0xa44f); 1258f1d2b4d3SLarry Finger break; 1259f1d2b4d3SLarry Finger case AC0_BE: 1260f1d2b4d3SLarry Finger /* rtl_write_dword(rtlpriv, REG_EDCA_BE_PARAM, u4b_ac_param); */ 1261f1d2b4d3SLarry Finger break; 1262f1d2b4d3SLarry Finger case AC2_VI: 1263f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_EDCA_VI_PARAM, 0x5e4322); 1264f1d2b4d3SLarry Finger break; 1265f1d2b4d3SLarry Finger case AC3_VO: 1266f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_EDCA_VO_PARAM, 0x2f3222); 1267f1d2b4d3SLarry Finger break; 1268f1d2b4d3SLarry Finger default: 1269531940f9SLarry Finger WARN_ONCE(true, "rtl8192ce: invalid aci: %d !\n", aci); 1270f1d2b4d3SLarry Finger break; 1271f1d2b4d3SLarry Finger } 1272f1d2b4d3SLarry Finger } 1273f1d2b4d3SLarry Finger 1274f1d2b4d3SLarry Finger void rtl92ce_enable_interrupt(struct ieee80211_hw *hw) 1275f1d2b4d3SLarry Finger { 1276f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1277f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1278f1d2b4d3SLarry Finger 1279f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_HIMR, rtlpci->irq_mask[0] & 0xFFFFFFFF); 1280f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_HIMRE, rtlpci->irq_mask[1] & 0xFFFFFFFF); 1281f1d2b4d3SLarry Finger rtlpci->irq_enabled = true; 1282f1d2b4d3SLarry Finger } 1283f1d2b4d3SLarry Finger 1284f1d2b4d3SLarry Finger void rtl92ce_disable_interrupt(struct ieee80211_hw *hw) 1285f1d2b4d3SLarry Finger { 1286f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1287f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1288f1d2b4d3SLarry Finger 1289f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_HIMR, IMR8190_DISABLED); 1290f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_HIMRE, IMR8190_DISABLED); 1291f1d2b4d3SLarry Finger rtlpci->irq_enabled = false; 1292f1d2b4d3SLarry Finger } 1293f1d2b4d3SLarry Finger 1294f1d2b4d3SLarry Finger static void _rtl92ce_poweroff_adapter(struct ieee80211_hw *hw) 1295f1d2b4d3SLarry Finger { 1296f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1297f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtlpriv); 1298f1d2b4d3SLarry Finger u8 u1b_tmp; 1299f1d2b4d3SLarry Finger u32 u4b_tmp; 1300f1d2b4d3SLarry Finger 1301f1d2b4d3SLarry Finger rtlpriv->intf_ops->enable_aspm(hw); 1302f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_TXPAUSE, 0xFF); 1303f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, 0x00, RFREG_OFFSET_MASK, 0x00); 1304f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RF_CTRL, 0x00); 1305f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_APSD_CTRL, 0x40); 1306f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN, 0xE2); 1307f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN, 0xE0); 1308f1d2b4d3SLarry Finger if (rtl_read_byte(rtlpriv, REG_MCUFWDL) & BIT(7)) 1309f1d2b4d3SLarry Finger rtl92c_firmware_selfreset(hw); 1310f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, 0x51); 1311f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_MCUFWDL, 0x00); 1312f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_GPIO_PIN_CTRL, 0x00000000); 1313f1d2b4d3SLarry Finger u1b_tmp = rtl_read_byte(rtlpriv, REG_GPIO_PIN_CTRL); 1314d5efe153SLarry Finger if ((rtlpriv->btcoexist.bt_coexistence) && 1315d5efe153SLarry Finger ((rtlpriv->btcoexist.bt_coexist_type == BT_CSR_BC4) || 1316d5efe153SLarry Finger (rtlpriv->btcoexist.bt_coexist_type == BT_CSR_BC8))) { 1317f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_GPIO_PIN_CTRL, 0x00F30000 | 1318f1d2b4d3SLarry Finger (u1b_tmp << 8)); 1319f1d2b4d3SLarry Finger } else { 1320f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_GPIO_PIN_CTRL, 0x00FF0000 | 1321f1d2b4d3SLarry Finger (u1b_tmp << 8)); 1322f1d2b4d3SLarry Finger } 1323f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_GPIO_IO_SEL, 0x0790); 1324f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_LEDCFG0, 0x8080); 1325f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_AFE_PLL_CTRL, 0x80); 1326f1d2b4d3SLarry Finger if (!IS_81XXC_VENDOR_UMC_B_CUT(rtlhal->version)) 1327f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_SPS0_CTRL, 0x23); 1328d5efe153SLarry Finger if (rtlpriv->btcoexist.bt_coexistence) { 1329f1d2b4d3SLarry Finger u4b_tmp = rtl_read_dword(rtlpriv, REG_AFE_XTAL_CTRL); 1330f1d2b4d3SLarry Finger u4b_tmp |= 0x03824800; 1331f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_AFE_XTAL_CTRL, u4b_tmp); 1332f1d2b4d3SLarry Finger } else { 1333f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_AFE_XTAL_CTRL, 0x0e); 1334f1d2b4d3SLarry Finger } 1335f1d2b4d3SLarry Finger 1336f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RSV_CTRL, 0x0e); 1337f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_APS_FSMCO + 1, 0x10); 1338f1d2b4d3SLarry Finger } 1339f1d2b4d3SLarry Finger 1340f1d2b4d3SLarry Finger void rtl92ce_card_disable(struct ieee80211_hw *hw) 1341f1d2b4d3SLarry Finger { 1342f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1343f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 1344f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1345f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1346f1d2b4d3SLarry Finger enum nl80211_iftype opmode; 1347f1d2b4d3SLarry Finger 1348f1d2b4d3SLarry Finger mac->link_state = MAC80211_NOLINK; 1349f1d2b4d3SLarry Finger opmode = NL80211_IFTYPE_UNSPECIFIED; 1350f1d2b4d3SLarry Finger _rtl92ce_set_media_status(hw, opmode); 1351f1d2b4d3SLarry Finger if (rtlpci->driver_is_goingto_unload || 1352f1d2b4d3SLarry Finger ppsc->rfoff_reason > RF_CHANGE_BY_PS) 1353f1d2b4d3SLarry Finger rtlpriv->cfg->ops->led_control(hw, LED_CTL_POWER_OFF); 1354f1d2b4d3SLarry Finger RT_SET_PS_LEVEL(ppsc, RT_RF_OFF_LEVL_HALT_NIC); 1355f1d2b4d3SLarry Finger _rtl92ce_poweroff_adapter(hw); 1356f1d2b4d3SLarry Finger 1357f1d2b4d3SLarry Finger /* after power off we should do iqk again */ 1358f1d2b4d3SLarry Finger rtlpriv->phy.iqk_initialized = false; 1359f1d2b4d3SLarry Finger } 1360f1d2b4d3SLarry Finger 1361f1d2b4d3SLarry Finger void rtl92ce_interrupt_recognized(struct ieee80211_hw *hw, 136278aa6012SLarry Finger struct rtl_int *intvec) 1363f1d2b4d3SLarry Finger { 1364f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1365f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1366f1d2b4d3SLarry Finger 136778aa6012SLarry Finger intvec->inta = rtl_read_dword(rtlpriv, ISR) & rtlpci->irq_mask[0]; 136878aa6012SLarry Finger rtl_write_dword(rtlpriv, ISR, intvec->inta); 1369f1d2b4d3SLarry Finger } 1370f1d2b4d3SLarry Finger 1371f1d2b4d3SLarry Finger void rtl92ce_set_beacon_related_registers(struct ieee80211_hw *hw) 1372f1d2b4d3SLarry Finger { 1373f1d2b4d3SLarry Finger 1374f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1375f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1376f1d2b4d3SLarry Finger u16 bcn_interval, atim_window; 1377f1d2b4d3SLarry Finger 1378f1d2b4d3SLarry Finger bcn_interval = mac->beacon_interval; 1379f1d2b4d3SLarry Finger atim_window = 2; /*FIX MERGE */ 1380f1d2b4d3SLarry Finger rtl92ce_disable_interrupt(hw); 1381f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_ATIMWND, atim_window); 1382f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_BCN_INTERVAL, bcn_interval); 1383f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_BCNTCFG, 0x660f); 1384f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RXTSF_OFFSET_CCK, 0x18); 1385f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_RXTSF_OFFSET_OFDM, 0x18); 1386f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x606, 0x30); 1387f1d2b4d3SLarry Finger rtl92ce_enable_interrupt(hw); 1388f1d2b4d3SLarry Finger } 1389f1d2b4d3SLarry Finger 1390f1d2b4d3SLarry Finger void rtl92ce_set_beacon_interval(struct ieee80211_hw *hw) 1391f1d2b4d3SLarry Finger { 1392f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1393f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1394f1d2b4d3SLarry Finger u16 bcn_interval = mac->beacon_interval; 1395f1d2b4d3SLarry Finger 1396de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_BEACON, DBG_DMESG, 1397f1d2b4d3SLarry Finger "beacon_interval:%d\n", bcn_interval); 1398f1d2b4d3SLarry Finger rtl92ce_disable_interrupt(hw); 1399f1d2b4d3SLarry Finger rtl_write_word(rtlpriv, REG_BCN_INTERVAL, bcn_interval); 1400f1d2b4d3SLarry Finger rtl92ce_enable_interrupt(hw); 1401f1d2b4d3SLarry Finger } 1402f1d2b4d3SLarry Finger 1403f1d2b4d3SLarry Finger void rtl92ce_update_interrupt_mask(struct ieee80211_hw *hw, 1404f1d2b4d3SLarry Finger u32 add_msr, u32 rm_msr) 1405f1d2b4d3SLarry Finger { 1406f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1407f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1408f1d2b4d3SLarry Finger 1409de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INTR, DBG_LOUD, "add_msr:%x, rm_msr:%x\n", 1410f1d2b4d3SLarry Finger add_msr, rm_msr); 1411f1d2b4d3SLarry Finger 1412f1d2b4d3SLarry Finger if (add_msr) 1413f1d2b4d3SLarry Finger rtlpci->irq_mask[0] |= add_msr; 1414f1d2b4d3SLarry Finger if (rm_msr) 1415f1d2b4d3SLarry Finger rtlpci->irq_mask[0] &= (~rm_msr); 1416f1d2b4d3SLarry Finger rtl92ce_disable_interrupt(hw); 1417f1d2b4d3SLarry Finger rtl92ce_enable_interrupt(hw); 1418f1d2b4d3SLarry Finger } 1419f1d2b4d3SLarry Finger 1420f1d2b4d3SLarry Finger static void _rtl92ce_read_txpower_info_from_hwpg(struct ieee80211_hw *hw, 1421f1d2b4d3SLarry Finger bool autoload_fail, 1422f1d2b4d3SLarry Finger u8 *hwinfo) 1423f1d2b4d3SLarry Finger { 1424f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1425f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1426f1d2b4d3SLarry Finger u8 rf_path, index, tempval; 1427f1d2b4d3SLarry Finger u16 i; 1428f1d2b4d3SLarry Finger 1429f1d2b4d3SLarry Finger for (rf_path = 0; rf_path < 2; rf_path++) { 1430f1d2b4d3SLarry Finger for (i = 0; i < 3; i++) { 1431f1d2b4d3SLarry Finger if (!autoload_fail) { 1432f1d2b4d3SLarry Finger rtlefuse-> 1433f1d2b4d3SLarry Finger eeprom_chnlarea_txpwr_cck[rf_path][i] = 1434f1d2b4d3SLarry Finger hwinfo[EEPROM_TXPOWERCCK + rf_path * 3 + i]; 1435f1d2b4d3SLarry Finger rtlefuse-> 1436f1d2b4d3SLarry Finger eeprom_chnlarea_txpwr_ht40_1s[rf_path][i] = 1437f1d2b4d3SLarry Finger hwinfo[EEPROM_TXPOWERHT40_1S + rf_path * 3 + 1438f1d2b4d3SLarry Finger i]; 1439f1d2b4d3SLarry Finger } else { 1440f1d2b4d3SLarry Finger rtlefuse-> 1441f1d2b4d3SLarry Finger eeprom_chnlarea_txpwr_cck[rf_path][i] = 1442f1d2b4d3SLarry Finger EEPROM_DEFAULT_TXPOWERLEVEL; 1443f1d2b4d3SLarry Finger rtlefuse-> 1444f1d2b4d3SLarry Finger eeprom_chnlarea_txpwr_ht40_1s[rf_path][i] = 1445f1d2b4d3SLarry Finger EEPROM_DEFAULT_TXPOWERLEVEL; 1446f1d2b4d3SLarry Finger } 1447f1d2b4d3SLarry Finger } 1448f1d2b4d3SLarry Finger } 1449f1d2b4d3SLarry Finger 1450f1d2b4d3SLarry Finger for (i = 0; i < 3; i++) { 1451f1d2b4d3SLarry Finger if (!autoload_fail) 1452f1d2b4d3SLarry Finger tempval = hwinfo[EEPROM_TXPOWERHT40_2SDIFF + i]; 1453f1d2b4d3SLarry Finger else 1454f1d2b4d3SLarry Finger tempval = EEPROM_DEFAULT_HT40_2SDIFF; 1455f1d2b4d3SLarry Finger rtlefuse->eprom_chnl_txpwr_ht40_2sdf[RF90_PATH_A][i] = 1456f1d2b4d3SLarry Finger (tempval & 0xf); 1457f1d2b4d3SLarry Finger rtlefuse->eprom_chnl_txpwr_ht40_2sdf[RF90_PATH_B][i] = 1458f1d2b4d3SLarry Finger ((tempval & 0xf0) >> 4); 1459f1d2b4d3SLarry Finger } 1460f1d2b4d3SLarry Finger 1461f1d2b4d3SLarry Finger for (rf_path = 0; rf_path < 2; rf_path++) 1462f1d2b4d3SLarry Finger for (i = 0; i < 3; i++) 1463f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_EEPROM, 1464f1d2b4d3SLarry Finger "RF(%d) EEPROM CCK Area(%d) = 0x%x\n", 1465f1d2b4d3SLarry Finger rf_path, i, 1466f1d2b4d3SLarry Finger rtlefuse-> 1467f1d2b4d3SLarry Finger eeprom_chnlarea_txpwr_cck[rf_path][i]); 1468f1d2b4d3SLarry Finger for (rf_path = 0; rf_path < 2; rf_path++) 1469f1d2b4d3SLarry Finger for (i = 0; i < 3; i++) 1470f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_EEPROM, 1471f1d2b4d3SLarry Finger "RF(%d) EEPROM HT40 1S Area(%d) = 0x%x\n", 1472f1d2b4d3SLarry Finger rf_path, i, 1473f1d2b4d3SLarry Finger rtlefuse-> 1474f1d2b4d3SLarry Finger eeprom_chnlarea_txpwr_ht40_1s[rf_path][i]); 1475f1d2b4d3SLarry Finger for (rf_path = 0; rf_path < 2; rf_path++) 1476f1d2b4d3SLarry Finger for (i = 0; i < 3; i++) 1477f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_EEPROM, 1478f1d2b4d3SLarry Finger "RF(%d) EEPROM HT40 2S Diff Area(%d) = 0x%x\n", 1479f1d2b4d3SLarry Finger rf_path, i, 1480f1d2b4d3SLarry Finger rtlefuse-> 1481f1d2b4d3SLarry Finger eprom_chnl_txpwr_ht40_2sdf[rf_path][i]); 1482f1d2b4d3SLarry Finger 1483f1d2b4d3SLarry Finger for (rf_path = 0; rf_path < 2; rf_path++) { 1484f1d2b4d3SLarry Finger for (i = 0; i < 14; i++) { 1485f1d2b4d3SLarry Finger index = rtl92c_get_chnl_group((u8)i); 1486f1d2b4d3SLarry Finger 1487f1d2b4d3SLarry Finger rtlefuse->txpwrlevel_cck[rf_path][i] = 1488f1d2b4d3SLarry Finger rtlefuse->eeprom_chnlarea_txpwr_cck[rf_path][index]; 1489f1d2b4d3SLarry Finger rtlefuse->txpwrlevel_ht40_1s[rf_path][i] = 1490f1d2b4d3SLarry Finger rtlefuse-> 1491f1d2b4d3SLarry Finger eeprom_chnlarea_txpwr_ht40_1s[rf_path][index]; 1492f1d2b4d3SLarry Finger 1493f1d2b4d3SLarry Finger if ((rtlefuse-> 1494f1d2b4d3SLarry Finger eeprom_chnlarea_txpwr_ht40_1s[rf_path][index] - 1495f1d2b4d3SLarry Finger rtlefuse-> 1496f1d2b4d3SLarry Finger eprom_chnl_txpwr_ht40_2sdf[rf_path][index]) 1497f1d2b4d3SLarry Finger > 0) { 1498f1d2b4d3SLarry Finger rtlefuse->txpwrlevel_ht40_2s[rf_path][i] = 1499f1d2b4d3SLarry Finger rtlefuse-> 1500f1d2b4d3SLarry Finger eeprom_chnlarea_txpwr_ht40_1s[rf_path] 1501f1d2b4d3SLarry Finger [index] - 1502f1d2b4d3SLarry Finger rtlefuse-> 1503f1d2b4d3SLarry Finger eprom_chnl_txpwr_ht40_2sdf[rf_path] 1504f1d2b4d3SLarry Finger [index]; 1505f1d2b4d3SLarry Finger } else { 1506f1d2b4d3SLarry Finger rtlefuse->txpwrlevel_ht40_2s[rf_path][i] = 0; 1507f1d2b4d3SLarry Finger } 1508f1d2b4d3SLarry Finger } 1509f1d2b4d3SLarry Finger 1510f1d2b4d3SLarry Finger for (i = 0; i < 14; i++) { 1511f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, 1512f1d2b4d3SLarry Finger "RF(%d)-Ch(%d) [CCK / HT40_1S / HT40_2S] = [0x%x / 0x%x / 0x%x]\n", 1513f1d2b4d3SLarry Finger rf_path, i, 1514f1d2b4d3SLarry Finger rtlefuse->txpwrlevel_cck[rf_path][i], 1515f1d2b4d3SLarry Finger rtlefuse->txpwrlevel_ht40_1s[rf_path][i], 1516f1d2b4d3SLarry Finger rtlefuse->txpwrlevel_ht40_2s[rf_path][i]); 1517f1d2b4d3SLarry Finger } 1518f1d2b4d3SLarry Finger } 1519f1d2b4d3SLarry Finger 1520f1d2b4d3SLarry Finger for (i = 0; i < 3; i++) { 1521f1d2b4d3SLarry Finger if (!autoload_fail) { 1522f1d2b4d3SLarry Finger rtlefuse->eeprom_pwrlimit_ht40[i] = 1523f1d2b4d3SLarry Finger hwinfo[EEPROM_TXPWR_GROUP + i]; 1524f1d2b4d3SLarry Finger rtlefuse->eeprom_pwrlimit_ht20[i] = 1525f1d2b4d3SLarry Finger hwinfo[EEPROM_TXPWR_GROUP + 3 + i]; 1526f1d2b4d3SLarry Finger } else { 1527f1d2b4d3SLarry Finger rtlefuse->eeprom_pwrlimit_ht40[i] = 0; 1528f1d2b4d3SLarry Finger rtlefuse->eeprom_pwrlimit_ht20[i] = 0; 1529f1d2b4d3SLarry Finger } 1530f1d2b4d3SLarry Finger } 1531f1d2b4d3SLarry Finger 1532f1d2b4d3SLarry Finger for (rf_path = 0; rf_path < 2; rf_path++) { 1533f1d2b4d3SLarry Finger for (i = 0; i < 14; i++) { 1534f1d2b4d3SLarry Finger index = rtl92c_get_chnl_group((u8)i); 1535f1d2b4d3SLarry Finger 1536f1d2b4d3SLarry Finger if (rf_path == RF90_PATH_A) { 1537f1d2b4d3SLarry Finger rtlefuse->pwrgroup_ht20[rf_path][i] = 1538f1d2b4d3SLarry Finger (rtlefuse->eeprom_pwrlimit_ht20[index] 1539f1d2b4d3SLarry Finger & 0xf); 1540f1d2b4d3SLarry Finger rtlefuse->pwrgroup_ht40[rf_path][i] = 1541f1d2b4d3SLarry Finger (rtlefuse->eeprom_pwrlimit_ht40[index] 1542f1d2b4d3SLarry Finger & 0xf); 1543f1d2b4d3SLarry Finger } else if (rf_path == RF90_PATH_B) { 1544f1d2b4d3SLarry Finger rtlefuse->pwrgroup_ht20[rf_path][i] = 1545f1d2b4d3SLarry Finger ((rtlefuse->eeprom_pwrlimit_ht20[index] 1546f1d2b4d3SLarry Finger & 0xf0) >> 4); 1547f1d2b4d3SLarry Finger rtlefuse->pwrgroup_ht40[rf_path][i] = 1548f1d2b4d3SLarry Finger ((rtlefuse->eeprom_pwrlimit_ht40[index] 1549f1d2b4d3SLarry Finger & 0xf0) >> 4); 1550f1d2b4d3SLarry Finger } 1551f1d2b4d3SLarry Finger 1552f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, 1553f1d2b4d3SLarry Finger "RF-%d pwrgroup_ht20[%d] = 0x%x\n", 1554f1d2b4d3SLarry Finger rf_path, i, 1555f1d2b4d3SLarry Finger rtlefuse->pwrgroup_ht20[rf_path][i]); 1556f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, 1557f1d2b4d3SLarry Finger "RF-%d pwrgroup_ht40[%d] = 0x%x\n", 1558f1d2b4d3SLarry Finger rf_path, i, 1559f1d2b4d3SLarry Finger rtlefuse->pwrgroup_ht40[rf_path][i]); 1560f1d2b4d3SLarry Finger } 1561f1d2b4d3SLarry Finger } 1562f1d2b4d3SLarry Finger 1563f1d2b4d3SLarry Finger for (i = 0; i < 14; i++) { 1564f1d2b4d3SLarry Finger index = rtl92c_get_chnl_group((u8)i); 1565f1d2b4d3SLarry Finger 1566f1d2b4d3SLarry Finger if (!autoload_fail) 1567f1d2b4d3SLarry Finger tempval = hwinfo[EEPROM_TXPOWERHT20DIFF + index]; 1568f1d2b4d3SLarry Finger else 1569f1d2b4d3SLarry Finger tempval = EEPROM_DEFAULT_HT20_DIFF; 1570f1d2b4d3SLarry Finger 1571f1d2b4d3SLarry Finger rtlefuse->txpwr_ht20diff[RF90_PATH_A][i] = (tempval & 0xF); 1572f1d2b4d3SLarry Finger rtlefuse->txpwr_ht20diff[RF90_PATH_B][i] = 1573f1d2b4d3SLarry Finger ((tempval >> 4) & 0xF); 1574f1d2b4d3SLarry Finger 1575f1d2b4d3SLarry Finger if (rtlefuse->txpwr_ht20diff[RF90_PATH_A][i] & BIT(3)) 1576f1d2b4d3SLarry Finger rtlefuse->txpwr_ht20diff[RF90_PATH_A][i] |= 0xF0; 1577f1d2b4d3SLarry Finger 1578f1d2b4d3SLarry Finger if (rtlefuse->txpwr_ht20diff[RF90_PATH_B][i] & BIT(3)) 1579f1d2b4d3SLarry Finger rtlefuse->txpwr_ht20diff[RF90_PATH_B][i] |= 0xF0; 1580f1d2b4d3SLarry Finger 1581f1d2b4d3SLarry Finger index = rtl92c_get_chnl_group((u8)i); 1582f1d2b4d3SLarry Finger 1583f1d2b4d3SLarry Finger if (!autoload_fail) 1584f1d2b4d3SLarry Finger tempval = hwinfo[EEPROM_TXPOWER_OFDMDIFF + index]; 1585f1d2b4d3SLarry Finger else 1586f1d2b4d3SLarry Finger tempval = EEPROM_DEFAULT_LEGACYHTTXPOWERDIFF; 1587f1d2b4d3SLarry Finger 1588f1d2b4d3SLarry Finger rtlefuse->txpwr_legacyhtdiff[RF90_PATH_A][i] = (tempval & 0xF); 1589f1d2b4d3SLarry Finger rtlefuse->txpwr_legacyhtdiff[RF90_PATH_B][i] = 1590f1d2b4d3SLarry Finger ((tempval >> 4) & 0xF); 1591f1d2b4d3SLarry Finger } 1592f1d2b4d3SLarry Finger 1593f1d2b4d3SLarry Finger rtlefuse->legacy_ht_txpowerdiff = 1594f1d2b4d3SLarry Finger rtlefuse->txpwr_legacyhtdiff[RF90_PATH_A][7]; 1595f1d2b4d3SLarry Finger 1596f1d2b4d3SLarry Finger for (i = 0; i < 14; i++) 1597f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, 1598f1d2b4d3SLarry Finger "RF-A Ht20 to HT40 Diff[%d] = 0x%x\n", 1599f1d2b4d3SLarry Finger i, rtlefuse->txpwr_ht20diff[RF90_PATH_A][i]); 1600f1d2b4d3SLarry Finger for (i = 0; i < 14; i++) 1601f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, 1602f1d2b4d3SLarry Finger "RF-A Legacy to Ht40 Diff[%d] = 0x%x\n", 1603f1d2b4d3SLarry Finger i, rtlefuse->txpwr_legacyhtdiff[RF90_PATH_A][i]); 1604f1d2b4d3SLarry Finger for (i = 0; i < 14; i++) 1605f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, 1606f1d2b4d3SLarry Finger "RF-B Ht20 to HT40 Diff[%d] = 0x%x\n", 1607f1d2b4d3SLarry Finger i, rtlefuse->txpwr_ht20diff[RF90_PATH_B][i]); 1608f1d2b4d3SLarry Finger for (i = 0; i < 14; i++) 1609f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, 1610f1d2b4d3SLarry Finger "RF-B Legacy to HT40 Diff[%d] = 0x%x\n", 1611f1d2b4d3SLarry Finger i, rtlefuse->txpwr_legacyhtdiff[RF90_PATH_B][i]); 1612f1d2b4d3SLarry Finger 1613f1d2b4d3SLarry Finger if (!autoload_fail) 1614f1d2b4d3SLarry Finger rtlefuse->eeprom_regulatory = (hwinfo[RF_OPTION1] & 0x7); 1615f1d2b4d3SLarry Finger else 1616f1d2b4d3SLarry Finger rtlefuse->eeprom_regulatory = 0; 1617f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, 1618f1d2b4d3SLarry Finger "eeprom_regulatory = 0x%x\n", rtlefuse->eeprom_regulatory); 1619f1d2b4d3SLarry Finger 1620f1d2b4d3SLarry Finger if (!autoload_fail) { 1621f1d2b4d3SLarry Finger rtlefuse->eeprom_tssi[RF90_PATH_A] = hwinfo[EEPROM_TSSI_A]; 1622f1d2b4d3SLarry Finger rtlefuse->eeprom_tssi[RF90_PATH_B] = hwinfo[EEPROM_TSSI_B]; 1623f1d2b4d3SLarry Finger } else { 1624f1d2b4d3SLarry Finger rtlefuse->eeprom_tssi[RF90_PATH_A] = EEPROM_DEFAULT_TSSI; 1625f1d2b4d3SLarry Finger rtlefuse->eeprom_tssi[RF90_PATH_B] = EEPROM_DEFAULT_TSSI; 1626f1d2b4d3SLarry Finger } 1627f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, "TSSI_A = 0x%x, TSSI_B = 0x%x\n", 1628f1d2b4d3SLarry Finger rtlefuse->eeprom_tssi[RF90_PATH_A], 1629f1d2b4d3SLarry Finger rtlefuse->eeprom_tssi[RF90_PATH_B]); 1630f1d2b4d3SLarry Finger 1631f1d2b4d3SLarry Finger if (!autoload_fail) 1632f1d2b4d3SLarry Finger tempval = hwinfo[EEPROM_THERMAL_METER]; 1633f1d2b4d3SLarry Finger else 1634f1d2b4d3SLarry Finger tempval = EEPROM_DEFAULT_THERMALMETER; 1635f1d2b4d3SLarry Finger rtlefuse->eeprom_thermalmeter = (tempval & 0x1f); 1636f1d2b4d3SLarry Finger 1637f1d2b4d3SLarry Finger if (rtlefuse->eeprom_thermalmeter == 0x1f || autoload_fail) 1638f1d2b4d3SLarry Finger rtlefuse->apk_thermalmeterignore = true; 1639f1d2b4d3SLarry Finger 1640f1d2b4d3SLarry Finger rtlefuse->thermalmeter[0] = rtlefuse->eeprom_thermalmeter; 1641f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FINIT, INIT_TXPOWER, 1642f1d2b4d3SLarry Finger "thermalmeter = 0x%x\n", rtlefuse->eeprom_thermalmeter); 1643f1d2b4d3SLarry Finger } 1644f1d2b4d3SLarry Finger 1645f1d2b4d3SLarry Finger static void _rtl92ce_read_adapter_info(struct ieee80211_hw *hw) 1646f1d2b4d3SLarry Finger { 1647f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1648f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1649f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 1650df5cbc69SLarry Finger int params[] = {RTL8190_EEPROM_ID, EEPROM_VID, EEPROM_DID, 1651df5cbc69SLarry Finger EEPROM_SVID, EEPROM_SMID, EEPROM_MAC_ADDR, 1652df5cbc69SLarry Finger EEPROM_CHANNELPLAN, EEPROM_VERSION, EEPROM_CUSTOMER_ID, 1653df5cbc69SLarry Finger COUNTRY_CODE_WORLD_WIDE_13}; 1654df5cbc69SLarry Finger u8 *hwinfo; 1655f1d2b4d3SLarry Finger 1656df5cbc69SLarry Finger hwinfo = kzalloc(HWSET_MAX_SIZE, GFP_KERNEL); 1657df5cbc69SLarry Finger if (!hwinfo) 16585345ea6aSArnd Bergmann return; 16595345ea6aSArnd Bergmann 1660df5cbc69SLarry Finger if (rtl_get_hwinfo(hw, rtlpriv, HWSET_MAX_SIZE, hwinfo, params)) 1661df5cbc69SLarry Finger goto exit; 1662f1d2b4d3SLarry Finger 1663f1d2b4d3SLarry Finger _rtl92ce_read_txpower_info_from_hwpg(hw, 1664f1d2b4d3SLarry Finger rtlefuse->autoload_failflag, 1665f1d2b4d3SLarry Finger hwinfo); 1666f1d2b4d3SLarry Finger 1667f1d2b4d3SLarry Finger rtl8192ce_read_bt_coexist_info_from_hwpg(hw, 1668f1d2b4d3SLarry Finger rtlefuse->autoload_failflag, 1669f1d2b4d3SLarry Finger hwinfo); 1670f1d2b4d3SLarry Finger if (rtlhal->oem_id == RT_CID_DEFAULT) { 1671f1d2b4d3SLarry Finger switch (rtlefuse->eeprom_oemid) { 1672f1d2b4d3SLarry Finger case EEPROM_CID_DEFAULT: 1673f1d2b4d3SLarry Finger if (rtlefuse->eeprom_did == 0x8176) { 1674f1d2b4d3SLarry Finger if ((rtlefuse->eeprom_svid == 0x103C && 1675f1d2b4d3SLarry Finger rtlefuse->eeprom_smid == 0x1629)) 1676f1d2b4d3SLarry Finger rtlhal->oem_id = RT_CID_819X_HP; 1677f1d2b4d3SLarry Finger else 1678f1d2b4d3SLarry Finger rtlhal->oem_id = RT_CID_DEFAULT; 1679f1d2b4d3SLarry Finger } else { 1680f1d2b4d3SLarry Finger rtlhal->oem_id = RT_CID_DEFAULT; 1681f1d2b4d3SLarry Finger } 1682f1d2b4d3SLarry Finger break; 1683f1d2b4d3SLarry Finger case EEPROM_CID_TOSHIBA: 1684f1d2b4d3SLarry Finger rtlhal->oem_id = RT_CID_TOSHIBA; 1685f1d2b4d3SLarry Finger break; 1686f1d2b4d3SLarry Finger case EEPROM_CID_QMI: 1687f1d2b4d3SLarry Finger rtlhal->oem_id = RT_CID_819X_QMI; 1688f1d2b4d3SLarry Finger break; 1689f1d2b4d3SLarry Finger case EEPROM_CID_WHQL: 1690f1d2b4d3SLarry Finger default: 1691f1d2b4d3SLarry Finger rtlhal->oem_id = RT_CID_DEFAULT; 1692f1d2b4d3SLarry Finger break; 1693f1d2b4d3SLarry Finger } 1694f1d2b4d3SLarry Finger } 1695df5cbc69SLarry Finger exit: 1696df5cbc69SLarry Finger kfree(hwinfo); 1697f1d2b4d3SLarry Finger } 1698f1d2b4d3SLarry Finger 1699f1d2b4d3SLarry Finger static void _rtl92ce_hal_customized_behavior(struct ieee80211_hw *hw) 1700f1d2b4d3SLarry Finger { 1701f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1702f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 1703f1d2b4d3SLarry Finger 1704f1d2b4d3SLarry Finger switch (rtlhal->oem_id) { 1705f1d2b4d3SLarry Finger case RT_CID_819X_HP: 1706d5efe153SLarry Finger rtlpriv->ledctl.led_opendrain = true; 1707f1d2b4d3SLarry Finger break; 1708f1d2b4d3SLarry Finger case RT_CID_819X_LENOVO: 1709f1d2b4d3SLarry Finger case RT_CID_DEFAULT: 1710f1d2b4d3SLarry Finger case RT_CID_TOSHIBA: 1711f1d2b4d3SLarry Finger case RT_CID_CCX: 1712f1d2b4d3SLarry Finger case RT_CID_819X_ACER: 1713f1d2b4d3SLarry Finger case RT_CID_WHQL: 1714f1d2b4d3SLarry Finger default: 1715f1d2b4d3SLarry Finger break; 1716f1d2b4d3SLarry Finger } 1717de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, 1718f1d2b4d3SLarry Finger "RT Customized ID: 0x%02X\n", rtlhal->oem_id); 1719f1d2b4d3SLarry Finger } 1720f1d2b4d3SLarry Finger 1721f1d2b4d3SLarry Finger void rtl92ce_read_eeprom_info(struct ieee80211_hw *hw) 1722f1d2b4d3SLarry Finger { 1723f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1724f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1725f1d2b4d3SLarry Finger struct rtl_phy *rtlphy = &(rtlpriv->phy); 1726f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 1727f1d2b4d3SLarry Finger u8 tmp_u1b; 1728f1d2b4d3SLarry Finger 1729f1d2b4d3SLarry Finger rtlhal->version = _rtl92ce_read_chip_version(hw); 1730f1d2b4d3SLarry Finger if (get_rf_type(rtlphy) == RF_1T1R) 1731f1d2b4d3SLarry Finger rtlpriv->dm.rfpath_rxenable[0] = true; 1732f1d2b4d3SLarry Finger else 1733f1d2b4d3SLarry Finger rtlpriv->dm.rfpath_rxenable[0] = 1734f1d2b4d3SLarry Finger rtlpriv->dm.rfpath_rxenable[1] = true; 1735de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "VersionID = 0x%4x\n", 1736f1d2b4d3SLarry Finger rtlhal->version); 1737f1d2b4d3SLarry Finger tmp_u1b = rtl_read_byte(rtlpriv, REG_9346CR); 1738f1d2b4d3SLarry Finger if (tmp_u1b & BIT(4)) { 1739de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, "Boot from EEPROM\n"); 1740f1d2b4d3SLarry Finger rtlefuse->epromtype = EEPROM_93C46; 1741f1d2b4d3SLarry Finger } else { 1742de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, "Boot from EFUSE\n"); 1743f1d2b4d3SLarry Finger rtlefuse->epromtype = EEPROM_BOOT_EFUSE; 1744f1d2b4d3SLarry Finger } 1745f1d2b4d3SLarry Finger if (tmp_u1b & BIT(5)) { 1746de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n"); 1747f1d2b4d3SLarry Finger rtlefuse->autoload_failflag = false; 1748f1d2b4d3SLarry Finger _rtl92ce_read_adapter_info(hw); 1749f1d2b4d3SLarry Finger } else { 1750e40a0056SLarry Finger pr_err("Autoload ERR!!\n"); 1751f1d2b4d3SLarry Finger } 1752f1d2b4d3SLarry Finger _rtl92ce_hal_customized_behavior(hw); 1753f1d2b4d3SLarry Finger } 1754f1d2b4d3SLarry Finger 1755f1d2b4d3SLarry Finger static void rtl92ce_update_hal_rate_table(struct ieee80211_hw *hw, 1756f1d2b4d3SLarry Finger struct ieee80211_sta *sta) 1757f1d2b4d3SLarry Finger { 1758f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1759f1d2b4d3SLarry Finger struct rtl_phy *rtlphy = &(rtlpriv->phy); 1760f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1761f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 1762f1d2b4d3SLarry Finger u32 ratr_value; 1763f1d2b4d3SLarry Finger u8 ratr_index = 0; 1764f1d2b4d3SLarry Finger u8 nmode = mac->ht_enable; 1765f1d2b4d3SLarry Finger u16 shortgi_rate; 1766f1d2b4d3SLarry Finger u32 tmp_ratr_value; 1767f1d2b4d3SLarry Finger u8 curtxbw_40mhz = mac->bw_40; 1768f1d2b4d3SLarry Finger u8 curshortgi_40mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40) ? 1769f1d2b4d3SLarry Finger 1 : 0; 1770f1d2b4d3SLarry Finger u8 curshortgi_20mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) ? 1771f1d2b4d3SLarry Finger 1 : 0; 1772f1d2b4d3SLarry Finger enum wireless_mode wirelessmode = mac->mode; 1773f1d2b4d3SLarry Finger u32 ratr_mask; 1774f1d2b4d3SLarry Finger 1775f1d2b4d3SLarry Finger if (rtlhal->current_bandtype == BAND_ON_5G) 1776f1d2b4d3SLarry Finger ratr_value = sta->supp_rates[1] << 4; 1777f1d2b4d3SLarry Finger else 1778f1d2b4d3SLarry Finger ratr_value = sta->supp_rates[0]; 1779f1d2b4d3SLarry Finger if (mac->opmode == NL80211_IFTYPE_ADHOC) 1780f1d2b4d3SLarry Finger ratr_value = 0xfff; 1781f1d2b4d3SLarry Finger 1782f1d2b4d3SLarry Finger ratr_value |= (sta->ht_cap.mcs.rx_mask[1] << 20 | 1783f1d2b4d3SLarry Finger sta->ht_cap.mcs.rx_mask[0] << 12); 1784f1d2b4d3SLarry Finger switch (wirelessmode) { 1785f1d2b4d3SLarry Finger case WIRELESS_MODE_B: 1786f1d2b4d3SLarry Finger if (ratr_value & 0x0000000c) 1787f1d2b4d3SLarry Finger ratr_value &= 0x0000000d; 1788f1d2b4d3SLarry Finger else 1789f1d2b4d3SLarry Finger ratr_value &= 0x0000000f; 1790f1d2b4d3SLarry Finger break; 1791f1d2b4d3SLarry Finger case WIRELESS_MODE_G: 1792f1d2b4d3SLarry Finger ratr_value &= 0x00000FF5; 1793f1d2b4d3SLarry Finger break; 1794f1d2b4d3SLarry Finger case WIRELESS_MODE_N_24G: 1795f1d2b4d3SLarry Finger case WIRELESS_MODE_N_5G: 1796f1d2b4d3SLarry Finger nmode = 1; 1797f1d2b4d3SLarry Finger if (get_rf_type(rtlphy) == RF_1T2R || 1798f1d2b4d3SLarry Finger get_rf_type(rtlphy) == RF_1T1R) 1799f1d2b4d3SLarry Finger ratr_mask = 0x000ff005; 1800f1d2b4d3SLarry Finger else 1801f1d2b4d3SLarry Finger ratr_mask = 0x0f0ff005; 1802f1d2b4d3SLarry Finger 1803f1d2b4d3SLarry Finger ratr_value &= ratr_mask; 1804f1d2b4d3SLarry Finger break; 1805f1d2b4d3SLarry Finger default: 1806f1d2b4d3SLarry Finger if (rtlphy->rf_type == RF_1T2R) 1807f1d2b4d3SLarry Finger ratr_value &= 0x000ff0ff; 1808f1d2b4d3SLarry Finger else 1809f1d2b4d3SLarry Finger ratr_value &= 0x0f0ff0ff; 1810f1d2b4d3SLarry Finger 1811f1d2b4d3SLarry Finger break; 1812f1d2b4d3SLarry Finger } 1813f1d2b4d3SLarry Finger 1814d5efe153SLarry Finger if ((rtlpriv->btcoexist.bt_coexistence) && 1815d5efe153SLarry Finger (rtlpriv->btcoexist.bt_coexist_type == BT_CSR_BC4) && 1816d5efe153SLarry Finger (rtlpriv->btcoexist.bt_cur_state) && 1817d5efe153SLarry Finger (rtlpriv->btcoexist.bt_ant_isolation) && 1818d5efe153SLarry Finger ((rtlpriv->btcoexist.bt_service == BT_SCO) || 1819d5efe153SLarry Finger (rtlpriv->btcoexist.bt_service == BT_BUSY))) 1820f1d2b4d3SLarry Finger ratr_value &= 0x0fffcfc0; 1821f1d2b4d3SLarry Finger else 1822f1d2b4d3SLarry Finger ratr_value &= 0x0FFFFFFF; 1823f1d2b4d3SLarry Finger 1824f1d2b4d3SLarry Finger if (nmode && ((curtxbw_40mhz && 1825f1d2b4d3SLarry Finger curshortgi_40mhz) || (!curtxbw_40mhz && 1826f1d2b4d3SLarry Finger curshortgi_20mhz))) { 1827f1d2b4d3SLarry Finger 1828f1d2b4d3SLarry Finger ratr_value |= 0x10000000; 1829f1d2b4d3SLarry Finger tmp_ratr_value = (ratr_value >> 12); 1830f1d2b4d3SLarry Finger 1831f1d2b4d3SLarry Finger for (shortgi_rate = 15; shortgi_rate > 0; shortgi_rate--) { 1832f1d2b4d3SLarry Finger if ((1 << shortgi_rate) & tmp_ratr_value) 1833f1d2b4d3SLarry Finger break; 1834f1d2b4d3SLarry Finger } 1835f1d2b4d3SLarry Finger 1836f1d2b4d3SLarry Finger shortgi_rate = (shortgi_rate << 12) | (shortgi_rate << 8) | 1837f1d2b4d3SLarry Finger (shortgi_rate << 4) | (shortgi_rate); 1838f1d2b4d3SLarry Finger } 1839f1d2b4d3SLarry Finger 1840f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_ARFR0 + ratr_index * 4, ratr_value); 1841f1d2b4d3SLarry Finger 1842de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_RATR, DBG_DMESG, "%x\n", 1843f1d2b4d3SLarry Finger rtl_read_dword(rtlpriv, REG_ARFR0)); 1844f1d2b4d3SLarry Finger } 1845f1d2b4d3SLarry Finger 1846f1d2b4d3SLarry Finger static void rtl92ce_update_hal_rate_mask(struct ieee80211_hw *hw, 18471d22b177SPing-Ke Shih struct ieee80211_sta *sta, u8 rssi_level, bool update_bw) 1848f1d2b4d3SLarry Finger { 1849f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1850f1d2b4d3SLarry Finger struct rtl_phy *rtlphy = &(rtlpriv->phy); 1851f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1852f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 1853f1d2b4d3SLarry Finger struct rtl_sta_info *sta_entry = NULL; 1854f1d2b4d3SLarry Finger u32 ratr_bitmap; 1855f1d2b4d3SLarry Finger u8 ratr_index; 1856f1d2b4d3SLarry Finger u8 curtxbw_40mhz = (sta->ht_cap.cap & 1857f1d2b4d3SLarry Finger IEEE80211_HT_CAP_SUP_WIDTH_20_40) ? 1 : 0; 1858f1d2b4d3SLarry Finger u8 curshortgi_40mhz = (sta->ht_cap.cap & 1859f1d2b4d3SLarry Finger IEEE80211_HT_CAP_SGI_40) ? 1 : 0; 1860f1d2b4d3SLarry Finger u8 curshortgi_20mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) ? 1861f1d2b4d3SLarry Finger 1 : 0; 1862f1d2b4d3SLarry Finger enum wireless_mode wirelessmode = 0; 1863f1d2b4d3SLarry Finger bool shortgi = false; 1864f1d2b4d3SLarry Finger u8 rate_mask[5]; 1865f1d2b4d3SLarry Finger u8 macid = 0; 1866f1d2b4d3SLarry Finger 1867f1d2b4d3SLarry Finger sta_entry = (struct rtl_sta_info *) sta->drv_priv; 1868f1d2b4d3SLarry Finger wirelessmode = sta_entry->wireless_mode; 1869f1d2b4d3SLarry Finger if (mac->opmode == NL80211_IFTYPE_STATION || 1870f1d2b4d3SLarry Finger mac->opmode == NL80211_IFTYPE_MESH_POINT) 1871f1d2b4d3SLarry Finger curtxbw_40mhz = mac->bw_40; 1872f1d2b4d3SLarry Finger else if (mac->opmode == NL80211_IFTYPE_AP || 1873f1d2b4d3SLarry Finger mac->opmode == NL80211_IFTYPE_ADHOC) 1874f1d2b4d3SLarry Finger macid = sta->aid + 1; 1875f1d2b4d3SLarry Finger 1876f1d2b4d3SLarry Finger if (rtlhal->current_bandtype == BAND_ON_5G) 1877f1d2b4d3SLarry Finger ratr_bitmap = sta->supp_rates[1] << 4; 1878f1d2b4d3SLarry Finger else 1879f1d2b4d3SLarry Finger ratr_bitmap = sta->supp_rates[0]; 1880f1d2b4d3SLarry Finger if (mac->opmode == NL80211_IFTYPE_ADHOC) 1881f1d2b4d3SLarry Finger ratr_bitmap = 0xfff; 1882f1d2b4d3SLarry Finger ratr_bitmap |= (sta->ht_cap.mcs.rx_mask[1] << 20 | 1883f1d2b4d3SLarry Finger sta->ht_cap.mcs.rx_mask[0] << 12); 1884f1d2b4d3SLarry Finger switch (wirelessmode) { 1885f1d2b4d3SLarry Finger case WIRELESS_MODE_B: 1886f1d2b4d3SLarry Finger ratr_index = RATR_INX_WIRELESS_B; 1887f1d2b4d3SLarry Finger if (ratr_bitmap & 0x0000000c) 1888f1d2b4d3SLarry Finger ratr_bitmap &= 0x0000000d; 1889f1d2b4d3SLarry Finger else 1890f1d2b4d3SLarry Finger ratr_bitmap &= 0x0000000f; 1891f1d2b4d3SLarry Finger break; 1892f1d2b4d3SLarry Finger case WIRELESS_MODE_G: 1893f1d2b4d3SLarry Finger ratr_index = RATR_INX_WIRELESS_GB; 1894f1d2b4d3SLarry Finger 1895f1d2b4d3SLarry Finger if (rssi_level == 1) 1896f1d2b4d3SLarry Finger ratr_bitmap &= 0x00000f00; 1897f1d2b4d3SLarry Finger else if (rssi_level == 2) 1898f1d2b4d3SLarry Finger ratr_bitmap &= 0x00000ff0; 1899f1d2b4d3SLarry Finger else 1900f1d2b4d3SLarry Finger ratr_bitmap &= 0x00000ff5; 1901f1d2b4d3SLarry Finger break; 1902f1d2b4d3SLarry Finger case WIRELESS_MODE_A: 1903f1d2b4d3SLarry Finger ratr_index = RATR_INX_WIRELESS_A; 1904f1d2b4d3SLarry Finger ratr_bitmap &= 0x00000ff0; 1905f1d2b4d3SLarry Finger break; 1906f1d2b4d3SLarry Finger case WIRELESS_MODE_N_24G: 1907f1d2b4d3SLarry Finger case WIRELESS_MODE_N_5G: 1908f1d2b4d3SLarry Finger ratr_index = RATR_INX_WIRELESS_NGB; 1909f1d2b4d3SLarry Finger 1910f1d2b4d3SLarry Finger if (rtlphy->rf_type == RF_1T2R || 1911f1d2b4d3SLarry Finger rtlphy->rf_type == RF_1T1R) { 1912f1d2b4d3SLarry Finger if (curtxbw_40mhz) { 1913f1d2b4d3SLarry Finger if (rssi_level == 1) 1914f1d2b4d3SLarry Finger ratr_bitmap &= 0x000f0000; 1915f1d2b4d3SLarry Finger else if (rssi_level == 2) 1916f1d2b4d3SLarry Finger ratr_bitmap &= 0x000ff000; 1917f1d2b4d3SLarry Finger else 1918f1d2b4d3SLarry Finger ratr_bitmap &= 0x000ff015; 1919f1d2b4d3SLarry Finger } else { 1920f1d2b4d3SLarry Finger if (rssi_level == 1) 1921f1d2b4d3SLarry Finger ratr_bitmap &= 0x000f0000; 1922f1d2b4d3SLarry Finger else if (rssi_level == 2) 1923f1d2b4d3SLarry Finger ratr_bitmap &= 0x000ff000; 1924f1d2b4d3SLarry Finger else 1925f1d2b4d3SLarry Finger ratr_bitmap &= 0x000ff005; 1926f1d2b4d3SLarry Finger } 1927f1d2b4d3SLarry Finger } else { 1928f1d2b4d3SLarry Finger if (curtxbw_40mhz) { 1929f1d2b4d3SLarry Finger if (rssi_level == 1) 1930f1d2b4d3SLarry Finger ratr_bitmap &= 0x0f0f0000; 1931f1d2b4d3SLarry Finger else if (rssi_level == 2) 1932f1d2b4d3SLarry Finger ratr_bitmap &= 0x0f0ff000; 1933f1d2b4d3SLarry Finger else 1934f1d2b4d3SLarry Finger ratr_bitmap &= 0x0f0ff015; 1935f1d2b4d3SLarry Finger } else { 1936f1d2b4d3SLarry Finger if (rssi_level == 1) 1937f1d2b4d3SLarry Finger ratr_bitmap &= 0x0f0f0000; 1938f1d2b4d3SLarry Finger else if (rssi_level == 2) 1939f1d2b4d3SLarry Finger ratr_bitmap &= 0x0f0ff000; 1940f1d2b4d3SLarry Finger else 1941f1d2b4d3SLarry Finger ratr_bitmap &= 0x0f0ff005; 1942f1d2b4d3SLarry Finger } 1943f1d2b4d3SLarry Finger } 1944f1d2b4d3SLarry Finger 1945f1d2b4d3SLarry Finger if ((curtxbw_40mhz && curshortgi_40mhz) || 1946f1d2b4d3SLarry Finger (!curtxbw_40mhz && curshortgi_20mhz)) { 1947f1d2b4d3SLarry Finger 1948f1d2b4d3SLarry Finger if (macid == 0) 1949f1d2b4d3SLarry Finger shortgi = true; 1950f1d2b4d3SLarry Finger else if (macid == 1) 1951f1d2b4d3SLarry Finger shortgi = false; 1952f1d2b4d3SLarry Finger } 1953f1d2b4d3SLarry Finger break; 1954f1d2b4d3SLarry Finger default: 1955f1d2b4d3SLarry Finger ratr_index = RATR_INX_WIRELESS_NGB; 1956f1d2b4d3SLarry Finger 1957f1d2b4d3SLarry Finger if (rtlphy->rf_type == RF_1T2R) 1958f1d2b4d3SLarry Finger ratr_bitmap &= 0x000ff0ff; 1959f1d2b4d3SLarry Finger else 1960f1d2b4d3SLarry Finger ratr_bitmap &= 0x0f0ff0ff; 1961f1d2b4d3SLarry Finger break; 1962f1d2b4d3SLarry Finger } 1963f1d2b4d3SLarry Finger sta_entry->ratr_index = ratr_index; 1964f1d2b4d3SLarry Finger 1965de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_RATR, DBG_DMESG, 1966f1d2b4d3SLarry Finger "ratr_bitmap :%x\n", ratr_bitmap); 1967f1d2b4d3SLarry Finger *(u32 *)&rate_mask = (ratr_bitmap & 0x0fffffff) | 1968f1d2b4d3SLarry Finger (ratr_index << 28); 1969f1d2b4d3SLarry Finger rate_mask[4] = macid | (shortgi ? 0x20 : 0x00) | 0x80; 1970de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_RATR, DBG_DMESG, 1971f1d2b4d3SLarry Finger "Rate_index:%x, ratr_val:%x, %5phC\n", 1972f1d2b4d3SLarry Finger ratr_index, ratr_bitmap, rate_mask); 1973f1d2b4d3SLarry Finger rtl92c_fill_h2c_cmd(hw, H2C_RA_MASK, 5, rate_mask); 1974f1d2b4d3SLarry Finger } 1975f1d2b4d3SLarry Finger 1976f1d2b4d3SLarry Finger void rtl92ce_update_hal_rate_tbl(struct ieee80211_hw *hw, 19771d22b177SPing-Ke Shih struct ieee80211_sta *sta, u8 rssi_level, bool update_bw) 1978f1d2b4d3SLarry Finger { 1979f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1980f1d2b4d3SLarry Finger 1981f1d2b4d3SLarry Finger if (rtlpriv->dm.useramask) 19821d22b177SPing-Ke Shih rtl92ce_update_hal_rate_mask(hw, sta, rssi_level, update_bw); 1983f1d2b4d3SLarry Finger else 1984f1d2b4d3SLarry Finger rtl92ce_update_hal_rate_table(hw, sta); 1985f1d2b4d3SLarry Finger } 1986f1d2b4d3SLarry Finger 1987f1d2b4d3SLarry Finger void rtl92ce_update_channel_access_setting(struct ieee80211_hw *hw) 1988f1d2b4d3SLarry Finger { 1989f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1990f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1991f1d2b4d3SLarry Finger u16 sifs_timer; 1992f1d2b4d3SLarry Finger 1993f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SLOT_TIME, 1994f1d2b4d3SLarry Finger &mac->slot_time); 1995f1d2b4d3SLarry Finger if (!mac->ht_enable) 1996f1d2b4d3SLarry Finger sifs_timer = 0x0a0a; 1997f1d2b4d3SLarry Finger else 1998f1d2b4d3SLarry Finger sifs_timer = 0x1010; 1999f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SIFS, (u8 *)&sifs_timer); 2000f1d2b4d3SLarry Finger } 2001f1d2b4d3SLarry Finger 2002f1d2b4d3SLarry Finger bool rtl92ce_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid) 2003f1d2b4d3SLarry Finger { 2004f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 2005f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 2006f1d2b4d3SLarry Finger struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 2007f1d2b4d3SLarry Finger enum rf_pwrstate e_rfpowerstate_toset; 2008f1d2b4d3SLarry Finger u8 u1tmp; 2009f1d2b4d3SLarry Finger bool actuallyset = false; 2010f1d2b4d3SLarry Finger unsigned long flag; 2011f1d2b4d3SLarry Finger 2012f1d2b4d3SLarry Finger if (rtlpci->being_init_adapter) 2013f1d2b4d3SLarry Finger return false; 2014f1d2b4d3SLarry Finger 2015f1d2b4d3SLarry Finger if (ppsc->swrf_processing) 2016f1d2b4d3SLarry Finger return false; 2017f1d2b4d3SLarry Finger 2018f1d2b4d3SLarry Finger spin_lock_irqsave(&rtlpriv->locks.rf_ps_lock, flag); 2019f1d2b4d3SLarry Finger if (ppsc->rfchange_inprogress) { 2020f1d2b4d3SLarry Finger spin_unlock_irqrestore(&rtlpriv->locks.rf_ps_lock, flag); 2021f1d2b4d3SLarry Finger return false; 2022f1d2b4d3SLarry Finger } else { 2023f1d2b4d3SLarry Finger ppsc->rfchange_inprogress = true; 2024f1d2b4d3SLarry Finger spin_unlock_irqrestore(&rtlpriv->locks.rf_ps_lock, flag); 2025f1d2b4d3SLarry Finger } 2026f1d2b4d3SLarry Finger 2027f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_MAC_PINMUX_CFG, rtl_read_byte(rtlpriv, 2028f1d2b4d3SLarry Finger REG_MAC_PINMUX_CFG)&~(BIT(3))); 2029f1d2b4d3SLarry Finger 2030f1d2b4d3SLarry Finger u1tmp = rtl_read_byte(rtlpriv, REG_GPIO_IO_SEL); 2031f1d2b4d3SLarry Finger e_rfpowerstate_toset = (u1tmp & BIT(3)) ? ERFON : ERFOFF; 2032f1d2b4d3SLarry Finger 2033f1d2b4d3SLarry Finger if ((ppsc->hwradiooff) && (e_rfpowerstate_toset == ERFON)) { 2034de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_RF, DBG_DMESG, 2035f1d2b4d3SLarry Finger "GPIOChangeRF - HW Radio ON, RF ON\n"); 2036f1d2b4d3SLarry Finger 2037f1d2b4d3SLarry Finger e_rfpowerstate_toset = ERFON; 2038f1d2b4d3SLarry Finger ppsc->hwradiooff = false; 2039f1d2b4d3SLarry Finger actuallyset = true; 2040f1d2b4d3SLarry Finger } else if (!ppsc->hwradiooff && (e_rfpowerstate_toset == ERFOFF)) { 2041de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_RF, DBG_DMESG, 2042f1d2b4d3SLarry Finger "GPIOChangeRF - HW Radio OFF, RF OFF\n"); 2043f1d2b4d3SLarry Finger 2044f1d2b4d3SLarry Finger e_rfpowerstate_toset = ERFOFF; 2045f1d2b4d3SLarry Finger ppsc->hwradiooff = true; 2046f1d2b4d3SLarry Finger actuallyset = true; 2047f1d2b4d3SLarry Finger } 2048f1d2b4d3SLarry Finger 2049f1d2b4d3SLarry Finger if (actuallyset) { 2050f1d2b4d3SLarry Finger spin_lock_irqsave(&rtlpriv->locks.rf_ps_lock, flag); 2051f1d2b4d3SLarry Finger ppsc->rfchange_inprogress = false; 2052f1d2b4d3SLarry Finger spin_unlock_irqrestore(&rtlpriv->locks.rf_ps_lock, flag); 2053f1d2b4d3SLarry Finger } else { 2054f1d2b4d3SLarry Finger if (ppsc->reg_rfps_level & RT_RF_OFF_LEVL_HALT_NIC) 2055f1d2b4d3SLarry Finger RT_SET_PS_LEVEL(ppsc, RT_RF_OFF_LEVL_HALT_NIC); 2056f1d2b4d3SLarry Finger 2057f1d2b4d3SLarry Finger spin_lock_irqsave(&rtlpriv->locks.rf_ps_lock, flag); 2058f1d2b4d3SLarry Finger ppsc->rfchange_inprogress = false; 2059f1d2b4d3SLarry Finger spin_unlock_irqrestore(&rtlpriv->locks.rf_ps_lock, flag); 2060f1d2b4d3SLarry Finger } 2061f1d2b4d3SLarry Finger 2062f1d2b4d3SLarry Finger *valid = 1; 2063f1d2b4d3SLarry Finger return !ppsc->hwradiooff; 2064f1d2b4d3SLarry Finger 2065f1d2b4d3SLarry Finger } 2066f1d2b4d3SLarry Finger 2067f1d2b4d3SLarry Finger void rtl92ce_set_key(struct ieee80211_hw *hw, u32 key_index, 2068f1d2b4d3SLarry Finger u8 *p_macaddr, bool is_group, u8 enc_algo, 2069f1d2b4d3SLarry Finger bool is_wepkey, bool clear_all) 2070f1d2b4d3SLarry Finger { 2071f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 2072f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 2073f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 2074f1d2b4d3SLarry Finger u8 *macaddr = p_macaddr; 2075f1d2b4d3SLarry Finger u32 entry_id = 0; 2076f1d2b4d3SLarry Finger bool is_pairwise = false; 2077f1d2b4d3SLarry Finger 2078f1d2b4d3SLarry Finger static u8 cam_const_addr[4][6] = { 2079f1d2b4d3SLarry Finger {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 2080f1d2b4d3SLarry Finger {0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 2081f1d2b4d3SLarry Finger {0x00, 0x00, 0x00, 0x00, 0x00, 0x02}, 2082f1d2b4d3SLarry Finger {0x00, 0x00, 0x00, 0x00, 0x00, 0x03} 2083f1d2b4d3SLarry Finger }; 2084f1d2b4d3SLarry Finger static u8 cam_const_broad[] = { 2085f1d2b4d3SLarry Finger 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 2086f1d2b4d3SLarry Finger }; 2087f1d2b4d3SLarry Finger 2088f1d2b4d3SLarry Finger if (clear_all) { 2089f1d2b4d3SLarry Finger u8 idx = 0; 2090f1d2b4d3SLarry Finger u8 cam_offset = 0; 2091f1d2b4d3SLarry Finger u8 clear_number = 5; 2092f1d2b4d3SLarry Finger 2093de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_SEC, DBG_DMESG, "clear_all\n"); 2094f1d2b4d3SLarry Finger 2095f1d2b4d3SLarry Finger for (idx = 0; idx < clear_number; idx++) { 2096f1d2b4d3SLarry Finger rtl_cam_mark_invalid(hw, cam_offset + idx); 2097f1d2b4d3SLarry Finger rtl_cam_empty_entry(hw, cam_offset + idx); 2098f1d2b4d3SLarry Finger 2099f1d2b4d3SLarry Finger if (idx < 5) { 2100f1d2b4d3SLarry Finger memset(rtlpriv->sec.key_buf[idx], 0, 2101f1d2b4d3SLarry Finger MAX_KEY_LEN); 2102f1d2b4d3SLarry Finger rtlpriv->sec.key_len[idx] = 0; 2103f1d2b4d3SLarry Finger } 2104f1d2b4d3SLarry Finger } 2105f1d2b4d3SLarry Finger 2106f1d2b4d3SLarry Finger } else { 2107f1d2b4d3SLarry Finger switch (enc_algo) { 2108f1d2b4d3SLarry Finger case WEP40_ENCRYPTION: 2109f1d2b4d3SLarry Finger enc_algo = CAM_WEP40; 2110f1d2b4d3SLarry Finger break; 2111f1d2b4d3SLarry Finger case WEP104_ENCRYPTION: 2112f1d2b4d3SLarry Finger enc_algo = CAM_WEP104; 2113f1d2b4d3SLarry Finger break; 2114f1d2b4d3SLarry Finger case TKIP_ENCRYPTION: 2115f1d2b4d3SLarry Finger enc_algo = CAM_TKIP; 2116f1d2b4d3SLarry Finger break; 2117f1d2b4d3SLarry Finger case AESCCMP_ENCRYPTION: 2118f1d2b4d3SLarry Finger enc_algo = CAM_AES; 2119f1d2b4d3SLarry Finger break; 2120f1d2b4d3SLarry Finger default: 2121e40a0056SLarry Finger pr_err("switch case %#x not processed\n", 2122e40a0056SLarry Finger enc_algo); 2123f1d2b4d3SLarry Finger enc_algo = CAM_TKIP; 2124f1d2b4d3SLarry Finger break; 2125f1d2b4d3SLarry Finger } 2126f1d2b4d3SLarry Finger 2127f1d2b4d3SLarry Finger if (is_wepkey || rtlpriv->sec.use_defaultkey) { 2128f1d2b4d3SLarry Finger macaddr = cam_const_addr[key_index]; 2129f1d2b4d3SLarry Finger entry_id = key_index; 2130f1d2b4d3SLarry Finger } else { 2131f1d2b4d3SLarry Finger if (is_group) { 2132f1d2b4d3SLarry Finger macaddr = cam_const_broad; 2133f1d2b4d3SLarry Finger entry_id = key_index; 2134f1d2b4d3SLarry Finger } else { 2135f1d2b4d3SLarry Finger if (mac->opmode == NL80211_IFTYPE_AP || 2136f1d2b4d3SLarry Finger mac->opmode == NL80211_IFTYPE_MESH_POINT) { 2137f1d2b4d3SLarry Finger entry_id = rtl_cam_get_free_entry(hw, 2138f1d2b4d3SLarry Finger p_macaddr); 2139f1d2b4d3SLarry Finger if (entry_id >= TOTAL_CAM_ENTRY) { 2140e40a0056SLarry Finger pr_err("Can not find free hw security cam entry\n"); 2141f1d2b4d3SLarry Finger return; 2142f1d2b4d3SLarry Finger } 2143f1d2b4d3SLarry Finger } else { 2144f1d2b4d3SLarry Finger entry_id = CAM_PAIRWISE_KEY_POSITION; 2145f1d2b4d3SLarry Finger } 2146f1d2b4d3SLarry Finger 2147f1d2b4d3SLarry Finger key_index = PAIRWISE_KEYIDX; 2148f1d2b4d3SLarry Finger is_pairwise = true; 2149f1d2b4d3SLarry Finger } 2150f1d2b4d3SLarry Finger } 2151f1d2b4d3SLarry Finger 2152f1d2b4d3SLarry Finger if (rtlpriv->sec.key_len[key_index] == 0) { 2153de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_SEC, DBG_DMESG, 2154f1d2b4d3SLarry Finger "delete one entry, entry_id is %d\n", 2155f1d2b4d3SLarry Finger entry_id); 2156f1d2b4d3SLarry Finger if (mac->opmode == NL80211_IFTYPE_AP || 2157f1d2b4d3SLarry Finger mac->opmode == NL80211_IFTYPE_MESH_POINT) 2158f1d2b4d3SLarry Finger rtl_cam_del_entry(hw, p_macaddr); 2159f1d2b4d3SLarry Finger rtl_cam_delete_one_entry(hw, p_macaddr, entry_id); 2160f1d2b4d3SLarry Finger } else { 2161de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_SEC, DBG_LOUD, 2162f1d2b4d3SLarry Finger "The insert KEY length is %d\n", 2163f1d2b4d3SLarry Finger rtlpriv->sec.key_len[PAIRWISE_KEYIDX]); 2164de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_SEC, DBG_LOUD, 2165f1d2b4d3SLarry Finger "The insert KEY is %x %x\n", 2166f1d2b4d3SLarry Finger rtlpriv->sec.key_buf[0][0], 2167f1d2b4d3SLarry Finger rtlpriv->sec.key_buf[0][1]); 2168f1d2b4d3SLarry Finger 2169de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_SEC, DBG_DMESG, 2170f1d2b4d3SLarry Finger "add one entry\n"); 2171f1d2b4d3SLarry Finger if (is_pairwise) { 2172f1d2b4d3SLarry Finger RT_PRINT_DATA(rtlpriv, COMP_SEC, DBG_LOUD, 2173f1d2b4d3SLarry Finger "Pairwise Key content", 2174f1d2b4d3SLarry Finger rtlpriv->sec.pairwise_key, 2175f1d2b4d3SLarry Finger rtlpriv->sec. 2176f1d2b4d3SLarry Finger key_len[PAIRWISE_KEYIDX]); 2177f1d2b4d3SLarry Finger 2178de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_SEC, DBG_DMESG, 2179f1d2b4d3SLarry Finger "set Pairwise key\n"); 2180f1d2b4d3SLarry Finger 2181f1d2b4d3SLarry Finger rtl_cam_add_one_entry(hw, macaddr, key_index, 2182f1d2b4d3SLarry Finger entry_id, enc_algo, 2183f1d2b4d3SLarry Finger CAM_CONFIG_NO_USEDK, 2184f1d2b4d3SLarry Finger rtlpriv->sec. 2185f1d2b4d3SLarry Finger key_buf[key_index]); 2186f1d2b4d3SLarry Finger } else { 2187de0c8a96SLarry Finger rtl_dbg(rtlpriv, COMP_SEC, DBG_DMESG, 2188f1d2b4d3SLarry Finger "set group key\n"); 2189f1d2b4d3SLarry Finger 2190f1d2b4d3SLarry Finger if (mac->opmode == NL80211_IFTYPE_ADHOC) { 2191f1d2b4d3SLarry Finger rtl_cam_add_one_entry(hw, 2192f1d2b4d3SLarry Finger rtlefuse->dev_addr, 2193f1d2b4d3SLarry Finger PAIRWISE_KEYIDX, 2194f1d2b4d3SLarry Finger CAM_PAIRWISE_KEY_POSITION, 2195f1d2b4d3SLarry Finger enc_algo, 2196f1d2b4d3SLarry Finger CAM_CONFIG_NO_USEDK, 2197f1d2b4d3SLarry Finger rtlpriv->sec.key_buf 2198f1d2b4d3SLarry Finger [entry_id]); 2199f1d2b4d3SLarry Finger } 2200f1d2b4d3SLarry Finger 2201f1d2b4d3SLarry Finger rtl_cam_add_one_entry(hw, macaddr, key_index, 2202f1d2b4d3SLarry Finger entry_id, enc_algo, 2203f1d2b4d3SLarry Finger CAM_CONFIG_NO_USEDK, 2204f1d2b4d3SLarry Finger rtlpriv->sec.key_buf[entry_id]); 2205f1d2b4d3SLarry Finger } 2206f1d2b4d3SLarry Finger 2207f1d2b4d3SLarry Finger } 2208f1d2b4d3SLarry Finger } 2209f1d2b4d3SLarry Finger } 2210f1d2b4d3SLarry Finger 2211f1d2b4d3SLarry Finger static void rtl8192ce_bt_var_init(struct ieee80211_hw *hw) 2212f1d2b4d3SLarry Finger { 2213d5efe153SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 2214f1d2b4d3SLarry Finger 2215d5efe153SLarry Finger rtlpriv->btcoexist.bt_coexistence = 2216d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_coexist; 2217d5efe153SLarry Finger rtlpriv->btcoexist.bt_ant_num = 2218d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_ant_num; 2219d5efe153SLarry Finger rtlpriv->btcoexist.bt_coexist_type = 2220d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_type; 2221f1d2b4d3SLarry Finger 2222d5efe153SLarry Finger if (rtlpriv->btcoexist.reg_bt_iso == 2) 2223d5efe153SLarry Finger rtlpriv->btcoexist.bt_ant_isolation = 2224d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_ant_isol; 2225f1d2b4d3SLarry Finger else 2226d5efe153SLarry Finger rtlpriv->btcoexist.bt_ant_isolation = 2227d5efe153SLarry Finger rtlpriv->btcoexist.reg_bt_iso; 2228f1d2b4d3SLarry Finger 2229d5efe153SLarry Finger rtlpriv->btcoexist.bt_radio_shared_type = 2230d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_radio_shared; 2231f1d2b4d3SLarry Finger 2232d5efe153SLarry Finger if (rtlpriv->btcoexist.bt_coexistence) { 2233d5efe153SLarry Finger if (rtlpriv->btcoexist.reg_bt_sco == 1) 2234d5efe153SLarry Finger rtlpriv->btcoexist.bt_service = BT_OTHER_ACTION; 2235d5efe153SLarry Finger else if (rtlpriv->btcoexist.reg_bt_sco == 2) 2236d5efe153SLarry Finger rtlpriv->btcoexist.bt_service = BT_SCO; 2237d5efe153SLarry Finger else if (rtlpriv->btcoexist.reg_bt_sco == 4) 2238d5efe153SLarry Finger rtlpriv->btcoexist.bt_service = BT_BUSY; 2239d5efe153SLarry Finger else if (rtlpriv->btcoexist.reg_bt_sco == 5) 2240d5efe153SLarry Finger rtlpriv->btcoexist.bt_service = BT_OTHERBUSY; 2241f1d2b4d3SLarry Finger else 2242d5efe153SLarry Finger rtlpriv->btcoexist.bt_service = BT_IDLE; 2243f1d2b4d3SLarry Finger 2244d5efe153SLarry Finger rtlpriv->btcoexist.bt_edca_ul = 0; 2245d5efe153SLarry Finger rtlpriv->btcoexist.bt_edca_dl = 0; 2246d5efe153SLarry Finger rtlpriv->btcoexist.bt_rssi_state = 0xff; 2247f1d2b4d3SLarry Finger } 2248f1d2b4d3SLarry Finger } 2249f1d2b4d3SLarry Finger 2250f1d2b4d3SLarry Finger void rtl8192ce_read_bt_coexist_info_from_hwpg(struct ieee80211_hw *hw, 2251f1d2b4d3SLarry Finger bool auto_load_fail, u8 *hwinfo) 2252f1d2b4d3SLarry Finger { 2253d5efe153SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 2254f1d2b4d3SLarry Finger u8 val; 2255f1d2b4d3SLarry Finger 2256f1d2b4d3SLarry Finger if (!auto_load_fail) { 2257d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_coexist = 2258f1d2b4d3SLarry Finger ((hwinfo[RF_OPTION1] & 0xe0) >> 5); 2259f1d2b4d3SLarry Finger val = hwinfo[RF_OPTION4]; 2260d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_type = ((val & 0xe) >> 1); 2261d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_ant_num = (val & 0x1); 2262d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_ant_isol = ((val & 0x10) >> 4); 2263d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_radio_shared = 2264f1d2b4d3SLarry Finger ((val & 0x20) >> 5); 2265f1d2b4d3SLarry Finger } else { 2266d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_coexist = 0; 2267d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_type = BT_2WIRE; 2268d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_ant_num = ANT_X2; 2269d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_ant_isol = 0; 2270d5efe153SLarry Finger rtlpriv->btcoexist.eeprom_bt_radio_shared = BT_RADIO_SHARED; 2271f1d2b4d3SLarry Finger } 2272f1d2b4d3SLarry Finger 2273f1d2b4d3SLarry Finger rtl8192ce_bt_var_init(hw); 2274f1d2b4d3SLarry Finger } 2275f1d2b4d3SLarry Finger 2276f1d2b4d3SLarry Finger void rtl8192ce_bt_reg_init(struct ieee80211_hw *hw) 2277f1d2b4d3SLarry Finger { 2278d5efe153SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 2279f1d2b4d3SLarry Finger 2280f1d2b4d3SLarry Finger /* 0:Low, 1:High, 2:From Efuse. */ 2281d5efe153SLarry Finger rtlpriv->btcoexist.reg_bt_iso = 2; 2282f1d2b4d3SLarry Finger /* 0:Idle, 1:None-SCO, 2:SCO, 3:From Counter. */ 2283d5efe153SLarry Finger rtlpriv->btcoexist.reg_bt_sco = 3; 2284f1d2b4d3SLarry Finger /* 0:Disable BT control A-MPDU, 1:Enable BT control A-MPDU. */ 2285d5efe153SLarry Finger rtlpriv->btcoexist.reg_bt_sco = 0; 2286f1d2b4d3SLarry Finger } 2287f1d2b4d3SLarry Finger 2288f1d2b4d3SLarry Finger void rtl8192ce_bt_hw_init(struct ieee80211_hw *hw) 2289f1d2b4d3SLarry Finger { 2290f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 2291f1d2b4d3SLarry Finger struct rtl_phy *rtlphy = &(rtlpriv->phy); 2292f1d2b4d3SLarry Finger 2293f1d2b4d3SLarry Finger u8 u1_tmp; 2294f1d2b4d3SLarry Finger 2295d5efe153SLarry Finger if (rtlpriv->btcoexist.bt_coexistence && 2296d5efe153SLarry Finger ((rtlpriv->btcoexist.bt_coexist_type == BT_CSR_BC4) || 2297d5efe153SLarry Finger rtlpriv->btcoexist.bt_coexist_type == BT_CSR_BC8)) { 2298f1d2b4d3SLarry Finger 2299d5efe153SLarry Finger if (rtlpriv->btcoexist.bt_ant_isolation) 2300f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, REG_GPIO_MUXCFG, 0xa0); 2301f1d2b4d3SLarry Finger 23024c8692d4SLarry Finger u1_tmp = rtl_read_byte(rtlpriv, 0x4fd) & BIT(0); 2303f1d2b4d3SLarry Finger u1_tmp = u1_tmp | 2304d5efe153SLarry Finger ((rtlpriv->btcoexist.bt_ant_isolation == 1) ? 23054c8692d4SLarry Finger 0 : BIT(1)) | 2306d5efe153SLarry Finger ((rtlpriv->btcoexist.bt_service == BT_SCO) ? 23074c8692d4SLarry Finger 0 : BIT(2)); 2308f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x4fd, u1_tmp); 2309f1d2b4d3SLarry Finger 2310f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_BT_COEX_TABLE+4, 0xaaaa9aaa); 2311f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_BT_COEX_TABLE+8, 0xffbd0040); 2312f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_BT_COEX_TABLE+0xc, 0x40000010); 2313f1d2b4d3SLarry Finger 2314f1d2b4d3SLarry Finger /* Config to 1T1R. */ 2315f1d2b4d3SLarry Finger if (rtlphy->rf_type == RF_1T1R) { 2316f1d2b4d3SLarry Finger u1_tmp = rtl_read_byte(rtlpriv, ROFDM0_TRXPATHENABLE); 23174c8692d4SLarry Finger u1_tmp &= ~(BIT(1)); 2318f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, ROFDM0_TRXPATHENABLE, u1_tmp); 2319f1d2b4d3SLarry Finger 2320f1d2b4d3SLarry Finger u1_tmp = rtl_read_byte(rtlpriv, ROFDM1_TRXPATHENABLE); 23214c8692d4SLarry Finger u1_tmp &= ~(BIT(1)); 2322f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, ROFDM1_TRXPATHENABLE, u1_tmp); 2323f1d2b4d3SLarry Finger } 2324f1d2b4d3SLarry Finger } 2325f1d2b4d3SLarry Finger } 2326f1d2b4d3SLarry Finger 2327f1d2b4d3SLarry Finger void rtl92ce_suspend(struct ieee80211_hw *hw) 2328f1d2b4d3SLarry Finger { 2329f1d2b4d3SLarry Finger } 2330f1d2b4d3SLarry Finger 2331f1d2b4d3SLarry Finger void rtl92ce_resume(struct ieee80211_hw *hw) 2332f1d2b4d3SLarry Finger { 2333f1d2b4d3SLarry Finger } 2334