1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
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
9 * The full GNU General Public License is included in this distribution in the
10 * file called LICENSE.
12 * Contact Information:
13 * wlanfae <wlanfae@realtek.com>
14 ******************************************************************************/
16 #include <linux/bitops.h>
18 #include "r8192E_hw.h"
19 #include "r8192E_phyreg.h"
20 #include "r8190P_rtl8256.h"
21 #include "r8192E_phy.h"
24 #include "r8192E_hwimg.h"
26 static u32 RF_CHANNEL_TABLE_ZEBRA[] = {
44 /*************************Define local function prototype**********************/
46 static u32 _rtl92e_phy_rf_fw_read(struct net_device *dev,
47 enum rf90_radio_path eRFPath, u32 Offset);
48 static void _rtl92e_phy_rf_fw_write(struct net_device *dev,
49 enum rf90_radio_path eRFPath, u32 Offset,
52 static u32 _rtl92e_calculate_bit_shift(u32 dwBitMask)
56 return ffs(dwBitMask) - 1;
59 u8 rtl92e_is_legal_rf_path(struct net_device *dev, u32 eRFPath)
62 struct r8192_priv *priv = rtllib_priv(dev);
64 if (priv->rf_type == RF_2T4R)
66 else if (priv->rf_type == RF_1T2R) {
67 if (eRFPath == RF90_PATH_A || eRFPath == RF90_PATH_B)
69 else if (eRFPath == RF90_PATH_C || eRFPath == RF90_PATH_D)
75 void rtl92e_set_bb_reg(struct net_device *dev, u32 dwRegAddr, u32 dwBitMask,
79 u32 OriginalValue, BitShift, NewValue;
81 if (dwBitMask != bMaskDWord) {
82 OriginalValue = rtl92e_readl(dev, dwRegAddr);
83 BitShift = _rtl92e_calculate_bit_shift(dwBitMask);
84 NewValue = (((OriginalValue) & (~dwBitMask)) |
85 (dwData << BitShift));
86 rtl92e_writel(dev, dwRegAddr, NewValue);
88 rtl92e_writel(dev, dwRegAddr, dwData);
91 u32 rtl92e_get_bb_reg(struct net_device *dev, u32 dwRegAddr, u32 dwBitMask)
93 u32 OriginalValue, BitShift;
95 OriginalValue = rtl92e_readl(dev, dwRegAddr);
96 BitShift = _rtl92e_calculate_bit_shift(dwBitMask);
98 return (OriginalValue & dwBitMask) >> BitShift;
101 static u32 _rtl92e_phy_rf_read(struct net_device *dev,
102 enum rf90_radio_path eRFPath, u32 Offset)
104 struct r8192_priv *priv = rtllib_priv(dev);
107 struct bb_reg_definition *pPhyReg = &priv->PHYRegDef[eRFPath];
111 if (priv->rf_chip == RF_8256) {
112 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0xf00, 0x0);
114 priv->RfReg0Value[eRFPath] |= 0x140;
115 rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset,
117 (priv->RfReg0Value[eRFPath]<<16));
118 NewOffset = Offset - 30;
119 } else if (Offset >= 16) {
120 priv->RfReg0Value[eRFPath] |= 0x100;
121 priv->RfReg0Value[eRFPath] &= (~0x40);
122 rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset,
124 (priv->RfReg0Value[eRFPath]<<16));
126 NewOffset = Offset - 15;
130 RT_TRACE((COMP_PHY|COMP_ERR),
131 "check RF type here, need to be 8256\n");
134 rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, bLSSIReadAddress,
136 rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x0);
137 rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x1);
141 ret = rtl92e_get_bb_reg(dev, pPhyReg->rfLSSIReadBack,
144 if (priv->rf_chip == RF_8256) {
145 priv->RfReg0Value[eRFPath] &= 0xebf;
147 rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, bMaskDWord,
148 (priv->RfReg0Value[eRFPath] << 16));
150 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0x300, 0x3);
158 static void _rtl92e_phy_rf_write(struct net_device *dev,
159 enum rf90_radio_path eRFPath, u32 Offset,
162 struct r8192_priv *priv = rtllib_priv(dev);
163 u32 DataAndAddr = 0, NewOffset = 0;
164 struct bb_reg_definition *pPhyReg = &priv->PHYRegDef[eRFPath];
167 if (priv->rf_chip == RF_8256) {
168 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0xf00, 0x0);
171 priv->RfReg0Value[eRFPath] |= 0x140;
172 rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset,
174 (priv->RfReg0Value[eRFPath] << 16));
175 NewOffset = Offset - 30;
176 } else if (Offset >= 16) {
177 priv->RfReg0Value[eRFPath] |= 0x100;
178 priv->RfReg0Value[eRFPath] &= (~0x40);
179 rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset,
181 (priv->RfReg0Value[eRFPath] << 16));
182 NewOffset = Offset - 15;
186 RT_TRACE((COMP_PHY|COMP_ERR),
187 "check RF type here, need to be 8256\n");
191 DataAndAddr = (Data<<16) | (NewOffset&0x3f);
193 rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, bMaskDWord, DataAndAddr);
196 priv->RfReg0Value[eRFPath] = Data;
198 if (priv->rf_chip == RF_8256) {
200 priv->RfReg0Value[eRFPath] &= 0xebf;
201 rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset,
203 (priv->RfReg0Value[eRFPath] << 16));
205 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0x300, 0x3);
209 void rtl92e_set_rf_reg(struct net_device *dev, enum rf90_radio_path eRFPath,
210 u32 RegAddr, u32 BitMask, u32 Data)
212 struct r8192_priv *priv = rtllib_priv(dev);
213 u32 Original_Value, BitShift, New_Value;
215 if (!rtl92e_is_legal_rf_path(dev, eRFPath))
217 if (priv->rtllib->eRFPowerState != eRfOn && !priv->being_init_adapter)
220 RT_TRACE(COMP_PHY, "FW RF CTRL is not ready now\n");
221 if (priv->Rf_Mode == RF_OP_By_FW) {
222 if (BitMask != bMask12Bits) {
223 Original_Value = _rtl92e_phy_rf_fw_read(dev, eRFPath,
225 BitShift = _rtl92e_calculate_bit_shift(BitMask);
226 New_Value = (((Original_Value) & (~BitMask)) |
229 _rtl92e_phy_rf_fw_write(dev, eRFPath, RegAddr,
232 _rtl92e_phy_rf_fw_write(dev, eRFPath, RegAddr, Data);
236 if (BitMask != bMask12Bits) {
237 Original_Value = _rtl92e_phy_rf_read(dev, eRFPath,
239 BitShift = _rtl92e_calculate_bit_shift(BitMask);
240 New_Value = (((Original_Value) & (~BitMask)) |
243 _rtl92e_phy_rf_write(dev, eRFPath, RegAddr, New_Value);
245 _rtl92e_phy_rf_write(dev, eRFPath, RegAddr, Data);
249 u32 rtl92e_get_rf_reg(struct net_device *dev, enum rf90_radio_path eRFPath,
250 u32 RegAddr, u32 BitMask)
252 u32 Original_Value, Readback_Value, BitShift;
253 struct r8192_priv *priv = rtllib_priv(dev);
255 if (!rtl92e_is_legal_rf_path(dev, eRFPath))
257 if (priv->rtllib->eRFPowerState != eRfOn && !priv->being_init_adapter)
259 mutex_lock(&priv->rf_mutex);
260 if (priv->Rf_Mode == RF_OP_By_FW) {
261 Original_Value = _rtl92e_phy_rf_fw_read(dev, eRFPath, RegAddr);
264 Original_Value = _rtl92e_phy_rf_read(dev, eRFPath, RegAddr);
266 BitShift = _rtl92e_calculate_bit_shift(BitMask);
267 Readback_Value = (Original_Value & BitMask) >> BitShift;
268 mutex_unlock(&priv->rf_mutex);
269 return Readback_Value;
272 static u32 _rtl92e_phy_rf_fw_read(struct net_device *dev,
273 enum rf90_radio_path eRFPath, u32 Offset)
278 Data |= ((Offset & 0xFF) << 12);
279 Data |= ((eRFPath & 0x3) << 20);
281 while (rtl92e_readl(dev, QPNR) & 0x80000000) {
287 rtl92e_writel(dev, QPNR, Data);
288 while (rtl92e_readl(dev, QPNR) & 0x80000000) {
294 return rtl92e_readl(dev, RF_DATA);
298 static void _rtl92e_phy_rf_fw_write(struct net_device *dev,
299 enum rf90_radio_path eRFPath, u32 Offset,
304 Data |= ((Offset & 0xFF) << 12);
305 Data |= ((eRFPath & 0x3) << 20);
309 while (rtl92e_readl(dev, QPNR) & 0x80000000) {
315 rtl92e_writel(dev, QPNR, Data);
320 void rtl92e_config_mac(struct net_device *dev)
322 u32 dwArrayLen = 0, i = 0;
323 u32 *pdwArray = NULL;
324 struct r8192_priv *priv = rtllib_priv(dev);
326 if (priv->bTXPowerDataReadFromEEPORM) {
327 RT_TRACE(COMP_PHY, "Rtl819XMACPHY_Array_PG\n");
328 dwArrayLen = MACPHY_Array_PGLength;
329 pdwArray = Rtl819XMACPHY_Array_PG;
332 RT_TRACE(COMP_PHY, "Read rtl819XMACPHY_Array\n");
333 dwArrayLen = MACPHY_ArrayLength;
334 pdwArray = Rtl819XMACPHY_Array;
336 for (i = 0; i < dwArrayLen; i += 3) {
338 "The Rtl8190MACPHY_Array[0] is %x Rtl8190MACPHY_Array[1] is %x Rtl8190MACPHY_Array[2] is %x\n",
339 pdwArray[i], pdwArray[i+1], pdwArray[i+2]);
340 if (pdwArray[i] == 0x318)
341 pdwArray[i+2] = 0x00000800;
342 rtl92e_set_bb_reg(dev, pdwArray[i], pdwArray[i+1],
349 static void _rtl92e_phy_config_bb(struct net_device *dev, u8 ConfigType)
352 u32 *Rtl819XPHY_REGArray_Table = NULL;
353 u32 *Rtl819XAGCTAB_Array_Table = NULL;
354 u16 AGCTAB_ArrayLen, PHY_REGArrayLen = 0;
355 struct r8192_priv *priv = rtllib_priv(dev);
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;
367 if (ConfigType == BaseBand_Config_PHY_REG) {
368 for (i = 0; i < PHY_REGArrayLen; i += 2) {
369 rtl92e_set_bb_reg(dev, Rtl819XPHY_REGArray_Table[i],
371 Rtl819XPHY_REGArray_Table[i+1]);
373 "i: %x, The Rtl819xUsbPHY_REGArray[0] is %x Rtl819xUsbPHY_REGArray[1] is %x\n",
374 i, Rtl819XPHY_REGArray_Table[i],
375 Rtl819XPHY_REGArray_Table[i+1]);
377 } else if (ConfigType == BaseBand_Config_AGC_TAB) {
378 for (i = 0; i < AGCTAB_ArrayLen; i += 2) {
379 rtl92e_set_bb_reg(dev, Rtl819XAGCTAB_Array_Table[i],
381 Rtl819XAGCTAB_Array_Table[i+1]);
383 "i:%x, The rtl819XAGCTAB_Array[0] is %x rtl819XAGCTAB_Array[1] is %x\n",
384 i, Rtl819XAGCTAB_Array_Table[i],
385 Rtl819XAGCTAB_Array_Table[i+1]);
390 static void _rtl92e_init_bb_rf_reg_def(struct net_device *dev)
392 struct r8192_priv *priv = rtllib_priv(dev);
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
481 bool rtl92e_check_bb_and_rf(struct net_device *dev, enum hw90_block CheckBlock,
482 enum rf90_radio_path eRFPath)
485 u32 i, CheckTimes = 4, dwRegRead = 0;
487 u32 WriteData[] = {0xfffff027, 0xaa55a02f, 0x00000027, 0x55aa502f};
489 WriteAddr[HW90_BLOCK_MAC] = 0x100;
490 WriteAddr[HW90_BLOCK_PHY0] = 0x900;
491 WriteAddr[HW90_BLOCK_PHY1] = 0x800;
492 WriteAddr[HW90_BLOCK_RF] = 0x3;
493 RT_TRACE(COMP_PHY, "=======>%s(), CheckBlock:%d\n", __func__,
496 if (CheckBlock == HW90_BLOCK_MAC) {
497 netdev_warn(dev, "%s(): No checks available for MAC block.\n",
502 for (i = 0; i < CheckTimes; i++) {
503 switch (CheckBlock) {
504 case HW90_BLOCK_PHY0:
505 case HW90_BLOCK_PHY1:
506 rtl92e_writel(dev, WriteAddr[CheckBlock],
508 dwRegRead = rtl92e_readl(dev, WriteAddr[CheckBlock]);
512 WriteData[i] &= 0xfff;
513 rtl92e_set_rf_reg(dev, eRFPath,
514 WriteAddr[HW90_BLOCK_RF],
515 bMask12Bits, WriteData[i]);
517 dwRegRead = rtl92e_get_rf_reg(dev, eRFPath,
518 WriteAddr[HW90_BLOCK_RF],
529 if (dwRegRead != WriteData[i]) {
530 netdev_warn(dev, "%s(): Check failed.\n", __func__);
539 static bool _rtl92e_bb_config_para_file(struct net_device *dev)
541 struct r8192_priv *priv = rtllib_priv(dev);
542 bool rtStatus = true;
543 u8 bRegValue = 0, eCheckItem = 0;
546 bRegValue = rtl92e_readb(dev, BB_GLOBAL_RESET);
547 rtl92e_writeb(dev, BB_GLOBAL_RESET, (bRegValue|BB_GLOBAL_RESET_BIT));
549 dwRegValue = rtl92e_readl(dev, CPU_GEN);
550 rtl92e_writel(dev, CPU_GEN, (dwRegValue&(~CPU_GEN_BB_RST)));
552 for (eCheckItem = (enum hw90_block)HW90_BLOCK_PHY0;
553 eCheckItem <= HW90_BLOCK_PHY1; eCheckItem++) {
554 rtStatus = rtl92e_check_bb_and_rf(dev,
555 (enum hw90_block)eCheckItem,
556 (enum rf90_radio_path)0);
558 RT_TRACE((COMP_ERR | COMP_PHY),
559 "rtl92e_config_rf():Check PHY%d Fail!!\n",
564 rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bCCKEn|bOFDMEn, 0x0);
565 _rtl92e_phy_config_bb(dev, BaseBand_Config_PHY_REG);
567 dwRegValue = rtl92e_readl(dev, CPU_GEN);
568 rtl92e_writel(dev, CPU_GEN, (dwRegValue|CPU_GEN_BB_RST));
570 _rtl92e_phy_config_bb(dev, BaseBand_Config_AGC_TAB);
572 if (priv->IC_Cut > VERSION_8190_BD) {
573 if (priv->rf_type == RF_2T4R)
574 dwRegValue = (priv->AntennaTxPwDiff[2]<<8 |
575 priv->AntennaTxPwDiff[1]<<4 |
576 priv->AntennaTxPwDiff[0]);
579 rtl92e_set_bb_reg(dev, rFPGA0_TxGainStage,
580 (bXBTxAGC|bXCTxAGC|bXDTxAGC), dwRegValue);
583 dwRegValue = priv->CrystalCap;
584 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, bXtalCap92x,
590 bool rtl92e_config_bb(struct net_device *dev)
592 _rtl92e_init_bb_rf_reg_def(dev);
593 return _rtl92e_bb_config_para_file(dev);
596 void rtl92e_get_tx_power(struct net_device *dev)
598 struct r8192_priv *priv = rtllib_priv(dev);
600 priv->MCSTxPowerLevelOriginalOffset[0] =
601 rtl92e_readl(dev, rTxAGC_Rate18_06);
602 priv->MCSTxPowerLevelOriginalOffset[1] =
603 rtl92e_readl(dev, rTxAGC_Rate54_24);
604 priv->MCSTxPowerLevelOriginalOffset[2] =
605 rtl92e_readl(dev, rTxAGC_Mcs03_Mcs00);
606 priv->MCSTxPowerLevelOriginalOffset[3] =
607 rtl92e_readl(dev, rTxAGC_Mcs07_Mcs04);
608 priv->MCSTxPowerLevelOriginalOffset[4] =
609 rtl92e_readl(dev, rTxAGC_Mcs11_Mcs08);
610 priv->MCSTxPowerLevelOriginalOffset[5] =
611 rtl92e_readl(dev, rTxAGC_Mcs15_Mcs12);
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);
618 "Default initial gain (c50=0x%x, c58=0x%x, c60=0x%x, c68=0x%x)\n",
619 priv->DefaultInitialGain[0], priv->DefaultInitialGain[1],
620 priv->DefaultInitialGain[2], priv->DefaultInitialGain[3]);
622 priv->framesync = rtl92e_readb(dev, rOFDM0_RxDetector3);
623 priv->framesyncC34 = rtl92e_readl(dev, rOFDM0_RxDetector2);
624 RT_TRACE(COMP_INIT, "Default framesync (0x%x) = 0x%x\n",
625 rOFDM0_RxDetector3, priv->framesync);
626 priv->SifsTime = rtl92e_readw(dev, SIFS);
629 void rtl92e_set_tx_power(struct net_device *dev, u8 channel)
631 struct r8192_priv *priv = rtllib_priv(dev);
632 u8 powerlevel = 0, powerlevelOFDM24G = 0;
636 if (priv->epromtype == EEPROM_93C46) {
637 powerlevel = priv->TxPowerLevelCCK[channel-1];
638 powerlevelOFDM24G = priv->TxPowerLevelOFDM24G[channel-1];
639 } else if (priv->epromtype == EEPROM_93C56) {
640 if (priv->rf_type == RF_1T2R) {
641 powerlevel = priv->TxPowerLevelCCK_C[channel-1];
642 powerlevelOFDM24G = priv->TxPowerLevelOFDM24G_C[channel-1];
643 } else if (priv->rf_type == RF_2T4R) {
644 powerlevel = priv->TxPowerLevelCCK_A[channel-1];
645 powerlevelOFDM24G = priv->TxPowerLevelOFDM24G_A[channel-1];
647 ant_pwr_diff = priv->TxPowerLevelOFDM24G_C[channel-1]
648 - priv->TxPowerLevelOFDM24G_A[channel-1];
650 priv->RF_C_TxPwDiff = ant_pwr_diff;
654 priv->AntennaTxPwDiff[2] = 0;
655 priv->AntennaTxPwDiff[1] = (u8)(ant_pwr_diff);
656 priv->AntennaTxPwDiff[0] = 0;
658 u4RegValue = (priv->AntennaTxPwDiff[2]<<8 |
659 priv->AntennaTxPwDiff[1]<<4 |
660 priv->AntennaTxPwDiff[0]);
662 rtl92e_set_bb_reg(dev, rFPGA0_TxGainStage,
663 (bXBTxAGC|bXCTxAGC|bXDTxAGC),
667 switch (priv->rf_chip) {
671 rtl92e_set_cck_tx_power(dev, powerlevel);
672 rtl92e_set_ofdm_tx_power(dev, powerlevelOFDM24G);
677 netdev_err(dev, "Invalid RF Chip ID.\n");
682 bool rtl92e_config_phy(struct net_device *dev)
684 struct r8192_priv *priv = rtllib_priv(dev);
685 bool rtStatus = true;
687 switch (priv->rf_chip) {
691 rtStatus = rtl92e_config_rf(dev);
700 netdev_err(dev, "Invalid RF Chip ID.\n");
706 u8 rtl92e_config_rf_path(struct net_device *dev, enum rf90_radio_path eRFPath)
713 for (i = 0; i < RadioA_ArrayLength; i += 2) {
714 if (Rtl819XRadioA_Array[i] == 0xfe) {
718 rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioA_Array[i],
720 Rtl819XRadioA_Array[i+1]);
725 for (i = 0; i < RadioB_ArrayLength; i += 2) {
726 if (Rtl819XRadioB_Array[i] == 0xfe) {
730 rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioB_Array[i],
732 Rtl819XRadioB_Array[i+1]);
737 for (i = 0; i < RadioC_ArrayLength; i += 2) {
738 if (Rtl819XRadioC_Array[i] == 0xfe) {
742 rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioC_Array[i],
744 Rtl819XRadioC_Array[i+1]);
749 for (i = 0; i < RadioD_ArrayLength; i += 2) {
750 if (Rtl819XRadioD_Array[i] == 0xfe) {
754 rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioD_Array[i],
756 Rtl819XRadioD_Array[i+1]);
768 static void _rtl92e_set_tx_power_level(struct net_device *dev, u8 channel)
770 struct r8192_priv *priv = rtllib_priv(dev);
771 u8 powerlevel = priv->TxPowerLevelCCK[channel-1];
772 u8 powerlevelOFDM24G = priv->TxPowerLevelOFDM24G[channel-1];
774 switch (priv->rf_chip) {
779 rtl92e_set_cck_tx_power(dev, powerlevel);
780 rtl92e_set_ofdm_tx_power(dev, powerlevelOFDM24G);
786 netdev_warn(dev, "%s(): Invalid RF Chip ID\n", __func__);
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)
797 struct sw_chnl_cmd *pCmd;
799 if (CmdTable == NULL) {
800 netdev_err(dev, "%s(): CmdTable cannot be NULL.\n", __func__);
803 if (CmdTableIdx >= CmdTableSz) {
804 netdev_err(dev, "%s(): Invalid index requested.\n", __func__);
808 pCmd = CmdTable + CmdTableIdx;
812 pCmd->msDelay = msDelay;
817 static u8 _rtl92e_phy_switch_channel_step(struct net_device *dev, u8 channel,
818 u8 *stage, u8 *step, u32 *delay)
820 struct r8192_priv *priv = rtllib_priv(dev);
821 struct rtllib_device *ieee = priv->rtllib;
823 u32 PostCommonCmdCnt;
825 struct sw_chnl_cmd *CurrentCmd = NULL;
828 RT_TRACE(COMP_TRACE, "====>%s()====stage:%d, step:%d, channel:%d\n",
829 __func__, *stage, *step, channel);
831 if (!rtllib_legal_channel(priv->rtllib, channel)) {
832 netdev_err(dev, "Invalid channel requested: %d\n", channel);
838 _rtl92e_phy_set_sw_chnl_cmd_array(dev, ieee->PreCommonCmd,
841 CmdID_SetTxPowerLevel,
843 _rtl92e_phy_set_sw_chnl_cmd_array(dev, ieee->PreCommonCmd,
845 MAX_PRECMD_CNT, CmdID_End,
848 PostCommonCmdCnt = 0;
850 _rtl92e_phy_set_sw_chnl_cmd_array(dev, ieee->PostCommonCmd,
852 MAX_POSTCMD_CNT, CmdID_End,
856 switch (priv->rf_chip) {
858 if (!(channel >= 1 && channel <= 14)) {
860 "Invalid channel requested for 8225: %d\n",
864 _rtl92e_phy_set_sw_chnl_cmd_array(dev,
870 RF_CHANNEL_TABLE_ZEBRA[channel],
872 _rtl92e_phy_set_sw_chnl_cmd_array(dev,
880 if (!(channel >= 1 && channel <= 14)) {
882 "Invalid channel requested for 8256: %d\n",
886 _rtl92e_phy_set_sw_chnl_cmd_array(dev,
893 _rtl92e_phy_set_sw_chnl_cmd_array(dev,
904 netdev_warn(dev, "Unknown RF Chip ID\n");
912 CurrentCmd = &ieee->PreCommonCmd[*step];
915 CurrentCmd = &ieee->RfDependCmd[*step];
918 CurrentCmd = &ieee->PostCommonCmd[*step];
922 if (CurrentCmd && CurrentCmd->CmdID == CmdID_End) {
932 switch (CurrentCmd->CmdID) {
933 case CmdID_SetTxPowerLevel:
934 if (priv->IC_Cut > (u8)VERSION_8190_BD)
935 _rtl92e_set_tx_power_level(dev,
938 case CmdID_WritePortUlong:
939 rtl92e_writel(dev, CurrentCmd->Para1,
942 case CmdID_WritePortUshort:
943 rtl92e_writew(dev, CurrentCmd->Para1,
944 (u16)CurrentCmd->Para2);
946 case CmdID_WritePortUchar:
947 rtl92e_writeb(dev, CurrentCmd->Para1,
948 (u8)CurrentCmd->Para2);
950 case CmdID_RF_WriteReg:
951 for (eRFPath = 0; eRFPath <
952 priv->NumTotalRFPath; eRFPath++)
953 rtl92e_set_rf_reg(dev,
954 (enum rf90_radio_path)eRFPath,
955 CurrentCmd->Para1, bMask12Bits,
956 CurrentCmd->Para2<<7);
964 } /*for (Number of RF paths)*/
966 (*delay) = CurrentCmd->msDelay;
971 static void _rtl92e_phy_switch_channel(struct net_device *dev, u8 channel)
973 struct r8192_priv *priv = rtllib_priv(dev);
976 while (!_rtl92e_phy_switch_channel_step(dev, channel,
978 &priv->SwChnlStep, &delay)) {
986 static void _rtl92e_phy_switch_channel_work_item(struct net_device *dev)
989 struct r8192_priv *priv = rtllib_priv(dev);
991 RT_TRACE(COMP_TRACE, "==> SwChnlCallback819xUsbWorkItem()\n");
993 RT_TRACE(COMP_TRACE, "=====>--%s(), set chan:%d, priv:%p\n", __func__,
996 _rtl92e_phy_switch_channel(dev, priv->chan);
998 RT_TRACE(COMP_TRACE, "<== SwChnlCallback819xUsbWorkItem()\n");
1001 u8 rtl92e_set_channel(struct net_device *dev, u8 channel)
1003 struct r8192_priv *priv = rtllib_priv(dev);
1005 RT_TRACE(COMP_PHY, "=====>%s()\n", __func__);
1007 netdev_err(dev, "%s(): Driver is not initialized\n", __func__);
1010 if (priv->SwChnlInProgress)
1014 switch (priv->rtllib->mode) {
1015 case WIRELESS_MODE_A:
1016 case WIRELESS_MODE_N_5G:
1017 if (channel <= 14) {
1019 "Channel %d not available in 802.11a.\n",
1024 case WIRELESS_MODE_B:
1027 "Channel %d not available in 802.11b.\n",
1032 case WIRELESS_MODE_G:
1033 case WIRELESS_MODE_N_24G:
1036 "Channel %d not available in 802.11g.\n",
1043 priv->SwChnlInProgress = true;
1047 priv->chan = channel;
1049 priv->SwChnlStage = 0;
1050 priv->SwChnlStep = 0;
1053 _rtl92e_phy_switch_channel_work_item(dev);
1054 priv->SwChnlInProgress = false;
1058 static void _rtl92e_cck_tx_power_track_bw_switch_tssi(struct net_device *dev)
1060 struct r8192_priv *priv = rtllib_priv(dev);
1062 switch (priv->CurrentChannelBW) {
1063 case HT_CHANNEL_WIDTH_20:
1064 priv->CCKPresentAttentuation =
1065 priv->CCKPresentAttentuation_20Mdefault +
1066 priv->CCKPresentAttentuation_difference;
1068 if (priv->CCKPresentAttentuation >
1069 (CCKTxBBGainTableLength-1))
1070 priv->CCKPresentAttentuation =
1071 CCKTxBBGainTableLength-1;
1072 if (priv->CCKPresentAttentuation < 0)
1073 priv->CCKPresentAttentuation = 0;
1075 RT_TRACE(COMP_POWER_TRACKING,
1076 "20M, priv->CCKPresentAttentuation = %d\n",
1077 priv->CCKPresentAttentuation);
1079 if (priv->rtllib->current_network.channel == 14 &&
1080 !priv->bcck_in_ch14) {
1081 priv->bcck_in_ch14 = true;
1082 rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
1083 } else if (priv->rtllib->current_network.channel !=
1084 14 && priv->bcck_in_ch14) {
1085 priv->bcck_in_ch14 = false;
1086 rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
1088 rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
1092 case HT_CHANNEL_WIDTH_20_40:
1093 priv->CCKPresentAttentuation =
1094 priv->CCKPresentAttentuation_40Mdefault +
1095 priv->CCKPresentAttentuation_difference;
1097 RT_TRACE(COMP_POWER_TRACKING,
1098 "40M, priv->CCKPresentAttentuation = %d\n",
1099 priv->CCKPresentAttentuation);
1100 if (priv->CCKPresentAttentuation >
1101 (CCKTxBBGainTableLength - 1))
1102 priv->CCKPresentAttentuation =
1103 CCKTxBBGainTableLength-1;
1104 if (priv->CCKPresentAttentuation < 0)
1105 priv->CCKPresentAttentuation = 0;
1107 if (priv->rtllib->current_network.channel == 14 &&
1108 !priv->bcck_in_ch14) {
1109 priv->bcck_in_ch14 = true;
1110 rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
1111 } else if (priv->rtllib->current_network.channel != 14
1112 && priv->bcck_in_ch14) {
1113 priv->bcck_in_ch14 = false;
1114 rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
1116 rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
1122 static void _rtl92e_cck_tx_power_track_bw_switch_thermal(struct net_device *dev)
1124 struct r8192_priv *priv = rtllib_priv(dev);
1126 if (priv->rtllib->current_network.channel == 14 &&
1127 !priv->bcck_in_ch14)
1128 priv->bcck_in_ch14 = true;
1129 else if (priv->rtllib->current_network.channel != 14 &&
1131 priv->bcck_in_ch14 = false;
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;
1138 RT_TRACE(COMP_POWER_TRACKING,
1139 "20MHz, _rtl92e_cck_tx_power_track_bw_switch_thermal(),CCK_index = %d\n",
1143 case HT_CHANNEL_WIDTH_20_40:
1144 priv->CCK_index = priv->Record_CCK_40Mindex;
1145 RT_TRACE(COMP_POWER_TRACKING,
1146 "40MHz, _rtl92e_cck_tx_power_track_bw_switch_thermal(), CCK_index = %d\n",
1150 rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
1153 static void _rtl92e_cck_tx_power_track_bw_switch(struct net_device *dev)
1155 struct r8192_priv *priv = rtllib_priv(dev);
1157 if (priv->IC_Cut >= IC_VersionCut_D)
1158 _rtl92e_cck_tx_power_track_bw_switch_tssi(dev);
1160 _rtl92e_cck_tx_power_track_bw_switch_thermal(dev);
1163 static void _rtl92e_set_bw_mode_work_item(struct net_device *dev)
1166 struct r8192_priv *priv = rtllib_priv(dev);
1170 "==>_rtl92e_set_bw_mode_work_item() Switch to %s bandwidth\n",
1171 priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 ?
1175 if (priv->rf_chip == RF_PSEUDO_11N) {
1176 priv->SetBWModeInProgress = false;
1180 netdev_err(dev, "%s(): Driver is not initialized\n", __func__);
1183 regBwOpMode = rtl92e_readb(dev, BW_OPMODE);
1185 switch (priv->CurrentChannelBW) {
1186 case HT_CHANNEL_WIDTH_20:
1187 regBwOpMode |= BW_OPMODE_20MHZ;
1188 rtl92e_writeb(dev, BW_OPMODE, regBwOpMode);
1191 case HT_CHANNEL_WIDTH_20_40:
1192 regBwOpMode &= ~BW_OPMODE_20MHZ;
1193 rtl92e_writeb(dev, BW_OPMODE, regBwOpMode);
1197 netdev_err(dev, "%s(): unknown Bandwidth: %#X\n", __func__,
1198 priv->CurrentChannelBW);
1202 switch (priv->CurrentChannelBW) {
1203 case HT_CHANNEL_WIDTH_20:
1204 rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bRFMOD, 0x0);
1205 rtl92e_set_bb_reg(dev, rFPGA1_RFMOD, bRFMOD, 0x0);
1207 if (!priv->btxpower_tracking) {
1208 rtl92e_writel(dev, rCCK0_TxFilter1, 0x1a1b0000);
1209 rtl92e_writel(dev, rCCK0_TxFilter2, 0x090e1317);
1210 rtl92e_writel(dev, rCCK0_DebugPort, 0x00000204);
1212 _rtl92e_cck_tx_power_track_bw_switch(dev);
1215 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x00100000, 1);
1218 case HT_CHANNEL_WIDTH_20_40:
1219 rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bRFMOD, 0x1);
1220 rtl92e_set_bb_reg(dev, rFPGA1_RFMOD, bRFMOD, 0x1);
1222 if (!priv->btxpower_tracking) {
1223 rtl92e_writel(dev, rCCK0_TxFilter1, 0x35360000);
1224 rtl92e_writel(dev, rCCK0_TxFilter2, 0x121c252e);
1225 rtl92e_writel(dev, rCCK0_DebugPort, 0x00000409);
1227 _rtl92e_cck_tx_power_track_bw_switch(dev);
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);
1235 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x00100000, 0);
1238 netdev_err(dev, "%s(): unknown Bandwidth: %#X\n", __func__,
1239 priv->CurrentChannelBW);
1244 switch (priv->rf_chip) {
1249 rtl92e_set_bandwidth(dev, priv->CurrentChannelBW);
1259 netdev_info(dev, "%s(): Unknown RFChipID: %d\n", __func__,
1264 atomic_dec(&(priv->rtllib->atm_swbw));
1265 priv->SetBWModeInProgress = false;
1267 RT_TRACE(COMP_SWBW, "<==SetBWMode819xUsb()");
1270 void rtl92e_set_bw_mode(struct net_device *dev, enum ht_channel_width Bandwidth,
1271 enum ht_extchnl_offset Offset)
1273 struct r8192_priv *priv = rtllib_priv(dev);
1276 if (priv->SetBWModeInProgress)
1279 atomic_inc(&(priv->rtllib->atm_swbw));
1280 priv->SetBWModeInProgress = true;
1282 priv->CurrentChannelBW = Bandwidth;
1284 if (Offset == HT_EXTCHNL_OFFSET_LOWER)
1285 priv->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_UPPER;
1286 else if (Offset == HT_EXTCHNL_OFFSET_UPPER)
1287 priv->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_LOWER;
1289 priv->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
1291 _rtl92e_set_bw_mode_work_item(dev);
1295 void rtl92e_init_gain(struct net_device *dev, u8 Operation)
1297 #define SCAN_RX_INITIAL_GAIN 0x17
1298 #define POWER_DETECTION_TH 0x08
1299 struct r8192_priv *priv = rtllib_priv(dev);
1304 switch (Operation) {
1307 "IG_Backup, backup the initial gain.\n");
1308 initial_gain = SCAN_RX_INITIAL_GAIN;
1309 BitMask = bMaskByte0;
1310 if (dm_digtable.dig_algorithm ==
1311 DIG_ALGO_BY_FALSE_ALARM)
1312 rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8);
1313 priv->initgain_backup.xaagccore1 =
1314 (u8)rtl92e_get_bb_reg(dev, rOFDM0_XAAGCCore1,
1316 priv->initgain_backup.xbagccore1 =
1317 (u8)rtl92e_get_bb_reg(dev, rOFDM0_XBAGCCore1,
1319 priv->initgain_backup.xcagccore1 =
1320 (u8)rtl92e_get_bb_reg(dev, rOFDM0_XCAGCCore1,
1322 priv->initgain_backup.xdagccore1 =
1323 (u8)rtl92e_get_bb_reg(dev, rOFDM0_XDAGCCore1,
1325 BitMask = bMaskByte2;
1326 priv->initgain_backup.cca = (u8)rtl92e_get_bb_reg(dev,
1327 rCCK0_CCA, BitMask);
1330 "Scan InitialGainBackup 0xc50 is %x\n",
1331 priv->initgain_backup.xaagccore1);
1333 "Scan InitialGainBackup 0xc58 is %x\n",
1334 priv->initgain_backup.xbagccore1);
1336 "Scan InitialGainBackup 0xc60 is %x\n",
1337 priv->initgain_backup.xcagccore1);
1339 "Scan InitialGainBackup 0xc68 is %x\n",
1340 priv->initgain_backup.xdagccore1);
1342 "Scan InitialGainBackup 0xa0a is %x\n",
1343 priv->initgain_backup.cca);
1345 RT_TRACE(COMP_SCAN, "Write scan initial gain = 0x%x\n",
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);
1351 RT_TRACE(COMP_SCAN, "Write scan 0xa0a = 0x%x\n",
1352 POWER_DETECTION_TH);
1353 rtl92e_writeb(dev, 0xa0a, POWER_DETECTION_TH);
1357 "IG_Restore, restore the initial gain.\n");
1359 if (dm_digtable.dig_algorithm ==
1360 DIG_ALGO_BY_FALSE_ALARM)
1361 rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8);
1363 rtl92e_set_bb_reg(dev, rOFDM0_XAAGCCore1, BitMask,
1364 (u32)priv->initgain_backup.xaagccore1);
1365 rtl92e_set_bb_reg(dev, rOFDM0_XBAGCCore1, BitMask,
1366 (u32)priv->initgain_backup.xbagccore1);
1367 rtl92e_set_bb_reg(dev, rOFDM0_XCAGCCore1, BitMask,
1368 (u32)priv->initgain_backup.xcagccore1);
1369 rtl92e_set_bb_reg(dev, rOFDM0_XDAGCCore1, BitMask,
1370 (u32)priv->initgain_backup.xdagccore1);
1371 BitMask = bMaskByte2;
1372 rtl92e_set_bb_reg(dev, rCCK0_CCA, BitMask,
1373 (u32)priv->initgain_backup.cca);
1376 "Scan BBInitialGainRestore 0xc50 is %x\n",
1377 priv->initgain_backup.xaagccore1);
1379 "Scan BBInitialGainRestore 0xc58 is %x\n",
1380 priv->initgain_backup.xbagccore1);
1382 "Scan BBInitialGainRestore 0xc60 is %x\n",
1383 priv->initgain_backup.xcagccore1);
1385 "Scan BBInitialGainRestore 0xc68 is %x\n",
1386 priv->initgain_backup.xdagccore1);
1388 "Scan BBInitialGainRestore 0xa0a is %x\n",
1389 priv->initgain_backup.cca);
1391 rtl92e_set_tx_power(dev,
1392 priv->rtllib->current_network.channel);
1394 if (dm_digtable.dig_algorithm ==
1395 DIG_ALGO_BY_FALSE_ALARM)
1396 rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x1);
1399 RT_TRACE(COMP_SCAN, "Unknown IG Operation.\n");
1405 void rtl92e_set_rf_off(struct net_device *dev)
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);
1415 rtl92e_writeb(dev, ANAPAR_FOR_8192PciE, 0x07);
1419 static bool _rtl92e_set_rf_power_state(struct net_device *dev,
1420 enum rt_rf_power_state eRFPowerState)
1422 struct r8192_priv *priv = rtllib_priv(dev);
1423 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
1424 (&(priv->rtllib->PowerSaveControl));
1425 bool bResult = true;
1426 u8 i = 0, QueueID = 0;
1427 struct rtl8192_tx_ring *ring = NULL;
1429 if (priv->SetRFPowerStateInProgress)
1431 RT_TRACE(COMP_PS, "===========> _rtl92e_set_rf_power_state()!\n");
1432 priv->SetRFPowerStateInProgress = true;
1434 switch (priv->rf_chip) {
1436 switch (eRFPowerState) {
1439 "_rtl92e_set_rf_power_state() eRfOn!\n");
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;
1447 priv->RegRfOff = false;
1448 rtstatus = rtl92e_enable_nic(dev);
1449 } while (!rtstatus && (InitilizeCount > 0));
1453 "%s(): Failed to initialize Adapter.\n",
1455 priv->SetRFPowerStateInProgress = false;
1459 RT_CLEAR_PS_LEVEL(pPSC,
1460 RT_RF_OFF_LEVL_HALT_NIC);
1462 rtl92e_writeb(dev, ANAPAR, 0x37);
1464 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1,
1466 priv->bHwRfOffAction = 0;
1468 rtl92e_set_bb_reg(dev, rFPGA0_XA_RFInterfaceOE,
1470 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4,
1472 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1,
1474 rtl92e_set_bb_reg(dev, rOFDM0_TRxPathEnable,
1476 rtl92e_set_bb_reg(dev, rOFDM1_TRxPathEnable,
1478 rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1,
1486 if (priv->rtllib->eRFPowerState == eRfOff)
1490 for (QueueID = 0, i = 0; QueueID < MAX_TX_QUEUE; ) {
1491 ring = &priv->tx_ring[QueueID];
1493 if (skb_queue_len(&ring->queue) == 0) {
1497 RT_TRACE((COMP_POWER|COMP_RF),
1498 "eRf Off/Sleep: %d times TcbBusyQueue[%d] !=0 before doze!\n",
1504 if (i >= MAX_DOZE_WAITING_TIMES_9x) {
1505 RT_TRACE(COMP_POWER,
1506 "\n\n\n TimeOut!! _rtl92e_set_rf_power_state(): eRfOff: %d times TcbBusyQueue[%d] != 0 !!!\n",
1507 MAX_DOZE_WAITING_TIMES_9x,
1512 rtl92e_set_rf_off(dev);
1517 "_rtl92e_set_rf_power_state() eRfOff/Sleep !\n");
1519 for (QueueID = 0, i = 0; QueueID < MAX_TX_QUEUE; ) {
1520 ring = &priv->tx_ring[QueueID];
1522 if (skb_queue_len(&ring->queue) == 0) {
1526 RT_TRACE(COMP_POWER,
1527 "eRf Off/Sleep: %d times TcbBusyQueue[%d] !=0 before doze!\n",
1533 if (i >= MAX_DOZE_WAITING_TIMES_9x) {
1534 RT_TRACE(COMP_POWER,
1535 "\n\n\n SetZebra: RFPowerState8185B(): eRfOff: %d times TcbBusyQueue[%d] != 0 !!!\n",
1536 MAX_DOZE_WAITING_TIMES_9x,
1542 if (pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_HALT_NIC &&
1543 !RT_IN_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC)) {
1544 rtl92e_disable_nic(dev);
1545 RT_SET_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
1546 } else if (!(pPSC->RegRfPsLevel &
1547 RT_RF_OFF_LEVL_HALT_NIC)) {
1548 rtl92e_set_rf_off(dev);
1556 "%s(): Unknown state requested: 0x%X.\n",
1557 __func__, eRFPowerState);
1564 netdev_warn(dev, "%s(): Unknown RF type\n", __func__);
1569 priv->rtllib->eRFPowerState = eRFPowerState;
1571 switch (priv->rf_chip) {
1576 netdev_warn(dev, "%s(): Unknown RF type\n", __func__);
1581 priv->SetRFPowerStateInProgress = false;
1583 "<=========== _rtl92e_set_rf_power_state() bResult = %d!\n",
1588 bool rtl92e_set_rf_power_state(struct net_device *dev,
1589 enum rt_rf_power_state eRFPowerState)
1591 struct r8192_priv *priv = rtllib_priv(dev);
1593 bool bResult = false;
1596 "---------> rtl92e_set_rf_power_state(): eRFPowerState(%d)\n",
1598 if (eRFPowerState == priv->rtllib->eRFPowerState &&
1599 priv->bHwRfOffAction == 0) {
1601 "<--------- rtl92e_set_rf_power_state(): discard the request for eRFPowerState(%d) is the same.\n",
1606 bResult = _rtl92e_set_rf_power_state(dev, eRFPowerState);
1609 "<--------- rtl92e_set_rf_power_state(): bResult(%d)\n",
1615 void rtl92e_scan_op_backup(struct net_device *dev, u8 Operation)
1617 struct r8192_priv *priv = rtllib_priv(dev);
1620 switch (Operation) {
1621 case SCAN_OPT_BACKUP:
1622 priv->rtllib->InitialGainHandler(dev, IG_Backup);
1625 case SCAN_OPT_RESTORE:
1626 priv->rtllib->InitialGainHandler(dev, IG_Restore);
1630 RT_TRACE(COMP_SCAN, "Unknown Scan Backup Operation.\n");