Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved. |
| 3 | * |
| 4 | * This program is distributed in the hope that it will be useful, but WITHOUT |
| 5 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 6 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 7 | * more details. |
| 8 | * |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 9 | * The full GNU General Public License is included in this distribution in the |
| 10 | * file called LICENSE. |
| 11 | * |
| 12 | * Contact Information: |
| 13 | * wlanfae <wlanfae@realtek.com> |
| 14 | ******************************************************************************/ |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 15 | |
Mateusz Kulikowski | 77b6c42 | 2015-09-20 21:04:32 +0200 | [diff] [blame] | 16 | #include <linux/bitops.h> |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 17 | #include "rtl_core.h" |
| 18 | #include "r8192E_hw.h" |
| 19 | #include "r8192E_phyreg.h" |
| 20 | #include "r8190P_rtl8256.h" |
| 21 | #include "r8192E_phy.h" |
| 22 | #include "rtl_dm.h" |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 23 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 24 | #include "r8192E_hwimg.h" |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 25 | |
| 26 | static u32 RF_CHANNEL_TABLE_ZEBRA[] = { |
| 27 | 0, |
| 28 | 0x085c, |
| 29 | 0x08dc, |
| 30 | 0x095c, |
| 31 | 0x09dc, |
| 32 | 0x0a5c, |
| 33 | 0x0adc, |
| 34 | 0x0b5c, |
| 35 | 0x0bdc, |
| 36 | 0x0c5c, |
| 37 | 0x0cdc, |
| 38 | 0x0d5c, |
| 39 | 0x0ddc, |
| 40 | 0x0e5c, |
| 41 | 0x0f72, |
| 42 | }; |
| 43 | |
| 44 | /*************************Define local function prototype**********************/ |
| 45 | |
Mateusz Kulikowski | 5269f55 | 2015-09-20 10:13:18 +0200 | [diff] [blame] | 46 | static u32 _rtl92e_phy_rf_fw_read(struct net_device *dev, |
| 47 | enum rf90_radio_path eRFPath, u32 Offset); |
Mateusz Kulikowski | f957076 | 2015-09-20 10:13:19 +0200 | [diff] [blame] | 48 | static void _rtl92e_phy_rf_fw_write(struct net_device *dev, |
| 49 | enum rf90_radio_path eRFPath, u32 Offset, |
| 50 | u32 Data); |
Larry Finger | 49aab5f | 2011-08-25 14:07:05 -0500 | [diff] [blame] | 51 | |
Mateusz Kulikowski | e8411ff | 2015-09-20 10:14:05 +0200 | [diff] [blame] | 52 | static u32 _rtl92e_calculate_bit_shift(u32 dwBitMask) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 53 | { |
Mateusz Kulikowski | 77b6c42 | 2015-09-20 21:04:32 +0200 | [diff] [blame] | 54 | if (!dwBitMask) |
| 55 | return 32; |
| 56 | return ffs(dwBitMask) - 1; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 57 | } |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 58 | |
Mateusz Kulikowski | 5948d1f | 2015-07-19 19:27:47 +0200 | [diff] [blame] | 59 | u8 rtl92e_is_legal_rf_path(struct net_device *dev, u32 eRFPath) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 60 | { |
| 61 | u8 ret = 1; |
| 62 | struct r8192_priv *priv = rtllib_priv(dev); |
Matthew Casey | 3a6b70c | 2014-08-22 06:27:52 -0400 | [diff] [blame] | 63 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 64 | if (priv->rf_type == RF_2T4R) |
| 65 | ret = 0; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 66 | else if (priv->rf_type == RF_1T2R) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 67 | if (eRFPath == RF90_PATH_A || eRFPath == RF90_PATH_B) |
| 68 | ret = 1; |
| 69 | else if (eRFPath == RF90_PATH_C || eRFPath == RF90_PATH_D) |
| 70 | ret = 0; |
| 71 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 72 | return ret; |
| 73 | } |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 74 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 75 | void rtl92e_set_bb_reg(struct net_device *dev, u32 dwRegAddr, u32 dwBitMask, |
| 76 | u32 dwData) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 77 | { |
| 78 | |
| 79 | u32 OriginalValue, BitShift, NewValue; |
| 80 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 81 | if (dwBitMask != bMaskDWord) { |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 82 | OriginalValue = rtl92e_readl(dev, dwRegAddr); |
Mateusz Kulikowski | e8411ff | 2015-09-20 10:14:05 +0200 | [diff] [blame] | 83 | BitShift = _rtl92e_calculate_bit_shift(dwBitMask); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 84 | NewValue = (((OriginalValue) & (~dwBitMask)) | |
| 85 | (dwData << BitShift)); |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 86 | rtl92e_writel(dev, dwRegAddr, NewValue); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 87 | } else |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 88 | rtl92e_writel(dev, dwRegAddr, dwData); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 89 | } |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 90 | |
Mateusz Kulikowski | 3c351fe | 2015-07-19 19:27:56 +0200 | [diff] [blame] | 91 | u32 rtl92e_get_bb_reg(struct net_device *dev, u32 dwRegAddr, u32 dwBitMask) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 92 | { |
Amitoj Kaur Chawla | 1017214 | 2015-10-31 20:22:03 +0530 | [diff] [blame] | 93 | u32 OriginalValue, BitShift; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 94 | |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 95 | OriginalValue = rtl92e_readl(dev, dwRegAddr); |
Mateusz Kulikowski | e8411ff | 2015-09-20 10:14:05 +0200 | [diff] [blame] | 96 | BitShift = _rtl92e_calculate_bit_shift(dwBitMask); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 97 | |
Amitoj Kaur Chawla | 1017214 | 2015-10-31 20:22:03 +0530 | [diff] [blame] | 98 | return (OriginalValue & dwBitMask) >> BitShift; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 99 | } |
Mateusz Kulikowski | 6edb176 | 2015-09-20 10:13:22 +0200 | [diff] [blame] | 100 | |
| 101 | static u32 _rtl92e_phy_rf_read(struct net_device *dev, |
| 102 | enum rf90_radio_path eRFPath, u32 Offset) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 103 | { |
| 104 | struct r8192_priv *priv = rtllib_priv(dev); |
| 105 | u32 ret = 0; |
| 106 | u32 NewOffset = 0; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 107 | struct bb_reg_definition *pPhyReg = &priv->PHYRegDef[eRFPath]; |
Matthew Casey | 3a6b70c | 2014-08-22 06:27:52 -0400 | [diff] [blame] | 108 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 109 | Offset &= 0x3f; |
| 110 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 111 | if (priv->rf_chip == RF_8256) { |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 112 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0xf00, 0x0); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 113 | if (Offset >= 31) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 114 | priv->RfReg0Value[eRFPath] |= 0x140; |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 115 | rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, |
| 116 | bMaskDWord, |
| 117 | (priv->RfReg0Value[eRFPath]<<16)); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 118 | NewOffset = Offset - 30; |
| 119 | } else if (Offset >= 16) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 120 | priv->RfReg0Value[eRFPath] |= 0x100; |
| 121 | priv->RfReg0Value[eRFPath] &= (~0x40); |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 122 | rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, |
| 123 | bMaskDWord, |
| 124 | (priv->RfReg0Value[eRFPath]<<16)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 125 | |
| 126 | NewOffset = Offset - 15; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 127 | } else |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 128 | NewOffset = Offset; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 129 | } else { |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 130 | RT_TRACE((COMP_PHY|COMP_ERR), |
| 131 | "check RF type here, need to be 8256\n"); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 132 | NewOffset = Offset; |
| 133 | } |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 134 | rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, bLSSIReadAddress, |
| 135 | NewOffset); |
| 136 | rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x0); |
| 137 | rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x1); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 138 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 139 | mdelay(1); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 140 | |
Mateusz Kulikowski | 3c351fe | 2015-07-19 19:27:56 +0200 | [diff] [blame] | 141 | ret = rtl92e_get_bb_reg(dev, pPhyReg->rfLSSIReadBack, |
| 142 | bLSSIReadBackData); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 143 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 144 | if (priv->rf_chip == RF_8256) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 145 | priv->RfReg0Value[eRFPath] &= 0xebf; |
| 146 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 147 | rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, bMaskDWord, |
| 148 | (priv->RfReg0Value[eRFPath] << 16)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 149 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 150 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0x300, 0x3); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 151 | } |
| 152 | |
| 153 | |
| 154 | return ret; |
| 155 | |
| 156 | } |
| 157 | |
Mateusz Kulikowski | 6c2d5ae | 2015-09-20 10:13:23 +0200 | [diff] [blame] | 158 | static void _rtl92e_phy_rf_write(struct net_device *dev, |
| 159 | enum rf90_radio_path eRFPath, u32 Offset, |
| 160 | u32 Data) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 161 | { |
| 162 | struct r8192_priv *priv = rtllib_priv(dev); |
| 163 | u32 DataAndAddr = 0, NewOffset = 0; |
Larry Finger | 9bf6e4c | 2011-07-18 21:16:51 -0500 | [diff] [blame] | 164 | struct bb_reg_definition *pPhyReg = &priv->PHYRegDef[eRFPath]; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 165 | |
| 166 | Offset &= 0x3f; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 167 | if (priv->rf_chip == RF_8256) { |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 168 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0xf00, 0x0); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 169 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 170 | if (Offset >= 31) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 171 | priv->RfReg0Value[eRFPath] |= 0x140; |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 172 | rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, |
| 173 | bMaskDWord, |
| 174 | (priv->RfReg0Value[eRFPath] << 16)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 175 | NewOffset = Offset - 30; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 176 | } else if (Offset >= 16) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 177 | priv->RfReg0Value[eRFPath] |= 0x100; |
| 178 | priv->RfReg0Value[eRFPath] &= (~0x40); |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 179 | rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, |
| 180 | bMaskDWord, |
| 181 | (priv->RfReg0Value[eRFPath] << 16)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 182 | NewOffset = Offset - 15; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 183 | } else |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 184 | NewOffset = Offset; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 185 | } else { |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 186 | RT_TRACE((COMP_PHY|COMP_ERR), |
| 187 | "check RF type here, need to be 8256\n"); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 188 | NewOffset = Offset; |
| 189 | } |
| 190 | |
| 191 | DataAndAddr = (Data<<16) | (NewOffset&0x3f); |
| 192 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 193 | rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, bMaskDWord, DataAndAddr); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 194 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 195 | if (Offset == 0x0) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 196 | priv->RfReg0Value[eRFPath] = Data; |
| 197 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 198 | if (priv->rf_chip == RF_8256) { |
| 199 | if (Offset != 0) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 200 | priv->RfReg0Value[eRFPath] &= 0xebf; |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 201 | rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, |
| 202 | bMaskDWord, |
| 203 | (priv->RfReg0Value[eRFPath] << 16)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 204 | } |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 205 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0x300, 0x3); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 206 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 207 | } |
| 208 | |
Mateusz Kulikowski | b0e044f | 2015-07-19 19:27:53 +0200 | [diff] [blame] | 209 | void rtl92e_set_rf_reg(struct net_device *dev, enum rf90_radio_path eRFPath, |
| 210 | u32 RegAddr, u32 BitMask, u32 Data) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 211 | { |
| 212 | struct r8192_priv *priv = rtllib_priv(dev); |
| 213 | u32 Original_Value, BitShift, New_Value; |
| 214 | |
Mateusz Kulikowski | 5948d1f | 2015-07-19 19:27:47 +0200 | [diff] [blame] | 215 | if (!rtl92e_is_legal_rf_path(dev, eRFPath)) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 216 | return; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 217 | if (priv->rtllib->eRFPowerState != eRfOn && !priv->being_init_adapter) |
| 218 | return; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 219 | |
| 220 | RT_TRACE(COMP_PHY, "FW RF CTRL is not ready now\n"); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 221 | if (priv->Rf_Mode == RF_OP_By_FW) { |
| 222 | if (BitMask != bMask12Bits) { |
Mateusz Kulikowski | 5269f55 | 2015-09-20 10:13:18 +0200 | [diff] [blame] | 223 | Original_Value = _rtl92e_phy_rf_fw_read(dev, eRFPath, |
| 224 | RegAddr); |
Mateusz Kulikowski | e8411ff | 2015-09-20 10:14:05 +0200 | [diff] [blame] | 225 | BitShift = _rtl92e_calculate_bit_shift(BitMask); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 226 | New_Value = (((Original_Value) & (~BitMask)) | |
| 227 | (Data << BitShift)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 228 | |
Mateusz Kulikowski | f957076 | 2015-09-20 10:13:19 +0200 | [diff] [blame] | 229 | _rtl92e_phy_rf_fw_write(dev, eRFPath, RegAddr, |
| 230 | New_Value); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 231 | } else |
Mateusz Kulikowski | f957076 | 2015-09-20 10:13:19 +0200 | [diff] [blame] | 232 | _rtl92e_phy_rf_fw_write(dev, eRFPath, RegAddr, Data); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 233 | udelay(200); |
| 234 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 235 | } else { |
| 236 | if (BitMask != bMask12Bits) { |
Mateusz Kulikowski | 6edb176 | 2015-09-20 10:13:22 +0200 | [diff] [blame] | 237 | Original_Value = _rtl92e_phy_rf_read(dev, eRFPath, |
| 238 | RegAddr); |
Mateusz Kulikowski | e8411ff | 2015-09-20 10:14:05 +0200 | [diff] [blame] | 239 | BitShift = _rtl92e_calculate_bit_shift(BitMask); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 240 | New_Value = (((Original_Value) & (~BitMask)) | |
| 241 | (Data << BitShift)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 242 | |
Mateusz Kulikowski | 6c2d5ae | 2015-09-20 10:13:23 +0200 | [diff] [blame] | 243 | _rtl92e_phy_rf_write(dev, eRFPath, RegAddr, New_Value); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 244 | } else |
Mateusz Kulikowski | 6c2d5ae | 2015-09-20 10:13:23 +0200 | [diff] [blame] | 245 | _rtl92e_phy_rf_write(dev, eRFPath, RegAddr, Data); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 246 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 247 | } |
| 248 | |
Mateusz Kulikowski | 4d415de | 2015-07-19 19:27:51 +0200 | [diff] [blame] | 249 | u32 rtl92e_get_rf_reg(struct net_device *dev, enum rf90_radio_path eRFPath, |
| 250 | u32 RegAddr, u32 BitMask) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 251 | { |
| 252 | u32 Original_Value, Readback_Value, BitShift; |
| 253 | struct r8192_priv *priv = rtllib_priv(dev); |
Matthew Casey | 3a6b70c | 2014-08-22 06:27:52 -0400 | [diff] [blame] | 254 | |
Mateusz Kulikowski | 5948d1f | 2015-07-19 19:27:47 +0200 | [diff] [blame] | 255 | if (!rtl92e_is_legal_rf_path(dev, eRFPath)) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 256 | return 0; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 257 | if (priv->rtllib->eRFPowerState != eRfOn && !priv->being_init_adapter) |
| 258 | return 0; |
Binoy Jayan | 5333496 | 2016-06-01 14:56:54 +0530 | [diff] [blame] | 259 | mutex_lock(&priv->rf_mutex); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 260 | if (priv->Rf_Mode == RF_OP_By_FW) { |
Mateusz Kulikowski | 5269f55 | 2015-09-20 10:13:18 +0200 | [diff] [blame] | 261 | Original_Value = _rtl92e_phy_rf_fw_read(dev, eRFPath, RegAddr); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 262 | udelay(200); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 263 | } else { |
Mateusz Kulikowski | 6edb176 | 2015-09-20 10:13:22 +0200 | [diff] [blame] | 264 | Original_Value = _rtl92e_phy_rf_read(dev, eRFPath, RegAddr); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 265 | } |
Mateusz Kulikowski | e8411ff | 2015-09-20 10:14:05 +0200 | [diff] [blame] | 266 | BitShift = _rtl92e_calculate_bit_shift(BitMask); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 267 | Readback_Value = (Original_Value & BitMask) >> BitShift; |
Binoy Jayan | 5333496 | 2016-06-01 14:56:54 +0530 | [diff] [blame] | 268 | mutex_unlock(&priv->rf_mutex); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 269 | return Readback_Value; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 270 | } |
| 271 | |
Mateusz Kulikowski | 5269f55 | 2015-09-20 10:13:18 +0200 | [diff] [blame] | 272 | static u32 _rtl92e_phy_rf_fw_read(struct net_device *dev, |
| 273 | enum rf90_radio_path eRFPath, u32 Offset) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 274 | { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 275 | u32 Data = 0; |
| 276 | u8 time = 0; |
Matthew Casey | 3a6b70c | 2014-08-22 06:27:52 -0400 | [diff] [blame] | 277 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 278 | Data |= ((Offset & 0xFF) << 12); |
| 279 | Data |= ((eRFPath & 0x3) << 20); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 280 | Data |= 0x80000000; |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 281 | while (rtl92e_readl(dev, QPNR) & 0x80000000) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 282 | if (time++ < 100) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 283 | udelay(10); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 284 | else |
| 285 | break; |
| 286 | } |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 287 | rtl92e_writel(dev, QPNR, Data); |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 288 | while (rtl92e_readl(dev, QPNR) & 0x80000000) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 289 | if (time++ < 100) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 290 | udelay(10); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 291 | else |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 292 | return 0; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 293 | } |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 294 | return rtl92e_readl(dev, RF_DATA); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 295 | |
Mateusz Kulikowski | 14b40d9 | 2015-04-01 00:24:37 +0200 | [diff] [blame] | 296 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 297 | |
Mateusz Kulikowski | f957076 | 2015-09-20 10:13:19 +0200 | [diff] [blame] | 298 | static void _rtl92e_phy_rf_fw_write(struct net_device *dev, |
| 299 | enum rf90_radio_path eRFPath, u32 Offset, |
| 300 | u32 Data) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 301 | { |
| 302 | u8 time = 0; |
| 303 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 304 | Data |= ((Offset & 0xFF) << 12); |
| 305 | Data |= ((eRFPath & 0x3) << 20); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 306 | Data |= 0x400000; |
| 307 | Data |= 0x80000000; |
| 308 | |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 309 | while (rtl92e_readl(dev, QPNR) & 0x80000000) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 310 | if (time++ < 100) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 311 | udelay(10); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 312 | else |
| 313 | break; |
| 314 | } |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 315 | rtl92e_writel(dev, QPNR, Data); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 316 | |
Mateusz Kulikowski | 14b40d9 | 2015-04-01 00:24:37 +0200 | [diff] [blame] | 317 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 318 | |
| 319 | |
Mateusz Kulikowski | 0efe710 | 2015-07-19 19:27:48 +0200 | [diff] [blame] | 320 | void rtl92e_config_mac(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 321 | { |
| 322 | u32 dwArrayLen = 0, i = 0; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 323 | u32 *pdwArray = NULL; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 324 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 325 | |
| 326 | if (priv->bTXPowerDataReadFromEEPORM) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 327 | RT_TRACE(COMP_PHY, "Rtl819XMACPHY_Array_PG\n"); |
| 328 | dwArrayLen = MACPHY_Array_PGLength; |
| 329 | pdwArray = Rtl819XMACPHY_Array_PG; |
| 330 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 331 | } else { |
| 332 | RT_TRACE(COMP_PHY, "Read rtl819XMACPHY_Array\n"); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 333 | dwArrayLen = MACPHY_ArrayLength; |
| 334 | pdwArray = Rtl819XMACPHY_Array; |
| 335 | } |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 336 | for (i = 0; i < dwArrayLen; i += 3) { |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 337 | RT_TRACE(COMP_DBG, |
| 338 | "The Rtl8190MACPHY_Array[0] is %x Rtl8190MACPHY_Array[1] is %x Rtl8190MACPHY_Array[2] is %x\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 339 | pdwArray[i], pdwArray[i+1], pdwArray[i+2]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 340 | if (pdwArray[i] == 0x318) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 341 | pdwArray[i+2] = 0x00000800; |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 342 | rtl92e_set_bb_reg(dev, pdwArray[i], pdwArray[i+1], |
| 343 | pdwArray[i+2]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 344 | } |
| 345 | return; |
| 346 | |
| 347 | } |
| 348 | |
Mateusz Kulikowski | a059e47 | 2015-09-20 10:13:20 +0200 | [diff] [blame] | 349 | static void _rtl92e_phy_config_bb(struct net_device *dev, u8 ConfigType) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 350 | { |
| 351 | int i; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 352 | u32 *Rtl819XPHY_REGArray_Table = NULL; |
| 353 | u32 *Rtl819XAGCTAB_Array_Table = NULL; |
| 354 | u16 AGCTAB_ArrayLen, PHY_REGArrayLen = 0; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 355 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 356 | |
| 357 | AGCTAB_ArrayLen = AGCTAB_ArrayLength; |
| 358 | Rtl819XAGCTAB_Array_Table = Rtl819XAGCTAB_Array; |
| 359 | if (priv->rf_type == RF_2T4R) { |
| 360 | PHY_REGArrayLen = PHY_REGArrayLength; |
| 361 | Rtl819XPHY_REGArray_Table = Rtl819XPHY_REGArray; |
| 362 | } else if (priv->rf_type == RF_1T2R) { |
| 363 | PHY_REGArrayLen = PHY_REG_1T2RArrayLength; |
| 364 | Rtl819XPHY_REGArray_Table = Rtl819XPHY_REG_1T2RArray; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 365 | } |
| 366 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 367 | if (ConfigType == BaseBand_Config_PHY_REG) { |
| 368 | for (i = 0; i < PHY_REGArrayLen; i += 2) { |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 369 | rtl92e_set_bb_reg(dev, Rtl819XPHY_REGArray_Table[i], |
| 370 | bMaskDWord, |
| 371 | Rtl819XPHY_REGArray_Table[i+1]); |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 372 | RT_TRACE(COMP_DBG, |
| 373 | "i: %x, The Rtl819xUsbPHY_REGArray[0] is %x Rtl819xUsbPHY_REGArray[1] is %x\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 374 | i, Rtl819XPHY_REGArray_Table[i], |
| 375 | Rtl819XPHY_REGArray_Table[i+1]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 376 | } |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 377 | } else if (ConfigType == BaseBand_Config_AGC_TAB) { |
| 378 | for (i = 0; i < AGCTAB_ArrayLen; i += 2) { |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 379 | rtl92e_set_bb_reg(dev, Rtl819XAGCTAB_Array_Table[i], |
| 380 | bMaskDWord, |
| 381 | Rtl819XAGCTAB_Array_Table[i+1]); |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 382 | RT_TRACE(COMP_DBG, |
| 383 | "i:%x, The rtl819XAGCTAB_Array[0] is %x rtl819XAGCTAB_Array[1] is %x\n", |
| 384 | i, Rtl819XAGCTAB_Array_Table[i], |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 385 | Rtl819XAGCTAB_Array_Table[i+1]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 386 | } |
| 387 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 388 | } |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 389 | |
Mateusz Kulikowski | 003486f | 2015-09-20 10:14:06 +0200 | [diff] [blame] | 390 | static void _rtl92e_init_bb_rf_reg_def(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 391 | { |
| 392 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 393 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 394 | priv->PHYRegDef[RF90_PATH_A].rfintfs = rFPGA0_XAB_RFInterfaceSW; |
| 395 | priv->PHYRegDef[RF90_PATH_B].rfintfs = rFPGA0_XAB_RFInterfaceSW; |
| 396 | priv->PHYRegDef[RF90_PATH_C].rfintfs = rFPGA0_XCD_RFInterfaceSW; |
| 397 | priv->PHYRegDef[RF90_PATH_D].rfintfs = rFPGA0_XCD_RFInterfaceSW; |
| 398 | |
| 399 | priv->PHYRegDef[RF90_PATH_A].rfintfi = rFPGA0_XAB_RFInterfaceRB; |
| 400 | priv->PHYRegDef[RF90_PATH_B].rfintfi = rFPGA0_XAB_RFInterfaceRB; |
| 401 | priv->PHYRegDef[RF90_PATH_C].rfintfi = rFPGA0_XCD_RFInterfaceRB; |
| 402 | priv->PHYRegDef[RF90_PATH_D].rfintfi = rFPGA0_XCD_RFInterfaceRB; |
| 403 | |
| 404 | priv->PHYRegDef[RF90_PATH_A].rfintfo = rFPGA0_XA_RFInterfaceOE; |
| 405 | priv->PHYRegDef[RF90_PATH_B].rfintfo = rFPGA0_XB_RFInterfaceOE; |
| 406 | priv->PHYRegDef[RF90_PATH_C].rfintfo = rFPGA0_XC_RFInterfaceOE; |
| 407 | priv->PHYRegDef[RF90_PATH_D].rfintfo = rFPGA0_XD_RFInterfaceOE; |
| 408 | |
| 409 | priv->PHYRegDef[RF90_PATH_A].rfintfe = rFPGA0_XA_RFInterfaceOE; |
| 410 | priv->PHYRegDef[RF90_PATH_B].rfintfe = rFPGA0_XB_RFInterfaceOE; |
| 411 | priv->PHYRegDef[RF90_PATH_C].rfintfe = rFPGA0_XC_RFInterfaceOE; |
| 412 | priv->PHYRegDef[RF90_PATH_D].rfintfe = rFPGA0_XD_RFInterfaceOE; |
| 413 | |
| 414 | priv->PHYRegDef[RF90_PATH_A].rf3wireOffset = rFPGA0_XA_LSSIParameter; |
| 415 | priv->PHYRegDef[RF90_PATH_B].rf3wireOffset = rFPGA0_XB_LSSIParameter; |
| 416 | priv->PHYRegDef[RF90_PATH_C].rf3wireOffset = rFPGA0_XC_LSSIParameter; |
| 417 | priv->PHYRegDef[RF90_PATH_D].rf3wireOffset = rFPGA0_XD_LSSIParameter; |
| 418 | |
| 419 | priv->PHYRegDef[RF90_PATH_A].rfLSSI_Select = rFPGA0_XAB_RFParameter; |
| 420 | priv->PHYRegDef[RF90_PATH_B].rfLSSI_Select = rFPGA0_XAB_RFParameter; |
| 421 | priv->PHYRegDef[RF90_PATH_C].rfLSSI_Select = rFPGA0_XCD_RFParameter; |
| 422 | priv->PHYRegDef[RF90_PATH_D].rfLSSI_Select = rFPGA0_XCD_RFParameter; |
| 423 | |
| 424 | priv->PHYRegDef[RF90_PATH_A].rfTxGainStage = rFPGA0_TxGainStage; |
| 425 | priv->PHYRegDef[RF90_PATH_B].rfTxGainStage = rFPGA0_TxGainStage; |
| 426 | priv->PHYRegDef[RF90_PATH_C].rfTxGainStage = rFPGA0_TxGainStage; |
| 427 | priv->PHYRegDef[RF90_PATH_D].rfTxGainStage = rFPGA0_TxGainStage; |
| 428 | |
| 429 | priv->PHYRegDef[RF90_PATH_A].rfHSSIPara1 = rFPGA0_XA_HSSIParameter1; |
| 430 | priv->PHYRegDef[RF90_PATH_B].rfHSSIPara1 = rFPGA0_XB_HSSIParameter1; |
| 431 | priv->PHYRegDef[RF90_PATH_C].rfHSSIPara1 = rFPGA0_XC_HSSIParameter1; |
| 432 | priv->PHYRegDef[RF90_PATH_D].rfHSSIPara1 = rFPGA0_XD_HSSIParameter1; |
| 433 | |
| 434 | priv->PHYRegDef[RF90_PATH_A].rfHSSIPara2 = rFPGA0_XA_HSSIParameter2; |
| 435 | priv->PHYRegDef[RF90_PATH_B].rfHSSIPara2 = rFPGA0_XB_HSSIParameter2; |
| 436 | priv->PHYRegDef[RF90_PATH_C].rfHSSIPara2 = rFPGA0_XC_HSSIParameter2; |
| 437 | priv->PHYRegDef[RF90_PATH_D].rfHSSIPara2 = rFPGA0_XD_HSSIParameter2; |
| 438 | |
| 439 | priv->PHYRegDef[RF90_PATH_A].rfSwitchControl = rFPGA0_XAB_SwitchControl; |
| 440 | priv->PHYRegDef[RF90_PATH_B].rfSwitchControl = rFPGA0_XAB_SwitchControl; |
| 441 | priv->PHYRegDef[RF90_PATH_C].rfSwitchControl = rFPGA0_XCD_SwitchControl; |
| 442 | priv->PHYRegDef[RF90_PATH_D].rfSwitchControl = rFPGA0_XCD_SwitchControl; |
| 443 | |
| 444 | priv->PHYRegDef[RF90_PATH_A].rfAGCControl1 = rOFDM0_XAAGCCore1; |
| 445 | priv->PHYRegDef[RF90_PATH_B].rfAGCControl1 = rOFDM0_XBAGCCore1; |
| 446 | priv->PHYRegDef[RF90_PATH_C].rfAGCControl1 = rOFDM0_XCAGCCore1; |
| 447 | priv->PHYRegDef[RF90_PATH_D].rfAGCControl1 = rOFDM0_XDAGCCore1; |
| 448 | |
| 449 | priv->PHYRegDef[RF90_PATH_A].rfAGCControl2 = rOFDM0_XAAGCCore2; |
| 450 | priv->PHYRegDef[RF90_PATH_B].rfAGCControl2 = rOFDM0_XBAGCCore2; |
| 451 | priv->PHYRegDef[RF90_PATH_C].rfAGCControl2 = rOFDM0_XCAGCCore2; |
| 452 | priv->PHYRegDef[RF90_PATH_D].rfAGCControl2 = rOFDM0_XDAGCCore2; |
| 453 | |
| 454 | priv->PHYRegDef[RF90_PATH_A].rfRxIQImbalance = rOFDM0_XARxIQImbalance; |
| 455 | priv->PHYRegDef[RF90_PATH_B].rfRxIQImbalance = rOFDM0_XBRxIQImbalance; |
| 456 | priv->PHYRegDef[RF90_PATH_C].rfRxIQImbalance = rOFDM0_XCRxIQImbalance; |
| 457 | priv->PHYRegDef[RF90_PATH_D].rfRxIQImbalance = rOFDM0_XDRxIQImbalance; |
| 458 | |
| 459 | priv->PHYRegDef[RF90_PATH_A].rfRxAFE = rOFDM0_XARxAFE; |
| 460 | priv->PHYRegDef[RF90_PATH_B].rfRxAFE = rOFDM0_XBRxAFE; |
| 461 | priv->PHYRegDef[RF90_PATH_C].rfRxAFE = rOFDM0_XCRxAFE; |
| 462 | priv->PHYRegDef[RF90_PATH_D].rfRxAFE = rOFDM0_XDRxAFE; |
| 463 | |
| 464 | priv->PHYRegDef[RF90_PATH_A].rfTxIQImbalance = rOFDM0_XATxIQImbalance; |
| 465 | priv->PHYRegDef[RF90_PATH_B].rfTxIQImbalance = rOFDM0_XBTxIQImbalance; |
| 466 | priv->PHYRegDef[RF90_PATH_C].rfTxIQImbalance = rOFDM0_XCTxIQImbalance; |
| 467 | priv->PHYRegDef[RF90_PATH_D].rfTxIQImbalance = rOFDM0_XDTxIQImbalance; |
| 468 | |
| 469 | priv->PHYRegDef[RF90_PATH_A].rfTxAFE = rOFDM0_XATxAFE; |
| 470 | priv->PHYRegDef[RF90_PATH_B].rfTxAFE = rOFDM0_XBTxAFE; |
| 471 | priv->PHYRegDef[RF90_PATH_C].rfTxAFE = rOFDM0_XCTxAFE; |
| 472 | priv->PHYRegDef[RF90_PATH_D].rfTxAFE = rOFDM0_XDTxAFE; |
| 473 | |
| 474 | priv->PHYRegDef[RF90_PATH_A].rfLSSIReadBack = rFPGA0_XA_LSSIReadBack; |
| 475 | priv->PHYRegDef[RF90_PATH_B].rfLSSIReadBack = rFPGA0_XB_LSSIReadBack; |
| 476 | priv->PHYRegDef[RF90_PATH_C].rfLSSIReadBack = rFPGA0_XC_LSSIReadBack; |
| 477 | priv->PHYRegDef[RF90_PATH_D].rfLSSIReadBack = rFPGA0_XD_LSSIReadBack; |
| 478 | |
| 479 | } |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 480 | |
Mateusz Kulikowski | e21d14d | 2015-07-19 19:27:46 +0200 | [diff] [blame] | 481 | bool rtl92e_check_bb_and_rf(struct net_device *dev, enum hw90_block CheckBlock, |
| 482 | enum rf90_radio_path eRFPath) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 483 | { |
| 484 | bool ret = true; |
| 485 | u32 i, CheckTimes = 4, dwRegRead = 0; |
| 486 | u32 WriteAddr[4]; |
| 487 | u32 WriteData[] = {0xfffff027, 0xaa55a02f, 0x00000027, 0x55aa502f}; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 488 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 489 | WriteAddr[HW90_BLOCK_MAC] = 0x100; |
| 490 | WriteAddr[HW90_BLOCK_PHY0] = 0x900; |
| 491 | WriteAddr[HW90_BLOCK_PHY1] = 0x800; |
| 492 | WriteAddr[HW90_BLOCK_RF] = 0x3; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 493 | RT_TRACE(COMP_PHY, "=======>%s(), CheckBlock:%d\n", __func__, |
| 494 | CheckBlock); |
Mateusz Kulikowski | 156b80d | 2015-05-31 20:19:49 +0200 | [diff] [blame] | 495 | |
| 496 | if (CheckBlock == HW90_BLOCK_MAC) { |
| 497 | netdev_warn(dev, "%s(): No checks available for MAC block.\n", |
| 498 | __func__); |
| 499 | return ret; |
| 500 | } |
| 501 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 502 | for (i = 0; i < CheckTimes; i++) { |
| 503 | switch (CheckBlock) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 504 | case HW90_BLOCK_PHY0: |
| 505 | case HW90_BLOCK_PHY1: |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 506 | rtl92e_writel(dev, WriteAddr[CheckBlock], |
| 507 | WriteData[i]); |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 508 | dwRegRead = rtl92e_readl(dev, WriteAddr[CheckBlock]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 509 | break; |
| 510 | |
| 511 | case HW90_BLOCK_RF: |
| 512 | WriteData[i] &= 0xfff; |
Mateusz Kulikowski | b0e044f | 2015-07-19 19:27:53 +0200 | [diff] [blame] | 513 | rtl92e_set_rf_reg(dev, eRFPath, |
| 514 | WriteAddr[HW90_BLOCK_RF], |
| 515 | bMask12Bits, WriteData[i]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 516 | mdelay(10); |
Mateusz Kulikowski | 4d415de | 2015-07-19 19:27:51 +0200 | [diff] [blame] | 517 | dwRegRead = rtl92e_get_rf_reg(dev, eRFPath, |
| 518 | WriteAddr[HW90_BLOCK_RF], |
| 519 | bMaskDWord); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 520 | mdelay(10); |
| 521 | break; |
| 522 | |
| 523 | default: |
| 524 | ret = false; |
| 525 | break; |
| 526 | } |
| 527 | |
| 528 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 529 | if (dwRegRead != WriteData[i]) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 530 | netdev_warn(dev, "%s(): Check failed.\n", __func__); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 531 | ret = false; |
| 532 | break; |
| 533 | } |
| 534 | } |
| 535 | |
| 536 | return ret; |
| 537 | } |
| 538 | |
Mateusz Kulikowski | 43af9f4 | 2015-09-20 10:14:04 +0200 | [diff] [blame] | 539 | static bool _rtl92e_bb_config_para_file(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 540 | { |
| 541 | struct r8192_priv *priv = rtllib_priv(dev); |
| 542 | bool rtStatus = true; |
| 543 | u8 bRegValue = 0, eCheckItem = 0; |
| 544 | u32 dwRegValue = 0; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 545 | |
Mateusz Kulikowski | b59a4ca | 2015-07-19 19:28:09 +0200 | [diff] [blame] | 546 | bRegValue = rtl92e_readb(dev, BB_GLOBAL_RESET); |
Mateusz Kulikowski | d8ae196 | 2015-07-19 19:28:26 +0200 | [diff] [blame] | 547 | rtl92e_writeb(dev, BB_GLOBAL_RESET, (bRegValue|BB_GLOBAL_RESET_BIT)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 548 | |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 549 | dwRegValue = rtl92e_readl(dev, CPU_GEN); |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 550 | rtl92e_writel(dev, CPU_GEN, (dwRegValue&(~CPU_GEN_BB_RST))); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 551 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 552 | for (eCheckItem = (enum hw90_block)HW90_BLOCK_PHY0; |
| 553 | eCheckItem <= HW90_BLOCK_PHY1; eCheckItem++) { |
Mateusz Kulikowski | e21d14d | 2015-07-19 19:27:46 +0200 | [diff] [blame] | 554 | rtStatus = rtl92e_check_bb_and_rf(dev, |
| 555 | (enum hw90_block)eCheckItem, |
| 556 | (enum rf90_radio_path)0); |
Valentina Manea | 4bb0142 | 2013-10-25 11:28:10 +0300 | [diff] [blame] | 557 | if (!rtStatus) { |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 558 | RT_TRACE((COMP_ERR | COMP_PHY), |
Mateusz Kulikowski | e4a1433 | 2015-07-19 19:27:14 +0200 | [diff] [blame] | 559 | "rtl92e_config_rf():Check PHY%d Fail!!\n", |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 560 | eCheckItem-1); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 561 | return rtStatus; |
| 562 | } |
| 563 | } |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 564 | rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bCCKEn|bOFDMEn, 0x0); |
Mateusz Kulikowski | a059e47 | 2015-09-20 10:13:20 +0200 | [diff] [blame] | 565 | _rtl92e_phy_config_bb(dev, BaseBand_Config_PHY_REG); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 566 | |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 567 | dwRegValue = rtl92e_readl(dev, CPU_GEN); |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 568 | rtl92e_writel(dev, CPU_GEN, (dwRegValue|CPU_GEN_BB_RST)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 569 | |
Mateusz Kulikowski | a059e47 | 2015-09-20 10:13:20 +0200 | [diff] [blame] | 570 | _rtl92e_phy_config_bb(dev, BaseBand_Config_AGC_TAB); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 571 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 572 | if (priv->IC_Cut > VERSION_8190_BD) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 573 | if (priv->rf_type == RF_2T4R) |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 574 | dwRegValue = (priv->AntennaTxPwDiff[2]<<8 | |
| 575 | priv->AntennaTxPwDiff[1]<<4 | |
| 576 | priv->AntennaTxPwDiff[0]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 577 | else |
| 578 | dwRegValue = 0x0; |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 579 | rtl92e_set_bb_reg(dev, rFPGA0_TxGainStage, |
| 580 | (bXBTxAGC|bXCTxAGC|bXDTxAGC), dwRegValue); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 581 | |
| 582 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 583 | dwRegValue = priv->CrystalCap; |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 584 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, bXtalCap92x, |
| 585 | dwRegValue); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 586 | } |
| 587 | |
| 588 | return rtStatus; |
| 589 | } |
Mateusz Kulikowski | 2949353 | 2015-07-19 19:27:45 +0200 | [diff] [blame] | 590 | bool rtl92e_config_bb(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 591 | { |
Mateusz Kulikowski | 003486f | 2015-09-20 10:14:06 +0200 | [diff] [blame] | 592 | _rtl92e_init_bb_rf_reg_def(dev); |
Mateusz Kulikowski | 43af9f4 | 2015-09-20 10:14:04 +0200 | [diff] [blame] | 593 | return _rtl92e_bb_config_para_file(dev); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 594 | } |
| 595 | |
Mateusz Kulikowski | 78cc16f | 2015-07-19 19:27:50 +0200 | [diff] [blame] | 596 | void rtl92e_get_tx_power(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 597 | { |
| 598 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 599 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 600 | priv->MCSTxPowerLevelOriginalOffset[0] = |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 601 | rtl92e_readl(dev, rTxAGC_Rate18_06); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 602 | priv->MCSTxPowerLevelOriginalOffset[1] = |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 603 | rtl92e_readl(dev, rTxAGC_Rate54_24); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 604 | priv->MCSTxPowerLevelOriginalOffset[2] = |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 605 | rtl92e_readl(dev, rTxAGC_Mcs03_Mcs00); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 606 | priv->MCSTxPowerLevelOriginalOffset[3] = |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 607 | rtl92e_readl(dev, rTxAGC_Mcs07_Mcs04); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 608 | priv->MCSTxPowerLevelOriginalOffset[4] = |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 609 | rtl92e_readl(dev, rTxAGC_Mcs11_Mcs08); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 610 | priv->MCSTxPowerLevelOriginalOffset[5] = |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 611 | rtl92e_readl(dev, rTxAGC_Mcs15_Mcs12); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 612 | |
Mateusz Kulikowski | b59a4ca | 2015-07-19 19:28:09 +0200 | [diff] [blame] | 613 | priv->DefaultInitialGain[0] = rtl92e_readb(dev, rOFDM0_XAAGCCore1); |
| 614 | priv->DefaultInitialGain[1] = rtl92e_readb(dev, rOFDM0_XBAGCCore1); |
| 615 | priv->DefaultInitialGain[2] = rtl92e_readb(dev, rOFDM0_XCAGCCore1); |
| 616 | priv->DefaultInitialGain[3] = rtl92e_readb(dev, rOFDM0_XDAGCCore1); |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 617 | RT_TRACE(COMP_INIT, |
| 618 | "Default initial gain (c50=0x%x, c58=0x%x, c60=0x%x, c68=0x%x)\n", |
Mateusz Kulikowski | 35e33b0 | 2015-05-31 20:19:40 +0200 | [diff] [blame] | 619 | priv->DefaultInitialGain[0], priv->DefaultInitialGain[1], |
| 620 | priv->DefaultInitialGain[2], priv->DefaultInitialGain[3]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 621 | |
Mateusz Kulikowski | b59a4ca | 2015-07-19 19:28:09 +0200 | [diff] [blame] | 622 | priv->framesync = rtl92e_readb(dev, rOFDM0_RxDetector3); |
Mateusz Kulikowski | 99aa47e | 2015-07-19 19:28:10 +0200 | [diff] [blame] | 623 | priv->framesyncC34 = rtl92e_readl(dev, rOFDM0_RxDetector2); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 624 | RT_TRACE(COMP_INIT, "Default framesync (0x%x) = 0x%x\n", |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 625 | rOFDM0_RxDetector3, priv->framesync); |
Mateusz Kulikowski | 1c0a7c0 | 2015-07-19 19:28:11 +0200 | [diff] [blame] | 626 | priv->SifsTime = rtl92e_readw(dev, SIFS); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 627 | } |
| 628 | |
Mateusz Kulikowski | 5aa1b9c | 2015-07-19 19:27:54 +0200 | [diff] [blame] | 629 | void rtl92e_set_tx_power(struct net_device *dev, u8 channel) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 630 | { |
| 631 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 632 | u8 powerlevel = 0, powerlevelOFDM24G = 0; |
Arnd Bergmann | 5d5fd35 | 2016-07-20 17:26:05 +0200 | [diff] [blame] | 633 | s8 ant_pwr_diff; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 634 | u32 u4RegValue; |
| 635 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 636 | if (priv->epromtype == EEPROM_93C46) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 637 | powerlevel = priv->TxPowerLevelCCK[channel-1]; |
| 638 | powerlevelOFDM24G = priv->TxPowerLevelOFDM24G[channel-1]; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 639 | } else if (priv->epromtype == EEPROM_93C56) { |
| 640 | if (priv->rf_type == RF_1T2R) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 641 | powerlevel = priv->TxPowerLevelCCK_C[channel-1]; |
| 642 | powerlevelOFDM24G = priv->TxPowerLevelOFDM24G_C[channel-1]; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 643 | } else if (priv->rf_type == RF_2T4R) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 644 | powerlevel = priv->TxPowerLevelCCK_A[channel-1]; |
| 645 | powerlevelOFDM24G = priv->TxPowerLevelOFDM24G_A[channel-1]; |
| 646 | |
| 647 | ant_pwr_diff = priv->TxPowerLevelOFDM24G_C[channel-1] |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 648 | - priv->TxPowerLevelOFDM24G_A[channel-1]; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 649 | |
| 650 | priv->RF_C_TxPwDiff = ant_pwr_diff; |
| 651 | |
| 652 | ant_pwr_diff &= 0xf; |
| 653 | |
| 654 | priv->AntennaTxPwDiff[2] = 0; |
| 655 | priv->AntennaTxPwDiff[1] = (u8)(ant_pwr_diff); |
| 656 | priv->AntennaTxPwDiff[0] = 0; |
| 657 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 658 | u4RegValue = (priv->AntennaTxPwDiff[2]<<8 | |
| 659 | priv->AntennaTxPwDiff[1]<<4 | |
| 660 | priv->AntennaTxPwDiff[0]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 661 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 662 | rtl92e_set_bb_reg(dev, rFPGA0_TxGainStage, |
| 663 | (bXBTxAGC|bXCTxAGC|bXDTxAGC), |
| 664 | u4RegValue); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 665 | } |
| 666 | } |
Mike McCormack | cb76215 | 2011-07-11 08:56:20 +0900 | [diff] [blame] | 667 | switch (priv->rf_chip) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 668 | case RF_8225: |
| 669 | break; |
| 670 | case RF_8256: |
Mateusz Kulikowski | abfda58 | 2015-07-19 19:27:16 +0200 | [diff] [blame] | 671 | rtl92e_set_cck_tx_power(dev, powerlevel); |
Mateusz Kulikowski | 2497ef5 | 2015-07-19 19:27:17 +0200 | [diff] [blame] | 672 | rtl92e_set_ofdm_tx_power(dev, powerlevelOFDM24G); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 673 | break; |
| 674 | case RF_8258: |
| 675 | break; |
| 676 | default: |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 677 | netdev_err(dev, "Invalid RF Chip ID.\n"); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 678 | break; |
| 679 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 680 | } |
| 681 | |
Mateusz Kulikowski | 31aebbe | 2015-07-19 19:27:52 +0200 | [diff] [blame] | 682 | bool rtl92e_config_phy(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 683 | { |
| 684 | struct r8192_priv *priv = rtllib_priv(dev); |
| 685 | bool rtStatus = true; |
Matthew Casey | 3a6b70c | 2014-08-22 06:27:52 -0400 | [diff] [blame] | 686 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 687 | switch (priv->rf_chip) { |
| 688 | case RF_8225: |
| 689 | break; |
| 690 | case RF_8256: |
Mateusz Kulikowski | e4a1433 | 2015-07-19 19:27:14 +0200 | [diff] [blame] | 691 | rtStatus = rtl92e_config_rf(dev); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 692 | break; |
| 693 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 694 | case RF_8258: |
| 695 | break; |
| 696 | case RF_PSEUDO_11N: |
| 697 | break; |
| 698 | |
| 699 | default: |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 700 | netdev_err(dev, "Invalid RF Chip ID.\n"); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 701 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 702 | } |
| 703 | return rtStatus; |
| 704 | } |
| 705 | |
Mateusz Kulikowski | 2504c11 | 2015-07-19 19:27:49 +0200 | [diff] [blame] | 706 | u8 rtl92e_config_rf_path(struct net_device *dev, enum rf90_radio_path eRFPath) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 707 | { |
| 708 | |
| 709 | int i; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 710 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 711 | switch (eRFPath) { |
| 712 | case RF90_PATH_A: |
| 713 | for (i = 0; i < RadioA_ArrayLength; i += 2) { |
| 714 | if (Rtl819XRadioA_Array[i] == 0xfe) { |
| 715 | msleep(100); |
| 716 | continue; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 717 | } |
Mateusz Kulikowski | b0e044f | 2015-07-19 19:27:53 +0200 | [diff] [blame] | 718 | rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioA_Array[i], |
| 719 | bMask12Bits, |
| 720 | Rtl819XRadioA_Array[i+1]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 721 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 722 | } |
| 723 | break; |
| 724 | case RF90_PATH_B: |
| 725 | for (i = 0; i < RadioB_ArrayLength; i += 2) { |
| 726 | if (Rtl819XRadioB_Array[i] == 0xfe) { |
| 727 | msleep(100); |
| 728 | continue; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 729 | } |
Mateusz Kulikowski | b0e044f | 2015-07-19 19:27:53 +0200 | [diff] [blame] | 730 | rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioB_Array[i], |
| 731 | bMask12Bits, |
| 732 | Rtl819XRadioB_Array[i+1]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 733 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 734 | } |
| 735 | break; |
| 736 | case RF90_PATH_C: |
| 737 | for (i = 0; i < RadioC_ArrayLength; i += 2) { |
| 738 | if (Rtl819XRadioC_Array[i] == 0xfe) { |
| 739 | msleep(100); |
| 740 | continue; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 741 | } |
Mateusz Kulikowski | b0e044f | 2015-07-19 19:27:53 +0200 | [diff] [blame] | 742 | rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioC_Array[i], |
| 743 | bMask12Bits, |
| 744 | Rtl819XRadioC_Array[i+1]); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 745 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 746 | } |
| 747 | break; |
| 748 | case RF90_PATH_D: |
| 749 | for (i = 0; i < RadioD_ArrayLength; i += 2) { |
| 750 | if (Rtl819XRadioD_Array[i] == 0xfe) { |
Mateusz Kulikowski | fc00af0 | 2015-09-20 21:04:26 +0200 | [diff] [blame] | 751 | msleep(100); |
| 752 | continue; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 753 | } |
Mateusz Kulikowski | b0e044f | 2015-07-19 19:27:53 +0200 | [diff] [blame] | 754 | rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioD_Array[i], |
| 755 | bMask12Bits, |
| 756 | Rtl819XRadioD_Array[i+1]); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 757 | |
| 758 | } |
| 759 | break; |
| 760 | default: |
| 761 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 762 | } |
| 763 | |
Peter Senna Tschudin | 4764ca9 | 2014-05-26 16:08:50 +0200 | [diff] [blame] | 764 | return 0; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 765 | |
| 766 | } |
Mateusz Kulikowski | 0e54431 | 2015-09-20 10:14:08 +0200 | [diff] [blame] | 767 | |
| 768 | static void _rtl92e_set_tx_power_level(struct net_device *dev, u8 channel) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 769 | { |
| 770 | struct r8192_priv *priv = rtllib_priv(dev); |
| 771 | u8 powerlevel = priv->TxPowerLevelCCK[channel-1]; |
| 772 | u8 powerlevelOFDM24G = priv->TxPowerLevelOFDM24G[channel-1]; |
| 773 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 774 | switch (priv->rf_chip) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 775 | case RF_8225: |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 776 | break; |
| 777 | |
| 778 | case RF_8256: |
Mateusz Kulikowski | abfda58 | 2015-07-19 19:27:16 +0200 | [diff] [blame] | 779 | rtl92e_set_cck_tx_power(dev, powerlevel); |
Mateusz Kulikowski | 2497ef5 | 2015-07-19 19:27:17 +0200 | [diff] [blame] | 780 | rtl92e_set_ofdm_tx_power(dev, powerlevelOFDM24G); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 781 | break; |
| 782 | |
| 783 | case RF_8258: |
| 784 | break; |
| 785 | default: |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 786 | netdev_warn(dev, "%s(): Invalid RF Chip ID\n", __func__); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 787 | break; |
| 788 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 789 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 790 | |
Mateusz Kulikowski | 5b94840 | 2015-09-20 10:13:24 +0200 | [diff] [blame] | 791 | static u8 _rtl92e_phy_set_sw_chnl_cmd_array(struct net_device *dev, |
| 792 | struct sw_chnl_cmd *CmdTable, |
| 793 | u32 CmdTableIdx, u32 CmdTableSz, |
| 794 | enum sw_chnl_cmd_id CmdID, |
| 795 | u32 Para1, u32 Para2, u32 msDelay) |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 796 | { |
| 797 | struct sw_chnl_cmd *pCmd; |
| 798 | |
| 799 | if (CmdTable == NULL) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 800 | netdev_err(dev, "%s(): CmdTable cannot be NULL.\n", __func__); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 801 | return false; |
| 802 | } |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 803 | if (CmdTableIdx >= CmdTableSz) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 804 | netdev_err(dev, "%s(): Invalid index requested.\n", __func__); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 805 | return false; |
| 806 | } |
| 807 | |
| 808 | pCmd = CmdTable + CmdTableIdx; |
| 809 | pCmd->CmdID = CmdID; |
| 810 | pCmd->Para1 = Para1; |
| 811 | pCmd->Para2 = Para2; |
| 812 | pCmd->msDelay = msDelay; |
| 813 | |
| 814 | return true; |
| 815 | } |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 816 | |
Mateusz Kulikowski | 1d53a5e | 2015-09-20 10:13:25 +0200 | [diff] [blame] | 817 | static u8 _rtl92e_phy_switch_channel_step(struct net_device *dev, u8 channel, |
| 818 | u8 *stage, u8 *step, u32 *delay) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 819 | { |
| 820 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 2eed3de | 2011-09-01 12:23:20 -0500 | [diff] [blame] | 821 | struct rtllib_device *ieee = priv->rtllib; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 822 | u32 PreCommonCmdCnt; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 823 | u32 PostCommonCmdCnt; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 824 | u32 RfDependCmdCnt; |
Larry Finger | 51ce231 | 2011-07-18 23:12:54 -0500 | [diff] [blame] | 825 | struct sw_chnl_cmd *CurrentCmd = NULL; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 826 | u8 eRFPath; |
| 827 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 828 | RT_TRACE(COMP_TRACE, "====>%s()====stage:%d, step:%d, channel:%d\n", |
| 829 | __func__, *stage, *step, channel); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 830 | |
Sean MacLennan | 976d534 | 2011-11-30 15:18:52 -0500 | [diff] [blame] | 831 | if (!rtllib_legal_channel(priv->rtllib, channel)) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 832 | netdev_err(dev, "Invalid channel requested: %d\n", channel); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 833 | return true; |
| 834 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 835 | |
| 836 | { |
| 837 | PreCommonCmdCnt = 0; |
Mateusz Kulikowski | 5b94840 | 2015-09-20 10:13:24 +0200 | [diff] [blame] | 838 | _rtl92e_phy_set_sw_chnl_cmd_array(dev, ieee->PreCommonCmd, |
| 839 | PreCommonCmdCnt++, |
| 840 | MAX_PRECMD_CNT, |
| 841 | CmdID_SetTxPowerLevel, |
| 842 | 0, 0, 0); |
| 843 | _rtl92e_phy_set_sw_chnl_cmd_array(dev, ieee->PreCommonCmd, |
| 844 | PreCommonCmdCnt++, |
| 845 | MAX_PRECMD_CNT, CmdID_End, |
| 846 | 0, 0, 0); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 847 | |
| 848 | PostCommonCmdCnt = 0; |
| 849 | |
Mateusz Kulikowski | 5b94840 | 2015-09-20 10:13:24 +0200 | [diff] [blame] | 850 | _rtl92e_phy_set_sw_chnl_cmd_array(dev, ieee->PostCommonCmd, |
| 851 | PostCommonCmdCnt++, |
| 852 | MAX_POSTCMD_CNT, CmdID_End, |
| 853 | 0, 0, 0); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 854 | |
| 855 | RfDependCmdCnt = 0; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 856 | switch (priv->rf_chip) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 857 | case RF_8225: |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 858 | if (!(channel >= 1 && channel <= 14)) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 859 | netdev_err(dev, |
| 860 | "Invalid channel requested for 8225: %d\n", |
| 861 | channel); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 862 | return false; |
| 863 | } |
Mateusz Kulikowski | 5b94840 | 2015-09-20 10:13:24 +0200 | [diff] [blame] | 864 | _rtl92e_phy_set_sw_chnl_cmd_array(dev, |
| 865 | ieee->RfDependCmd, |
| 866 | RfDependCmdCnt++, |
| 867 | MAX_RFDEPENDCMD_CNT, |
| 868 | CmdID_RF_WriteReg, |
| 869 | rZebra1_Channel, |
| 870 | RF_CHANNEL_TABLE_ZEBRA[channel], |
| 871 | 10); |
| 872 | _rtl92e_phy_set_sw_chnl_cmd_array(dev, |
| 873 | ieee->RfDependCmd, |
| 874 | RfDependCmdCnt++, |
| 875 | MAX_RFDEPENDCMD_CNT, |
| 876 | CmdID_End, 0, 0, 0); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 877 | break; |
| 878 | |
| 879 | case RF_8256: |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 880 | if (!(channel >= 1 && channel <= 14)) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 881 | netdev_err(dev, |
| 882 | "Invalid channel requested for 8256: %d\n", |
| 883 | channel); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 884 | return false; |
| 885 | } |
Mateusz Kulikowski | 5b94840 | 2015-09-20 10:13:24 +0200 | [diff] [blame] | 886 | _rtl92e_phy_set_sw_chnl_cmd_array(dev, |
| 887 | ieee->RfDependCmd, |
| 888 | RfDependCmdCnt++, |
| 889 | MAX_RFDEPENDCMD_CNT, |
| 890 | CmdID_RF_WriteReg, |
| 891 | rZebra1_Channel, |
| 892 | channel, 10); |
| 893 | _rtl92e_phy_set_sw_chnl_cmd_array(dev, |
| 894 | ieee->RfDependCmd, |
| 895 | RfDependCmdCnt++, |
| 896 | MAX_RFDEPENDCMD_CNT, |
| 897 | CmdID_End, 0, 0, 0); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 898 | break; |
| 899 | |
| 900 | case RF_8258: |
| 901 | break; |
| 902 | |
| 903 | default: |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 904 | netdev_warn(dev, "Unknown RF Chip ID\n"); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 905 | return false; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 906 | } |
| 907 | |
| 908 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 909 | do { |
| 910 | switch (*stage) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 911 | case 0: |
Larry Finger | 2eed3de | 2011-09-01 12:23:20 -0500 | [diff] [blame] | 912 | CurrentCmd = &ieee->PreCommonCmd[*step]; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 913 | break; |
| 914 | case 1: |
Larry Finger | 2eed3de | 2011-09-01 12:23:20 -0500 | [diff] [blame] | 915 | CurrentCmd = &ieee->RfDependCmd[*step]; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 916 | break; |
| 917 | case 2: |
Larry Finger | 2eed3de | 2011-09-01 12:23:20 -0500 | [diff] [blame] | 918 | CurrentCmd = &ieee->PostCommonCmd[*step]; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 919 | break; |
| 920 | } |
| 921 | |
Larry Finger | 52a7fb0 | 2011-09-01 12:23:19 -0500 | [diff] [blame] | 922 | if (CurrentCmd && CurrentCmd->CmdID == CmdID_End) { |
Mateusz Kulikowski | 285b7c0 | 2015-04-01 00:24:26 +0200 | [diff] [blame] | 923 | if ((*stage) == 2) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 924 | return true; |
Mateusz Kulikowski | 285b7c0 | 2015-04-01 00:24:26 +0200 | [diff] [blame] | 925 | (*stage)++; |
| 926 | (*step) = 0; |
| 927 | continue; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 928 | } |
| 929 | |
Larry Finger | 52a7fb0 | 2011-09-01 12:23:19 -0500 | [diff] [blame] | 930 | if (!CurrentCmd) |
| 931 | continue; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 932 | switch (CurrentCmd->CmdID) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 933 | case CmdID_SetTxPowerLevel: |
| 934 | if (priv->IC_Cut > (u8)VERSION_8190_BD) |
Mateusz Kulikowski | 0e54431 | 2015-09-20 10:14:08 +0200 | [diff] [blame] | 935 | _rtl92e_set_tx_power_level(dev, |
| 936 | channel); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 937 | break; |
| 938 | case CmdID_WritePortUlong: |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 939 | rtl92e_writel(dev, CurrentCmd->Para1, |
| 940 | CurrentCmd->Para2); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 941 | break; |
| 942 | case CmdID_WritePortUshort: |
Mateusz Kulikowski | 6dee0c8 | 2015-07-19 19:28:28 +0200 | [diff] [blame] | 943 | rtl92e_writew(dev, CurrentCmd->Para1, |
| 944 | (u16)CurrentCmd->Para2); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 945 | break; |
| 946 | case CmdID_WritePortUchar: |
Mateusz Kulikowski | d8ae196 | 2015-07-19 19:28:26 +0200 | [diff] [blame] | 947 | rtl92e_writeb(dev, CurrentCmd->Para1, |
| 948 | (u8)CurrentCmd->Para2); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 949 | break; |
| 950 | case CmdID_RF_WriteReg: |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 951 | for (eRFPath = 0; eRFPath < |
| 952 | priv->NumTotalRFPath; eRFPath++) |
Mateusz Kulikowski | b0e044f | 2015-07-19 19:27:53 +0200 | [diff] [blame] | 953 | rtl92e_set_rf_reg(dev, |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 954 | (enum rf90_radio_path)eRFPath, |
| 955 | CurrentCmd->Para1, bMask12Bits, |
| 956 | CurrentCmd->Para2<<7); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 957 | break; |
| 958 | default: |
| 959 | break; |
| 960 | } |
| 961 | |
| 962 | break; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 963 | } while (true); |
| 964 | } /*for (Number of RF paths)*/ |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 965 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 966 | (*delay) = CurrentCmd->msDelay; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 967 | (*step)++; |
| 968 | return false; |
| 969 | } |
| 970 | |
Mateusz Kulikowski | 6266879 | 2015-09-20 10:13:21 +0200 | [diff] [blame] | 971 | static void _rtl92e_phy_switch_channel(struct net_device *dev, u8 channel) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 972 | { |
| 973 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 974 | u32 delay = 0; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 975 | |
Mateusz Kulikowski | 1d53a5e | 2015-09-20 10:13:25 +0200 | [diff] [blame] | 976 | while (!_rtl92e_phy_switch_channel_step(dev, channel, |
| 977 | &priv->SwChnlStage, |
| 978 | &priv->SwChnlStep, &delay)) { |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 979 | if (delay > 0) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 980 | msleep(delay); |
Vaishali Thakkar | 5dc4296 | 2015-03-03 13:08:24 +0530 | [diff] [blame] | 981 | if (!priv->up) |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 982 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 983 | } |
| 984 | } |
Mateusz Kulikowski | 8760225 | 2015-09-20 10:13:26 +0200 | [diff] [blame] | 985 | |
| 986 | static void _rtl92e_phy_switch_channel_work_item(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 987 | { |
| 988 | |
| 989 | struct r8192_priv *priv = rtllib_priv(dev); |
| 990 | |
| 991 | RT_TRACE(COMP_TRACE, "==> SwChnlCallback819xUsbWorkItem()\n"); |
| 992 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 993 | RT_TRACE(COMP_TRACE, "=====>--%s(), set chan:%d, priv:%p\n", __func__, |
| 994 | priv->chan, priv); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 995 | |
Mateusz Kulikowski | 6266879 | 2015-09-20 10:13:21 +0200 | [diff] [blame] | 996 | _rtl92e_phy_switch_channel(dev, priv->chan); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 997 | |
| 998 | RT_TRACE(COMP_TRACE, "<== SwChnlCallback819xUsbWorkItem()\n"); |
| 999 | } |
| 1000 | |
Mateusz Kulikowski | 68a5143 | 2015-07-19 19:27:55 +0200 | [diff] [blame] | 1001 | u8 rtl92e_set_channel(struct net_device *dev, u8 channel) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1002 | { |
| 1003 | struct r8192_priv *priv = rtllib_priv(dev); |
Matthew Casey | 3a6b70c | 2014-08-22 06:27:52 -0400 | [diff] [blame] | 1004 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1005 | RT_TRACE(COMP_PHY, "=====>%s()\n", __func__); |
Vaishali Thakkar | 5dc4296 | 2015-03-03 13:08:24 +0530 | [diff] [blame] | 1006 | if (!priv->up) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1007 | netdev_err(dev, "%s(): Driver is not initialized\n", __func__); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1008 | return false; |
| 1009 | } |
| 1010 | if (priv->SwChnlInProgress) |
| 1011 | return false; |
| 1012 | |
| 1013 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1014 | switch (priv->rtllib->mode) { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1015 | case WIRELESS_MODE_A: |
| 1016 | case WIRELESS_MODE_N_5G: |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1017 | if (channel <= 14) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1018 | netdev_warn(dev, |
| 1019 | "Channel %d not available in 802.11a.\n", |
| 1020 | channel); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1021 | return false; |
| 1022 | } |
| 1023 | break; |
| 1024 | case WIRELESS_MODE_B: |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1025 | if (channel > 14) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1026 | netdev_warn(dev, |
| 1027 | "Channel %d not available in 802.11b.\n", |
| 1028 | channel); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1029 | return false; |
| 1030 | } |
| 1031 | break; |
| 1032 | case WIRELESS_MODE_G: |
| 1033 | case WIRELESS_MODE_N_24G: |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1034 | if (channel > 14) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1035 | netdev_warn(dev, |
| 1036 | "Channel %d not available in 802.11g.\n", |
| 1037 | channel); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1038 | return false; |
| 1039 | } |
| 1040 | break; |
| 1041 | } |
| 1042 | |
| 1043 | priv->SwChnlInProgress = true; |
| 1044 | if (channel == 0) |
| 1045 | channel = 1; |
| 1046 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1047 | priv->chan = channel; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1048 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1049 | priv->SwChnlStage = 0; |
| 1050 | priv->SwChnlStep = 0; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1051 | |
Vaishali Thakkar | 5dc4296 | 2015-03-03 13:08:24 +0530 | [diff] [blame] | 1052 | if (priv->up) |
Mateusz Kulikowski | 8760225 | 2015-09-20 10:13:26 +0200 | [diff] [blame] | 1053 | _rtl92e_phy_switch_channel_work_item(dev); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1054 | priv->SwChnlInProgress = false; |
| 1055 | return true; |
| 1056 | } |
| 1057 | |
Mateusz Kulikowski | 6a2c58a2 | 2015-09-20 10:14:03 +0200 | [diff] [blame] | 1058 | static void _rtl92e_cck_tx_power_track_bw_switch_tssi(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1059 | { |
| 1060 | struct r8192_priv *priv = rtllib_priv(dev); |
| 1061 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1062 | switch (priv->CurrentChannelBW) { |
| 1063 | case HT_CHANNEL_WIDTH_20: |
| 1064 | priv->CCKPresentAttentuation = |
| 1065 | priv->CCKPresentAttentuation_20Mdefault + |
| 1066 | priv->CCKPresentAttentuation_difference; |
| 1067 | |
| 1068 | if (priv->CCKPresentAttentuation > |
| 1069 | (CCKTxBBGainTableLength-1)) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1070 | priv->CCKPresentAttentuation = |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1071 | CCKTxBBGainTableLength-1; |
| 1072 | if (priv->CCKPresentAttentuation < 0) |
| 1073 | priv->CCKPresentAttentuation = 0; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1074 | |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1075 | RT_TRACE(COMP_POWER_TRACKING, |
| 1076 | "20M, priv->CCKPresentAttentuation = %d\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1077 | priv->CCKPresentAttentuation); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1078 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1079 | if (priv->rtllib->current_network.channel == 14 && |
| 1080 | !priv->bcck_in_ch14) { |
| 1081 | priv->bcck_in_ch14 = true; |
Mateusz Kulikowski | 59e84dc | 2015-07-19 19:28:31 +0200 | [diff] [blame] | 1082 | rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1083 | } else if (priv->rtllib->current_network.channel != |
| 1084 | 14 && priv->bcck_in_ch14) { |
| 1085 | priv->bcck_in_ch14 = false; |
Mateusz Kulikowski | 59e84dc | 2015-07-19 19:28:31 +0200 | [diff] [blame] | 1086 | rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1087 | } else { |
Mateusz Kulikowski | 59e84dc | 2015-07-19 19:28:31 +0200 | [diff] [blame] | 1088 | rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1089 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1090 | break; |
| 1091 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1092 | case HT_CHANNEL_WIDTH_20_40: |
| 1093 | priv->CCKPresentAttentuation = |
| 1094 | priv->CCKPresentAttentuation_40Mdefault + |
| 1095 | priv->CCKPresentAttentuation_difference; |
| 1096 | |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1097 | RT_TRACE(COMP_POWER_TRACKING, |
| 1098 | "40M, priv->CCKPresentAttentuation = %d\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1099 | priv->CCKPresentAttentuation); |
| 1100 | if (priv->CCKPresentAttentuation > |
| 1101 | (CCKTxBBGainTableLength - 1)) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1102 | priv->CCKPresentAttentuation = |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1103 | CCKTxBBGainTableLength-1; |
| 1104 | if (priv->CCKPresentAttentuation < 0) |
| 1105 | priv->CCKPresentAttentuation = 0; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1106 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1107 | if (priv->rtllib->current_network.channel == 14 && |
| 1108 | !priv->bcck_in_ch14) { |
| 1109 | priv->bcck_in_ch14 = true; |
Mateusz Kulikowski | 59e84dc | 2015-07-19 19:28:31 +0200 | [diff] [blame] | 1110 | rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1111 | } else if (priv->rtllib->current_network.channel != 14 |
| 1112 | && priv->bcck_in_ch14) { |
| 1113 | priv->bcck_in_ch14 = false; |
Mateusz Kulikowski | 59e84dc | 2015-07-19 19:28:31 +0200 | [diff] [blame] | 1114 | rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1115 | } else { |
Mateusz Kulikowski | 59e84dc | 2015-07-19 19:28:31 +0200 | [diff] [blame] | 1116 | rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1117 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1118 | break; |
| 1119 | } |
| 1120 | } |
| 1121 | |
Mateusz Kulikowski | fca7024 | 2015-09-20 10:14:02 +0200 | [diff] [blame] | 1122 | static void _rtl92e_cck_tx_power_track_bw_switch_thermal(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1123 | { |
| 1124 | struct r8192_priv *priv = rtllib_priv(dev); |
| 1125 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1126 | if (priv->rtllib->current_network.channel == 14 && |
| 1127 | !priv->bcck_in_ch14) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1128 | priv->bcck_in_ch14 = true; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1129 | else if (priv->rtllib->current_network.channel != 14 && |
| 1130 | priv->bcck_in_ch14) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1131 | priv->bcck_in_ch14 = false; |
| 1132 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1133 | switch (priv->CurrentChannelBW) { |
| 1134 | case HT_CHANNEL_WIDTH_20: |
| 1135 | if (priv->Record_CCK_20Mindex == 0) |
| 1136 | priv->Record_CCK_20Mindex = 6; |
| 1137 | priv->CCK_index = priv->Record_CCK_20Mindex; |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1138 | RT_TRACE(COMP_POWER_TRACKING, |
Mateusz Kulikowski | fca7024 | 2015-09-20 10:14:02 +0200 | [diff] [blame] | 1139 | "20MHz, _rtl92e_cck_tx_power_track_bw_switch_thermal(),CCK_index = %d\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1140 | priv->CCK_index); |
| 1141 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1142 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1143 | case HT_CHANNEL_WIDTH_20_40: |
| 1144 | priv->CCK_index = priv->Record_CCK_40Mindex; |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1145 | RT_TRACE(COMP_POWER_TRACKING, |
Mateusz Kulikowski | fca7024 | 2015-09-20 10:14:02 +0200 | [diff] [blame] | 1146 | "40MHz, _rtl92e_cck_tx_power_track_bw_switch_thermal(), CCK_index = %d\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1147 | priv->CCK_index); |
| 1148 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1149 | } |
Mateusz Kulikowski | 59e84dc | 2015-07-19 19:28:31 +0200 | [diff] [blame] | 1150 | rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1151 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1152 | |
Mateusz Kulikowski | 81f5847 | 2015-09-20 10:14:01 +0200 | [diff] [blame] | 1153 | static void _rtl92e_cck_tx_power_track_bw_switch(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1154 | { |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1155 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1156 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1157 | if (priv->IC_Cut >= IC_VersionCut_D) |
Mateusz Kulikowski | 6a2c58a2 | 2015-09-20 10:14:03 +0200 | [diff] [blame] | 1158 | _rtl92e_cck_tx_power_track_bw_switch_tssi(dev); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1159 | else |
Mateusz Kulikowski | fca7024 | 2015-09-20 10:14:02 +0200 | [diff] [blame] | 1160 | _rtl92e_cck_tx_power_track_bw_switch_thermal(dev); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1161 | } |
| 1162 | |
Mateusz Kulikowski | 7b54d76 | 2015-09-20 10:14:07 +0200 | [diff] [blame] | 1163 | static void _rtl92e_set_bw_mode_work_item(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1164 | { |
| 1165 | |
| 1166 | struct r8192_priv *priv = rtllib_priv(dev); |
| 1167 | u8 regBwOpMode; |
| 1168 | |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1169 | RT_TRACE(COMP_SWBW, |
Mateusz Kulikowski | 7b54d76 | 2015-09-20 10:14:07 +0200 | [diff] [blame] | 1170 | "==>_rtl92e_set_bw_mode_work_item() Switch to %s bandwidth\n", |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1171 | priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 ? |
| 1172 | "20MHz" : "40MHz"); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1173 | |
| 1174 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1175 | if (priv->rf_chip == RF_PSEUDO_11N) { |
| 1176 | priv->SetBWModeInProgress = false; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1177 | return; |
| 1178 | } |
Vaishali Thakkar | 5dc4296 | 2015-03-03 13:08:24 +0530 | [diff] [blame] | 1179 | if (!priv->up) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1180 | netdev_err(dev, "%s(): Driver is not initialized\n", __func__); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1181 | return; |
| 1182 | } |
Mateusz Kulikowski | b59a4ca | 2015-07-19 19:28:09 +0200 | [diff] [blame] | 1183 | regBwOpMode = rtl92e_readb(dev, BW_OPMODE); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1184 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1185 | switch (priv->CurrentChannelBW) { |
| 1186 | case HT_CHANNEL_WIDTH_20: |
| 1187 | regBwOpMode |= BW_OPMODE_20MHZ; |
Mateusz Kulikowski | d8ae196 | 2015-07-19 19:28:26 +0200 | [diff] [blame] | 1188 | rtl92e_writeb(dev, BW_OPMODE, regBwOpMode); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1189 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1190 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1191 | case HT_CHANNEL_WIDTH_20_40: |
| 1192 | regBwOpMode &= ~BW_OPMODE_20MHZ; |
Mateusz Kulikowski | d8ae196 | 2015-07-19 19:28:26 +0200 | [diff] [blame] | 1193 | rtl92e_writeb(dev, BW_OPMODE, regBwOpMode); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1194 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1195 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1196 | default: |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1197 | netdev_err(dev, "%s(): unknown Bandwidth: %#X\n", __func__, |
| 1198 | priv->CurrentChannelBW); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1199 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1200 | } |
| 1201 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1202 | switch (priv->CurrentChannelBW) { |
| 1203 | case HT_CHANNEL_WIDTH_20: |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1204 | rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bRFMOD, 0x0); |
| 1205 | rtl92e_set_bb_reg(dev, rFPGA1_RFMOD, bRFMOD, 0x0); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1206 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1207 | if (!priv->btxpower_tracking) { |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 1208 | rtl92e_writel(dev, rCCK0_TxFilter1, 0x1a1b0000); |
| 1209 | rtl92e_writel(dev, rCCK0_TxFilter2, 0x090e1317); |
| 1210 | rtl92e_writel(dev, rCCK0_DebugPort, 0x00000204); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1211 | } else { |
Mateusz Kulikowski | 81f5847 | 2015-09-20 10:14:01 +0200 | [diff] [blame] | 1212 | _rtl92e_cck_tx_power_track_bw_switch(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1213 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1214 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1215 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x00100000, 1); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1216 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1217 | break; |
| 1218 | case HT_CHANNEL_WIDTH_20_40: |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1219 | rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bRFMOD, 0x1); |
| 1220 | rtl92e_set_bb_reg(dev, rFPGA1_RFMOD, bRFMOD, 0x1); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1221 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1222 | if (!priv->btxpower_tracking) { |
Mateusz Kulikowski | 8ea5410 | 2015-07-19 19:28:27 +0200 | [diff] [blame] | 1223 | rtl92e_writel(dev, rCCK0_TxFilter1, 0x35360000); |
| 1224 | rtl92e_writel(dev, rCCK0_TxFilter2, 0x121c252e); |
| 1225 | rtl92e_writel(dev, rCCK0_DebugPort, 0x00000409); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1226 | } else { |
Mateusz Kulikowski | 81f5847 | 2015-09-20 10:14:01 +0200 | [diff] [blame] | 1227 | _rtl92e_cck_tx_power_track_bw_switch(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1228 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1229 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1230 | rtl92e_set_bb_reg(dev, rCCK0_System, bCCKSideBand, |
| 1231 | (priv->nCur40MhzPrimeSC>>1)); |
| 1232 | rtl92e_set_bb_reg(dev, rOFDM1_LSTF, 0xC00, |
| 1233 | priv->nCur40MhzPrimeSC); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1234 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1235 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x00100000, 0); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1236 | break; |
| 1237 | default: |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1238 | netdev_err(dev, "%s(): unknown Bandwidth: %#X\n", __func__, |
| 1239 | priv->CurrentChannelBW); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1240 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1241 | |
| 1242 | } |
| 1243 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1244 | switch (priv->rf_chip) { |
| 1245 | case RF_8225: |
| 1246 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1247 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1248 | case RF_8256: |
Mateusz Kulikowski | 766b0128 | 2015-07-19 19:27:15 +0200 | [diff] [blame] | 1249 | rtl92e_set_bandwidth(dev, priv->CurrentChannelBW); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1250 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1251 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1252 | case RF_8258: |
| 1253 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1254 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1255 | case RF_PSEUDO_11N: |
| 1256 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1257 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1258 | default: |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1259 | netdev_info(dev, "%s(): Unknown RFChipID: %d\n", __func__, |
| 1260 | priv->rf_chip); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1261 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1262 | } |
Mike McCormack | 4f6807e | 2011-07-11 08:56:20 +0900 | [diff] [blame] | 1263 | |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1264 | atomic_dec(&(priv->rtllib->atm_swbw)); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1265 | priv->SetBWModeInProgress = false; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1266 | |
| 1267 | RT_TRACE(COMP_SWBW, "<==SetBWMode819xUsb()"); |
| 1268 | } |
| 1269 | |
Mateusz Kulikowski | ae924ac | 2015-07-19 19:27:58 +0200 | [diff] [blame] | 1270 | void rtl92e_set_bw_mode(struct net_device *dev, enum ht_channel_width Bandwidth, |
| 1271 | enum ht_extchnl_offset Offset) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1272 | { |
| 1273 | struct r8192_priv *priv = rtllib_priv(dev); |
| 1274 | |
| 1275 | |
| 1276 | if (priv->SetBWModeInProgress) |
| 1277 | return; |
| 1278 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1279 | atomic_inc(&(priv->rtllib->atm_swbw)); |
| 1280 | priv->SetBWModeInProgress = true; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1281 | |
| 1282 | priv->CurrentChannelBW = Bandwidth; |
| 1283 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1284 | if (Offset == HT_EXTCHNL_OFFSET_LOWER) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1285 | priv->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_UPPER; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1286 | else if (Offset == HT_EXTCHNL_OFFSET_UPPER) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1287 | priv->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_LOWER; |
| 1288 | else |
| 1289 | priv->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_DONT_CARE; |
| 1290 | |
Mateusz Kulikowski | 7b54d76 | 2015-09-20 10:14:07 +0200 | [diff] [blame] | 1291 | _rtl92e_set_bw_mode_work_item(dev); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1292 | |
| 1293 | } |
| 1294 | |
Mateusz Kulikowski | dfb7a12 | 2015-07-19 19:27:42 +0200 | [diff] [blame] | 1295 | void rtl92e_init_gain(struct net_device *dev, u8 Operation) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1296 | { |
| 1297 | #define SCAN_RX_INITIAL_GAIN 0x17 |
| 1298 | #define POWER_DETECTION_TH 0x08 |
| 1299 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1300 | u32 BitMask; |
| 1301 | u8 initial_gain; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1302 | |
Vaishali Thakkar | 5dc4296 | 2015-03-03 13:08:24 +0530 | [diff] [blame] | 1303 | if (priv->up) { |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1304 | switch (Operation) { |
| 1305 | case IG_Backup: |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1306 | RT_TRACE(COMP_SCAN, |
| 1307 | "IG_Backup, backup the initial gain.\n"); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1308 | initial_gain = SCAN_RX_INITIAL_GAIN; |
| 1309 | BitMask = bMaskByte0; |
| 1310 | if (dm_digtable.dig_algorithm == |
| 1311 | DIG_ALGO_BY_FALSE_ALARM) |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1312 | rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1313 | priv->initgain_backup.xaagccore1 = |
Mateusz Kulikowski | 3c351fe | 2015-07-19 19:27:56 +0200 | [diff] [blame] | 1314 | (u8)rtl92e_get_bb_reg(dev, rOFDM0_XAAGCCore1, |
| 1315 | BitMask); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1316 | priv->initgain_backup.xbagccore1 = |
Mateusz Kulikowski | 3c351fe | 2015-07-19 19:27:56 +0200 | [diff] [blame] | 1317 | (u8)rtl92e_get_bb_reg(dev, rOFDM0_XBAGCCore1, |
| 1318 | BitMask); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1319 | priv->initgain_backup.xcagccore1 = |
Mateusz Kulikowski | 3c351fe | 2015-07-19 19:27:56 +0200 | [diff] [blame] | 1320 | (u8)rtl92e_get_bb_reg(dev, rOFDM0_XCAGCCore1, |
| 1321 | BitMask); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1322 | priv->initgain_backup.xdagccore1 = |
Mateusz Kulikowski | 3c351fe | 2015-07-19 19:27:56 +0200 | [diff] [blame] | 1323 | (u8)rtl92e_get_bb_reg(dev, rOFDM0_XDAGCCore1, |
| 1324 | BitMask); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1325 | BitMask = bMaskByte2; |
Mateusz Kulikowski | 3c351fe | 2015-07-19 19:27:56 +0200 | [diff] [blame] | 1326 | priv->initgain_backup.cca = (u8)rtl92e_get_bb_reg(dev, |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1327 | rCCK0_CCA, BitMask); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1328 | |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1329 | RT_TRACE(COMP_SCAN, |
| 1330 | "Scan InitialGainBackup 0xc50 is %x\n", |
| 1331 | priv->initgain_backup.xaagccore1); |
| 1332 | RT_TRACE(COMP_SCAN, |
| 1333 | "Scan InitialGainBackup 0xc58 is %x\n", |
| 1334 | priv->initgain_backup.xbagccore1); |
| 1335 | RT_TRACE(COMP_SCAN, |
| 1336 | "Scan InitialGainBackup 0xc60 is %x\n", |
| 1337 | priv->initgain_backup.xcagccore1); |
| 1338 | RT_TRACE(COMP_SCAN, |
| 1339 | "Scan InitialGainBackup 0xc68 is %x\n", |
| 1340 | priv->initgain_backup.xdagccore1); |
| 1341 | RT_TRACE(COMP_SCAN, |
| 1342 | "Scan InitialGainBackup 0xa0a is %x\n", |
| 1343 | priv->initgain_backup.cca); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1344 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1345 | RT_TRACE(COMP_SCAN, "Write scan initial gain = 0x%x\n", |
| 1346 | initial_gain); |
Mateusz Kulikowski | d8ae196 | 2015-07-19 19:28:26 +0200 | [diff] [blame] | 1347 | rtl92e_writeb(dev, rOFDM0_XAAGCCore1, initial_gain); |
| 1348 | rtl92e_writeb(dev, rOFDM0_XBAGCCore1, initial_gain); |
| 1349 | rtl92e_writeb(dev, rOFDM0_XCAGCCore1, initial_gain); |
| 1350 | rtl92e_writeb(dev, rOFDM0_XDAGCCore1, initial_gain); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1351 | RT_TRACE(COMP_SCAN, "Write scan 0xa0a = 0x%x\n", |
| 1352 | POWER_DETECTION_TH); |
Mateusz Kulikowski | d8ae196 | 2015-07-19 19:28:26 +0200 | [diff] [blame] | 1353 | rtl92e_writeb(dev, 0xa0a, POWER_DETECTION_TH); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1354 | break; |
| 1355 | case IG_Restore: |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1356 | RT_TRACE(COMP_SCAN, |
| 1357 | "IG_Restore, restore the initial gain.\n"); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1358 | BitMask = 0x7f; |
| 1359 | if (dm_digtable.dig_algorithm == |
| 1360 | DIG_ALGO_BY_FALSE_ALARM) |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1361 | rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1362 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1363 | rtl92e_set_bb_reg(dev, rOFDM0_XAAGCCore1, BitMask, |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1364 | (u32)priv->initgain_backup.xaagccore1); |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1365 | rtl92e_set_bb_reg(dev, rOFDM0_XBAGCCore1, BitMask, |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1366 | (u32)priv->initgain_backup.xbagccore1); |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1367 | rtl92e_set_bb_reg(dev, rOFDM0_XCAGCCore1, BitMask, |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1368 | (u32)priv->initgain_backup.xcagccore1); |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1369 | rtl92e_set_bb_reg(dev, rOFDM0_XDAGCCore1, BitMask, |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1370 | (u32)priv->initgain_backup.xdagccore1); |
| 1371 | BitMask = bMaskByte2; |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1372 | rtl92e_set_bb_reg(dev, rCCK0_CCA, BitMask, |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1373 | (u32)priv->initgain_backup.cca); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1374 | |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1375 | RT_TRACE(COMP_SCAN, |
| 1376 | "Scan BBInitialGainRestore 0xc50 is %x\n", |
| 1377 | priv->initgain_backup.xaagccore1); |
| 1378 | RT_TRACE(COMP_SCAN, |
| 1379 | "Scan BBInitialGainRestore 0xc58 is %x\n", |
| 1380 | priv->initgain_backup.xbagccore1); |
| 1381 | RT_TRACE(COMP_SCAN, |
| 1382 | "Scan BBInitialGainRestore 0xc60 is %x\n", |
| 1383 | priv->initgain_backup.xcagccore1); |
| 1384 | RT_TRACE(COMP_SCAN, |
| 1385 | "Scan BBInitialGainRestore 0xc68 is %x\n", |
| 1386 | priv->initgain_backup.xdagccore1); |
| 1387 | RT_TRACE(COMP_SCAN, |
| 1388 | "Scan BBInitialGainRestore 0xa0a is %x\n", |
| 1389 | priv->initgain_backup.cca); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1390 | |
Mateusz Kulikowski | 5aa1b9c | 2015-07-19 19:27:54 +0200 | [diff] [blame] | 1391 | rtl92e_set_tx_power(dev, |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1392 | priv->rtllib->current_network.channel); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1393 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1394 | if (dm_digtable.dig_algorithm == |
| 1395 | DIG_ALGO_BY_FALSE_ALARM) |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1396 | rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x1); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1397 | break; |
| 1398 | default: |
| 1399 | RT_TRACE(COMP_SCAN, "Unknown IG Operation.\n"); |
| 1400 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1401 | } |
| 1402 | } |
| 1403 | } |
| 1404 | |
Mateusz Kulikowski | 3803cb2 | 2015-07-19 19:27:44 +0200 | [diff] [blame] | 1405 | void rtl92e_set_rf_off(struct net_device *dev) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1406 | { |
| 1407 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1408 | rtl92e_set_bb_reg(dev, rFPGA0_XA_RFInterfaceOE, BIT4, 0x0); |
| 1409 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0x300, 0x0); |
| 1410 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x18, 0x0); |
| 1411 | rtl92e_set_bb_reg(dev, rOFDM0_TRxPathEnable, 0xf, 0x0); |
| 1412 | rtl92e_set_bb_reg(dev, rOFDM1_TRxPathEnable, 0xf, 0x0); |
| 1413 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x60, 0x0); |
| 1414 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x4, 0x0); |
Mateusz Kulikowski | d8ae196 | 2015-07-19 19:28:26 +0200 | [diff] [blame] | 1415 | rtl92e_writeb(dev, ANAPAR_FOR_8192PciE, 0x07); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1416 | |
| 1417 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1418 | |
Mateusz Kulikowski | 64c6ee9 | 2015-09-20 10:14:09 +0200 | [diff] [blame] | 1419 | static bool _rtl92e_set_rf_power_state(struct net_device *dev, |
| 1420 | enum rt_rf_power_state eRFPowerState) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1421 | { |
| 1422 | struct r8192_priv *priv = rtllib_priv(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1423 | struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *) |
| 1424 | (&(priv->rtllib->PowerSaveControl)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1425 | bool bResult = true; |
| 1426 | u8 i = 0, QueueID = 0; |
| 1427 | struct rtl8192_tx_ring *ring = NULL; |
| 1428 | |
Valentina Manea | 4bb0142 | 2013-10-25 11:28:10 +0300 | [diff] [blame] | 1429 | if (priv->SetRFPowerStateInProgress) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1430 | return false; |
Mateusz Kulikowski | 64c6ee9 | 2015-09-20 10:14:09 +0200 | [diff] [blame] | 1431 | RT_TRACE(COMP_PS, "===========> _rtl92e_set_rf_power_state()!\n"); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1432 | priv->SetRFPowerStateInProgress = true; |
| 1433 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1434 | switch (priv->rf_chip) { |
| 1435 | case RF_8256: |
| 1436 | switch (eRFPowerState) { |
| 1437 | case eRfOn: |
Mateusz Kulikowski | 64c6ee9 | 2015-09-20 10:14:09 +0200 | [diff] [blame] | 1438 | RT_TRACE(COMP_PS, |
| 1439 | "_rtl92e_set_rf_power_state() eRfOn!\n"); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1440 | if ((priv->rtllib->eRFPowerState == eRfOff) && |
| 1441 | RT_IN_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC)) { |
| 1442 | bool rtstatus = true; |
| 1443 | u32 InitilizeCount = 3; |
Matthew Casey | 3a6b70c | 2014-08-22 06:27:52 -0400 | [diff] [blame] | 1444 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1445 | do { |
| 1446 | InitilizeCount--; |
| 1447 | priv->RegRfOff = false; |
Mateusz Kulikowski | 502bd1d | 2015-07-19 19:28:08 +0200 | [diff] [blame] | 1448 | rtstatus = rtl92e_enable_nic(dev); |
Valentina Manea | 4bb0142 | 2013-10-25 11:28:10 +0300 | [diff] [blame] | 1449 | } while (!rtstatus && (InitilizeCount > 0)); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1450 | |
Valentina Manea | 4bb0142 | 2013-10-25 11:28:10 +0300 | [diff] [blame] | 1451 | if (!rtstatus) { |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1452 | netdev_err(dev, |
| 1453 | "%s(): Failed to initialize Adapter.\n", |
| 1454 | __func__); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1455 | priv->SetRFPowerStateInProgress = false; |
| 1456 | return false; |
| 1457 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1458 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1459 | RT_CLEAR_PS_LEVEL(pPSC, |
| 1460 | RT_RF_OFF_LEVL_HALT_NIC); |
| 1461 | } else { |
Mateusz Kulikowski | d8ae196 | 2015-07-19 19:28:26 +0200 | [diff] [blame] | 1462 | rtl92e_writeb(dev, ANAPAR, 0x37); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1463 | mdelay(1); |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1464 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1465 | 0x4, 0x1); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1466 | priv->bHwRfOffAction = 0; |
| 1467 | |
Mateusz Kulikowski | 153f9dd | 2015-07-19 19:27:57 +0200 | [diff] [blame] | 1468 | rtl92e_set_bb_reg(dev, rFPGA0_XA_RFInterfaceOE, |
| 1469 | BIT4, 0x1); |
| 1470 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, |
| 1471 | 0x300, 0x3); |
| 1472 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, |
| 1473 | 0x18, 0x3); |
| 1474 | rtl92e_set_bb_reg(dev, rOFDM0_TRxPathEnable, |
| 1475 | 0x3, 0x3); |
| 1476 | rtl92e_set_bb_reg(dev, rOFDM1_TRxPathEnable, |
| 1477 | 0x3, 0x3); |
| 1478 | rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, |
| 1479 | 0x60, 0x3); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1480 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1481 | } |
| 1482 | |
| 1483 | break; |
| 1484 | |
| 1485 | case eRfSleep: |
| 1486 | if (priv->rtllib->eRFPowerState == eRfOff) |
| 1487 | break; |
| 1488 | |
| 1489 | |
| 1490 | for (QueueID = 0, i = 0; QueueID < MAX_TX_QUEUE; ) { |
| 1491 | ring = &priv->tx_ring[QueueID]; |
| 1492 | |
| 1493 | if (skb_queue_len(&ring->queue) == 0) { |
| 1494 | QueueID++; |
| 1495 | continue; |
| 1496 | } else { |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1497 | RT_TRACE((COMP_POWER|COMP_RF), |
| 1498 | "eRf Off/Sleep: %d times TcbBusyQueue[%d] !=0 before doze!\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1499 | (i+1), QueueID); |
| 1500 | udelay(10); |
| 1501 | i++; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1502 | } |
| 1503 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1504 | if (i >= MAX_DOZE_WAITING_TIMES_9x) { |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1505 | RT_TRACE(COMP_POWER, |
Mateusz Kulikowski | 64c6ee9 | 2015-09-20 10:14:09 +0200 | [diff] [blame] | 1506 | "\n\n\n TimeOut!! _rtl92e_set_rf_power_state(): eRfOff: %d times TcbBusyQueue[%d] != 0 !!!\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1507 | MAX_DOZE_WAITING_TIMES_9x, |
| 1508 | QueueID); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1509 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1510 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1511 | } |
Mateusz Kulikowski | 3803cb2 | 2015-07-19 19:27:44 +0200 | [diff] [blame] | 1512 | rtl92e_set_rf_off(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1513 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1514 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1515 | case eRfOff: |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1516 | RT_TRACE(COMP_PS, |
Mateusz Kulikowski | 64c6ee9 | 2015-09-20 10:14:09 +0200 | [diff] [blame] | 1517 | "_rtl92e_set_rf_power_state() eRfOff/Sleep !\n"); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1518 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1519 | for (QueueID = 0, i = 0; QueueID < MAX_TX_QUEUE; ) { |
| 1520 | ring = &priv->tx_ring[QueueID]; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1521 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1522 | if (skb_queue_len(&ring->queue) == 0) { |
| 1523 | QueueID++; |
| 1524 | continue; |
| 1525 | } else { |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1526 | RT_TRACE(COMP_POWER, |
| 1527 | "eRf Off/Sleep: %d times TcbBusyQueue[%d] !=0 before doze!\n", |
| 1528 | (i+1), QueueID); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1529 | udelay(10); |
| 1530 | i++; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1531 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1532 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1533 | if (i >= MAX_DOZE_WAITING_TIMES_9x) { |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1534 | RT_TRACE(COMP_POWER, |
| 1535 | "\n\n\n SetZebra: RFPowerState8185B(): eRfOff: %d times TcbBusyQueue[%d] != 0 !!!\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1536 | MAX_DOZE_WAITING_TIMES_9x, |
| 1537 | QueueID); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1538 | break; |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1539 | } |
| 1540 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1541 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1542 | if (pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_HALT_NIC && |
| 1543 | !RT_IN_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC)) { |
Mateusz Kulikowski | af002dc | 2015-07-19 19:28:07 +0200 | [diff] [blame] | 1544 | rtl92e_disable_nic(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1545 | RT_SET_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC); |
| 1546 | } else if (!(pPSC->RegRfPsLevel & |
| 1547 | RT_RF_OFF_LEVL_HALT_NIC)) { |
Mateusz Kulikowski | 3803cb2 | 2015-07-19 19:27:44 +0200 | [diff] [blame] | 1548 | rtl92e_set_rf_off(dev); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1549 | } |
| 1550 | |
| 1551 | break; |
| 1552 | |
| 1553 | default: |
| 1554 | bResult = false; |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1555 | netdev_warn(dev, |
| 1556 | "%s(): Unknown state requested: 0x%X.\n", |
| 1557 | __func__, eRFPowerState); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1558 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1559 | } |
| 1560 | |
| 1561 | break; |
| 1562 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1563 | default: |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1564 | netdev_warn(dev, "%s(): Unknown RF type\n", __func__); |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1565 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1566 | } |
| 1567 | |
| 1568 | if (bResult) { |
| 1569 | priv->rtllib->eRFPowerState = eRFPowerState; |
| 1570 | |
Larry Finger | d064307 | 2011-07-12 22:08:32 -0500 | [diff] [blame] | 1571 | switch (priv->rf_chip) { |
| 1572 | case RF_8256: |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1573 | break; |
| 1574 | |
Larry Finger | d064307 | 2011-07-12 22:08:32 -0500 | [diff] [blame] | 1575 | default: |
Mateusz Kulikowski | 3b4140a | 2015-05-31 20:19:50 +0200 | [diff] [blame] | 1576 | netdev_warn(dev, "%s(): Unknown RF type\n", __func__); |
Larry Finger | d064307 | 2011-07-12 22:08:32 -0500 | [diff] [blame] | 1577 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1578 | } |
| 1579 | } |
| 1580 | |
| 1581 | priv->SetRFPowerStateInProgress = false; |
Mateusz Kulikowski | 64c6ee9 | 2015-09-20 10:14:09 +0200 | [diff] [blame] | 1582 | RT_TRACE(COMP_PS, |
| 1583 | "<=========== _rtl92e_set_rf_power_state() bResult = %d!\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1584 | bResult); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1585 | return bResult; |
| 1586 | } |
| 1587 | |
Mateusz Kulikowski | ad8d516 | 2015-07-19 19:27:59 +0200 | [diff] [blame] | 1588 | bool rtl92e_set_rf_power_state(struct net_device *dev, |
| 1589 | enum rt_rf_power_state eRFPowerState) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1590 | { |
| 1591 | struct r8192_priv *priv = rtllib_priv(dev); |
| 1592 | |
| 1593 | bool bResult = false; |
| 1594 | |
Mateusz Kulikowski | ad8d516 | 2015-07-19 19:27:59 +0200 | [diff] [blame] | 1595 | RT_TRACE(COMP_PS, |
| 1596 | "---------> rtl92e_set_rf_power_state(): eRFPowerState(%d)\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1597 | eRFPowerState); |
| 1598 | if (eRFPowerState == priv->rtllib->eRFPowerState && |
| 1599 | priv->bHwRfOffAction == 0) { |
Mateusz Kulikowski | 0822339 | 2015-03-17 00:00:48 +0100 | [diff] [blame] | 1600 | RT_TRACE(COMP_PS, |
Mateusz Kulikowski | ad8d516 | 2015-07-19 19:27:59 +0200 | [diff] [blame] | 1601 | "<--------- rtl92e_set_rf_power_state(): discard the request for eRFPowerState(%d) is the same.\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1602 | eRFPowerState); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1603 | return bResult; |
| 1604 | } |
| 1605 | |
Mateusz Kulikowski | 64c6ee9 | 2015-09-20 10:14:09 +0200 | [diff] [blame] | 1606 | bResult = _rtl92e_set_rf_power_state(dev, eRFPowerState); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1607 | |
Mateusz Kulikowski | ad8d516 | 2015-07-19 19:27:59 +0200 | [diff] [blame] | 1608 | RT_TRACE(COMP_PS, |
| 1609 | "<--------- rtl92e_set_rf_power_state(): bResult(%d)\n", |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1610 | bResult); |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1611 | |
| 1612 | return bResult; |
| 1613 | } |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1614 | |
Mateusz Kulikowski | 9a44c6e | 2015-07-19 19:27:43 +0200 | [diff] [blame] | 1615 | void rtl92e_scan_op_backup(struct net_device *dev, u8 Operation) |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1616 | { |
| 1617 | struct r8192_priv *priv = rtllib_priv(dev); |
| 1618 | |
| 1619 | if (priv->up) { |
| 1620 | switch (Operation) { |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1621 | case SCAN_OPT_BACKUP: |
| 1622 | priv->rtllib->InitialGainHandler(dev, IG_Backup); |
| 1623 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1624 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1625 | case SCAN_OPT_RESTORE: |
| 1626 | priv->rtllib->InitialGainHandler(dev, IG_Restore); |
| 1627 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1628 | |
Larry Finger | 547d0c3 | 2011-08-25 11:48:16 -0500 | [diff] [blame] | 1629 | default: |
| 1630 | RT_TRACE(COMP_SCAN, "Unknown Scan Backup Operation.\n"); |
| 1631 | break; |
Larry Finger | 94a7994 | 2011-08-23 19:00:42 -0500 | [diff] [blame] | 1632 | } |
| 1633 | } |
| 1634 | |
| 1635 | } |