From 8d91c1e411f55d7ea91b1183a2e9f8088fb4d5be Mon Sep 17 00:00:00 2001 From: André Fabian Silva Delgado Date: Tue, 15 Dec 2015 14:52:16 -0300 Subject: Linux-libre 4.3.2-gnu --- drivers/staging/rtl8192e/dot11d.c | 39 -- drivers/staging/rtl8192e/dot11d.h | 6 - drivers/staging/rtl8192e/rtl8192e/r8190P_def.h | 46 -- drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.c | 192 ++----- drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.h | 11 +- drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.c | 11 +- drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.h | 5 +- drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c | 440 +++++++-------- drivers/staging/rtl8192e/rtl8192e/r8192E_dev.h | 58 +- .../staging/rtl8192e/rtl8192e/r8192E_firmware.c | 20 +- .../staging/rtl8192e/rtl8192e/r8192E_firmware.h | 6 +- drivers/staging/rtl8192e/rtl8192e/r8192E_hw.h | 8 +- drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c | 448 ++++++++------- drivers/staging/rtl8192e/rtl8192e/r8192E_phy.h | 66 +-- drivers/staging/rtl8192e/rtl8192e/rtl_cam.c | 125 +++-- drivers/staging/rtl8192e/rtl8192e/rtl_cam.h | 16 +- drivers/staging/rtl8192e/rtl8192e/rtl_core.c | 611 +++++++-------------- drivers/staging/rtl8192e/rtl8192e/rtl_core.h | 112 ++-- drivers/staging/rtl8192e/rtl8192e/rtl_dm.c | 472 ++++++++-------- drivers/staging/rtl8192e/rtl8192e/rtl_dm.h | 44 +- drivers/staging/rtl8192e/rtl8192e/rtl_eeprom.c | 130 ++--- drivers/staging/rtl8192e/rtl8192e/rtl_eeprom.h | 2 +- drivers/staging/rtl8192e/rtl8192e/rtl_pci.c | 2 +- drivers/staging/rtl8192e/rtl8192e/rtl_pci.h | 2 +- drivers/staging/rtl8192e/rtl8192e/rtl_pm.c | 24 +- drivers/staging/rtl8192e/rtl8192e/rtl_pm.h | 4 +- drivers/staging/rtl8192e/rtl8192e/rtl_ps.c | 53 +- drivers/staging/rtl8192e/rtl8192e/rtl_ps.h | 19 +- drivers/staging/rtl8192e/rtl8192e/rtl_wx.c | 132 +++-- drivers/staging/rtl8192e/rtl819x_BA.h | 5 - drivers/staging/rtl8192e/rtl819x_BAProc.c | 5 +- drivers/staging/rtl8192e/rtl819x_HT.h | 2 - drivers/staging/rtl8192e/rtl819x_HTProc.c | 5 +- drivers/staging/rtl8192e/rtl819x_Qos.h | 5 - drivers/staging/rtl8192e/rtl819x_TS.h | 2 - drivers/staging/rtl8192e/rtl819x_TSProc.c | 2 +- drivers/staging/rtl8192e/rtllib.h | 439 ++++++--------- drivers/staging/rtl8192e/rtllib_debug.h | 8 - drivers/staging/rtl8192e/rtllib_rx.c | 91 +-- drivers/staging/rtl8192e/rtllib_softmac.c | 30 +- drivers/staging/rtl8192e/rtllib_tx.c | 9 +- 41 files changed, 1528 insertions(+), 2179 deletions(-) (limited to 'drivers/staging/rtl8192e') diff --git a/drivers/staging/rtl8192e/dot11d.c b/drivers/staging/rtl8192e/dot11d.c index ef9da863c..fcf9b3bcf 100644 --- a/drivers/staging/rtl8192e/dot11d.c +++ b/drivers/staging/rtl8192e/dot11d.c @@ -160,21 +160,6 @@ void Dot11d_UpdateCountryIe(struct rtllib_device *dev, u8 *pTaddr, pDot11dInfo->State = DOT11D_STATE_LEARNED; } -u8 DOT11D_GetMaxTxPwrInDbm(struct rtllib_device *dev, u8 Channel) -{ - struct rt_dot11d_info *pDot11dInfo = GET_DOT11D_INFO(dev); - u8 MaxTxPwrInDbm = 255; - - if (MAX_CHANNEL_NUMBER < Channel) { - netdev_info(dev->dev, "DOT11D_GetMaxTxPwrInDbm(): Invalid Channel\n"); - return MaxTxPwrInDbm; - } - if (pDot11dInfo->channel_map[Channel]) - MaxTxPwrInDbm = pDot11dInfo->MaxTxPwrDbmList[Channel]; - - return MaxTxPwrInDbm; -} - void DOT11D_ScanComplete(struct rtllib_device *dev) { struct rt_dot11d_info *pDot11dInfo = GET_DOT11D_INFO(dev); @@ -190,27 +175,3 @@ void DOT11D_ScanComplete(struct rtllib_device *dev) break; } } - -int ToLegalChannel(struct rtllib_device *dev, u8 channel) -{ - struct rt_dot11d_info *pDot11dInfo = GET_DOT11D_INFO(dev); - u8 default_chn = 0; - u32 i; - - for (i = 1; i <= MAX_CHANNEL_NUMBER; i++) { - if (pDot11dInfo->channel_map[i] > 0) { - default_chn = i; - break; - } - } - - if (MAX_CHANNEL_NUMBER < channel) { - netdev_err(dev->dev, "%s(): Invalid Channel\n", __func__); - return default_chn; - } - - if (pDot11dInfo->channel_map[channel] > 0) - return channel; - - return default_chn; -} diff --git a/drivers/staging/rtl8192e/dot11d.h b/drivers/staging/rtl8192e/dot11d.h index 69e0f8f7e..129ebed2e 100644 --- a/drivers/staging/rtl8192e/dot11d.h +++ b/drivers/staging/rtl8192e/dot11d.h @@ -79,7 +79,6 @@ static inline void cpMacAddr(unsigned char *des, unsigned char *src) #define UPDATE_CIE_SRC(__pIeeeDev, __pTa) \ cpMacAddr(GET_DOT11D_INFO(__pIeeeDev)->CountryIeSrcAddr, __pTa) -#define CIE_WATCHDOG_TH 1 #define GET_CIE_WATCHDOG(__pIeeeDev) \ (GET_DOT11D_INFO(__pIeeeDev)->CountryIeWatchdog) static inline void RESET_CIE_WATCHDOG(struct rtllib_device *__pIeeeDev) @@ -88,16 +87,11 @@ static inline void RESET_CIE_WATCHDOG(struct rtllib_device *__pIeeeDev) } #define UPDATE_CIE_WATCHDOG(__pIeeeDev) (++GET_CIE_WATCHDOG(__pIeeeDev)) -#define IS_DOT11D_STATE_DONE(__pIeeeDev) \ - (GET_DOT11D_INFO(__pIeeeDev)->State == DOT11D_STATE_DONE) - void dot11d_init(struct rtllib_device *dev); void Dot11d_Channelmap(u8 channel_plan, struct rtllib_device *ieee); void Dot11d_Reset(struct rtllib_device *dev); void Dot11d_UpdateCountryIe(struct rtllib_device *dev, u8 *pTaddr, u16 CoutryIeLen, u8 *pCoutryIe); -u8 DOT11D_GetMaxTxPwrInDbm(struct rtllib_device *dev, u8 Channel); void DOT11D_ScanComplete(struct rtllib_device *dev); -int ToLegalChannel(struct rtllib_device *dev, u8 channel); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/r8190P_def.h b/drivers/staging/rtl8192e/rtl8192e/r8190P_def.h index d0b08301b..dba4584c7 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8190P_def.h +++ b/drivers/staging/rtl8192e/rtl8192e/r8190P_def.h @@ -26,8 +26,6 @@ #define MAX_SILENT_RESET_RX_SLOT_NUM 10 #define RX_MPDU_QUEUE 0 -#define RX_CMD_QUEUE 1 - enum rtl819x_loopback { RTL819X_NO_LOOPBACK = 0, @@ -36,11 +34,6 @@ enum rtl819x_loopback { RTL819X_CCK_LOOPBACK = 3, }; - -#define RESET_DELAY_8185 20 - -#define RT_IBSS_INT_MASKS (IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER) - #define DESC90_RATE1M 0x00 #define DESC90_RATE2M 0x01 #define DESC90_RATE5_5M 0x02 @@ -74,17 +67,6 @@ enum rtl819x_loopback { #define SHORT_SLOT_TIME 9 #define NON_SHORT_SLOT_TIME 20 - -#define MAX_LINES_HWCONFIG_TXT 1000 -#define MAX_BYTES_LINE_HWCONFIG_TXT 128 - -#define SW_THREE_WIRE 0 -#define HW_THREE_WIRE 2 - -#define BT_DEMO_BOARD 0 -#define BT_QA_BOARD 1 -#define BT_FPGA 2 - #define RX_SMOOTH 20 #define QSLT_BK 0x1 @@ -96,25 +78,14 @@ enum rtl819x_loopback { #define QSLT_MGNT 0x12 #define QSLT_CMD 0x13 -#define NUM_OF_FIRMWARE_QUEUE 10 -#define NUM_OF_PAGES_IN_FW 0x100 #define NUM_OF_PAGE_IN_FW_QUEUE_BK 0x007 #define NUM_OF_PAGE_IN_FW_QUEUE_BE 0x0aa #define NUM_OF_PAGE_IN_FW_QUEUE_VI 0x024 #define NUM_OF_PAGE_IN_FW_QUEUE_VO 0x007 -#define NUM_OF_PAGE_IN_FW_QUEUE_HCCA 0 -#define NUM_OF_PAGE_IN_FW_QUEUE_CMD 0x2 #define NUM_OF_PAGE_IN_FW_QUEUE_MGNT 0x10 -#define NUM_OF_PAGE_IN_FW_QUEUE_HIGH 0 #define NUM_OF_PAGE_IN_FW_QUEUE_BCN 0x4 #define NUM_OF_PAGE_IN_FW_QUEUE_PUB 0xd -#define NUM_OF_PAGE_IN_FW_QUEUE_BK_DTM 0x026 -#define NUM_OF_PAGE_IN_FW_QUEUE_BE_DTM 0x048 -#define NUM_OF_PAGE_IN_FW_QUEUE_VI_DTM 0x048 -#define NUM_OF_PAGE_IN_FW_QUEUE_VO_DTM 0x026 -#define NUM_OF_PAGE_IN_FW_QUEUE_PUB_DTM 0x00 - #define APPLIED_RESERVED_QUEUE_IN_FW 0x80000000 #define RSVD_FW_QUEUE_PAGE_BK_SHIFT 0x00 #define RSVD_FW_QUEUE_PAGE_BE_SHIFT 0x08 @@ -197,23 +168,6 @@ struct tx_fwinfo_8190pci { }; - -#define TX_DESC_SIZE 32 - -#define TX_DESC_CMD_SIZE 32 - - -#define TX_STATUS_DESC_SIZE 32 - -#define TX_FWINFO_SIZE 8 - - -#define RX_DESC_SIZE 16 - -#define RX_STATUS_DESC_SIZE 16 - -#define RX_DRIVER_INFO_SIZE 8 - struct log_int_8190 { u32 nIMR_COMDOK; u32 nIMR_MGNTDOK; diff --git a/drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.c b/drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.c index facc6f1f3..c8f25ade2 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.c +++ b/drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.c @@ -22,55 +22,38 @@ #include "r8192E_phy.h" #include "r8190P_rtl8256.h" -void PHY_SetRF8256Bandwidth(struct net_device *dev, - enum ht_channel_width Bandwidth) +void rtl92e_set_bandwidth(struct net_device *dev, + enum ht_channel_width Bandwidth) { u8 eRFPath; struct r8192_priv *priv = rtllib_priv(dev); + if (priv->card_8192_version != VERSION_8190_BD && + priv->card_8192_version != VERSION_8190_BE) { + netdev_warn(dev, "%s(): Unknown HW version.\n", __func__); + return; + } + for (eRFPath = 0; eRFPath < priv->NumTotalRFPath; eRFPath++) { - if (!rtl8192_phy_CheckIsLegalRFPath(dev, eRFPath)) + if (!rtl92e_is_legal_rf_path(dev, eRFPath)) continue; switch (Bandwidth) { case HT_CHANNEL_WIDTH_20: - if (priv->card_8192_version == VERSION_8190_BD || - priv->card_8192_version == VERSION_8190_BE) { - rtl8192_phy_SetRFReg(dev, - (enum rf90_radio_path)eRFPath, - 0x0b, bMask12Bits, 0x100); - rtl8192_phy_SetRFReg(dev, - (enum rf90_radio_path)eRFPath, - 0x2c, bMask12Bits, 0x3d7); - rtl8192_phy_SetRFReg(dev, - (enum rf90_radio_path)eRFPath, - 0x0e, bMask12Bits, 0x021); - - } else { - netdev_warn(dev, "%s(): Unknown HW version.\n", - __func__); - } - + rtl92e_set_rf_reg(dev, (enum rf90_radio_path)eRFPath, + 0x0b, bMask12Bits, 0x100); + rtl92e_set_rf_reg(dev, (enum rf90_radio_path)eRFPath, + 0x2c, bMask12Bits, 0x3d7); + rtl92e_set_rf_reg(dev, (enum rf90_radio_path)eRFPath, + 0x0e, bMask12Bits, 0x021); break; case HT_CHANNEL_WIDTH_20_40: - if (priv->card_8192_version == VERSION_8190_BD || - priv->card_8192_version == VERSION_8190_BE) { - rtl8192_phy_SetRFReg(dev, - (enum rf90_radio_path)eRFPath, - 0x0b, bMask12Bits, 0x300); - rtl8192_phy_SetRFReg(dev, - (enum rf90_radio_path)eRFPath, - 0x2c, bMask12Bits, 0x3ff); - rtl8192_phy_SetRFReg(dev, - (enum rf90_radio_path)eRFPath, - 0x0e, bMask12Bits, 0x0e1); - - } else { - netdev_warn(dev, "%s(): Unknown HW version.\n", - __func__); - } - - + rtl92e_set_rf_reg(dev, (enum rf90_radio_path)eRFPath, + 0x0b, bMask12Bits, 0x300); + rtl92e_set_rf_reg(dev, (enum rf90_radio_path)eRFPath, + 0x2c, bMask12Bits, 0x3ff); + rtl92e_set_rf_reg(dev, (enum rf90_radio_path)eRFPath, + 0x0e, bMask12Bits, 0x0e1); break; default: netdev_err(dev, "%s(): Unknown bandwidth: %#X\n", @@ -81,15 +64,7 @@ void PHY_SetRF8256Bandwidth(struct net_device *dev, } } -bool PHY_RF8256_Config(struct net_device *dev) -{ - struct r8192_priv *priv = rtllib_priv(dev); - - priv->NumTotalRFPath = RTL819X_TOTAL_RF_PATH; - return phy_RF8256_Config_ParaFile(dev); -} - -bool phy_RF8256_Config_ParaFile(struct net_device *dev) +bool rtl92e_config_rf(struct net_device *dev) { u32 u4RegValue = 0; u8 eRFPath; @@ -102,9 +77,11 @@ bool phy_RF8256_Config_ParaFile(struct net_device *dev) u8 ConstRetryTimes = 5, RetryTimes = 5; u8 ret = 0; + priv->NumTotalRFPath = RTL819X_TOTAL_RF_PATH; + for (eRFPath = (enum rf90_radio_path)RF90_PATH_A; eRFPath < priv->NumTotalRFPath; eRFPath++) { - if (!rtl8192_phy_CheckIsLegalRFPath(dev, eRFPath)) + if (!rtl92e_is_legal_rf_path(dev, eRFPath)) continue; pPhyReg = &priv->PHYRegDef[eRFPath]; @@ -113,114 +90,63 @@ bool phy_RF8256_Config_ParaFile(struct net_device *dev) switch (eRFPath) { case RF90_PATH_A: case RF90_PATH_C: - u4RegValue = rtl8192_QueryBBReg(dev, pPhyReg->rfintfs, - bRFSI_RFENV); + u4RegValue = rtl92e_get_bb_reg(dev, pPhyReg->rfintfs, + bRFSI_RFENV); break; case RF90_PATH_B: case RF90_PATH_D: - u4RegValue = rtl8192_QueryBBReg(dev, pPhyReg->rfintfs, - bRFSI_RFENV<<16); + u4RegValue = rtl92e_get_bb_reg(dev, pPhyReg->rfintfs, + bRFSI_RFENV<<16); break; } - rtl8192_setBBreg(dev, pPhyReg->rfintfe, bRFSI_RFENV<<16, 0x1); + rtl92e_set_bb_reg(dev, pPhyReg->rfintfe, bRFSI_RFENV<<16, 0x1); - rtl8192_setBBreg(dev, pPhyReg->rfintfo, bRFSI_RFENV, 0x1); + rtl92e_set_bb_reg(dev, pPhyReg->rfintfo, bRFSI_RFENV, 0x1); - rtl8192_setBBreg(dev, pPhyReg->rfHSSIPara2, - b3WireAddressLength, 0x0); - rtl8192_setBBreg(dev, pPhyReg->rfHSSIPara2, - b3WireDataLength, 0x0); + rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, + b3WireAddressLength, 0x0); + rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, + b3WireDataLength, 0x0); - rtl8192_phy_SetRFReg(dev, (enum rf90_radio_path) eRFPath, 0x0, - bMask12Bits, 0xbf); + rtl92e_set_rf_reg(dev, (enum rf90_radio_path)eRFPath, 0x0, + bMask12Bits, 0xbf); - rtStatus = rtl8192_phy_checkBBAndRF(dev, HW90_BLOCK_RF, - (enum rf90_radio_path)eRFPath); + rtStatus = rtl92e_check_bb_and_rf(dev, HW90_BLOCK_RF, + (enum rf90_radio_path)eRFPath); if (!rtStatus) { netdev_err(dev, "%s(): Failed to check RF Path %d.\n", __func__, eRFPath); - goto phy_RF8256_Config_ParaFile_Fail; + goto fail; } RetryTimes = ConstRetryTimes; RF3_Final_Value = 0; - switch (eRFPath) { - case RF90_PATH_A: - while (RF3_Final_Value != RegValueToBeCheck && - RetryTimes != 0) { - ret = rtl8192_phy_ConfigRFWithHeaderFile(dev, - (enum rf90_radio_path)eRFPath); - RF3_Final_Value = rtl8192_phy_QueryRFReg(dev, - (enum rf90_radio_path)eRFPath, - RegOffSetToBeCheck, - bMask12Bits); - RT_TRACE(COMP_RF, - "RF %d %d register final value: %x\n", - eRFPath, RegOffSetToBeCheck, - RF3_Final_Value); - RetryTimes--; - } - break; - case RF90_PATH_B: - while (RF3_Final_Value != RegValueToBeCheck && - RetryTimes != 0) { - ret = rtl8192_phy_ConfigRFWithHeaderFile(dev, - (enum rf90_radio_path)eRFPath); - RF3_Final_Value = rtl8192_phy_QueryRFReg(dev, - (enum rf90_radio_path)eRFPath, - RegOffSetToBeCheck, - bMask12Bits); - RT_TRACE(COMP_RF, - "RF %d %d register final value: %x\n", - eRFPath, RegOffSetToBeCheck, - RF3_Final_Value); - RetryTimes--; - } - break; - case RF90_PATH_C: - while (RF3_Final_Value != RegValueToBeCheck && - RetryTimes != 0) { - ret = rtl8192_phy_ConfigRFWithHeaderFile(dev, + while (RF3_Final_Value != RegValueToBeCheck && + RetryTimes != 0) { + ret = rtl92e_config_rf_path(dev, (enum rf90_radio_path)eRFPath); - RF3_Final_Value = rtl8192_phy_QueryRFReg(dev, + RF3_Final_Value = rtl92e_get_rf_reg(dev, (enum rf90_radio_path)eRFPath, RegOffSetToBeCheck, bMask12Bits); - RT_TRACE(COMP_RF, - "RF %d %d register final value: %x\n", - eRFPath, RegOffSetToBeCheck, - RF3_Final_Value); - RetryTimes--; - } - break; - case RF90_PATH_D: - while (RF3_Final_Value != RegValueToBeCheck && - RetryTimes != 0) { - ret = rtl8192_phy_ConfigRFWithHeaderFile(dev, - (enum rf90_radio_path)eRFPath); - RF3_Final_Value = rtl8192_phy_QueryRFReg(dev, - (enum rf90_radio_path)eRFPath, - RegOffSetToBeCheck, bMask12Bits); - RT_TRACE(COMP_RF, - "RF %d %d register final value: %x\n", - eRFPath, RegOffSetToBeCheck, - RF3_Final_Value); - RetryTimes--; - } - break; + RT_TRACE(COMP_RF, + "RF %d %d register final value: %x\n", + eRFPath, RegOffSetToBeCheck, + RF3_Final_Value); + RetryTimes--; } switch (eRFPath) { case RF90_PATH_A: case RF90_PATH_C: - rtl8192_setBBreg(dev, pPhyReg->rfintfs, bRFSI_RFENV, - u4RegValue); + rtl92e_set_bb_reg(dev, pPhyReg->rfintfs, bRFSI_RFENV, + u4RegValue); break; case RF90_PATH_B: case RF90_PATH_D: - rtl8192_setBBreg(dev, pPhyReg->rfintfs, bRFSI_RFENV<<16, - u4RegValue); + rtl92e_set_bb_reg(dev, pPhyReg->rfintfs, + bRFSI_RFENV<<16, u4RegValue); break; } @@ -228,7 +154,7 @@ bool phy_RF8256_Config_ParaFile(struct net_device *dev) netdev_err(dev, "%s(): Failed to initialize RF Path %d.\n", __func__, eRFPath); - goto phy_RF8256_Config_ParaFile_Fail; + goto fail; } } @@ -236,11 +162,11 @@ bool phy_RF8256_Config_ParaFile(struct net_device *dev) RT_TRACE(COMP_PHY, "PHY Initialization Success\n"); return true; -phy_RF8256_Config_ParaFile_Fail: +fail: return false; } -void PHY_SetRF8256CCKTxPower(struct net_device *dev, u8 powerlevel) +void rtl92e_set_cck_tx_power(struct net_device *dev, u8 powerlevel) { u32 TxAGC = 0; struct r8192_priv *priv = rtllib_priv(dev); @@ -254,11 +180,11 @@ void PHY_SetRF8256CCKTxPower(struct net_device *dev, u8 powerlevel) } if (TxAGC > 0x24) TxAGC = 0x24; - rtl8192_setBBreg(dev, rTxAGC_CCK_Mcs32, bTxAGCRateCCK, TxAGC); + rtl92e_set_bb_reg(dev, rTxAGC_CCK_Mcs32, bTxAGCRateCCK, TxAGC); } -void PHY_SetRF8256OFDMTxPower(struct net_device *dev, u8 powerlevel) +void rtl92e_set_ofdm_tx_power(struct net_device *dev, u8 powerlevel) { struct r8192_priv *priv = rtllib_priv(dev); u32 writeVal, powerBase0, powerBase1, writeVal_tmp; @@ -300,7 +226,7 @@ void PHY_SetRF8256OFDMTxPower(struct net_device *dev, u8 powerlevel) else writeVal = (byte3 << 24) | (byte2 << 16) | (byte1 << 8) | byte0; - rtl8192_setBBreg(dev, RegOffset[index], 0x7f7f7f7f, writeVal); + rtl92e_set_bb_reg(dev, RegOffset[index], 0x7f7f7f7f, writeVal); } } diff --git a/drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.h b/drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.h index 64e831d2f..3e4363f41 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.h +++ b/drivers/staging/rtl8192e/rtl8192e/r8190P_rtl8256.h @@ -21,11 +21,10 @@ #define RTL8225H #define RTL819X_TOTAL_RF_PATH 2 -extern void PHY_SetRF8256Bandwidth(struct net_device *dev, - enum ht_channel_width Bandwidth); -extern bool PHY_RF8256_Config(struct net_device *dev); -extern bool phy_RF8256_Config_ParaFile(struct net_device *dev); -extern void PHY_SetRF8256CCKTxPower(struct net_device *dev, u8 powerlevel); -extern void PHY_SetRF8256OFDMTxPower(struct net_device *dev, u8 powerlevel); +void rtl92e_set_bandwidth(struct net_device *dev, + enum ht_channel_width Bandwidth); +bool rtl92e_config_rf(struct net_device *dev); +void rtl92e_set_cck_tx_power(struct net_device *dev, u8 powerlevel); +void rtl92e_set_ofdm_tx_power(struct net_device *dev, u8 powerlevel); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.c b/drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.c index ebd08a166..9ddabf597 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.c +++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.c @@ -21,11 +21,8 @@ #include "r8192E_hw.h" #include "r8192E_cmdpkt.h" -bool cmpk_message_handle_tx( - struct net_device *dev, - u8 *code_virtual_address, - u32 packettype, - u32 buffer_len) +bool rtl92e_send_cmd_pkt(struct net_device *dev, u8 *code_virtual_address, + u32 packettype, u32 buffer_len) { bool rt_status = true; @@ -41,7 +38,7 @@ bool cmpk_message_handle_tx( struct tx_fwinfo_8190pci *pTxFwInfo = NULL; RT_TRACE(COMP_CMDPKT, "%s(),buffer_len is %d\n", __func__, buffer_len); - firmware_init_param(dev); + rtl92e_init_fw_param(dev); frag_threshold = pfirmware->cmdpacket_frag_thresold; do { @@ -84,7 +81,7 @@ bool cmpk_message_handle_tx( } while (frag_offset < buffer_len); - write_nic_byte(dev, TPPoll, TPPoll_CQ); + rtl92e_writeb(dev, TPPoll, TPPoll_CQ); Failed: return rt_status; } diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.h b/drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.h index f714d5100..2a8b165cb 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.h +++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_cmdpkt.h @@ -19,7 +19,6 @@ #ifndef R819XUSB_CMDPKT_H #define R819XUSB_CMDPKT_H -extern bool cmpk_message_handle_tx(struct net_device *dev, - u8 *codevirtualaddress, u32 packettype, - u32 buffer_len); +bool rtl92e_send_cmd_pkt(struct net_device *dev, u8 *codevirtualaddress, + u32 packettype, u32 buffer_len); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c b/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c index f6661bbae..c28cabc23 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c +++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c @@ -33,7 +33,7 @@ static int WDCAPARA_ADD[] = {EDCAPARA_BE, EDCAPARA_BK, EDCAPARA_VI, EDCAPARA_VO}; -void rtl8192e_start_beacon(struct net_device *dev) +void rtl92e_start_beacon(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); struct rtllib_network *net = &priv->rtllib->current_network; @@ -41,21 +41,20 @@ void rtl8192e_start_beacon(struct net_device *dev) u16 BcnCW = 6; u16 BcnIFS = 0xf; - DMESG("Enabling beacon TX"); - rtl8192_irq_disable(dev); + rtl92e_irq_disable(dev); - write_nic_word(dev, ATIMWND, 2); + rtl92e_writew(dev, ATIMWND, 2); - write_nic_word(dev, BCN_INTERVAL, net->beacon_interval); - write_nic_word(dev, BCN_DRV_EARLY_INT, 10); - write_nic_word(dev, BCN_DMATIME, 256); + rtl92e_writew(dev, BCN_INTERVAL, net->beacon_interval); + rtl92e_writew(dev, BCN_DRV_EARLY_INT, 10); + rtl92e_writew(dev, BCN_DMATIME, 256); - write_nic_byte(dev, BCN_ERR_THRESH, 100); + rtl92e_writeb(dev, BCN_ERR_THRESH, 100); BcnTimeCfg |= BcnCW<rtllib->iw_mode) { @@ -91,26 +90,26 @@ static void rtl8192e_update_msr(struct net_device *dev) break; } - write_nic_byte(dev, MSR, msr); + rtl92e_writeb(dev, MSR, msr); if (priv->rtllib->LedControlHandler) priv->rtllib->LedControlHandler(dev, LedAction); } -void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) +void rtl92e_set_reg(struct net_device *dev, u8 variable, u8 *val) { struct r8192_priv *priv = rtllib_priv(dev); switch (variable) { case HW_VAR_BSSID: - write_nic_dword(dev, BSSIDR, ((u32 *)(val))[0]); - write_nic_word(dev, BSSIDR+2, ((u16 *)(val+2))[0]); + rtl92e_writel(dev, BSSIDR, ((u32 *)(val))[0]); + rtl92e_writew(dev, BSSIDR+2, ((u16 *)(val+2))[0]); break; case HW_VAR_MEDIA_STATUS: { enum rt_op_mode OpMode = *((enum rt_op_mode *)(val)); enum led_ctl_mode LedAction = LED_CTL_NO_LINK; - u8 btMsr = read_nic_byte(dev, MSR); + u8 btMsr = rtl92e_readb(dev, MSR); btMsr &= 0xfc; @@ -134,7 +133,7 @@ void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) break; } - write_nic_byte(dev, MSR, btMsr); + rtl92e_writeb(dev, MSR, btMsr); } break; @@ -144,7 +143,7 @@ void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) u32 RegRCR, Type; Type = ((u8 *)(val))[0]; - RegRCR = read_nic_dword(dev, RCR); + RegRCR = rtl92e_readl(dev, RCR); priv->ReceiveConfig = RegRCR; if (Type == true) @@ -152,7 +151,7 @@ void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) else if (Type == false) RegRCR &= (~RCR_CBSSID); - write_nic_dword(dev, RCR, RegRCR); + rtl92e_writel(dev, RCR, RegRCR); priv->ReceiveConfig = RegRCR; } @@ -161,7 +160,7 @@ void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) case HW_VAR_SLOT_TIME: priv->slot_time = val[0]; - write_nic_byte(dev, SLOT_TIME, val[0]); + rtl92e_writeb(dev, SLOT_TIME, val[0]); break; @@ -173,12 +172,12 @@ void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) regTmp = priv->basic_rate; if (priv->short_preamble) regTmp |= BRSR_AckShortPmb; - write_nic_dword(dev, RRSR, regTmp); + rtl92e_writel(dev, RRSR, regTmp); break; } case HW_VAR_CPU_RST: - write_nic_dword(dev, CPU_GEN, ((u32 *)(val))[0]); + rtl92e_writel(dev, CPU_GEN, ((u32 *)(val))[0]); break; case HW_VAR_AC_PARAM: @@ -194,7 +193,7 @@ void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) u1bAIFS = qop->aifs[pAcParam] * ((mode&(IEEE_G|IEEE_N_24G)) ? 9 : 20) + aSifsTime; - dm_init_edca_turbo(dev); + rtl92e_dm_init_edca_turbo(dev); u4bAcParam = (le16_to_cpu(qop->tx_op_limit[pAcParam]) << AC_PARAM_TXOP_LIMIT_OFFSET) | @@ -208,19 +207,19 @@ void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) __func__, eACI, u4bAcParam); switch (eACI) { case AC1_BK: - write_nic_dword(dev, EDCAPARA_BK, u4bAcParam); + rtl92e_writel(dev, EDCAPARA_BK, u4bAcParam); break; case AC0_BE: - write_nic_dword(dev, EDCAPARA_BE, u4bAcParam); + rtl92e_writel(dev, EDCAPARA_BE, u4bAcParam); break; case AC2_VI: - write_nic_dword(dev, EDCAPARA_VI, u4bAcParam); + rtl92e_writel(dev, EDCAPARA_VI, u4bAcParam); break; case AC3_VO: - write_nic_dword(dev, EDCAPARA_VO, u4bAcParam); + rtl92e_writel(dev, EDCAPARA_VO, u4bAcParam); break; default: @@ -242,7 +241,7 @@ void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) union aci_aifsn *pAciAifsn = (union aci_aifsn *) & (qos_parameters->aifs[0]); u8 acm = pAciAifsn->f.acm; - u8 AcmCtrl = read_nic_byte(dev, AcmHwCtrl); + u8 AcmCtrl = rtl92e_readb(dev, AcmHwCtrl); RT_TRACE(COMP_DBG, "===========>%s():HW_VAR_ACM_CTRL:%x\n", __func__, eACI); @@ -290,20 +289,20 @@ void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val) RT_TRACE(COMP_QOS, "SetHwReg8190pci(): [HW_VAR_ACM_CTRL] Write 0x%X\n", AcmCtrl); - write_nic_byte(dev, AcmHwCtrl, AcmCtrl); + rtl92e_writeb(dev, AcmHwCtrl, AcmCtrl); break; } case HW_VAR_SIFS: - write_nic_byte(dev, SIFS, val[0]); - write_nic_byte(dev, SIFS+1, val[0]); + rtl92e_writeb(dev, SIFS, val[0]); + rtl92e_writeb(dev, SIFS+1, val[0]); break; case HW_VAR_RF_TIMING: { u8 Rf_Timing = *((u8 *)val); - write_nic_byte(dev, rFPGA0_RFTiming1, Rf_Timing); + rtl92e_writeb(dev, rFPGA0_RFTiming1, Rf_Timing); break; } @@ -324,7 +323,7 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) RT_TRACE(COMP_INIT, "====> rtl8192_read_eeprom_info\n"); - EEPROMId = eprom_read(dev, 0); + EEPROMId = rtl92e_eeprom_read(dev, 0); if (EEPROMId != RTL8190_EEPROM_ID) { netdev_err(dev, "%s(): Invalid EEPROM ID: %x\n", __func__, EEPROMId); @@ -334,12 +333,14 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) } if (!priv->AutoloadFailFlag) { - priv->eeprom_vid = eprom_read(dev, EEPROM_VID >> 1); - priv->eeprom_did = eprom_read(dev, EEPROM_DID >> 1); + priv->eeprom_vid = rtl92e_eeprom_read(dev, EEPROM_VID >> 1); + priv->eeprom_did = rtl92e_eeprom_read(dev, EEPROM_DID >> 1); - usValue = eprom_read(dev, (u16)(EEPROM_Customer_ID>>1)) >> 8; + usValue = rtl92e_eeprom_read(dev, + (u16)(EEPROM_Customer_ID>>1)) >> 8; priv->eeprom_CustomerID = (u8)(usValue & 0xff); - usValue = eprom_read(dev, EEPROM_ICVersion_ChannelPlan>>1); + usValue = rtl92e_eeprom_read(dev, + EEPROM_ICVersion_ChannelPlan>>1); priv->eeprom_ChannelPlan = usValue&0xff; IC_Version = (usValue & 0xff00)>>8; @@ -377,7 +378,7 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) if (!priv->AutoloadFailFlag) { for (i = 0; i < 6; i += 2) { - usValue = eprom_read(dev, + usValue = rtl92e_eeprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i) >> 1)); *(u16 *)(&dev->dev_addr[i]) = usValue; } @@ -397,8 +398,8 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) if (priv->card_8192_version > VERSION_8190_BD) { if (!priv->AutoloadFailFlag) { - tempval = (eprom_read(dev, (EEPROM_RFInd_PowerDiff >> - 1))) & 0xff; + tempval = (rtl92e_eeprom_read(dev, + (EEPROM_RFInd_PowerDiff >> 1))) & 0xff; priv->EEPROMLegacyHTTxPowerDiff = tempval & 0xf; if (tempval&0x80) @@ -412,7 +413,7 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) priv->EEPROMLegacyHTTxPowerDiff); if (!priv->AutoloadFailFlag) - priv->EEPROMThermalMeter = (u8)(((eprom_read(dev, + priv->EEPROMThermalMeter = (u8)(((rtl92e_eeprom_read(dev, (EEPROM_ThermalMeter>>1))) & 0xff00)>>8); else @@ -423,7 +424,7 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) if (priv->epromtype == EEPROM_93C46) { if (!priv->AutoloadFailFlag) { - usValue = eprom_read(dev, + usValue = rtl92e_eeprom_read(dev, EEPROM_TxPwDiff_CrystalCap >> 1); priv->EEPROMAntPwDiff = (usValue&0x0fff); priv->EEPROMCrystalCap = (u8)((usValue & 0xf000) @@ -441,7 +442,7 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) for (i = 0; i < 14; i += 2) { if (!priv->AutoloadFailFlag) - usValue = eprom_read(dev, + usValue = rtl92e_eeprom_read(dev, (u16)((EEPROM_TxPwIndex_CCK + i) >> 1)); else @@ -457,7 +458,7 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) } for (i = 0; i < 14; i += 2) { if (!priv->AutoloadFailFlag) - usValue = eprom_read(dev, + usValue = rtl92e_eeprom_read(dev, (u16)((EEPROM_TxPwIndex_OFDM_24G + i) >> 1)); else @@ -561,7 +562,7 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) RT_TRACE(COMP_INIT, "\n2T4R config\n"); } - init_rate_adaptive(dev); + rtl92e_init_adaptive_rate(dev); priv->rf_chip = RF_8256; @@ -626,13 +627,13 @@ static void rtl8192_read_eeprom_info(struct net_device *dev) RT_TRACE(COMP_TRACE, "<==== ReadAdapterInfo\n"); } -void rtl8192_get_eeprom_size(struct net_device *dev) +void rtl92e_get_eeprom_size(struct net_device *dev) { u16 curCR; struct r8192_priv *priv = rtllib_priv(dev); RT_TRACE(COMP_INIT, "===========>%s()\n", __func__); - curCR = read_nic_dword(dev, EPROM_CMD); + curCR = rtl92e_readl(dev, EPROM_CMD); RT_TRACE(COMP_INIT, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD, curCR); priv->epromtype = (curCR & EPROM_CMD_9356SEL) ? EEPROM_93C56 : @@ -684,26 +685,26 @@ static void rtl8192_hwconfig(struct net_device *dev) break; } - write_nic_byte(dev, BW_OPMODE, regBwOpMode); + rtl92e_writeb(dev, BW_OPMODE, regBwOpMode); { u32 ratr_value = 0; ratr_value = regRATR; if (priv->rf_type == RF_1T2R) ratr_value &= ~(RATE_ALL_OFDM_2SS); - write_nic_dword(dev, RATR0, ratr_value); - write_nic_byte(dev, UFWP, 1); + rtl92e_writel(dev, RATR0, ratr_value); + rtl92e_writeb(dev, UFWP, 1); } - regTmp = read_nic_byte(dev, 0x313); + regTmp = rtl92e_readb(dev, 0x313); regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff); - write_nic_dword(dev, RRSR, regRRSR); + rtl92e_writel(dev, RRSR, regRRSR); - write_nic_word(dev, RETRY_LIMIT, - priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | - priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT); + rtl92e_writew(dev, RETRY_LIMIT, + priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | + priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT); } -bool rtl8192_adapter_start(struct net_device *dev) +bool rtl92e_start_adapter(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); u32 ulRegRead; @@ -719,10 +720,10 @@ bool rtl8192_adapter_start(struct net_device *dev) priv->being_init_adapter = true; start: - rtl8192_pci_resetdescring(dev); + rtl92e_reset_desc_ring(dev); priv->Rf_Mode = RF_OP_By_SW_3wire; if (priv->ResetProgress == RESET_TYPE_NORESET) { - write_nic_byte(dev, ANAPAR, 0x37); + rtl92e_writeb(dev, ANAPAR, 0x37); mdelay(500); } priv->pFirmware->firmware_status = FW_STATUS_0_INIT; @@ -730,7 +731,7 @@ start: if (priv->RegRfOff) priv->rtllib->eRFPowerState = eRfOff; - ulRegRead = read_nic_dword(dev, CPU_GEN); + ulRegRead = rtl92e_readl(dev, CPU_GEN); if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT) ulRegRead |= CPU_GEN_SYSTEM_RESET; else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY) @@ -739,19 +740,19 @@ start: netdev_err(dev, "%s(): undefined firmware state: %d.\n", __func__, priv->pFirmware->firmware_status); - write_nic_dword(dev, CPU_GEN, ulRegRead); + rtl92e_writel(dev, CPU_GEN, ulRegRead); - ICVersion = read_nic_byte(dev, IC_VERRSION); + ICVersion = rtl92e_readb(dev, IC_VERRSION); if (ICVersion >= 0x4) { - SwitchingRegulatorOutput = read_nic_byte(dev, SWREGULATOR); + SwitchingRegulatorOutput = rtl92e_readb(dev, SWREGULATOR); if (SwitchingRegulatorOutput != 0xb8) { - write_nic_byte(dev, SWREGULATOR, 0xa8); + rtl92e_writeb(dev, SWREGULATOR, 0xa8); mdelay(1); - write_nic_byte(dev, SWREGULATOR, 0xb8); + rtl92e_writeb(dev, SWREGULATOR, 0xb8); } } RT_TRACE(COMP_INIT, "BB Config Start!\n"); - rtStatus = rtl8192_BBConfig(dev); + rtStatus = rtl92e_config_bb(dev); if (!rtStatus) { netdev_warn(dev, "%s(): Failed to configure BB\n", __func__); return rtStatus; @@ -760,7 +761,7 @@ start: priv->LoopbackMode = RTL819X_NO_LOOPBACK; if (priv->ResetProgress == RESET_TYPE_NORESET) { - ulRegRead = read_nic_dword(dev, CPU_GEN); + ulRegRead = rtl92e_readl(dev, CPU_GEN); if (priv->LoopbackMode == RTL819X_NO_LOOPBACK) ulRegRead = ((ulRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET); @@ -770,73 +771,73 @@ start: netdev_err(dev, "%s: Invalid loopback mode setting.\n", __func__); - write_nic_dword(dev, CPU_GEN, ulRegRead); + rtl92e_writel(dev, CPU_GEN, ulRegRead); udelay(500); } rtl8192_hwconfig(dev); - write_nic_byte(dev, CMDR, CR_RE | CR_TE); - - write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<dev_addr)[0]); - write_nic_word(dev, MAC4, ((u16 *)(dev->dev_addr + 4))[0]); - write_nic_dword(dev, RCR, priv->ReceiveConfig); - - write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << - RSVD_FW_QUEUE_PAGE_BK_SHIFT | - NUM_OF_PAGE_IN_FW_QUEUE_BE << - RSVD_FW_QUEUE_PAGE_BE_SHIFT | - NUM_OF_PAGE_IN_FW_QUEUE_VI << - RSVD_FW_QUEUE_PAGE_VI_SHIFT | - NUM_OF_PAGE_IN_FW_QUEUE_VO << - RSVD_FW_QUEUE_PAGE_VO_SHIFT); - write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << - RSVD_FW_QUEUE_PAGE_MGNT_SHIFT); - write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW | - NUM_OF_PAGE_IN_FW_QUEUE_BCN << - RSVD_FW_QUEUE_PAGE_BCN_SHIFT| - NUM_OF_PAGE_IN_FW_QUEUE_PUB << - RSVD_FW_QUEUE_PAGE_PUB_SHIFT); - - rtl8192_tx_enable(dev); - rtl8192_rx_enable(dev); - ulRegRead = (0xFFF00000 & read_nic_dword(dev, RRSR)) | + rtl92e_writeb(dev, CMDR, CR_RE | CR_TE); + + rtl92e_writeb(dev, PCIF, ((MXDMA2_NoLimit<dev_addr)[0]); + rtl92e_writew(dev, MAC4, ((u16 *)(dev->dev_addr + 4))[0]); + rtl92e_writel(dev, RCR, priv->ReceiveConfig); + + rtl92e_writel(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << + RSVD_FW_QUEUE_PAGE_BK_SHIFT | + NUM_OF_PAGE_IN_FW_QUEUE_BE << + RSVD_FW_QUEUE_PAGE_BE_SHIFT | + NUM_OF_PAGE_IN_FW_QUEUE_VI << + RSVD_FW_QUEUE_PAGE_VI_SHIFT | + NUM_OF_PAGE_IN_FW_QUEUE_VO << + RSVD_FW_QUEUE_PAGE_VO_SHIFT); + rtl92e_writel(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << + RSVD_FW_QUEUE_PAGE_MGNT_SHIFT); + rtl92e_writel(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW | + NUM_OF_PAGE_IN_FW_QUEUE_BCN << + RSVD_FW_QUEUE_PAGE_BCN_SHIFT| + NUM_OF_PAGE_IN_FW_QUEUE_PUB << + RSVD_FW_QUEUE_PAGE_PUB_SHIFT); + + rtl92e_tx_enable(dev); + rtl92e_rx_enable(dev); + ulRegRead = (0xFFF00000 & rtl92e_readl(dev, RRSR)) | RATE_ALL_OFDM_AG | RATE_ALL_CCK; - write_nic_dword(dev, RRSR, ulRegRead); - write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK)); + rtl92e_writel(dev, RRSR, ulRegRead); + rtl92e_writel(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK)); - write_nic_byte(dev, ACK_TIMEOUT, 0x30); + rtl92e_writeb(dev, ACK_TIMEOUT, 0x30); if (priv->ResetProgress == RESET_TYPE_NORESET) - rtl8192_SetWirelessMode(dev, priv->rtllib->mode); - CamResetAllEntry(dev); + rtl92e_set_wireless_mode(dev, priv->rtllib->mode); + rtl92e_cam_reset(dev); { u8 SECR_value = 0x0; SECR_value |= SCR_TxEncEnable; SECR_value |= SCR_RxDecEnable; SECR_value |= SCR_NoSKMC; - write_nic_byte(dev, SECR, SECR_value); + rtl92e_writeb(dev, SECR, SECR_value); } - write_nic_word(dev, ATIMWND, 2); - write_nic_word(dev, BCN_INTERVAL, 100); + rtl92e_writew(dev, ATIMWND, 2); + rtl92e_writew(dev, BCN_INTERVAL, 100); { int i; for (i = 0; i < QOS_QUEUE_NUM; i++) - write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332); + rtl92e_writel(dev, WDCAPARA_ADD[i], 0x005e4332); } - write_nic_byte(dev, 0xbe, 0xc0); + rtl92e_writeb(dev, 0xbe, 0xc0); - rtl8192_phy_configmac(dev); + rtl92e_config_mac(dev); if (priv->card_8192_version > (u8) VERSION_8190_BD) { - rtl8192_phy_getTxPower(dev); - rtl8192_phy_setTxPower(dev, priv->chan); + rtl92e_get_tx_power(dev); + rtl92e_set_tx_power(dev, priv->chan); } - tmpvalue = read_nic_byte(dev, IC_VERRSION); + tmpvalue = rtl92e_readb(dev, IC_VERRSION); priv->IC_Cut = tmpvalue; RT_TRACE(COMP_INIT, "priv->IC_Cut= 0x%x\n", priv->IC_Cut); if (priv->IC_Cut >= IC_VersionCut_D) { @@ -851,7 +852,7 @@ start: } RT_TRACE(COMP_INIT, "Load Firmware!\n"); - bfirmwareok = init_firmware(dev); + bfirmwareok = rtl92e_init_fw(dev); if (!bfirmwareok) { if (retry_times < 10) { retry_times++; @@ -864,37 +865,34 @@ start: RT_TRACE(COMP_INIT, "Load Firmware finished!\n"); if (priv->ResetProgress == RESET_TYPE_NORESET) { RT_TRACE(COMP_INIT, "RF Config Started!\n"); - rtStatus = rtl8192_phy_RFConfig(dev); + rtStatus = rtl92e_config_phy(dev); if (!rtStatus) { netdev_info(dev, "RF Config failed\n"); return rtStatus; } RT_TRACE(COMP_INIT, "RF Config Finished!\n"); } - rtl8192_phy_updateInitGain(dev); - rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1); - rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1); + rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bCCKEn, 0x1); + rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1); - write_nic_byte(dev, 0x87, 0x0); + rtl92e_writeb(dev, 0x87, 0x0); if (priv->RegRfOff) { RT_TRACE((COMP_INIT | COMP_RF | COMP_POWER), "%s(): Turn off RF for RegRfOff ----------\n", __func__); - MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW, true); + rtl92e_set_rf_state(dev, eRfOff, RF_CHANGE_BY_SW); } else if (priv->rtllib->RfOffReason > RF_CHANGE_BY_PS) { RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __func__, priv->rtllib->RfOffReason); - MgntActSet_RF_State(dev, eRfOff, priv->rtllib->RfOffReason, - true); + rtl92e_set_rf_state(dev, eRfOff, priv->rtllib->RfOffReason); } else if (priv->rtllib->RfOffReason >= RF_CHANGE_BY_IPS) { RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __func__, priv->rtllib->RfOffReason); - MgntActSet_RF_State(dev, eRfOff, priv->rtllib->RfOffReason, - true); + rtl92e_set_rf_state(dev, eRfOff, priv->rtllib->RfOffReason); } else { RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): RF-ON\n", __func__); @@ -908,13 +906,13 @@ start: priv->Rf_Mode = RF_OP_By_SW_3wire; if (priv->ResetProgress == RESET_TYPE_NORESET) { - dm_initialize_txpower_tracking(dev); + rtl92e_dm_init_txpower_tracking(dev); if (priv->IC_Cut >= IC_VersionCut_D) { - tmpRegA = rtl8192_QueryBBReg(dev, - rOFDM0_XATxIQImbalance, bMaskDWord); - tmpRegC = rtl8192_QueryBBReg(dev, - rOFDM0_XCTxIQImbalance, bMaskDWord); + tmpRegA = rtl92e_get_bb_reg(dev, rOFDM0_XATxIQImbalance, + bMaskDWord); + tmpRegC = rtl92e_get_bb_reg(dev, rOFDM0_XCTxIQImbalance, + bMaskDWord); for (i = 0; i < TxBBGainTableLength; i++) { if (tmpRegA == dm_tx_bb_gain[i]) { priv->rfa_txpowertrackingindex = (u8)i; @@ -926,8 +924,8 @@ start: } } - TempCCk = rtl8192_QueryBBReg(dev, - rCCK0_TxFilter1, bMaskByte2); + TempCCk = rtl92e_get_bb_reg(dev, rCCK0_TxFilter1, + bMaskByte2); for (i = 0; i < CCKTxBBGainTableLength; i++) { if (TempCCk == dm_cck_tx_bb_gain[i][0]) { @@ -954,7 +952,7 @@ start: priv->btxpower_tracking = false; } } - rtl8192_irq_enable(dev); + rtl92e_irq_enable(dev); end: priv->being_init_adapter = false; return rtStatus; @@ -969,27 +967,27 @@ static void rtl8192_net_update(struct net_device *dev) u16 rate_config = 0; net = &priv->rtllib->current_network; - rtl8192_config_rate(dev, &rate_config); + rtl92e_config_rate(dev, &rate_config); priv->dot11CurrentPreambleMode = PREAMBLE_AUTO; priv->basic_rate = rate_config &= 0x15f; - write_nic_dword(dev, BSSIDR, ((u32 *)net->bssid)[0]); - write_nic_word(dev, BSSIDR+4, ((u16 *)net->bssid)[2]); + rtl92e_writel(dev, BSSIDR, ((u32 *)net->bssid)[0]); + rtl92e_writew(dev, BSSIDR+4, ((u16 *)net->bssid)[2]); if (priv->rtllib->iw_mode == IW_MODE_ADHOC) { - write_nic_word(dev, ATIMWND, 2); - write_nic_word(dev, BCN_DMATIME, 256); - write_nic_word(dev, BCN_INTERVAL, net->beacon_interval); - write_nic_word(dev, BCN_DRV_EARLY_INT, 10); - write_nic_byte(dev, BCN_ERR_THRESH, 100); + rtl92e_writew(dev, ATIMWND, 2); + rtl92e_writew(dev, BCN_DMATIME, 256); + rtl92e_writew(dev, BCN_INTERVAL, net->beacon_interval); + rtl92e_writew(dev, BCN_DRV_EARLY_INT, 10); + rtl92e_writeb(dev, BCN_ERR_THRESH, 100); BcnTimeCfg |= (BcnCW<rtllib; @@ -1002,16 +1000,16 @@ void rtl8192_link_change(struct net_device *dev) priv->ops->update_ratr_table(dev); if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) - EnableHWSecurityConfig8192(dev); + rtl92e_enable_hw_security_config(dev); } else { - write_nic_byte(dev, 0x173, 0); + rtl92e_writeb(dev, 0x173, 0); } rtl8192e_update_msr(dev); if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC) { u32 reg = 0; - reg = read_nic_dword(dev, RCR); + reg = rtl92e_readl(dev, RCR); if (priv->rtllib->state == RTLLIB_LINKED) { if (ieee->IntelPromiscuousModeInfo.bPromiscuousOn) ; @@ -1020,12 +1018,12 @@ void rtl8192_link_change(struct net_device *dev) } else priv->ReceiveConfig = reg &= ~RCR_CBSSID; - write_nic_dword(dev, RCR, reg); + rtl92e_writel(dev, RCR, reg); } } -void rtl8192_AllowAllDestAddr(struct net_device *dev, - bool bAllowAllDA, bool WriteIntoReg) +void rtl92e_set_monitor_mode(struct net_device *dev, bool bAllowAllDA, + bool WriteIntoReg) { struct r8192_priv *priv = rtllib_priv(dev); @@ -1035,7 +1033,7 @@ void rtl8192_AllowAllDestAddr(struct net_device *dev, priv->ReceiveConfig &= ~RCR_AAP; if (WriteIntoReg) - write_nic_dword(dev, RCR, priv->ReceiveConfig); + rtl92e_writel(dev, RCR, priv->ReceiveConfig); } static u8 MRateToHwRate8190Pci(u8 rate) @@ -1177,8 +1175,20 @@ static u8 rtl8192_MapHwQueueToFirmwareQueue(struct net_device *dev, u8 QueueID, return QueueSelect; } -void rtl8192_tx_fill_desc(struct net_device *dev, struct tx_desc *pdesc, - struct cb_desc *cb_desc, struct sk_buff *skb) +static u8 rtl8192_QueryIsShort(u8 TxHT, u8 TxRate, struct cb_desc *tcb_desc) +{ + u8 tmp_Short; + + tmp_Short = (TxHT == 1) ? ((tcb_desc->bUseShortGI) ? 1 : 0) : + ((tcb_desc->bUseShortPreamble) ? 1 : 0); + if (TxHT == 1 && TxRate != DESC90_RATEMCS15) + tmp_Short = 0; + + return tmp_Short; +} + +void rtl92e_fill_tx_desc(struct net_device *dev, struct tx_desc *pdesc, + struct cb_desc *cb_desc, struct sk_buff *skb) { struct r8192_priv *priv = rtllib_priv(dev); dma_addr_t mapping = pci_map_single(priv->pdev, skb->data, skb->len, @@ -1286,9 +1296,8 @@ void rtl8192_tx_fill_desc(struct net_device *dev, struct tx_desc *pdesc, pdesc->TxBuffAddr = mapping; } -void rtl8192_tx_fill_cmd_desc(struct net_device *dev, - struct tx_desc_cmd *entry, - struct cb_desc *cb_desc, struct sk_buff *skb) +void rtl92e_fill_tx_cmd_desc(struct net_device *dev, struct tx_desc_cmd *entry, + struct cb_desc *cb_desc, struct sk_buff *skb) { struct r8192_priv *priv = rtllib_priv(dev); dma_addr_t mapping = pci_map_single(priv->pdev, skb->data, skb->len, @@ -1506,8 +1515,9 @@ static void rtl8192_query_rxphystatus( pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon; pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA; if (check_reg824 == 0) { - reg824_bit9 = rtl8192_QueryBBReg(priv->rtllib->dev, - rFPGA0_XA_HSSIParameter2, 0x200); + reg824_bit9 = rtl92e_get_bb_reg(priv->rtllib->dev, + rFPGA0_XA_HSSIParameter2, + 0x200); check_reg824 = 1; } @@ -1575,7 +1585,7 @@ static void rtl8192_query_rxphystatus( } } - pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all); + pwdb_all = rtl92e_rx_db_to_percent(rx_pwr_all); pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all; pstats->RecvSignalPower = rx_pwr_all; @@ -1615,7 +1625,7 @@ static void rtl8192_query_rxphystatus( rx_snrX /= 2; priv->stats.rxSNRdB[i] = (long)rx_snrX; - RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]); + RSSI = rtl92e_rx_db_to_percent(rx_pwr[i]); if (priv->brfpath_rxenable[i]) total_rssi += RSSI; @@ -1628,7 +1638,7 @@ static void rtl8192_query_rxphystatus( rx_pwr_all = (((pofdm_buf->pwdb_all) >> 1) & 0x7f) - 106; - pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all); + pwdb_all = rtl92e_rx_db_to_percent(rx_pwr_all); pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all; pstats->RxPower = precord_stats->RxPower = rx_pwr_all; @@ -1645,7 +1655,7 @@ static void rtl8192_query_rxphystatus( rx_evmX /= 2; - evm = rtl819x_evm_dbtopercentage(rx_evmX); + evm = rtl92e_evm_db_to_percent(rx_evmX); if (bpacket_match_bssid) { if (i == 0) { pstats->SignalQuality = (u8)(evm & @@ -1721,8 +1731,8 @@ static void rtl8192_process_phyinfo(struct r8192_priv *priv, u8 *buffer, slide_rssi_index = 0; tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics; - priv->stats.signal_strength = rtl819x_translate_todbm(priv, - (u8)tmp_val); + priv->stats.signal_strength = rtl92e_translate_to_dbm(priv, + (u8)tmp_val); curr_st->rssi = priv->stats.signal_strength; if (!prev_st->bPacketMatchBSSID) { if (!prev_st->bToSelfBA) @@ -1732,13 +1742,10 @@ static void rtl8192_process_phyinfo(struct r8192_priv *priv, u8 *buffer, if (!bcheck) return; - rtl819x_process_cck_rxpathsel(priv, prev_st); - priv->stats.num_process_phyinfo++; if (!prev_st->bIsCCK && prev_st->bPacketToSelf) { for (rfpath = RF90_PATH_A; rfpath < RF90_PATH_C; rfpath++) { - if (!rtl8192_phy_CheckIsLegalRFPath(priv->rtllib->dev, - rfpath)) + if (!rtl92e_is_legal_rf_path(priv->rtllib->dev, rfpath)) continue; RT_TRACE(COMP_DBG, "Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d\n", @@ -1813,7 +1820,7 @@ static void rtl8192_process_phyinfo(struct r8192_priv *priv, u8 *buffer, (RX_SMOOTH-1)) + (prev_st->RxPWDBAll)) / (RX_SMOOTH); } - rtl819x_update_rxsignalstatistics8190pci(priv, prev_st); + rtl92e_update_rx_statistics(priv, prev_st); } if (prev_st->SignalQuality != 0) { @@ -1900,7 +1907,7 @@ static void rtl8192_TranslateRxSignalStuff(struct net_device *dev, rtl8192_query_rxphystatus(priv, pstats, pdesc, pdrvinfo, &previous_stats, bpacket_match_bssid, bpacket_toself, bPacketBeacon, bToSelfBA); - rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats); + rtl92e_copy_mpdu_stats(pstats, &previous_stats); } static void rtl8192_UpdateReceivedRateHistogramStatistics( @@ -2016,10 +2023,8 @@ static void rtl8192_UpdateReceivedRateHistogramStatistics( priv->stats.received_rate_histogram[rcvType][rateIndex]++; } -bool rtl8192_rx_query_status_desc(struct net_device *dev, - struct rtllib_rx_stats *stats, - struct rx_desc *pdesc, - struct sk_buff *skb) +bool rtl92e_get_rx_stats(struct net_device *dev, struct rtllib_rx_stats *stats, + struct rx_desc *pdesc, struct sk_buff *skb) { struct r8192_priv *priv = rtllib_priv(dev); struct rx_fwinfo *pDrvInfo = NULL; @@ -2063,9 +2068,9 @@ bool rtl8192_rx_query_status_desc(struct net_device *dev, (pDrvInfo->FirstAGGR == 1); stats->TimeStampLow = pDrvInfo->TSFL; - stats->TimeStampHigh = read_nic_dword(dev, TSFR+4); + stats->TimeStampHigh = rtl92e_readl(dev, TSFR+4); - rtl819x_UpdateRxPktTimeStamp(dev, stats); + rtl92e_update_rx_pkt_timestamp(dev, stats); if ((stats->RxBufShift + stats->RxDrvInfoSize) > 0) stats->bShift = 1; @@ -2089,7 +2094,7 @@ bool rtl8192_rx_query_status_desc(struct net_device *dev, return true; } -void rtl8192_halt_adapter(struct net_device *dev, bool reset) +void rtl92e_stop_adapter(struct net_device *dev, bool reset) { struct r8192_priv *priv = rtllib_priv(dev); int i; @@ -2102,7 +2107,7 @@ void rtl8192_halt_adapter(struct net_device *dev, bool reset) if (!priv->rtllib->bSupportRemoteWakeUp) { u1bTmp = 0x0; - write_nic_byte(dev, CMDR, u1bTmp); + rtl92e_writeb(dev, CMDR, u1bTmp); } mdelay(20); @@ -2113,18 +2118,18 @@ void rtl8192_halt_adapter(struct net_device *dev, bool reset) priv->bHwRfOffAction = 2; if (!priv->rtllib->bSupportRemoteWakeUp) { - PHY_SetRtl8192eRfOff(dev); - ulRegRead = read_nic_dword(dev, CPU_GEN); + rtl92e_set_rf_off(dev); + ulRegRead = rtl92e_readl(dev, CPU_GEN); ulRegRead |= CPU_GEN_SYSTEM_RESET; - write_nic_dword(dev, CPU_GEN, ulRegRead); + rtl92e_writel(dev, CPU_GEN, ulRegRead); } else { - write_nic_dword(dev, WFCRC0, 0xffffffff); - write_nic_dword(dev, WFCRC1, 0xffffffff); - write_nic_dword(dev, WFCRC2, 0xffffffff); + rtl92e_writel(dev, WFCRC0, 0xffffffff); + rtl92e_writel(dev, WFCRC1, 0xffffffff); + rtl92e_writel(dev, WFCRC2, 0xffffffff); - write_nic_byte(dev, PMR, 0x5); - write_nic_byte(dev, MacBlkCtrl, 0xa); + rtl92e_writeb(dev, PMR, 0x5); + rtl92e_writeb(dev, MacBlkCtrl, 0xa); } } @@ -2136,7 +2141,7 @@ void rtl8192_halt_adapter(struct net_device *dev, bool reset) skb_queue_purge(&priv->skb_queue); } -void rtl8192_update_ratr_table(struct net_device *dev) +void rtl92e_update_ratr_table(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_device *ieee = priv->rtllib; @@ -2145,7 +2150,7 @@ void rtl8192_update_ratr_table(struct net_device *dev) u16 rate_config = 0; u8 rate_index = 0; - rtl8192_config_rate(dev, &rate_config); + rtl92e_config_rate(dev, &rate_config); ratr_value = rate_config | *pMcsRate << 12; switch (ieee->mode) { case IEEE_A: @@ -2179,12 +2184,12 @@ void rtl8192_update_ratr_table(struct net_device *dev) else if (!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz) ratr_value |= 0x80000000; - write_nic_dword(dev, RATR0+rate_index*4, ratr_value); - write_nic_byte(dev, UFWP, 1); + rtl92e_writel(dev, RATR0+rate_index*4, ratr_value); + rtl92e_writeb(dev, UFWP, 1); } void -rtl8192_InitializeVariables(struct net_device *dev) +rtl92e_init_variables(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -2218,66 +2223,65 @@ rtl8192_InitializeVariables(struct net_device *dev) priv->bfirst_after_down = false; } -void rtl8192_EnableInterrupt(struct net_device *dev) +void rtl92e_enable_irq(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); priv->irq_enabled = 1; - write_nic_dword(dev, INTA_MASK, priv->irq_mask[0]); + rtl92e_writel(dev, INTA_MASK, priv->irq_mask[0]); } -void rtl8192_DisableInterrupt(struct net_device *dev) +void rtl92e_disable_irq(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); - write_nic_dword(dev, INTA_MASK, 0); + rtl92e_writel(dev, INTA_MASK, 0); priv->irq_enabled = 0; } -void rtl8192_ClearInterrupt(struct net_device *dev) +void rtl92e_clear_irq(struct net_device *dev) { u32 tmp = 0; - tmp = read_nic_dword(dev, ISR); - write_nic_dword(dev, ISR, tmp); + tmp = rtl92e_readl(dev, ISR); + rtl92e_writel(dev, ISR, tmp); } -void rtl8192_enable_rx(struct net_device *dev) +void rtl92e_enable_rx(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); - write_nic_dword(dev, RDQDA, priv->rx_ring_dma[RX_MPDU_QUEUE]); + rtl92e_writel(dev, RDQDA, priv->rx_ring_dma[RX_MPDU_QUEUE]); } static const u32 TX_DESC_BASE[] = { BKQDA, BEQDA, VIQDA, VOQDA, HCCAQDA, CQDA, MQDA, HQDA, BQDA }; -void rtl8192_enable_tx(struct net_device *dev) +void rtl92e_enable_tx(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); u32 i; for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) - write_nic_dword(dev, TX_DESC_BASE[i], priv->tx_ring[i].dma); + rtl92e_writel(dev, TX_DESC_BASE[i], priv->tx_ring[i].dma); } -void rtl8192_interrupt_recognized(struct net_device *dev, u32 *p_inta, - u32 *p_intb) +void rtl92e_ack_irq(struct net_device *dev, u32 *p_inta, u32 *p_intb) { - *p_inta = read_nic_dword(dev, ISR); - write_nic_dword(dev, ISR, *p_inta); + *p_inta = rtl92e_readl(dev, ISR); + rtl92e_writel(dev, ISR, *p_inta); } -bool rtl8192_HalRxCheckStuck(struct net_device *dev) +bool rtl92e_is_rx_stuck(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); - u16 RegRxCounter = read_nic_word(dev, 0x130); + u16 RegRxCounter = rtl92e_readw(dev, 0x130); bool bStuck = false; static u8 rx_chk_cnt; u32 SlotIndex = 0, TotalRxStuckCount = 0; @@ -2338,11 +2342,11 @@ bool rtl8192_HalRxCheckStuck(struct net_device *dev) return bStuck; } -bool rtl8192_HalTxCheckStuck(struct net_device *dev) +bool rtl92e_is_tx_stuck(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); bool bStuck = false; - u16 RegTxCounter = read_nic_word(dev, 0x128); + u16 RegTxCounter = rtl92e_readw(dev, 0x128); RT_TRACE(COMP_RESET, "%s():RegTxCounter is %d,TxCounter is %d\n", __func__, RegTxCounter, priv->TxCounter); @@ -2355,7 +2359,7 @@ bool rtl8192_HalTxCheckStuck(struct net_device *dev) return bStuck; } -bool rtl8192_GetNmodeSupportBySecCfg(struct net_device *dev) +bool rtl92e_get_nmode_support_by_sec(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_device *ieee = priv->rtllib; @@ -2369,34 +2373,10 @@ bool rtl8192_GetNmodeSupportBySecCfg(struct net_device *dev) } } -bool rtl8192_GetHalfNmodeSupportByAPs(struct net_device *dev) +bool rtl92e_is_halfn_supported_by_ap(struct net_device *dev) { - bool Reval; struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_device *ieee = priv->rtllib; - if (ieee->bHalfWirelessN24GMode == true) - Reval = true; - else - Reval = false; - - return Reval; -} - -u8 rtl8192_QueryIsShort(u8 TxHT, u8 TxRate, struct cb_desc *tcb_desc) -{ - u8 tmp_Short; - - tmp_Short = (TxHT == 1) ? ((tcb_desc->bUseShortGI) ? 1 : 0) : - ((tcb_desc->bUseShortPreamble) ? 1 : 0); - if (TxHT == 1 && TxRate != DESC90_RATEMCS15) - tmp_Short = 0; - - return tmp_Short; -} - -void ActUpdateChannelAccessSetting(struct net_device *dev, - enum wireless_mode WirelessMode, - struct channel_access_setting *ChnlAccessSetting) -{ + return ieee->bHalfWirelessN24GMode; } diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.h b/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.h index dbe0e1c87..6bd6b3a4f 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.h +++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.h @@ -27,36 +27,30 @@ #include "r8190P_def.h" -u8 rtl8192_QueryIsShort(u8 TxHT, u8 TxRate, struct cb_desc *tcb_desc); -bool rtl8192_GetHalfNmodeSupportByAPs(struct net_device *dev); -bool rtl8192_GetNmodeSupportBySecCfg(struct net_device *dev); -bool rtl8192_HalTxCheckStuck(struct net_device *dev); -bool rtl8192_HalRxCheckStuck(struct net_device *dev); -void rtl8192_interrupt_recognized(struct net_device *dev, u32 *p_inta, - u32 *p_intb); -void rtl8192_enable_rx(struct net_device *dev); -void rtl8192_enable_tx(struct net_device *dev); -void rtl8192_EnableInterrupt(struct net_device *dev); -void rtl8192_DisableInterrupt(struct net_device *dev); -void rtl8192_ClearInterrupt(struct net_device *dev); -void rtl8192_InitializeVariables(struct net_device *dev); -void rtl8192e_start_beacon(struct net_device *dev); -void rtl8192e_SetHwReg(struct net_device *dev, u8 variable, u8 *val); -void rtl8192_get_eeprom_size(struct net_device *dev); -bool rtl8192_adapter_start(struct net_device *dev); -void rtl8192_link_change(struct net_device *dev); -void rtl8192_AllowAllDestAddr(struct net_device *dev, bool bAllowAllDA, - bool WriteIntoReg); -void rtl8192_tx_fill_desc(struct net_device *dev, struct tx_desc *pdesc, - struct cb_desc *cb_desc, - struct sk_buff *skb); -void rtl8192_tx_fill_cmd_desc(struct net_device *dev, - struct tx_desc_cmd *entry, - struct cb_desc *cb_desc, struct sk_buff *skb); -bool rtl8192_rx_query_status_desc(struct net_device *dev, - struct rtllib_rx_stats *stats, - struct rx_desc *pdesc, - struct sk_buff *skb); -void rtl8192_halt_adapter(struct net_device *dev, bool reset); -void rtl8192_update_ratr_table(struct net_device *dev); +bool rtl92e_is_halfn_supported_by_ap(struct net_device *dev); +bool rtl92e_get_nmode_support_by_sec(struct net_device *dev); +bool rtl92e_is_tx_stuck(struct net_device *dev); +bool rtl92e_is_rx_stuck(struct net_device *dev); +void rtl92e_ack_irq(struct net_device *dev, u32 *p_inta, u32 *p_intb); +void rtl92e_enable_rx(struct net_device *dev); +void rtl92e_enable_tx(struct net_device *dev); +void rtl92e_enable_irq(struct net_device *dev); +void rtl92e_disable_irq(struct net_device *dev); +void rtl92e_clear_irq(struct net_device *dev); +void rtl92e_init_variables(struct net_device *dev); +void rtl92e_start_beacon(struct net_device *dev); +void rtl92e_set_reg(struct net_device *dev, u8 variable, u8 *val); +void rtl92e_get_eeprom_size(struct net_device *dev); +bool rtl92e_start_adapter(struct net_device *dev); +void rtl92e_link_change(struct net_device *dev); +void rtl92e_set_monitor_mode(struct net_device *dev, bool bAllowAllDA, + bool WriteIntoReg); +void rtl92e_fill_tx_desc(struct net_device *dev, struct tx_desc *pdesc, + struct cb_desc *cb_desc, struct sk_buff *skb); +void rtl92e_fill_tx_cmd_desc(struct net_device *dev, struct tx_desc_cmd *entry, + struct cb_desc *cb_desc, struct sk_buff *skb); +bool rtl92e_get_rx_stats(struct net_device *dev, struct rtllib_rx_stats *stats, + struct rx_desc *pdesc, struct sk_buff *skb); +void rtl92e_stop_adapter(struct net_device *dev, bool reset); +void rtl92e_update_ratr_table(struct net_device *dev); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_firmware.c b/drivers/staging/rtl8192e/rtl8192e/r8192E_firmware.c index 389c90b20..0e69789b1 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8192E_firmware.c +++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_firmware.c @@ -23,7 +23,7 @@ #include "r8192E_firmware.h" #include -void firmware_init_param(struct net_device *dev) +void rtl92e_init_fw_param(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); struct rt_firmware *pfirmware = priv->pFirmware; @@ -46,7 +46,7 @@ static bool fw_download_code(struct net_device *dev, u8 *code_virtual_address, struct cb_desc *tcb_desc; u8 bLastIniPkt; - firmware_init_param(dev); + rtl92e_init_fw_param(dev); frag_threshold = pfirmware->cmdpacket_frag_thresold; do { if ((buffer_len - frag_offset) > frag_threshold) { @@ -96,7 +96,7 @@ static bool fw_download_code(struct net_device *dev, u8 *code_virtual_address, } while (frag_offset < buffer_len); - write_nic_byte(dev, TPPoll, TPPoll_CQ); + rtl92e_writeb(dev, TPPoll, TPPoll_CQ); return true; } @@ -109,7 +109,7 @@ static bool CPUcheck_maincodeok_turnonCPU(struct net_device *dev) timeout = jiffies + msecs_to_jiffies(200); while (time_before(jiffies, timeout)) { - CPU_status = read_nic_dword(dev, CPU_GEN); + CPU_status = rtl92e_readl(dev, CPU_GEN); if (CPU_status & CPU_GEN_PUT_CODE_OK) break; mdelay(2); @@ -122,14 +122,14 @@ static bool CPUcheck_maincodeok_turnonCPU(struct net_device *dev) RT_TRACE(COMP_FIRMWARE, "Download Firmware: Put code ok!\n"); } - CPU_status = read_nic_dword(dev, CPU_GEN); - write_nic_byte(dev, CPU_GEN, - (u8)((CPU_status|CPU_GEN_PWR_STB_CPU)&0xff)); + CPU_status = rtl92e_readl(dev, CPU_GEN); + rtl92e_writeb(dev, CPU_GEN, + (u8)((CPU_status|CPU_GEN_PWR_STB_CPU)&0xff)); mdelay(1); timeout = jiffies + msecs_to_jiffies(200); while (time_before(jiffies, timeout)) { - CPU_status = read_nic_dword(dev, CPU_GEN); + CPU_status = rtl92e_readl(dev, CPU_GEN); if (CPU_status&CPU_GEN_BOOT_RDY) break; mdelay(2); @@ -158,7 +158,7 @@ static bool CPUcheck_firmware_ready(struct net_device *dev) timeout = jiffies + msecs_to_jiffies(20); while (time_before(jiffies, timeout)) { - CPU_status = read_nic_dword(dev, CPU_GEN); + CPU_status = rtl92e_readl(dev, CPU_GEN); if (CPU_status&CPU_GEN_FIRM_RDY) break; mdelay(2); @@ -223,7 +223,7 @@ static bool firmware_check_ready(struct net_device *dev, return rt_status; } -bool init_firmware(struct net_device *dev) +bool rtl92e_init_fw(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); bool rt_status = true; diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_firmware.h b/drivers/staging/rtl8192e/rtl8192e/r8192E_firmware.h index 1771c1680..61307e676 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8192E_firmware.h +++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_firmware.h @@ -19,8 +19,6 @@ #ifndef __INC_FIRMWARE_H #define __INC_FIRMWARE_H -#define RTL8190_CPU_START_OFFSET 0x80 - #define GET_COMMAND_PACKET_FRAG_THRESHOLD(v) (4*(v/4) - 8) #define RTL8192E_BOOT_IMG_FW "/*(DEBLOBBED)*/" @@ -61,7 +59,7 @@ struct rt_firmware { u16 firmware_buf_size[MAX_FW_INIT_STEP]; }; -bool init_firmware(struct net_device *dev); -extern void firmware_init_param(struct net_device *dev); +bool rtl92e_init_fw(struct net_device *dev); +void rtl92e_init_fw_param(struct net_device *dev); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_hw.h b/drivers/staging/rtl8192e/rtl8192e/r8192E_hw.h index 43c3fb859..c81832dcf 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8192E_hw.h +++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_hw.h @@ -119,10 +119,10 @@ enum _RTL8192Pci_HW { #define EPROM_CMD_NORMAL 0 #define EPROM_CMD_LOAD 1 #define EPROM_CMD_PROGRAM 2 -#define EPROM_CS_SHIFT 3 -#define EPROM_CK_SHIFT 2 -#define EPROM_W_SHIFT 1 -#define EPROM_R_SHIFT 0 +#define EPROM_CS_BIT 3 +#define EPROM_CK_BIT 2 +#define EPROM_W_BIT 1 +#define EPROM_R_BIT 0 AFR = 0x010, #define AFR_CardBEn (1<<0) diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c b/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c index fba765416..3a15a0f5b 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c +++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c @@ -64,7 +64,7 @@ static u32 rtl8192_CalculateBitShift(u32 dwBitMask) return i; } -u8 rtl8192_phy_CheckIsLegalRFPath(struct net_device *dev, u32 eRFPath) +u8 rtl92e_is_legal_rf_path(struct net_device *dev, u32 eRFPath) { u8 ret = 1; struct r8192_priv *priv = rtllib_priv(dev); @@ -80,27 +80,27 @@ u8 rtl8192_phy_CheckIsLegalRFPath(struct net_device *dev, u32 eRFPath) return ret; } -void rtl8192_setBBreg(struct net_device *dev, u32 dwRegAddr, u32 dwBitMask, - u32 dwData) +void rtl92e_set_bb_reg(struct net_device *dev, u32 dwRegAddr, u32 dwBitMask, + u32 dwData) { u32 OriginalValue, BitShift, NewValue; if (dwBitMask != bMaskDWord) { - OriginalValue = read_nic_dword(dev, dwRegAddr); + OriginalValue = rtl92e_readl(dev, dwRegAddr); BitShift = rtl8192_CalculateBitShift(dwBitMask); NewValue = (((OriginalValue) & (~dwBitMask)) | (dwData << BitShift)); - write_nic_dword(dev, dwRegAddr, NewValue); + rtl92e_writel(dev, dwRegAddr, NewValue); } else - write_nic_dword(dev, dwRegAddr, dwData); + rtl92e_writel(dev, dwRegAddr, dwData); } -u32 rtl8192_QueryBBReg(struct net_device *dev, u32 dwRegAddr, u32 dwBitMask) +u32 rtl92e_get_bb_reg(struct net_device *dev, u32 dwRegAddr, u32 dwBitMask) { u32 Ret = 0, OriginalValue, BitShift; - OriginalValue = read_nic_dword(dev, dwRegAddr); + OriginalValue = rtl92e_readl(dev, dwRegAddr); BitShift = rtl8192_CalculateBitShift(dwBitMask); Ret = (OriginalValue & dwBitMask) >> BitShift; @@ -117,19 +117,19 @@ static u32 rtl8192_phy_RFSerialRead(struct net_device *dev, Offset &= 0x3f; if (priv->rf_chip == RF_8256) { - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0xf00, 0x0); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0xf00, 0x0); if (Offset >= 31) { priv->RfReg0Value[eRFPath] |= 0x140; - rtl8192_setBBreg(dev, pPhyReg->rf3wireOffset, - bMaskDWord, - (priv->RfReg0Value[eRFPath]<<16)); + rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, + bMaskDWord, + (priv->RfReg0Value[eRFPath]<<16)); NewOffset = Offset - 30; } else if (Offset >= 16) { priv->RfReg0Value[eRFPath] |= 0x100; priv->RfReg0Value[eRFPath] &= (~0x40); - rtl8192_setBBreg(dev, pPhyReg->rf3wireOffset, - bMaskDWord, - (priv->RfReg0Value[eRFPath]<<16)); + rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, + bMaskDWord, + (priv->RfReg0Value[eRFPath]<<16)); NewOffset = Offset - 15; } else @@ -139,23 +139,23 @@ static u32 rtl8192_phy_RFSerialRead(struct net_device *dev, "check RF type here, need to be 8256\n"); NewOffset = Offset; } - rtl8192_setBBreg(dev, pPhyReg->rfHSSIPara2, bLSSIReadAddress, - NewOffset); - rtl8192_setBBreg(dev, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x0); - rtl8192_setBBreg(dev, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x1); + rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, bLSSIReadAddress, + NewOffset); + rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x0); + rtl92e_set_bb_reg(dev, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x1); mdelay(1); - ret = rtl8192_QueryBBReg(dev, pPhyReg->rfLSSIReadBack, - bLSSIReadBackData); + ret = rtl92e_get_bb_reg(dev, pPhyReg->rfLSSIReadBack, + bLSSIReadBackData); if (priv->rf_chip == RF_8256) { priv->RfReg0Value[eRFPath] &= 0xebf; - rtl8192_setBBreg(dev, pPhyReg->rf3wireOffset, bMaskDWord, - (priv->RfReg0Value[eRFPath] << 16)); + rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, bMaskDWord, + (priv->RfReg0Value[eRFPath] << 16)); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0x300, 0x3); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0x300, 0x3); } @@ -173,20 +173,20 @@ static void rtl8192_phy_RFSerialWrite(struct net_device *dev, Offset &= 0x3f; if (priv->rf_chip == RF_8256) { - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0xf00, 0x0); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0xf00, 0x0); if (Offset >= 31) { priv->RfReg0Value[eRFPath] |= 0x140; - rtl8192_setBBreg(dev, pPhyReg->rf3wireOffset, - bMaskDWord, - (priv->RfReg0Value[eRFPath] << 16)); + rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, + bMaskDWord, + (priv->RfReg0Value[eRFPath] << 16)); NewOffset = Offset - 30; } else if (Offset >= 16) { priv->RfReg0Value[eRFPath] |= 0x100; priv->RfReg0Value[eRFPath] &= (~0x40); - rtl8192_setBBreg(dev, pPhyReg->rf3wireOffset, - bMaskDWord, - (priv->RfReg0Value[eRFPath] << 16)); + rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, + bMaskDWord, + (priv->RfReg0Value[eRFPath] << 16)); NewOffset = Offset - 15; } else NewOffset = Offset; @@ -198,7 +198,7 @@ static void rtl8192_phy_RFSerialWrite(struct net_device *dev, DataAndAddr = (Data<<16) | (NewOffset&0x3f); - rtl8192_setBBreg(dev, pPhyReg->rf3wireOffset, bMaskDWord, DataAndAddr); + rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, bMaskDWord, DataAndAddr); if (Offset == 0x0) priv->RfReg0Value[eRFPath] = Data; @@ -206,23 +206,21 @@ static void rtl8192_phy_RFSerialWrite(struct net_device *dev, if (priv->rf_chip == RF_8256) { if (Offset != 0) { priv->RfReg0Value[eRFPath] &= 0xebf; - rtl8192_setBBreg( - dev, - pPhyReg->rf3wireOffset, - bMaskDWord, - (priv->RfReg0Value[eRFPath] << 16)); + rtl92e_set_bb_reg(dev, pPhyReg->rf3wireOffset, + bMaskDWord, + (priv->RfReg0Value[eRFPath] << 16)); } - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0x300, 0x3); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0x300, 0x3); } } -void rtl8192_phy_SetRFReg(struct net_device *dev, enum rf90_radio_path eRFPath, - u32 RegAddr, u32 BitMask, u32 Data) +void rtl92e_set_rf_reg(struct net_device *dev, enum rf90_radio_path eRFPath, + u32 RegAddr, u32 BitMask, u32 Data) { struct r8192_priv *priv = rtllib_priv(dev); u32 Original_Value, BitShift, New_Value; - if (!rtl8192_phy_CheckIsLegalRFPath(dev, eRFPath)) + if (!rtl92e_is_legal_rf_path(dev, eRFPath)) return; if (priv->rtllib->eRFPowerState != eRfOn && !priv->being_init_adapter) return; @@ -256,13 +254,13 @@ void rtl8192_phy_SetRFReg(struct net_device *dev, enum rf90_radio_path eRFPath, } } -u32 rtl8192_phy_QueryRFReg(struct net_device *dev, enum rf90_radio_path eRFPath, - u32 RegAddr, u32 BitMask) +u32 rtl92e_get_rf_reg(struct net_device *dev, enum rf90_radio_path eRFPath, + u32 RegAddr, u32 BitMask) { u32 Original_Value, Readback_Value, BitShift; struct r8192_priv *priv = rtllib_priv(dev); - if (!rtl8192_phy_CheckIsLegalRFPath(dev, eRFPath)) + if (!rtl92e_is_legal_rf_path(dev, eRFPath)) return 0; if (priv->rtllib->eRFPowerState != eRfOn && !priv->being_init_adapter) return 0; @@ -289,20 +287,20 @@ static u32 phy_FwRFSerialRead(struct net_device *dev, Data |= ((Offset & 0xFF) << 12); Data |= ((eRFPath & 0x3) << 20); Data |= 0x80000000; - while (read_nic_dword(dev, QPNR)&0x80000000) { + while (rtl92e_readl(dev, QPNR) & 0x80000000) { if (time++ < 100) udelay(10); else break; } - write_nic_dword(dev, QPNR, Data); - while (read_nic_dword(dev, QPNR) & 0x80000000) { + rtl92e_writel(dev, QPNR, Data); + while (rtl92e_readl(dev, QPNR) & 0x80000000) { if (time++ < 100) udelay(10); else return 0; } - return read_nic_dword(dev, RF_DATA); + return rtl92e_readl(dev, RF_DATA); } @@ -317,18 +315,18 @@ static void phy_FwRFSerialWrite(struct net_device *dev, Data |= 0x400000; Data |= 0x80000000; - while (read_nic_dword(dev, QPNR) & 0x80000000) { + while (rtl92e_readl(dev, QPNR) & 0x80000000) { if (time++ < 100) udelay(10); else break; } - write_nic_dword(dev, QPNR, Data); + rtl92e_writel(dev, QPNR, Data); } -void rtl8192_phy_configmac(struct net_device *dev) +void rtl92e_config_mac(struct net_device *dev) { u32 dwArrayLen = 0, i = 0; u32 *pdwArray = NULL; @@ -350,14 +348,14 @@ void rtl8192_phy_configmac(struct net_device *dev) pdwArray[i], pdwArray[i+1], pdwArray[i+2]); if (pdwArray[i] == 0x318) pdwArray[i+2] = 0x00000800; - rtl8192_setBBreg(dev, pdwArray[i], pdwArray[i+1], - pdwArray[i+2]); + rtl92e_set_bb_reg(dev, pdwArray[i], pdwArray[i+1], + pdwArray[i+2]); } return; } -void rtl8192_phyConfigBB(struct net_device *dev, u8 ConfigType) +static void rtl8192_phyConfigBB(struct net_device *dev, u8 ConfigType) { int i; u32 *Rtl819XPHY_REGArray_Table = NULL; @@ -377,9 +375,9 @@ void rtl8192_phyConfigBB(struct net_device *dev, u8 ConfigType) if (ConfigType == BaseBand_Config_PHY_REG) { for (i = 0; i < PHY_REGArrayLen; i += 2) { - rtl8192_setBBreg(dev, Rtl819XPHY_REGArray_Table[i], - bMaskDWord, - Rtl819XPHY_REGArray_Table[i+1]); + rtl92e_set_bb_reg(dev, Rtl819XPHY_REGArray_Table[i], + bMaskDWord, + Rtl819XPHY_REGArray_Table[i+1]); RT_TRACE(COMP_DBG, "i: %x, The Rtl819xUsbPHY_REGArray[0] is %x Rtl819xUsbPHY_REGArray[1] is %x\n", i, Rtl819XPHY_REGArray_Table[i], @@ -387,9 +385,9 @@ void rtl8192_phyConfigBB(struct net_device *dev, u8 ConfigType) } } else if (ConfigType == BaseBand_Config_AGC_TAB) { for (i = 0; i < AGCTAB_ArrayLen; i += 2) { - rtl8192_setBBreg(dev, Rtl819XAGCTAB_Array_Table[i], - bMaskDWord, - Rtl819XAGCTAB_Array_Table[i+1]); + rtl92e_set_bb_reg(dev, Rtl819XAGCTAB_Array_Table[i], + bMaskDWord, + Rtl819XAGCTAB_Array_Table[i+1]); RT_TRACE(COMP_DBG, "i:%x, The rtl819XAGCTAB_Array[0] is %x rtl819XAGCTAB_Array[1] is %x\n", i, Rtl819XAGCTAB_Array_Table[i], @@ -489,9 +487,8 @@ static void rtl8192_InitBBRFRegDef(struct net_device *dev) } -bool rtl8192_phy_checkBBAndRF(struct net_device *dev, - enum hw90_block CheckBlock, - enum rf90_radio_path eRFPath) +bool rtl92e_check_bb_and_rf(struct net_device *dev, enum hw90_block CheckBlock, + enum rf90_radio_path eRFPath) { bool ret = true; u32 i, CheckTimes = 4, dwRegRead = 0; @@ -515,20 +512,20 @@ bool rtl8192_phy_checkBBAndRF(struct net_device *dev, switch (CheckBlock) { case HW90_BLOCK_PHY0: case HW90_BLOCK_PHY1: - write_nic_dword(dev, WriteAddr[CheckBlock], - WriteData[i]); - dwRegRead = read_nic_dword(dev, WriteAddr[CheckBlock]); + rtl92e_writel(dev, WriteAddr[CheckBlock], + WriteData[i]); + dwRegRead = rtl92e_readl(dev, WriteAddr[CheckBlock]); break; case HW90_BLOCK_RF: WriteData[i] &= 0xfff; - rtl8192_phy_SetRFReg(dev, eRFPath, - WriteAddr[HW90_BLOCK_RF], - bMask12Bits, WriteData[i]); + rtl92e_set_rf_reg(dev, eRFPath, + WriteAddr[HW90_BLOCK_RF], + bMask12Bits, WriteData[i]); mdelay(10); - dwRegRead = rtl8192_phy_QueryRFReg(dev, eRFPath, - WriteAddr[HW90_BLOCK_RF], - bMaskDWord); + dwRegRead = rtl92e_get_rf_reg(dev, eRFPath, + WriteAddr[HW90_BLOCK_RF], + bMaskDWord); mdelay(10); break; @@ -555,29 +552,29 @@ static bool rtl8192_BB_Config_ParaFile(struct net_device *dev) u8 bRegValue = 0, eCheckItem = 0; u32 dwRegValue = 0; - bRegValue = read_nic_byte(dev, BB_GLOBAL_RESET); - write_nic_byte(dev, BB_GLOBAL_RESET, (bRegValue|BB_GLOBAL_RESET_BIT)); + bRegValue = rtl92e_readb(dev, BB_GLOBAL_RESET); + rtl92e_writeb(dev, BB_GLOBAL_RESET, (bRegValue|BB_GLOBAL_RESET_BIT)); - dwRegValue = read_nic_dword(dev, CPU_GEN); - write_nic_dword(dev, CPU_GEN, (dwRegValue&(~CPU_GEN_BB_RST))); + dwRegValue = rtl92e_readl(dev, CPU_GEN); + rtl92e_writel(dev, CPU_GEN, (dwRegValue&(~CPU_GEN_BB_RST))); for (eCheckItem = (enum hw90_block)HW90_BLOCK_PHY0; eCheckItem <= HW90_BLOCK_PHY1; eCheckItem++) { - rtStatus = rtl8192_phy_checkBBAndRF(dev, - (enum hw90_block)eCheckItem, - (enum rf90_radio_path)0); + rtStatus = rtl92e_check_bb_and_rf(dev, + (enum hw90_block)eCheckItem, + (enum rf90_radio_path)0); if (!rtStatus) { RT_TRACE((COMP_ERR | COMP_PHY), - "PHY_RF8256_Config():Check PHY%d Fail!!\n", + "rtl92e_config_rf():Check PHY%d Fail!!\n", eCheckItem-1); return rtStatus; } } - rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn|bOFDMEn, 0x0); + rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bCCKEn|bOFDMEn, 0x0); rtl8192_phyConfigBB(dev, BaseBand_Config_PHY_REG); - dwRegValue = read_nic_dword(dev, CPU_GEN); - write_nic_dword(dev, CPU_GEN, (dwRegValue|CPU_GEN_BB_RST)); + dwRegValue = rtl92e_readl(dev, CPU_GEN); + rtl92e_writel(dev, CPU_GEN, (dwRegValue|CPU_GEN_BB_RST)); rtl8192_phyConfigBB(dev, BaseBand_Config_AGC_TAB); @@ -588,57 +585,57 @@ static bool rtl8192_BB_Config_ParaFile(struct net_device *dev) priv->AntennaTxPwDiff[0]); else dwRegValue = 0x0; - rtl8192_setBBreg(dev, rFPGA0_TxGainStage, - (bXBTxAGC|bXCTxAGC|bXDTxAGC), dwRegValue); + rtl92e_set_bb_reg(dev, rFPGA0_TxGainStage, + (bXBTxAGC|bXCTxAGC|bXDTxAGC), dwRegValue); dwRegValue = priv->CrystalCap; - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, bXtalCap92x, - dwRegValue); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, bXtalCap92x, + dwRegValue); } return rtStatus; } -bool rtl8192_BBConfig(struct net_device *dev) +bool rtl92e_config_bb(struct net_device *dev) { rtl8192_InitBBRFRegDef(dev); return rtl8192_BB_Config_ParaFile(dev); } -void rtl8192_phy_getTxPower(struct net_device *dev) +void rtl92e_get_tx_power(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); priv->MCSTxPowerLevelOriginalOffset[0] = - read_nic_dword(dev, rTxAGC_Rate18_06); + rtl92e_readl(dev, rTxAGC_Rate18_06); priv->MCSTxPowerLevelOriginalOffset[1] = - read_nic_dword(dev, rTxAGC_Rate54_24); + rtl92e_readl(dev, rTxAGC_Rate54_24); priv->MCSTxPowerLevelOriginalOffset[2] = - read_nic_dword(dev, rTxAGC_Mcs03_Mcs00); + rtl92e_readl(dev, rTxAGC_Mcs03_Mcs00); priv->MCSTxPowerLevelOriginalOffset[3] = - read_nic_dword(dev, rTxAGC_Mcs07_Mcs04); + rtl92e_readl(dev, rTxAGC_Mcs07_Mcs04); priv->MCSTxPowerLevelOriginalOffset[4] = - read_nic_dword(dev, rTxAGC_Mcs11_Mcs08); + rtl92e_readl(dev, rTxAGC_Mcs11_Mcs08); priv->MCSTxPowerLevelOriginalOffset[5] = - read_nic_dword(dev, rTxAGC_Mcs15_Mcs12); + rtl92e_readl(dev, rTxAGC_Mcs15_Mcs12); - priv->DefaultInitialGain[0] = read_nic_byte(dev, rOFDM0_XAAGCCore1); - priv->DefaultInitialGain[1] = read_nic_byte(dev, rOFDM0_XBAGCCore1); - priv->DefaultInitialGain[2] = read_nic_byte(dev, rOFDM0_XCAGCCore1); - priv->DefaultInitialGain[3] = read_nic_byte(dev, rOFDM0_XDAGCCore1); + priv->DefaultInitialGain[0] = rtl92e_readb(dev, rOFDM0_XAAGCCore1); + priv->DefaultInitialGain[1] = rtl92e_readb(dev, rOFDM0_XBAGCCore1); + priv->DefaultInitialGain[2] = rtl92e_readb(dev, rOFDM0_XCAGCCore1); + priv->DefaultInitialGain[3] = rtl92e_readb(dev, rOFDM0_XDAGCCore1); RT_TRACE(COMP_INIT, "Default initial gain (c50=0x%x, c58=0x%x, c60=0x%x, c68=0x%x)\n", priv->DefaultInitialGain[0], priv->DefaultInitialGain[1], priv->DefaultInitialGain[2], priv->DefaultInitialGain[3]); - priv->framesync = read_nic_byte(dev, rOFDM0_RxDetector3); - priv->framesyncC34 = read_nic_dword(dev, rOFDM0_RxDetector2); + priv->framesync = rtl92e_readb(dev, rOFDM0_RxDetector3); + priv->framesyncC34 = rtl92e_readl(dev, rOFDM0_RxDetector2); RT_TRACE(COMP_INIT, "Default framesync (0x%x) = 0x%x\n", rOFDM0_RxDetector3, priv->framesync); - priv->SifsTime = read_nic_word(dev, SIFS); + priv->SifsTime = rtl92e_readw(dev, SIFS); } -void rtl8192_phy_setTxPower(struct net_device *dev, u8 channel) +void rtl92e_set_tx_power(struct net_device *dev, u8 channel) { struct r8192_priv *priv = rtllib_priv(dev); u8 powerlevel = 0, powerlevelOFDM24G = 0; @@ -671,16 +668,17 @@ void rtl8192_phy_setTxPower(struct net_device *dev, u8 channel) priv->AntennaTxPwDiff[1]<<4 | priv->AntennaTxPwDiff[0]); - rtl8192_setBBreg(dev, rFPGA0_TxGainStage, - (bXBTxAGC|bXCTxAGC|bXDTxAGC), u4RegValue); + rtl92e_set_bb_reg(dev, rFPGA0_TxGainStage, + (bXBTxAGC|bXCTxAGC|bXDTxAGC), + u4RegValue); } } switch (priv->rf_chip) { case RF_8225: break; case RF_8256: - PHY_SetRF8256CCKTxPower(dev, powerlevel); - PHY_SetRF8256OFDMTxPower(dev, powerlevelOFDM24G); + rtl92e_set_cck_tx_power(dev, powerlevel); + rtl92e_set_ofdm_tx_power(dev, powerlevelOFDM24G); break; case RF_8258: break; @@ -690,7 +688,7 @@ void rtl8192_phy_setTxPower(struct net_device *dev, u8 channel) } } -bool rtl8192_phy_RFConfig(struct net_device *dev) +bool rtl92e_config_phy(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); bool rtStatus = true; @@ -699,7 +697,7 @@ bool rtl8192_phy_RFConfig(struct net_device *dev) case RF_8225: break; case RF_8256: - rtStatus = PHY_RF8256_Config(dev); + rtStatus = rtl92e_config_rf(dev); break; case RF_8258: @@ -714,12 +712,7 @@ bool rtl8192_phy_RFConfig(struct net_device *dev) return rtStatus; } -void rtl8192_phy_updateInitGain(struct net_device *dev) -{ -} - -u8 rtl8192_phy_ConfigRFWithHeaderFile(struct net_device *dev, - enum rf90_radio_path eRFPath) +u8 rtl92e_config_rf_path(struct net_device *dev, enum rf90_radio_path eRFPath) { int i; @@ -731,10 +724,9 @@ u8 rtl8192_phy_ConfigRFWithHeaderFile(struct net_device *dev, msleep(100); continue; } - rtl8192_phy_SetRFReg(dev, eRFPath, - Rtl819XRadioA_Array[i], - bMask12Bits, - Rtl819XRadioA_Array[i+1]); + rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioA_Array[i], + bMask12Bits, + Rtl819XRadioA_Array[i+1]); } break; @@ -744,10 +736,9 @@ u8 rtl8192_phy_ConfigRFWithHeaderFile(struct net_device *dev, msleep(100); continue; } - rtl8192_phy_SetRFReg(dev, eRFPath, - Rtl819XRadioB_Array[i], - bMask12Bits, - Rtl819XRadioB_Array[i+1]); + rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioB_Array[i], + bMask12Bits, + Rtl819XRadioB_Array[i+1]); } break; @@ -757,10 +748,9 @@ u8 rtl8192_phy_ConfigRFWithHeaderFile(struct net_device *dev, msleep(100); continue; } - rtl8192_phy_SetRFReg(dev, eRFPath, - Rtl819XRadioC_Array[i], - bMask12Bits, - Rtl819XRadioC_Array[i+1]); + rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioC_Array[i], + bMask12Bits, + Rtl819XRadioC_Array[i+1]); } break; @@ -770,9 +760,9 @@ u8 rtl8192_phy_ConfigRFWithHeaderFile(struct net_device *dev, msleep(100); continue; } - rtl8192_phy_SetRFReg(dev, eRFPath, - Rtl819XRadioD_Array[i], bMask12Bits, - Rtl819XRadioD_Array[i+1]); + rtl92e_set_rf_reg(dev, eRFPath, Rtl819XRadioD_Array[i], + bMask12Bits, + Rtl819XRadioD_Array[i+1]); } break; @@ -794,8 +784,8 @@ static void rtl8192_SetTxPowerLevel(struct net_device *dev, u8 channel) break; case RF_8256: - PHY_SetRF8256CCKTxPower(dev, powerlevel); - PHY_SetRF8256OFDMTxPower(dev, powerlevelOFDM24G); + rtl92e_set_cck_tx_power(dev, powerlevel); + rtl92e_set_ofdm_tx_power(dev, powerlevelOFDM24G); break; case RF_8258: @@ -941,21 +931,21 @@ static u8 rtl8192_phy_SwChnlStepByStep(struct net_device *dev, u8 channel, rtl8192_SetTxPowerLevel(dev, channel); break; case CmdID_WritePortUlong: - write_nic_dword(dev, CurrentCmd->Para1, - CurrentCmd->Para2); + rtl92e_writel(dev, CurrentCmd->Para1, + CurrentCmd->Para2); break; case CmdID_WritePortUshort: - write_nic_word(dev, CurrentCmd->Para1, - (u16)CurrentCmd->Para2); + rtl92e_writew(dev, CurrentCmd->Para1, + (u16)CurrentCmd->Para2); break; case CmdID_WritePortUchar: - write_nic_byte(dev, CurrentCmd->Para1, - (u8)CurrentCmd->Para2); + rtl92e_writeb(dev, CurrentCmd->Para1, + (u8)CurrentCmd->Para2); break; case CmdID_RF_WriteReg: for (eRFPath = 0; eRFPath < priv->NumTotalRFPath; eRFPath++) - rtl8192_phy_SetRFReg(dev, + rtl92e_set_rf_reg(dev, (enum rf90_radio_path)eRFPath, CurrentCmd->Para1, bMask12Bits, CurrentCmd->Para2<<7); @@ -986,7 +976,7 @@ static void rtl8192_phy_FinishSwChnlNow(struct net_device *dev, u8 channel) break; } } -void rtl8192_SwChnl_WorkItem(struct net_device *dev) +static void rtl8192_SwChnl_WorkItem(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -1001,7 +991,7 @@ void rtl8192_SwChnl_WorkItem(struct net_device *dev) RT_TRACE(COMP_TRACE, "<== SwChnlCallback819xUsbWorkItem()\n"); } -u8 rtl8192_phy_SwChnl(struct net_device *dev, u8 channel) +u8 rtl92e_set_channel(struct net_device *dev, u8 channel) { struct r8192_priv *priv = rtllib_priv(dev); @@ -1082,13 +1072,13 @@ static void CCK_Tx_Power_Track_BW_Switch_TSSI(struct net_device *dev) if (priv->rtllib->current_network.channel == 14 && !priv->bcck_in_ch14) { priv->bcck_in_ch14 = true; - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } else if (priv->rtllib->current_network.channel != 14 && priv->bcck_in_ch14) { priv->bcck_in_ch14 = false; - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } else { - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } break; @@ -1110,13 +1100,13 @@ static void CCK_Tx_Power_Track_BW_Switch_TSSI(struct net_device *dev) if (priv->rtllib->current_network.channel == 14 && !priv->bcck_in_ch14) { priv->bcck_in_ch14 = true; - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } else if (priv->rtllib->current_network.channel != 14 && priv->bcck_in_ch14) { priv->bcck_in_ch14 = false; - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } else { - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } break; } @@ -1150,7 +1140,7 @@ static void CCK_Tx_Power_Track_BW_Switch_ThermalMeter(struct net_device *dev) priv->CCK_index); break; } - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } static void CCK_Tx_Power_Track_BW_Switch(struct net_device *dev) @@ -1163,7 +1153,7 @@ static void CCK_Tx_Power_Track_BW_Switch(struct net_device *dev) CCK_Tx_Power_Track_BW_Switch_ThermalMeter(dev); } -void rtl8192_SetBWModeWorkItem(struct net_device *dev) +static void rtl8192_SetBWModeWorkItem(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -1183,17 +1173,17 @@ void rtl8192_SetBWModeWorkItem(struct net_device *dev) netdev_err(dev, "%s(): Driver is not initialized\n", __func__); return; } - regBwOpMode = read_nic_byte(dev, BW_OPMODE); + regBwOpMode = rtl92e_readb(dev, BW_OPMODE); switch (priv->CurrentChannelBW) { case HT_CHANNEL_WIDTH_20: regBwOpMode |= BW_OPMODE_20MHZ; - write_nic_byte(dev, BW_OPMODE, regBwOpMode); + rtl92e_writeb(dev, BW_OPMODE, regBwOpMode); break; case HT_CHANNEL_WIDTH_20_40: regBwOpMode &= ~BW_OPMODE_20MHZ; - write_nic_byte(dev, BW_OPMODE, regBwOpMode); + rtl92e_writeb(dev, BW_OPMODE, regBwOpMode); break; default: @@ -1204,38 +1194,38 @@ void rtl8192_SetBWModeWorkItem(struct net_device *dev) switch (priv->CurrentChannelBW) { case HT_CHANNEL_WIDTH_20: - rtl8192_setBBreg(dev, rFPGA0_RFMOD, bRFMOD, 0x0); - rtl8192_setBBreg(dev, rFPGA1_RFMOD, bRFMOD, 0x0); + rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bRFMOD, 0x0); + rtl92e_set_bb_reg(dev, rFPGA1_RFMOD, bRFMOD, 0x0); if (!priv->btxpower_tracking) { - write_nic_dword(dev, rCCK0_TxFilter1, 0x1a1b0000); - write_nic_dword(dev, rCCK0_TxFilter2, 0x090e1317); - write_nic_dword(dev, rCCK0_DebugPort, 0x00000204); + rtl92e_writel(dev, rCCK0_TxFilter1, 0x1a1b0000); + rtl92e_writel(dev, rCCK0_TxFilter2, 0x090e1317); + rtl92e_writel(dev, rCCK0_DebugPort, 0x00000204); } else { CCK_Tx_Power_Track_BW_Switch(dev); } - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x00100000, 1); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x00100000, 1); break; case HT_CHANNEL_WIDTH_20_40: - rtl8192_setBBreg(dev, rFPGA0_RFMOD, bRFMOD, 0x1); - rtl8192_setBBreg(dev, rFPGA1_RFMOD, bRFMOD, 0x1); + rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bRFMOD, 0x1); + rtl92e_set_bb_reg(dev, rFPGA1_RFMOD, bRFMOD, 0x1); if (!priv->btxpower_tracking) { - write_nic_dword(dev, rCCK0_TxFilter1, 0x35360000); - write_nic_dword(dev, rCCK0_TxFilter2, 0x121c252e); - write_nic_dword(dev, rCCK0_DebugPort, 0x00000409); + rtl92e_writel(dev, rCCK0_TxFilter1, 0x35360000); + rtl92e_writel(dev, rCCK0_TxFilter2, 0x121c252e); + rtl92e_writel(dev, rCCK0_DebugPort, 0x00000409); } else { CCK_Tx_Power_Track_BW_Switch(dev); } - rtl8192_setBBreg(dev, rCCK0_System, bCCKSideBand, - (priv->nCur40MhzPrimeSC>>1)); - rtl8192_setBBreg(dev, rOFDM1_LSTF, 0xC00, - priv->nCur40MhzPrimeSC); + rtl92e_set_bb_reg(dev, rCCK0_System, bCCKSideBand, + (priv->nCur40MhzPrimeSC>>1)); + rtl92e_set_bb_reg(dev, rOFDM1_LSTF, 0xC00, + priv->nCur40MhzPrimeSC); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x00100000, 0); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x00100000, 0); break; default: netdev_err(dev, "%s(): unknown Bandwidth: %#X\n", __func__, @@ -1249,7 +1239,7 @@ void rtl8192_SetBWModeWorkItem(struct net_device *dev) break; case RF_8256: - PHY_SetRF8256Bandwidth(dev, priv->CurrentChannelBW); + rtl92e_set_bandwidth(dev, priv->CurrentChannelBW); break; case RF_8258: @@ -1270,8 +1260,8 @@ void rtl8192_SetBWModeWorkItem(struct net_device *dev) RT_TRACE(COMP_SWBW, "<==SetBWMode819xUsb()"); } -void rtl8192_SetBWMode(struct net_device *dev, enum ht_channel_width Bandwidth, - enum ht_extchnl_offset Offset) +void rtl92e_set_bw_mode(struct net_device *dev, enum ht_channel_width Bandwidth, + enum ht_extchnl_offset Offset) { struct r8192_priv *priv = rtllib_priv(dev); @@ -1295,7 +1285,7 @@ void rtl8192_SetBWMode(struct net_device *dev, enum ht_channel_width Bandwidth, } -void InitialGain819xPci(struct net_device *dev, u8 Operation) +void rtl92e_init_gain(struct net_device *dev, u8 Operation) { #define SCAN_RX_INITIAL_GAIN 0x17 #define POWER_DETECTION_TH 0x08 @@ -1312,21 +1302,21 @@ void InitialGain819xPci(struct net_device *dev, u8 Operation) BitMask = bMaskByte0; if (dm_digtable.dig_algorithm == DIG_ALGO_BY_FALSE_ALARM) - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8); priv->initgain_backup.xaagccore1 = - (u8)rtl8192_QueryBBReg(dev, rOFDM0_XAAGCCore1, - BitMask); + (u8)rtl92e_get_bb_reg(dev, rOFDM0_XAAGCCore1, + BitMask); priv->initgain_backup.xbagccore1 = - (u8)rtl8192_QueryBBReg(dev, rOFDM0_XBAGCCore1, - BitMask); + (u8)rtl92e_get_bb_reg(dev, rOFDM0_XBAGCCore1, + BitMask); priv->initgain_backup.xcagccore1 = - (u8)rtl8192_QueryBBReg(dev, rOFDM0_XCAGCCore1, - BitMask); + (u8)rtl92e_get_bb_reg(dev, rOFDM0_XCAGCCore1, + BitMask); priv->initgain_backup.xdagccore1 = - (u8)rtl8192_QueryBBReg(dev, rOFDM0_XDAGCCore1, - BitMask); + (u8)rtl92e_get_bb_reg(dev, rOFDM0_XDAGCCore1, + BitMask); BitMask = bMaskByte2; - priv->initgain_backup.cca = (u8)rtl8192_QueryBBReg(dev, + priv->initgain_backup.cca = (u8)rtl92e_get_bb_reg(dev, rCCK0_CCA, BitMask); RT_TRACE(COMP_SCAN, @@ -1347,13 +1337,13 @@ void InitialGain819xPci(struct net_device *dev, u8 Operation) RT_TRACE(COMP_SCAN, "Write scan initial gain = 0x%x\n", initial_gain); - write_nic_byte(dev, rOFDM0_XAAGCCore1, initial_gain); - write_nic_byte(dev, rOFDM0_XBAGCCore1, initial_gain); - write_nic_byte(dev, rOFDM0_XCAGCCore1, initial_gain); - write_nic_byte(dev, rOFDM0_XDAGCCore1, initial_gain); + rtl92e_writeb(dev, rOFDM0_XAAGCCore1, initial_gain); + rtl92e_writeb(dev, rOFDM0_XBAGCCore1, initial_gain); + rtl92e_writeb(dev, rOFDM0_XCAGCCore1, initial_gain); + rtl92e_writeb(dev, rOFDM0_XDAGCCore1, initial_gain); RT_TRACE(COMP_SCAN, "Write scan 0xa0a = 0x%x\n", POWER_DETECTION_TH); - write_nic_byte(dev, 0xa0a, POWER_DETECTION_TH); + rtl92e_writeb(dev, 0xa0a, POWER_DETECTION_TH); break; case IG_Restore: RT_TRACE(COMP_SCAN, @@ -1361,18 +1351,18 @@ void InitialGain819xPci(struct net_device *dev, u8 Operation) BitMask = 0x7f; if (dm_digtable.dig_algorithm == DIG_ALGO_BY_FALSE_ALARM) - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8); - rtl8192_setBBreg(dev, rOFDM0_XAAGCCore1, BitMask, + rtl92e_set_bb_reg(dev, rOFDM0_XAAGCCore1, BitMask, (u32)priv->initgain_backup.xaagccore1); - rtl8192_setBBreg(dev, rOFDM0_XBAGCCore1, BitMask, + rtl92e_set_bb_reg(dev, rOFDM0_XBAGCCore1, BitMask, (u32)priv->initgain_backup.xbagccore1); - rtl8192_setBBreg(dev, rOFDM0_XCAGCCore1, BitMask, + rtl92e_set_bb_reg(dev, rOFDM0_XCAGCCore1, BitMask, (u32)priv->initgain_backup.xcagccore1); - rtl8192_setBBreg(dev, rOFDM0_XDAGCCore1, BitMask, + rtl92e_set_bb_reg(dev, rOFDM0_XDAGCCore1, BitMask, (u32)priv->initgain_backup.xdagccore1); BitMask = bMaskByte2; - rtl8192_setBBreg(dev, rCCK0_CCA, BitMask, + rtl92e_set_bb_reg(dev, rCCK0_CCA, BitMask, (u32)priv->initgain_backup.cca); RT_TRACE(COMP_SCAN, @@ -1391,12 +1381,12 @@ void InitialGain819xPci(struct net_device *dev, u8 Operation) "Scan BBInitialGainRestore 0xa0a is %x\n", priv->initgain_backup.cca); - rtl8192_phy_setTxPower(dev, + rtl92e_set_tx_power(dev, priv->rtllib->current_network.channel); if (dm_digtable.dig_algorithm == DIG_ALGO_BY_FALSE_ALARM) - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x1); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x1); break; default: RT_TRACE(COMP_SCAN, "Unknown IG Operation.\n"); @@ -1405,17 +1395,17 @@ void InitialGain819xPci(struct net_device *dev, u8 Operation) } } -void PHY_SetRtl8192eRfOff(struct net_device *dev) +void rtl92e_set_rf_off(struct net_device *dev) { - rtl8192_setBBreg(dev, rFPGA0_XA_RFInterfaceOE, BIT4, 0x0); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0x300, 0x0); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x18, 0x0); - rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, 0xf, 0x0); - rtl8192_setBBreg(dev, rOFDM1_TRxPathEnable, 0xf, 0x0); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x60, 0x0); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x4, 0x0); - write_nic_byte(dev, ANAPAR_FOR_8192PciE, 0x07); + rtl92e_set_bb_reg(dev, rFPGA0_XA_RFInterfaceOE, BIT4, 0x0); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, 0x300, 0x0); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x18, 0x0); + rtl92e_set_bb_reg(dev, rOFDM0_TRxPathEnable, 0xf, 0x0); + rtl92e_set_bb_reg(dev, rOFDM1_TRxPathEnable, 0xf, 0x0); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x60, 0x0); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x4, 0x0); + rtl92e_writeb(dev, ANAPAR_FOR_8192PciE, 0x07); } @@ -1447,7 +1437,7 @@ static bool SetRFPowerState8190(struct net_device *dev, do { InitilizeCount--; priv->RegRfOff = false; - rtstatus = NicIFEnableNIC(dev); + rtstatus = rtl92e_enable_nic(dev); } while (!rtstatus && (InitilizeCount > 0)); if (!rtstatus) { @@ -1461,24 +1451,24 @@ static bool SetRFPowerState8190(struct net_device *dev, RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC); } else { - write_nic_byte(dev, ANAPAR, 0x37); + rtl92e_writeb(dev, ANAPAR, 0x37); mdelay(1); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, 0x4, 0x1); priv->bHwRfOffAction = 0; - rtl8192_setBBreg(dev, rFPGA0_XA_RFInterfaceOE, - BIT4, 0x1); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, - 0x300, 0x3); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, - 0x18, 0x3); - rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, 0x3, - 0x3); - rtl8192_setBBreg(dev, rOFDM1_TRxPathEnable, 0x3, - 0x3); - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, - 0x60, 0x3); + rtl92e_set_bb_reg(dev, rFPGA0_XA_RFInterfaceOE, + BIT4, 0x1); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter4, + 0x300, 0x3); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, + 0x18, 0x3); + rtl92e_set_bb_reg(dev, rOFDM0_TRxPathEnable, + 0x3, 0x3); + rtl92e_set_bb_reg(dev, rOFDM1_TRxPathEnable, + 0x3, 0x3); + rtl92e_set_bb_reg(dev, rFPGA0_AnalogParameter1, + 0x60, 0x3); } @@ -1511,7 +1501,7 @@ static bool SetRFPowerState8190(struct net_device *dev, break; } } - PHY_SetRtl8192eRfOff(dev); + rtl92e_set_rf_off(dev); break; case eRfOff: @@ -1543,11 +1533,11 @@ static bool SetRFPowerState8190(struct net_device *dev, if (pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_HALT_NIC && !RT_IN_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC)) { - NicIFDisableNIC(dev); + rtl92e_disable_nic(dev); RT_SET_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC); } else if (!(pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_HALT_NIC)) { - PHY_SetRtl8192eRfOff(dev); + rtl92e_set_rf_off(dev); } break; @@ -1586,32 +1576,34 @@ static bool SetRFPowerState8190(struct net_device *dev, return bResult; } -bool SetRFPowerState(struct net_device *dev, - enum rt_rf_power_state eRFPowerState) +bool rtl92e_set_rf_power_state(struct net_device *dev, + enum rt_rf_power_state eRFPowerState) { struct r8192_priv *priv = rtllib_priv(dev); bool bResult = false; - RT_TRACE(COMP_PS, "---------> SetRFPowerState(): eRFPowerState(%d)\n", + RT_TRACE(COMP_PS, + "---------> rtl92e_set_rf_power_state(): eRFPowerState(%d)\n", eRFPowerState); if (eRFPowerState == priv->rtllib->eRFPowerState && priv->bHwRfOffAction == 0) { RT_TRACE(COMP_PS, - "<--------- SetRFPowerState(): discard the request for eRFPowerState(%d) is the same.\n", + "<--------- rtl92e_set_rf_power_state(): discard the request for eRFPowerState(%d) is the same.\n", eRFPowerState); return bResult; } bResult = SetRFPowerState8190(dev, eRFPowerState); - RT_TRACE(COMP_PS, "<--------- SetRFPowerState(): bResult(%d)\n", + RT_TRACE(COMP_PS, + "<--------- rtl92e_set_rf_power_state(): bResult(%d)\n", bResult); return bResult; } -void PHY_ScanOperationBackup8192(struct net_device *dev, u8 Operation) +void rtl92e_scan_op_backup(struct net_device *dev, u8 Operation) { struct r8192_priv *priv = rtllib_priv(dev); diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.h b/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.h index 18bc58240..96015d342 100644 --- a/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.h +++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.h @@ -67,48 +67,36 @@ enum rf90_radio_path { #define bMaskLWord 0x0000ffff #define bMaskDWord 0xffffffff -extern u8 rtl8192_phy_CheckIsLegalRFPath(struct net_device *dev, - u32 eRFPath); -extern void rtl8192_setBBreg(struct net_device *dev, u32 dwRegAddr, - u32 dwBitMask, u32 dwData); -extern u32 rtl8192_QueryBBReg(struct net_device *dev, u32 dwRegAddr, - u32 dwBitMask); -extern void rtl8192_phy_SetRFReg(struct net_device *dev, - enum rf90_radio_path eRFPath, - u32 RegAddr, u32 BitMask, u32 Data); -extern u32 rtl8192_phy_QueryRFReg(struct net_device *dev, - enum rf90_radio_path eRFPath, - u32 RegAddr, u32 BitMask); -extern void rtl8192_phy_configmac(struct net_device *dev); -extern void rtl8192_phyConfigBB(struct net_device *dev, u8 ConfigType); -extern bool rtl8192_phy_checkBBAndRF(struct net_device *dev, - enum hw90_block CheckBlock, - enum rf90_radio_path eRFPath); -extern bool rtl8192_BBConfig(struct net_device *dev); -extern void rtl8192_phy_getTxPower(struct net_device *dev); -extern void rtl8192_phy_setTxPower(struct net_device *dev, u8 channel); -extern bool rtl8192_phy_RFConfig(struct net_device *dev); -extern void rtl8192_phy_updateInitGain(struct net_device *dev); -extern u8 rtl8192_phy_ConfigRFWithHeaderFile(struct net_device *dev, - enum rf90_radio_path eRFPath); +u8 rtl92e_is_legal_rf_path(struct net_device *dev, u32 eRFPath); +void rtl92e_set_bb_reg(struct net_device *dev, u32 dwRegAddr, + u32 dwBitMask, u32 dwData); +u32 rtl92e_get_bb_reg(struct net_device *dev, u32 dwRegAddr, u32 dwBitMask); +void rtl92e_set_rf_reg(struct net_device *dev, enum rf90_radio_path eRFPath, + u32 RegAddr, u32 BitMask, u32 Data); +u32 rtl92e_get_rf_reg(struct net_device *dev, enum rf90_radio_path eRFPath, + u32 RegAddr, u32 BitMask); +void rtl92e_config_mac(struct net_device *dev); +bool rtl92e_check_bb_and_rf(struct net_device *dev, + enum hw90_block CheckBlock, + enum rf90_radio_path eRFPath); +bool rtl92e_config_bb(struct net_device *dev); +void rtl92e_get_tx_power(struct net_device *dev); +void rtl92e_set_tx_power(struct net_device *dev, u8 channel); +bool rtl92e_config_phy(struct net_device *dev); +u8 rtl92e_config_rf_path(struct net_device *dev, enum rf90_radio_path eRFPath); -extern u8 rtl8192_phy_SwChnl(struct net_device *dev, u8 channel); -extern void rtl8192_SetBWMode(struct net_device *dev, - enum ht_channel_width Bandwidth, - enum ht_extchnl_offset Offset); -extern void rtl8192_SwChnl_WorkItem(struct net_device *dev); -extern void rtl8192_SetBWModeWorkItem(struct net_device *dev); -extern void InitialGain819xPci(struct net_device *dev, u8 Operation); +u8 rtl92e_set_channel(struct net_device *dev, u8 channel); +void rtl92e_set_bw_mode(struct net_device *dev, + enum ht_channel_width Bandwidth, + enum ht_extchnl_offset Offset); +void rtl92e_init_gain(struct net_device *dev, u8 Operation); -extern void PHY_SetRtl8192eRfOff(struct net_device *dev); +void rtl92e_set_rf_off(struct net_device *dev); -bool -SetRFPowerState( - struct net_device *dev, - enum rt_rf_power_state eRFPowerState - ); -#define PHY_SetRFPowerState SetRFPowerState +bool rtl92e_set_rf_power_state(struct net_device *dev, + enum rt_rf_power_state eRFPowerState); +#define PHY_SetRFPowerState rtl92e_set_rf_power_state -extern void PHY_ScanOperationBackup8192(struct net_device *dev, u8 Operation); +void rtl92e_scan_op_backup(struct net_device *dev, u8 Operation); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_cam.c b/drivers/staging/rtl8192e/rtl8192e/rtl_cam.c index f246222e5..29dd93ac5 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_cam.c +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_cam.c @@ -28,15 +28,15 @@ #include "r8190P_rtl8256.h" /* RTL8225 Radio frontend */ #include "r8192E_cmdpkt.h" -void CamResetAllEntry(struct net_device *dev) +void rtl92e_cam_reset(struct net_device *dev) { u32 ulcommand = 0; ulcommand |= BIT31|BIT30; - write_nic_dword(dev, RWCAM, ulcommand); + rtl92e_writel(dev, RWCAM, ulcommand); } -void EnableHWSecurityConfig8192(struct net_device *dev) +void rtl92e_enable_hw_security_config(struct net_device *dev) { u8 SECR_value = 0x0; struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); @@ -65,11 +65,12 @@ void EnableHWSecurityConfig8192(struct net_device *dev) RT_TRACE(COMP_SEC, "%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __func__, ieee->hwsec_active, ieee->pairwise_key_type, SECR_value); - write_nic_byte(dev, SECR, SECR_value); + rtl92e_writeb(dev, SECR, SECR_value); } -void set_swcam(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, - const u8 *MacAddr, u8 DefaultKey, u32 *KeyContent, u8 is_mesh) +void rtl92e_set_swcam(struct net_device *dev, u8 EntryNo, u8 KeyIndex, + u16 KeyType, const u8 *MacAddr, u8 DefaultKey, + u32 *KeyContent, u8 is_mesh) { struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_device *ieee = priv->rtllib; @@ -77,6 +78,10 @@ void set_swcam(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, RT_TRACE(COMP_DBG, "===========>%s():EntryNo is %d,KeyIndex is %d,KeyType is %d,is_mesh is %d\n", __func__, EntryNo, KeyIndex, KeyType, is_mesh); + + if (EntryNo >= TOTAL_CAM_ENTRY) + return; + if (!is_mesh) { ieee->swcamtable[EntryNo].bused = true; ieee->swcamtable[EntryNo].key_index = KeyIndex; @@ -87,8 +92,9 @@ void set_swcam(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, } } -void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, - const u8 *MacAddr, u8 DefaultKey, u32 *KeyContent) +void rtl92e_set_key(struct net_device *dev, u8 EntryNo, u8 KeyIndex, + u16 KeyType, const u8 *MacAddr, u8 DefaultKey, + u32 *KeyContent) { u32 TargetCommand = 0; u32 TargetContent = 0; @@ -106,16 +112,18 @@ void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, return; } down(&priv->rtllib->ips_sem); - IPSLeave(dev); + rtl92e_ips_leave(dev); up(&priv->rtllib->ips_sem); } } priv->rtllib->is_set_key = true; - if (EntryNo >= TOTAL_CAM_ENTRY) + if (EntryNo >= TOTAL_CAM_ENTRY) { netdev_info(dev, "%s(): Invalid CAM entry\n", __func__); + return; + } RT_TRACE(COMP_SEC, - "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d,KeyType:%d, MacAddr %pM\n", + "====>to rtl92e_set_key(), dev:%p, EntryNo:%d, KeyIndex:%d,KeyType:%d, MacAddr %pM\n", dev, EntryNo, KeyIndex, KeyType, MacAddr); if (DefaultKey) @@ -133,20 +141,20 @@ void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, (u32)(*(MacAddr+1)) << 24 | (u32)usConfig; - write_nic_dword(dev, WCAMI, TargetContent); - write_nic_dword(dev, RWCAM, TargetCommand); + rtl92e_writel(dev, WCAMI, TargetContent); + rtl92e_writel(dev, RWCAM, TargetCommand); } else if (i == 1) { TargetContent = (u32)(*(MacAddr+2)) | (u32)(*(MacAddr+3)) << 8 | (u32)(*(MacAddr+4)) << 16 | (u32)(*(MacAddr+5)) << 24; - write_nic_dword(dev, WCAMI, TargetContent); - write_nic_dword(dev, RWCAM, TargetCommand); + rtl92e_writel(dev, WCAMI, TargetContent); + rtl92e_writel(dev, RWCAM, TargetCommand); } else { if (KeyContent != NULL) { - write_nic_dword(dev, WCAMI, - (u32)(*(KeyContent+i-2))); - write_nic_dword(dev, RWCAM, TargetCommand); + rtl92e_writel(dev, WCAMI, + (u32)(*(KeyContent+i-2))); + rtl92e_writel(dev, RWCAM, TargetCommand); udelay(100); } } @@ -154,7 +162,7 @@ void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, RT_TRACE(COMP_SEC, "=========>after set key, usconfig:%x\n", usConfig); } -void CamRestoreAllEntry(struct net_device *dev) +void rtl92e_cam_restore(struct net_device *dev) { u8 EntryId = 0; struct r8192_priv *priv = rtllib_priv(dev); @@ -170,7 +178,7 @@ void CamRestoreAllEntry(struct net_device *dev) 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; - RT_TRACE(COMP_SEC, "CamRestoreAllEntry:\n"); + RT_TRACE(COMP_SEC, "rtl92e_cam_restore:\n"); if ((priv->rtllib->pairwise_key_type == KEY_TYPE_WEP40) || @@ -179,36 +187,41 @@ void CamRestoreAllEntry(struct net_device *dev) for (EntryId = 0; EntryId < 4; EntryId++) { MacAddr = CAM_CONST_ADDR[EntryId]; if (priv->rtllib->swcamtable[EntryId].bused) { - setKey(dev, EntryId, EntryId, - priv->rtllib->pairwise_key_type, MacAddr, - 0, (u32 *)(&priv->rtllib->swcamtable - [EntryId].key_buf[0])); + rtl92e_set_key(dev, EntryId, EntryId, + priv->rtllib->pairwise_key_type, + MacAddr, 0, + (u32 *)(&priv->rtllib->swcamtable + [EntryId].key_buf[0])); } } } else if (priv->rtllib->pairwise_key_type == KEY_TYPE_TKIP) { if (priv->rtllib->iw_mode == IW_MODE_ADHOC) { - setKey(dev, 4, 0, priv->rtllib->pairwise_key_type, - (u8 *)dev->dev_addr, 0, - (u32 *)(&priv->rtllib->swcamtable[4].key_buf[0])); + rtl92e_set_key(dev, 4, 0, + priv->rtllib->pairwise_key_type, + (u8 *)dev->dev_addr, 0, + (u32 *)(&priv->rtllib->swcamtable[4]. + key_buf[0])); } else { - setKey(dev, 4, 0, priv->rtllib->pairwise_key_type, - MacAddr, 0, - (u32 *)(&priv->rtllib->swcamtable[4].key_buf[0])); + rtl92e_set_key(dev, 4, 0, + priv->rtllib->pairwise_key_type, + MacAddr, 0, + (u32 *)(&priv->rtllib->swcamtable[4]. + key_buf[0])); } } else if (priv->rtllib->pairwise_key_type == KEY_TYPE_CCMP) { if (priv->rtllib->iw_mode == IW_MODE_ADHOC) { - setKey(dev, 4, 0, - priv->rtllib->pairwise_key_type, - (u8 *)dev->dev_addr, 0, - (u32 *)(&priv->rtllib->swcamtable[4]. - key_buf[0])); + rtl92e_set_key(dev, 4, 0, + priv->rtllib->pairwise_key_type, + (u8 *)dev->dev_addr, 0, + (u32 *)(&priv->rtllib->swcamtable[4]. + key_buf[0])); } else { - setKey(dev, 4, 0, - priv->rtllib->pairwise_key_type, MacAddr, - 0, (u32 *)(&priv->rtllib->swcamtable[4]. - key_buf[0])); + rtl92e_set_key(dev, 4, 0, + priv->rtllib->pairwise_key_type, MacAddr, + 0, (u32 *)(&priv->rtllib->swcamtable[4]. + key_buf[0])); } } @@ -216,20 +229,18 @@ void CamRestoreAllEntry(struct net_device *dev) MacAddr = CAM_CONST_BROAD; for (EntryId = 1; EntryId < 4; EntryId++) { if (priv->rtllib->swcamtable[EntryId].bused) { - setKey(dev, EntryId, EntryId, - priv->rtllib->group_key_type, - MacAddr, 0, - (u32 *)(&priv->rtllib->swcamtable[EntryId].key_buf[0]) - ); + rtl92e_set_key(dev, EntryId, EntryId, + priv->rtllib->group_key_type, + MacAddr, 0, + (u32 *)(&priv->rtllib->swcamtable[EntryId].key_buf[0])); } } if (priv->rtllib->iw_mode == IW_MODE_ADHOC) { if (priv->rtllib->swcamtable[0].bused) { - setKey(dev, 0, 0, - priv->rtllib->group_key_type, - CAM_CONST_ADDR[0], 0, - (u32 *)(&priv->rtllib->swcamtable[0].key_buf[0]) - ); + rtl92e_set_key(dev, 0, 0, + priv->rtllib->group_key_type, + CAM_CONST_ADDR[0], 0, + (u32 *)(&priv->rtllib->swcamtable[0].key_buf[0])); } else { netdev_warn(dev, "%s(): ADHOC TKIP: missing key entry.\n", @@ -241,19 +252,19 @@ void CamRestoreAllEntry(struct net_device *dev) MacAddr = CAM_CONST_BROAD; for (EntryId = 1; EntryId < 4; EntryId++) { if (priv->rtllib->swcamtable[EntryId].bused) { - setKey(dev, EntryId, EntryId, - priv->rtllib->group_key_type, - MacAddr, 0, - (u32 *)(&priv->rtllib->swcamtable[EntryId].key_buf[0])); + rtl92e_set_key(dev, EntryId, EntryId, + priv->rtllib->group_key_type, + MacAddr, 0, + (u32 *)(&priv->rtllib->swcamtable[EntryId].key_buf[0])); } } if (priv->rtllib->iw_mode == IW_MODE_ADHOC) { if (priv->rtllib->swcamtable[0].bused) { - setKey(dev, 0, 0, - priv->rtllib->group_key_type, - CAM_CONST_ADDR[0], 0, - (u32 *)(&priv->rtllib->swcamtable[0].key_buf[0])); + rtl92e_set_key(dev, 0, 0, + priv->rtllib->group_key_type, + CAM_CONST_ADDR[0], 0, + (u32 *)(&priv->rtllib->swcamtable[0].key_buf[0])); } else { netdev_warn(dev, "%s(): ADHOC CCMP: missing key entry.\n", diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_cam.h b/drivers/staging/rtl8192e/rtl8192e/rtl_cam.h index f23ab46c7..9ef8b36fc 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_cam.h +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_cam.h @@ -28,12 +28,14 @@ #include struct net_device; -void CamResetAllEntry(struct net_device *dev); -void EnableHWSecurityConfig8192(struct net_device *dev); -void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, - const u8 *MacAddr, u8 DefaultKey, u32 *KeyContent); -void set_swcam(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, - const u8 *MacAddr, u8 DefaultKey, u32 *KeyContent, u8 is_mesh); -void CamRestoreAllEntry(struct net_device *dev); +void rtl92e_cam_reset(struct net_device *dev); +void rtl92e_enable_hw_security_config(struct net_device *dev); +void rtl92e_set_key(struct net_device *dev, u8 EntryNo, u8 KeyIndex, + u16 KeyType, const u8 *MacAddr, u8 DefaultKey, + u32 *KeyContent); +void rtl92e_set_swcam(struct net_device *dev, u8 EntryNo, u8 KeyIndex, + u16 KeyType, const u8 *MacAddr, u8 DefaultKey, + u32 *KeyContent, u8 is_mesh); +void rtl92e_cam_restore(struct net_device *dev); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_core.c b/drivers/staging/rtl8192e/rtl8192e/rtl_core.c index fc141a00f..1266e1461 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_core.c +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_core.c @@ -22,25 +22,6 @@ * Contact Information: * wlanfae ******************************************************************************/ -#undef RX_DONT_PASS_UL -#undef DEBUG_EPROM -#undef DEBUG_RX_VERBOSE -#undef DUMMY_RX -#undef DEBUG_ZERO_RX -#undef DEBUG_RX_SKB -#undef DEBUG_TX_FRAG -#undef DEBUG_RX_FRAG -#undef DEBUG_TX_FILLDESC -#undef DEBUG_TX -#undef DEBUG_IRQ -#undef DEBUG_RX -#undef DEBUG_RXALLOC -#undef DEBUG_REGISTERS -#undef DEBUG_RING -#undef DEBUG_IRQ_TASKLET -#undef DEBUG_TX_ALLOC -#undef DEBUG_TX_DESC - #include #include #include @@ -63,24 +44,24 @@ static char *ifname = "wlan%d"; static struct rtl819x_ops rtl819xp_ops = { .nic_type = NIC_8192E, - .get_eeprom_size = rtl8192_get_eeprom_size, - .init_adapter_variable = rtl8192_InitializeVariables, - .initialize_adapter = rtl8192_adapter_start, - .link_change = rtl8192_link_change, - .tx_fill_descriptor = rtl8192_tx_fill_desc, - .tx_fill_cmd_descriptor = rtl8192_tx_fill_cmd_desc, - .rx_query_status_descriptor = rtl8192_rx_query_status_desc, + .get_eeprom_size = rtl92e_get_eeprom_size, + .init_adapter_variable = rtl92e_init_variables, + .initialize_adapter = rtl92e_start_adapter, + .link_change = rtl92e_link_change, + .tx_fill_descriptor = rtl92e_fill_tx_desc, + .tx_fill_cmd_descriptor = rtl92e_fill_tx_cmd_desc, + .rx_query_status_descriptor = rtl92e_get_rx_stats, .rx_command_packet_handler = NULL, - .stop_adapter = rtl8192_halt_adapter, - .update_ratr_table = rtl8192_update_ratr_table, - .irq_enable = rtl8192_EnableInterrupt, - .irq_disable = rtl8192_DisableInterrupt, - .irq_clear = rtl8192_ClearInterrupt, - .rx_enable = rtl8192_enable_rx, - .tx_enable = rtl8192_enable_tx, - .interrupt_recognized = rtl8192_interrupt_recognized, - .TxCheckStuckHandler = rtl8192_HalTxCheckStuck, - .RxCheckStuckHandler = rtl8192_HalRxCheckStuck, + .stop_adapter = rtl92e_stop_adapter, + .update_ratr_table = rtl92e_update_ratr_table, + .irq_enable = rtl92e_enable_irq, + .irq_disable = rtl92e_disable_irq, + .irq_clear = rtl92e_clear_irq, + .rx_enable = rtl92e_enable_rx, + .tx_enable = rtl92e_enable_tx, + .interrupt_recognized = rtl92e_ack_irq, + .TxCheckStuckHandler = rtl92e_is_tx_stuck, + .RxCheckStuckHandler = rtl92e_is_rx_stuck, }; static struct pci_device_id rtl8192_pci_id_tbl[] = { @@ -102,202 +83,61 @@ static struct pci_driver rtl8192_pci_driver = { .id_table = rtl8192_pci_id_tbl, /* PCI_ID table */ .probe = rtl8192_pci_probe, /* probe fn */ .remove = rtl8192_pci_disconnect, /* remove fn */ - .suspend = rtl8192E_suspend, /* PM suspend fn */ - .resume = rtl8192E_resume, /* PM resume fn */ + .suspend = rtl92e_suspend, /* PM suspend fn */ + .resume = rtl92e_resume, /* PM resume fn */ }; +static short rtl8192_is_tx_queue_empty(struct net_device *dev); +static void rtl819x_watchdog_wqcallback(void *data); +static void watch_dog_timer_callback(unsigned long data); +static void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, + int rate); +static int rtl8192_hard_start_xmit(struct sk_buff *skb, struct net_device *dev); +static void rtl8192_tx_cmd(struct net_device *dev, struct sk_buff *skb); +static short rtl8192_tx(struct net_device *dev, struct sk_buff *skb); +static short rtl8192_pci_initdescring(struct net_device *dev); +static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv); +static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv); +static void rtl8192_cancel_deferred_work(struct r8192_priv *priv); +static int _rtl8192_up(struct net_device *dev, bool is_silent_reset); +static int rtl8192_up(struct net_device *dev); +static int rtl8192_down(struct net_device *dev, bool shutdownrf); +static void rtl8192_restart(void *data); + /**************************************************************************** -----------------------------IO STUFF------------------------- *****************************************************************************/ -static bool PlatformIOCheckPageLegalAndGetRegMask(u32 u4bPage, u8 *pu1bPageMask) -{ - bool bReturn = false; - - *pu1bPageMask = 0xfe; - - switch (u4bPage) { - case 1: case 2: case 3: case 4: - case 8: case 9: case 10: case 12: case 13: - bReturn = true; - *pu1bPageMask = 0xf0; - break; - - default: - bReturn = false; - break; - } - - return bReturn; -} - -void write_nic_io_byte(struct net_device *dev, int x, u8 y) -{ - u32 u4bPage = x >> 8; - u8 u1PageMask = 0; - bool bIsLegalPage = false; - - if (u4bPage == 0) { - outb(y&0xff, dev->base_addr + x); - - } else { - bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage, - &u1PageMask); - if (bIsLegalPage) { - u8 u1bPsr = read_nic_io_byte(dev, PSR); - - write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) | - (u8)u4bPage)); - write_nic_io_byte(dev, (x & 0xff), y); - write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask)); - } - } -} - -void write_nic_io_word(struct net_device *dev, int x, u16 y) -{ - u32 u4bPage = x >> 8; - u8 u1PageMask = 0; - bool bIsLegalPage = false; - - if (u4bPage == 0) { - outw(y, dev->base_addr + x); - } else { - bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage, - &u1PageMask); - if (bIsLegalPage) { - u8 u1bPsr = read_nic_io_byte(dev, PSR); - - write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) | - (u8)u4bPage)); - write_nic_io_word(dev, (x & 0xff), y); - write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask)); - - } - } -} - -void write_nic_io_dword(struct net_device *dev, int x, u32 y) -{ - u32 u4bPage = x >> 8; - u8 u1PageMask = 0; - bool bIsLegalPage = false; - - if (u4bPage == 0) { - outl(y, dev->base_addr + x); - } else { - bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage, - &u1PageMask); - if (bIsLegalPage) { - u8 u1bPsr = read_nic_io_byte(dev, PSR); - - write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) | - (u8)u4bPage)); - write_nic_io_dword(dev, (x & 0xff), y); - write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask)); - } - } -} - -u8 read_nic_io_byte(struct net_device *dev, int x) -{ - u32 u4bPage = x >> 8; - u8 u1PageMask = 0; - bool bIsLegalPage = false; - u8 Data = 0; - - if (u4bPage == 0) - return 0xff&inb(dev->base_addr + x); - - bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage, - &u1PageMask); - if (bIsLegalPage) { - u8 u1bPsr = read_nic_io_byte(dev, PSR); - - write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) | - (u8)u4bPage)); - Data = read_nic_io_byte(dev, (x & 0xff)); - write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask)); - } - - return Data; -} - -u16 read_nic_io_word(struct net_device *dev, int x) -{ - u32 u4bPage = x >> 8; - u8 u1PageMask = 0; - bool bIsLegalPage = false; - u16 Data = 0; - - if (u4bPage == 0) - return inw(dev->base_addr + x); - bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage, - &u1PageMask); - if (bIsLegalPage) { - u8 u1bPsr = read_nic_io_byte(dev, PSR); - - write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) | - (u8)u4bPage)); - Data = read_nic_io_word(dev, (x & 0xff)); - write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask)); - } - - return Data; -} -u32 read_nic_io_dword(struct net_device *dev, int x) -{ - u32 u4bPage = x >> 8; - u8 u1PageMask = 0; - bool bIsLegalPage = false; - u32 Data = 0; - - if (u4bPage == 0) - return inl(dev->base_addr + x); - bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage, - &u1PageMask); - if (bIsLegalPage) { - u8 u1bPsr = read_nic_io_byte(dev, PSR); - - write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) | - (u8)u4bPage)); - Data = read_nic_io_dword(dev, (x & 0xff)); - write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask)); - } - - return Data; -} - -u8 read_nic_byte(struct net_device *dev, int x) +u8 rtl92e_readb(struct net_device *dev, int x) { return 0xff & readb((u8 __iomem *)dev->mem_start + x); } -u32 read_nic_dword(struct net_device *dev, int x) +u32 rtl92e_readl(struct net_device *dev, int x) { return readl((u8 __iomem *)dev->mem_start + x); } -u16 read_nic_word(struct net_device *dev, int x) +u16 rtl92e_readw(struct net_device *dev, int x) { return readw((u8 __iomem *)dev->mem_start + x); } -void write_nic_byte(struct net_device *dev, int x, u8 y) +void rtl92e_writeb(struct net_device *dev, int x, u8 y) { writeb(y, (u8 __iomem *)dev->mem_start + x); udelay(20); } -void write_nic_dword(struct net_device *dev, int x, u32 y) +void rtl92e_writel(struct net_device *dev, int x, u32 y) { writel(y, (u8 __iomem *)dev->mem_start + x); udelay(20); } -void write_nic_word(struct net_device *dev, int x, u16 y) +void rtl92e_writew(struct net_device *dev, int x, u16 y) { writew(y, (u8 __iomem *)dev->mem_start + x); @@ -307,10 +147,9 @@ void write_nic_word(struct net_device *dev, int x, u16 y) /**************************************************************************** -----------------------------GENERAL FUNCTION------------------------- *****************************************************************************/ -bool MgntActSet_RF_State(struct net_device *dev, +bool rtl92e_set_rf_state(struct net_device *dev, enum rt_rf_power_state StateToSet, - RT_RF_CHANGE_SOURCE ChangeSource, - bool ProtectOrNot) + RT_RF_CHANGE_SOURCE ChangeSource) { struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_device *ieee = priv->rtllib; @@ -321,39 +160,34 @@ bool MgntActSet_RF_State(struct net_device *dev, unsigned long flag; RT_TRACE((COMP_PS | COMP_RF), - "===>MgntActSet_RF_State(): StateToSet(%d)\n", StateToSet); - - ProtectOrNot = false; + "===>rtl92e_set_rf_state(): StateToSet(%d)\n", StateToSet); + while (true) { + spin_lock_irqsave(&priv->rf_ps_lock, flag); + if (priv->RFChangeInProgress) { + spin_unlock_irqrestore(&priv->rf_ps_lock, flag); + RT_TRACE((COMP_PS | COMP_RF), + "rtl92e_set_rf_state(): RF Change in progress! Wait to set..StateToSet(%d).\n", + StateToSet); - if (!ProtectOrNot) { - while (true) { - spin_lock_irqsave(&priv->rf_ps_lock, flag); - if (priv->RFChangeInProgress) { - spin_unlock_irqrestore(&priv->rf_ps_lock, flag); + while (priv->RFChangeInProgress) { + RFWaitCounter++; RT_TRACE((COMP_PS | COMP_RF), - "MgntActSet_RF_State(): RF Change in progress! Wait to set..StateToSet(%d).\n", - StateToSet); - - while (priv->RFChangeInProgress) { - RFWaitCounter++; - RT_TRACE((COMP_PS | COMP_RF), - "MgntActSet_RF_State(): Wait 1 ms (%d times)...\n", - RFWaitCounter); - mdelay(1); - - if (RFWaitCounter > 100) { - netdev_warn(dev, - "%s(): Timeout waiting for RF change.\n", - __func__); - return false; - } + "rtl92e_set_rf_state(): Wait 1 ms (%d times)...\n", + RFWaitCounter); + mdelay(1); + + if (RFWaitCounter > 100) { + netdev_warn(dev, + "%s(): Timeout waiting for RF change.\n", + __func__); + return false; } - } else { - priv->RFChangeInProgress = true; - spin_unlock_irqrestore(&priv->rf_ps_lock, flag); - break; } + } else { + priv->RFChangeInProgress = true; + spin_unlock_irqrestore(&priv->rf_ps_lock, flag); + break; } } @@ -376,7 +210,7 @@ bool MgntActSet_RF_State(struct net_device *dev, bConnectBySSID = true; } else { RT_TRACE((COMP_PS | COMP_RF), - "MgntActSet_RF_State - eRfon reject pMgntInfo->RfOffReason= 0x%x, ChangeSource=0x%X\n", + "rtl92e_set_rf_state - eRfon reject pMgntInfo->RfOffReason= 0x%x, ChangeSource=0x%X\n", priv->rtllib->RfOffReason, ChangeSource); } @@ -413,7 +247,7 @@ bool MgntActSet_RF_State(struct net_device *dev, if (bActionAllowed) { RT_TRACE((COMP_PS | COMP_RF), - "MgntActSet_RF_State(): Action is allowed.... StateToSet(%d), RfOffReason(%#X)\n", + "rtl92e_set_rf_state(): Action is allowed.... StateToSet(%d), RfOffReason(%#X)\n", StateToSet, priv->rtllib->RfOffReason); PHY_SetRFPowerState(dev, StateToSet); if (StateToSet == eRfOn) { @@ -426,17 +260,15 @@ bool MgntActSet_RF_State(struct net_device *dev, } } else { RT_TRACE((COMP_PS | COMP_RF), - "MgntActSet_RF_State(): Action is rejected.... StateToSet(%d), ChangeSource(%#X), RfOffReason(%#X)\n", + "rtl92e_set_rf_state(): Action is rejected.... StateToSet(%d), ChangeSource(%#X), RfOffReason(%#X)\n", StateToSet, ChangeSource, priv->rtllib->RfOffReason); } - if (!ProtectOrNot) { - spin_lock_irqsave(&priv->rf_ps_lock, flag); - priv->RFChangeInProgress = false; - spin_unlock_irqrestore(&priv->rf_ps_lock, flag); - } + spin_lock_irqsave(&priv->rf_ps_lock, flag); + priv->RFChangeInProgress = false; + spin_unlock_irqrestore(&priv->rf_ps_lock, flag); - RT_TRACE((COMP_PS | COMP_RF), "<===MgntActSet_RF_State()\n"); + RT_TRACE((COMP_PS | COMP_RF), "<===rtl92e_set_rf_state()\n"); return bActionAllowed; } @@ -450,7 +282,7 @@ static short rtl8192_check_nic_enough_desc(struct net_device *dev, int prio) return 0; } -void rtl8192_tx_timeout(struct net_device *dev) +static void rtl8192_tx_timeout(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -458,7 +290,7 @@ void rtl8192_tx_timeout(struct net_device *dev) netdev_info(dev, "TXTIMEOUT"); } -void rtl8192_irq_enable(struct net_device *dev) +void rtl92e_irq_enable(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); @@ -467,7 +299,7 @@ void rtl8192_irq_enable(struct net_device *dev) priv->ops->irq_enable(dev); } -void rtl8192_irq_disable(struct net_device *dev) +void rtl92e_irq_disable(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); @@ -476,7 +308,7 @@ void rtl8192_irq_disable(struct net_device *dev) priv->irq_enabled = 0; } -void rtl8192_set_chan(struct net_device *dev, short ch) +static void rtl8192_set_chan(struct net_device *dev, short ch) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); @@ -490,7 +322,7 @@ void rtl8192_set_chan(struct net_device *dev, short ch) priv->rf_set_chan(dev, priv->chan); } -void rtl8192_update_cap(struct net_device *dev, u16 cap) +static void rtl8192_update_cap(struct net_device *dev, u16 cap) { struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_network *net = &priv->rtllib->current_network; @@ -683,7 +515,7 @@ static int rtl8192_qos_association_resp(struct r8192_priv *priv, RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n", __func__, network->flags, priv->rtllib->current_network.qos_data.active); if (set_qos_param == 1) { - dm_init_edca_turbo(priv->rtllib->dev); + rtl92e_dm_init_edca_turbo(priv->rtllib->dev); queue_work_rsl(priv->priv_wq, &priv->qos_activate); } return 0; @@ -733,7 +565,7 @@ static void rtl8192_stop_beacon(struct net_device *dev) { } -void rtl8192_config_rate(struct net_device *dev, u16 *rate_config) +void rtl92e_config_rate(struct net_device *dev, u16 *rate_config) { struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_network *net; @@ -864,7 +696,7 @@ static u8 rtl8192_getSupportedWireleeMode(struct net_device *dev) return ret; } -void rtl8192_SetWirelessMode(struct net_device *dev, u8 wireless_mode) +void rtl92e_set_wireless_mode(struct net_device *dev, u8 wireless_mode) { struct r8192_priv *priv = rtllib_priv(dev); u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev); @@ -895,9 +727,6 @@ void rtl8192_SetWirelessMode(struct net_device *dev, u8 wireless_mode) priv->rtllib->mode = wireless_mode; - ActUpdateChannelAccessSetting(dev, wireless_mode, - &priv->ChannelAccessSetting); - if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G)) { priv->rtllib->pHTInfo->bEnableHT = 1; @@ -941,7 +770,7 @@ static int _rtl8192_sta_up(struct net_device *dev, bool is_silent_reset) priv->bfirst_init = false; if (priv->polling_timer_on == 0) - check_rfctrl_gpio_timer((unsigned long)dev); + rtl92e_check_rfctrl_gpio_timer((unsigned long)dev); if (priv->rtllib->state != RTLLIB_LINKED) rtllib_softmac_start_protocol(priv->rtllib, 0); @@ -969,7 +798,7 @@ static int rtl8192_sta_down(struct net_device *dev, bool shutdownrf) priv->rtllib->rtllib_ips_leave(dev); if (priv->rtllib->state == RTLLIB_LINKED) - LeisurePSLeave(dev); + rtl92e_leisure_ps_leave(dev); priv->bDriverIsGoingToUnload = true; priv->up = 0; @@ -982,9 +811,9 @@ static int rtl8192_sta_down(struct net_device *dev, bool shutdownrf) priv->rtllib->wpa_ie_len = 0; kfree(priv->rtllib->wpa_ie); priv->rtllib->wpa_ie = NULL; - CamResetAllEntry(dev); + rtl92e_cam_reset(dev); memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32); - rtl8192_irq_disable(dev); + rtl92e_irq_disable(dev); del_timer_sync(&priv->watch_dog_timer); rtl8192_cancel_deferred_work(priv); @@ -1027,38 +856,36 @@ static void rtl8192_init_priv_handler(struct net_device *dev) priv->rtllib->set_chan = rtl8192_set_chan; priv->rtllib->link_change = priv->ops->link_change; priv->rtllib->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit; - priv->rtllib->data_hard_stop = rtl8192_data_hard_stop; - priv->rtllib->data_hard_resume = rtl8192_data_hard_resume; priv->rtllib->check_nic_enough_desc = rtl8192_check_nic_enough_desc; priv->rtllib->handle_assoc_response = rtl8192_handle_assoc_response; priv->rtllib->handle_beacon = rtl8192_handle_beacon; - priv->rtllib->SetWirelessMode = rtl8192_SetWirelessMode; - priv->rtllib->LeisurePSLeave = LeisurePSLeave; - priv->rtllib->SetBWModeHandler = rtl8192_SetBWMode; - priv->rf_set_chan = rtl8192_phy_SwChnl; + priv->rtllib->SetWirelessMode = rtl92e_set_wireless_mode; + priv->rtllib->LeisurePSLeave = rtl92e_leisure_ps_leave; + priv->rtllib->SetBWModeHandler = rtl92e_set_bw_mode; + priv->rf_set_chan = rtl92e_set_channel; - priv->rtllib->start_send_beacons = rtl8192e_start_beacon; + priv->rtllib->start_send_beacons = rtl92e_start_beacon; priv->rtllib->stop_send_beacons = rtl8192_stop_beacon; - priv->rtllib->sta_wake_up = rtl8192_hw_wakeup; - priv->rtllib->enter_sleep_state = rtl8192_hw_to_sleep; + priv->rtllib->sta_wake_up = rtl92e_hw_wakeup; + priv->rtllib->enter_sleep_state = rtl92e_enter_sleep; priv->rtllib->ps_is_queue_empty = rtl8192_is_tx_queue_empty; - priv->rtllib->GetNmodeSupportBySecCfg = rtl8192_GetNmodeSupportBySecCfg; + priv->rtllib->GetNmodeSupportBySecCfg = rtl92e_get_nmode_support_by_sec; priv->rtllib->GetHalfNmodeSupportByAPsHandler = - rtl8192_GetHalfNmodeSupportByAPs; + rtl92e_is_halfn_supported_by_ap; - priv->rtllib->SetHwRegHandler = rtl8192e_SetHwReg; - priv->rtllib->AllowAllDestAddrHandler = rtl8192_AllowAllDestAddr; + priv->rtllib->SetHwRegHandler = rtl92e_set_reg; + priv->rtllib->AllowAllDestAddrHandler = rtl92e_set_monitor_mode; priv->rtllib->SetFwCmdHandler = NULL; - priv->rtllib->InitialGainHandler = InitialGain819xPci; - priv->rtllib->rtllib_ips_leave_wq = rtllib_ips_leave_wq; - priv->rtllib->rtllib_ips_leave = rtllib_ips_leave; + priv->rtllib->InitialGainHandler = rtl92e_init_gain; + priv->rtllib->rtllib_ips_leave_wq = rtl92e_rtllib_ips_leave_wq; + priv->rtllib->rtllib_ips_leave = rtl92e_rtllib_ips_leave; priv->rtllib->LedControlHandler = NULL; priv->rtllib->UpdateBeaconInterruptHandler = NULL; - priv->rtllib->ScanOperationBackupHandler = PHY_ScanOperationBackup8192; + priv->rtllib->ScanOperationBackupHandler = rtl92e_scan_op_backup; } static void rtl8192_init_priv_constant(struct net_device *dev) @@ -1181,20 +1008,21 @@ static void rtl8192_init_priv_task(struct net_device *dev) priv->priv_wq = create_workqueue(DRV_NAME); INIT_WORK_RSL(&priv->reset_wq, (void *)rtl8192_restart, dev); - INIT_WORK_RSL(&priv->rtllib->ips_leave_wq, (void *)IPSLeave_wq, dev); + INIT_WORK_RSL(&priv->rtllib->ips_leave_wq, (void *)rtl92e_ips_leave_wq, + dev); INIT_DELAYED_WORK_RSL(&priv->watch_dog_wq, (void *)rtl819x_watchdog_wqcallback, dev); INIT_DELAYED_WORK_RSL(&priv->txpower_tracking_wq, - (void *)dm_txpower_trackingcallback, dev); + (void *)rtl92e_dm_txpower_tracking_wq, dev); INIT_DELAYED_WORK_RSL(&priv->rfpath_check_wq, - (void *)dm_rf_pathcheck_workitemcallback, dev); + (void *)rtl92e_dm_rf_pathcheck_wq, dev); INIT_DELAYED_WORK_RSL(&priv->update_beacon_wq, (void *)rtl8192_update_beacon, dev); INIT_WORK_RSL(&priv->qos_activate, (void *)rtl8192_qos_activate, dev); INIT_DELAYED_WORK_RSL(&priv->rtllib->hw_wakeup_wq, - (void *) rtl8192_hw_wakeup_wq, dev); + (void *) rtl92e_hw_wakeup_wq, dev); INIT_DELAYED_WORK_RSL(&priv->rtllib->hw_sleep_wq, - (void *) rtl8192_hw_sleep_wq, dev); + (void *) rtl92e_hw_sleep_wq, dev); tasklet_init(&priv->irq_rx_tasklet, (void(*)(unsigned long))rtl8192_irq_rx_tasklet, (unsigned long)priv); @@ -1250,17 +1078,17 @@ static short rtl8192_init(struct net_device *dev) priv->ops->init_adapter_variable(dev); rtl8192_get_channel_map(dev); - init_hal_dm(dev); + rtl92e_dm_init(dev); setup_timer(&priv->watch_dog_timer, watch_dog_timer_callback, (unsigned long) dev); setup_timer(&priv->gpio_polling_timer, - check_rfctrl_gpio_timer, + rtl92e_check_rfctrl_gpio_timer, (unsigned long)dev); - rtl8192_irq_disable(dev); + rtl92e_irq_disable(dev); if (request_irq(dev->irq, rtl8192_interrupt, IRQF_SHARED, dev->name, dev)) { netdev_err(dev, "Error allocating IRQ %d", dev->irq); @@ -1282,7 +1110,7 @@ static short rtl8192_init(struct net_device *dev) /*************************************************************************** -------------------------------WATCHDOG STUFF--------------------------- ***************************************************************************/ -short rtl8192_is_tx_queue_empty(struct net_device *dev) +static short rtl8192_is_tx_queue_empty(struct net_device *dev) { int i = 0; struct r8192_priv *priv = rtllib_priv(dev); @@ -1439,7 +1267,7 @@ RESET_START: down(&priv->wx_sem); if (priv->rtllib->state == RTLLIB_LINKED) - LeisurePSLeave(dev); + rtl92e_leisure_ps_leave(dev); if (priv->up) { netdev_info(dev, "%s():the driver is not up.\n", @@ -1459,10 +1287,10 @@ RESET_START: if (!netif_queue_stopped(dev)) netif_stop_queue(dev); - rtl8192_irq_disable(dev); + rtl92e_irq_disable(dev); del_timer_sync(&priv->watch_dog_timer); rtl8192_cancel_deferred_work(priv); - deinit_hal_dm(dev); + rtl92e_dm_deinit(dev); rtllib_stop_scan_syncro(ieee); if (ieee->state == RTLLIB_LINKED) { @@ -1479,7 +1307,7 @@ RESET_START: rtllib_softmac_stop_protocol(priv->rtllib, 0, true); } - dm_backup_dynamic_mechanism_state(dev); + rtl92e_dm_backup_state(dev); up(&priv->wx_sem); RT_TRACE(COMP_RESET, @@ -1508,7 +1336,7 @@ RESET_START: priv->RFChangeInProgress = false; spin_unlock_irqrestore(&priv->rf_ps_lock, flag); - EnableHWSecurityConfig8192(dev); + rtl92e_enable_hw_security_config(dev); if (ieee->state == RTLLIB_LINKED && ieee->iw_mode == IW_MODE_INFRA) { @@ -1527,15 +1355,13 @@ RESET_START: rtllib_start_send_beacons(ieee); - if (ieee->data_hard_resume) - ieee->data_hard_resume(ieee->dev); netif_carrier_on(ieee->dev); } else if (ieee->iw_mode == IW_MODE_MESH) { rtl819x_silentreset_mesh_bk(dev, IsPortal); } - CamRestoreAllEntry(dev); - dm_restore_dynamic_mechanism_state(dev); + rtl92e_cam_restore(dev); + rtl92e_dm_restore_state(dev); END: priv->ResetProgress = RESET_TYPE_NORESET; priv->reset_count++; @@ -1543,7 +1369,7 @@ END: priv->bForcedSilentReset = false; priv->bResetInProgress = false; - write_nic_byte(dev, UFWP, 1); + rtl92e_writeb(dev, UFWP, 1); RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count); } @@ -1570,8 +1396,7 @@ static void rtl819x_update_rxcounts(struct r8192_priv *priv, u32 *TotalRxBcnNum, } } - -void rtl819x_watchdog_wqcallback(void *data) +static void rtl819x_watchdog_wqcallback(void *data) { struct r8192_priv *priv = container_of_dwork_rsl(data, struct r8192_priv, watch_dog_wq); @@ -1597,7 +1422,7 @@ void rtl819x_watchdog_wqcallback(void *data) priv->rtllib->CntAfterLink = 0; } - hal_dm_watchdog(dev); + rtl92e_dm_watchdog(dev); if (rtllib_act_scanning(priv->rtllib, false) == false) { if ((ieee->iw_mode == IW_MODE_INFRA) && (ieee->state == @@ -1608,8 +1433,8 @@ void rtl819x_watchdog_wqcallback(void *data) IPS_CALLBACK_NONE) && (!ieee->bNetPromiscuousMode)) { RT_TRACE(COMP_PS, - "====================>haha: IPSEnter()\n"); - IPSEnter(dev); + "====================>haha: rtl92e_ips_enter()\n"); + rtl92e_ips_enter(dev); } } } @@ -1640,13 +1465,13 @@ void rtl819x_watchdog_wqcallback(void *data) bEnterPS = false; if (bEnterPS) - LeisurePSEnter(dev); + rtl92e_leisure_ps_enter(dev); else - LeisurePSLeave(dev); + rtl92e_leisure_ps_leave(dev); } else { RT_TRACE(COMP_LPS, "====>no link LPS leave\n"); - LeisurePSLeave(dev); + rtl92e_leisure_ps_leave(dev); } ieee->LinkDetectInfo.NumRxOkInPeriod = 0; @@ -1725,7 +1550,7 @@ void rtl819x_watchdog_wqcallback(void *data) RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n"); } -void watch_dog_timer_callback(unsigned long data) +static void watch_dog_timer_callback(unsigned long data) { struct r8192_priv *priv = rtllib_priv((struct net_device *)data); @@ -1737,14 +1562,14 @@ void watch_dog_timer_callback(unsigned long data) /**************************************************************************** ---------------------------- NIC TX/RX STUFF--------------------------- *****************************************************************************/ -void rtl8192_rx_enable(struct net_device *dev) +void rtl92e_rx_enable(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); priv->ops->rx_enable(dev); } -void rtl8192_tx_enable(struct net_device *dev) +void rtl92e_tx_enable(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); @@ -1802,16 +1627,7 @@ static void rtl8192_free_tx_ring(struct net_device *dev, unsigned int prio) ring->desc = NULL; } -void rtl8192_data_hard_stop(struct net_device *dev) -{ -} - - -void rtl8192_data_hard_resume(struct net_device *dev) -{ -} - -void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, +static void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); @@ -1843,7 +1659,7 @@ void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, } } -int rtl8192_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) +static int rtl8192_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); int ret; @@ -1902,7 +1718,7 @@ static void rtl8192_tx_isr(struct net_device *dev, int prio) tasklet_schedule(&priv->irq_tx_tasklet); } -void rtl8192_tx_cmd(struct net_device *dev, struct sk_buff *skb) +static void rtl8192_tx_cmd(struct net_device *dev, struct sk_buff *skb) { struct r8192_priv *priv = rtllib_priv(dev); struct rtl8192_tx_ring *ring; @@ -1925,7 +1741,7 @@ void rtl8192_tx_cmd(struct net_device *dev, struct sk_buff *skb) spin_unlock_irqrestore(&priv->irq_th_lock, flags); } -short rtl8192_tx(struct net_device *dev, struct sk_buff *skb) +static short rtl8192_tx(struct net_device *dev, struct sk_buff *skb) { struct r8192_priv *priv = rtllib_priv(dev); struct rtl8192_tx_ring *ring; @@ -1997,7 +1813,7 @@ short rtl8192_tx(struct net_device *dev, struct sk_buff *skb) spin_unlock_irqrestore(&priv->irq_th_lock, flags); dev->trans_start = jiffies; - write_nic_word(dev, TPPoll, 0x01 << tcb_desc->queue_index); + rtl92e_writew(dev, TPPoll, 0x01 << tcb_desc->queue_index); return 0; } @@ -2077,8 +1893,7 @@ static int rtl8192_alloc_tx_desc_ring(struct net_device *dev, return 0; } - -short rtl8192_pci_initdescring(struct net_device *dev) +static short rtl8192_pci_initdescring(struct net_device *dev) { u32 ret; int i; @@ -2104,7 +1919,7 @@ err_free_rings: return 1; } -void rtl8192_pci_resetdescring(struct net_device *dev) +void rtl92e_reset_desc_ring(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); int i, rx_queue_idx; @@ -2144,8 +1959,8 @@ void rtl8192_pci_resetdescring(struct net_device *dev) spin_unlock_irqrestore(&priv->irq_th_lock, flags); } -void rtl819x_UpdateRxPktTimeStamp(struct net_device *dev, - struct rtllib_rx_stats *stats) +void rtl92e_update_rx_pkt_timestamp(struct net_device *dev, + struct rtllib_rx_stats *stats) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); @@ -2155,7 +1970,7 @@ void rtl819x_UpdateRxPktTimeStamp(struct net_device *dev, priv->LastRxDescTSF = stats->mac_time; } -long rtl819x_translate_todbm(struct r8192_priv *priv, u8 signal_strength_index) +long rtl92e_translate_to_dbm(struct r8192_priv *priv, u8 signal_strength_index) { long signal_power; @@ -2166,11 +1981,8 @@ long rtl819x_translate_todbm(struct r8192_priv *priv, u8 signal_strength_index) } -void -rtl819x_update_rxsignalstatistics8190pci( - struct r8192_priv *priv, - struct rtllib_rx_stats *pprevious_stats - ) +void rtl92e_update_rx_statistics(struct r8192_priv *priv, + struct rtllib_rx_stats *pprevious_stats) { int weighting = 0; @@ -2189,13 +2001,7 @@ rtl819x_update_rxsignalstatistics8190pci( weighting) / 6; } -void rtl819x_process_cck_rxpathsel(struct r8192_priv *priv, - struct rtllib_rx_stats *pprevious_stats) -{ -} - - -u8 rtl819x_query_rxpwrpercentage(char antpower) +u8 rtl92e_rx_db_to_percent(char antpower) { if ((antpower <= -100) || (antpower >= 20)) return 0; @@ -2206,10 +2012,7 @@ u8 rtl819x_query_rxpwrpercentage(char antpower) } /* QueryRxPwrPercentage */ -u8 -rtl819x_evm_dbtopercentage( - char value - ) +u8 rtl92e_evm_db_to_percent(char value) { char ret_val; @@ -2226,11 +2029,8 @@ rtl819x_evm_dbtopercentage( return ret_val; } -void -rtl8192_record_rxdesc_forlateruse( - struct rtllib_rx_stats *psrc_stats, - struct rtllib_rx_stats *ptarget_stats -) +void rtl92e_copy_mpdu_stats(struct rtllib_rx_stats *psrc_stats, + struct rtllib_rx_stats *ptarget_stats) { ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU; ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU; @@ -2344,11 +2144,6 @@ done: } -static void rtl8192_rx_cmd(struct net_device *dev) -{ -} - - static void rtl8192_tx_resume(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); @@ -2366,26 +2161,23 @@ static void rtl8192_tx_resume(struct net_device *dev) } } -void rtl8192_irq_tx_tasklet(struct r8192_priv *priv) +static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv) { rtl8192_tx_resume(priv->rtllib->dev); } -void rtl8192_irq_rx_tasklet(struct r8192_priv *priv) +static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv) { rtl8192_rx_normal(priv->rtllib->dev); - if (MAX_RX_QUEUE > 1) - rtl8192_rx_cmd(priv->rtllib->dev); - - write_nic_dword(priv->rtllib->dev, INTA_MASK, - read_nic_dword(priv->rtllib->dev, INTA_MASK) | IMR_RDU); + rtl92e_writel(priv->rtllib->dev, INTA_MASK, + rtl92e_readl(priv->rtllib->dev, INTA_MASK) | IMR_RDU); } /**************************************************************************** ---------------------------- NIC START/CLOSE STUFF--------------------------- *****************************************************************************/ -void rtl8192_cancel_deferred_work(struct r8192_priv *priv) +static void rtl8192_cancel_deferred_work(struct r8192_priv *priv) { cancel_delayed_work(&priv->watch_dog_wq); cancel_delayed_work(&priv->update_beacon_wq); @@ -2394,14 +2186,13 @@ void rtl8192_cancel_deferred_work(struct r8192_priv *priv) cancel_work_sync(&priv->qos_activate); } -int _rtl8192_up(struct net_device *dev, bool is_silent_reset) +static int _rtl8192_up(struct net_device *dev, bool is_silent_reset) { if (_rtl8192_sta_up(dev, is_silent_reset) == -1) return -1; return 0; } - static int rtl8192_open(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -2414,8 +2205,7 @@ static int rtl8192_open(struct net_device *dev) } - -int rtl8192_up(struct net_device *dev) +static int rtl8192_up(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -2445,7 +2235,7 @@ static int rtl8192_close(struct net_device *dev) } -int rtl8192_down(struct net_device *dev, bool shutdownrf) +static int rtl8192_down(struct net_device *dev, bool shutdownrf) { if (rtl8192_sta_down(dev, shutdownrf) == -1) return -1; @@ -2453,19 +2243,19 @@ int rtl8192_down(struct net_device *dev, bool shutdownrf) return 0; } -void rtl8192_commit(struct net_device *dev) +void rtl92e_commit(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); if (priv->up == 0) return; rtllib_softmac_stop_protocol(priv->rtllib, 0, true); - rtl8192_irq_disable(dev); + rtl92e_irq_disable(dev); priv->ops->stop_adapter(dev, true); _rtl8192_up(dev, false); } -void rtl8192_restart(void *data) +static void rtl8192_restart(void *data) { struct r8192_priv *priv = container_of_work_rsl(data, struct r8192_priv, reset_wq); @@ -2473,7 +2263,7 @@ void rtl8192_restart(void *data) down(&priv->wx_sem); - rtl8192_commit(dev); + rtl92e_commit(dev); up(&priv->wx_sem); } @@ -2552,30 +2342,34 @@ static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) if (is_zero_ether_addr(ieee->ap_mac_addr)) ieee->iw_mode = IW_MODE_ADHOC; memcpy((u8 *)key, ipw->u.crypt.key, 16); - EnableHWSecurityConfig8192(dev); - set_swcam(dev, 4, ipw->u.crypt.idx, - ieee->pairwise_key_type, - (u8 *)ieee->ap_mac_addr, - 0, key, 0); - setKey(dev, 4, ipw->u.crypt.idx, - ieee->pairwise_key_type, - (u8 *)ieee->ap_mac_addr, 0, key); - if (ieee->iw_mode == IW_MODE_ADHOC) { - set_swcam(dev, ipw->u.crypt.idx, - ipw->u.crypt.idx, - ieee->pairwise_key_type, - (u8 *)ieee->ap_mac_addr, - 0, key, 0); - setKey(dev, ipw->u.crypt.idx, - ipw->u.crypt.idx, + rtl92e_enable_hw_security_config(dev); + rtl92e_set_swcam(dev, 4, + ipw->u.crypt.idx, + ieee->pairwise_key_type, + (u8 *)ieee->ap_mac_addr, + 0, key, 0); + rtl92e_set_key(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8 *)ieee->ap_mac_addr, 0, key); + if (ieee->iw_mode == IW_MODE_ADHOC) { + rtl92e_set_swcam(dev, + ipw->u.crypt.idx, + ipw->u.crypt.idx, + ieee->pairwise_key_type, + (u8 *)ieee->ap_mac_addr, + 0, key, 0); + rtl92e_set_key(dev, + ipw->u.crypt.idx, + ipw->u.crypt.idx, + ieee->pairwise_key_type, + (u8 *)ieee->ap_mac_addr, + 0, key); } } if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) && ieee->pHTInfo->bCurrentHTSupport) { - write_nic_byte(dev, 0x173, 1); + rtl92e_writeb(dev, 0x173, 1); } } else { @@ -2595,14 +2389,15 @@ static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) ieee->group_key_type = KEY_TYPE_NA; if (ieee->group_key_type) { - set_swcam(dev, ipw->u.crypt.idx, - ipw->u.crypt.idx, - ieee->group_key_type, - broadcast_addr, 0, key, 0); - setKey(dev, ipw->u.crypt.idx, - ipw->u.crypt.idx, - ieee->group_key_type, - broadcast_addr, 0, key); + rtl92e_set_swcam(dev, ipw->u.crypt.idx, + ipw->u.crypt.idx, + ieee->group_key_type, + broadcast_addr, 0, key, + 0); + rtl92e_set_key(dev, ipw->u.crypt.idx, + ipw->u.crypt.idx, + ieee->group_key_type, + broadcast_addr, 0, key); } } } @@ -2707,8 +2502,8 @@ static irqreturn_t rtl8192_interrupt(int irq, void *netdev) if (inta & IMR_RDU) { RT_TRACE(COMP_INTR, "rx descriptor unavailable!\n"); priv->stats.rxrdu++; - write_nic_dword(dev, INTA_MASK, - read_nic_dword(dev, INTA_MASK) & ~IMR_RDU); + rtl92e_writel(dev, INTA_MASK, + rtl92e_readl(dev, INTA_MASK) & ~IMR_RDU); tasklet_schedule(&priv->irq_rx_tasklet); } @@ -2782,7 +2577,6 @@ static int rtl8192_pci_probe(struct pci_dev *pdev, struct rtl819x_ops *ops = (struct rtl819x_ops *)(id->driver_data); unsigned long pmem_start, pmem_len, pmem_flags; int err = -ENOMEM; - bool bdma64 = false; u8 revision_id; RT_TRACE(COMP_INIT, "Configuring chip resources"); @@ -2806,8 +2600,6 @@ static int rtl8192_pci_probe(struct pci_dev *pdev, goto err_pci_disable; err = -ENODEV; - if (bdma64) - dev->features |= NETIF_F_HIGHDMA; pci_set_drvdata(pdev, dev); SET_NETDEV_DEV(dev, &pdev->dev); @@ -2850,12 +2642,12 @@ static int rtl8192_pci_probe(struct pci_dev *pdev, pci_read_config_byte(pdev, 0x08, &revision_id); /* If the revisionid is 0x10, the device uses rtl8192se. */ if (pdev->device == 0x8192 && revision_id == 0x10) - goto err_rel_mem; + goto err_unmap; priv->ops = ops; - if (rtl8192_pci_findadapter(pdev, dev) == false) - goto err_rel_mem; + if (rtl92e_check_adapter(pdev, dev) == false) + goto err_unmap; dev->irq = pdev->irq; priv->irq = 0; @@ -2888,7 +2680,7 @@ static int rtl8192_pci_probe(struct pci_dev *pdev, RT_TRACE(COMP_INIT, "dev name: %s\n", dev->name); if (priv->polling_timer_on == 0) - check_rfctrl_gpio_timer((unsigned long)dev); + rtl92e_check_rfctrl_gpio_timer((unsigned long)dev); RT_TRACE(COMP_INIT, "Driver probe completed\n"); return 0; @@ -2896,12 +2688,12 @@ static int rtl8192_pci_probe(struct pci_dev *pdev, err_free_irq: free_irq(dev->irq, dev); priv->irq = 0; +err_unmap: + iounmap((void __iomem *)ioaddr); err_rel_mem: release_mem_region(pmem_start, pmem_len); err_rel_rtllib: free_rtllib(dev); - - DMESG("wlan driver load failed\n"); err_pci_disable: pci_disable_device(pdev); return err; @@ -2922,7 +2714,7 @@ static void rtl8192_pci_disconnect(struct pci_dev *pdev) cancel_delayed_work(&priv->gpio_change_rf_wq); priv->polling_timer_on = 0; rtl8192_down(dev, true); - deinit_hal_dm(dev); + rtl92e_dm_deinit(dev); if (priv->pFirmware) { vfree(priv->pFirmware); priv->pFirmware = NULL; @@ -2952,7 +2744,7 @@ static void rtl8192_pci_disconnect(struct pci_dev *pdev) RT_TRACE(COMP_DOWN, "wlan driver removed\n"); } -bool NicIFEnableNIC(struct net_device *dev) +bool rtl92e_enable_nic(struct net_device *dev) { bool init_status = true; struct r8192_priv *priv = rtllib_priv(dev); @@ -2977,12 +2769,12 @@ bool NicIFEnableNIC(struct net_device *dev) RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC); priv->bfirst_init = false; - rtl8192_irq_enable(dev); + rtl92e_irq_enable(dev); priv->bdisable_nic = false; RT_TRACE(COMP_PS, "<===========%s()\n", __func__); return init_status; } -bool NicIFDisableNIC(struct net_device *dev) +bool rtl92e_disable_nic(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); u8 tmp_state = 0; @@ -2993,7 +2785,7 @@ bool NicIFDisableNIC(struct net_device *dev) rtllib_softmac_stop_protocol(priv->rtllib, 0, false); priv->rtllib->state = tmp_state; rtl8192_cancel_deferred_work(priv); - rtl8192_irq_disable(dev); + rtl92e_irq_disable(dev); priv->ops->stop_adapter(dev, false); RT_TRACE(COMP_PS, "<=========%s()\n", __func__); @@ -3007,7 +2799,6 @@ static int __init rtl8192_pci_module_init(void) pr_info("Copyright (c) 2007-2008, Realsil Wlan Driver\n"); if (0 != pci_register_driver(&rtl8192_pci_driver)) { - DMESG("No device found"); /*pci_unregister_driver (&rtl8192_pci_driver);*/ return -ENODEV; } @@ -3021,7 +2812,7 @@ static void __exit rtl8192_pci_module_exit(void) RT_TRACE(COMP_DOWN, "Exiting"); } -void check_rfctrl_gpio_timer(unsigned long data) +void rtl92e_check_rfctrl_gpio_timer(unsigned long data) { struct r8192_priv *priv = rtllib_priv((struct net_device *)data); diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_core.h b/drivers/staging/rtl8192e/rtl8192e/rtl_core.h index 776d95065..cd948bb13 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_core.h +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_core.h @@ -578,84 +578,44 @@ struct r8192_priv { extern const struct ethtool_ops rtl819x_ethtool_ops; -void rtl8192_tx_cmd(struct net_device *dev, struct sk_buff *skb); -short rtl8192_tx(struct net_device *dev, struct sk_buff *skb); - -u8 read_nic_io_byte(struct net_device *dev, int x); -u32 read_nic_io_dword(struct net_device *dev, int x); -u16 read_nic_io_word(struct net_device *dev, int x); -void write_nic_io_byte(struct net_device *dev, int x, u8 y); -void write_nic_io_word(struct net_device *dev, int x, u16 y); -void write_nic_io_dword(struct net_device *dev, int x, u32 y); - -u8 read_nic_byte(struct net_device *dev, int x); -u32 read_nic_dword(struct net_device *dev, int x); -u16 read_nic_word(struct net_device *dev, int x); -void write_nic_byte(struct net_device *dev, int x, u8 y); -void write_nic_word(struct net_device *dev, int x, u16 y); -void write_nic_dword(struct net_device *dev, int x, u32 y); +u8 rtl92e_readb(struct net_device *dev, int x); +u32 rtl92e_readl(struct net_device *dev, int x); +u16 rtl92e_readw(struct net_device *dev, int x); +void rtl92e_writeb(struct net_device *dev, int x, u8 y); +void rtl92e_writew(struct net_device *dev, int x, u16 y); +void rtl92e_writel(struct net_device *dev, int x, u32 y); void force_pci_posting(struct net_device *dev); -void rtl8192_rx_enable(struct net_device *); -void rtl8192_tx_enable(struct net_device *); - -int rtl8192_hard_start_xmit(struct sk_buff *skb, struct net_device *dev); -void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, - int rate); -void rtl8192_data_hard_stop(struct net_device *dev); -void rtl8192_data_hard_resume(struct net_device *dev); -void rtl8192_restart(void *data); -void rtl819x_watchdog_wqcallback(void *data); -void rtl8192_hw_sleep_wq(void *data); -void watch_dog_timer_callback(unsigned long data); -void rtl8192_irq_rx_tasklet(struct r8192_priv *priv); -void rtl8192_irq_tx_tasklet(struct r8192_priv *priv); -int rtl8192_down(struct net_device *dev, bool shutdownrf); -int rtl8192_up(struct net_device *dev); -void rtl8192_commit(struct net_device *dev); -void rtl8192_set_chan(struct net_device *dev, short ch); - -void check_rfctrl_gpio_timer(unsigned long data); - -void rtl8192_hw_wakeup_wq(void *data); -short rtl8192_pci_initdescring(struct net_device *dev); - -void rtl8192_cancel_deferred_work(struct r8192_priv *priv); - -int _rtl8192_up(struct net_device *dev, bool is_silent_reset); - -short rtl8192_is_tx_queue_empty(struct net_device *dev); -void rtl8192_irq_disable(struct net_device *dev); - -void rtl8192_tx_timeout(struct net_device *dev); -void rtl8192_pci_resetdescring(struct net_device *dev); -void rtl8192_SetWirelessMode(struct net_device *dev, u8 wireless_mode); -void rtl8192_irq_enable(struct net_device *dev); -void rtl8192_config_rate(struct net_device *dev, u16 *rate_config); -void rtl8192_update_cap(struct net_device *dev, u16 cap); -void rtl8192_irq_disable(struct net_device *dev); - -void rtl819x_UpdateRxPktTimeStamp(struct net_device *dev, - struct rtllib_rx_stats *stats); -long rtl819x_translate_todbm(struct r8192_priv *priv, u8 signal_strength_index); -void rtl819x_update_rxsignalstatistics8190pci(struct r8192_priv *priv, - struct rtllib_rx_stats *pprevious_stats); -u8 rtl819x_evm_dbtopercentage(char value); -void rtl819x_process_cck_rxpathsel(struct r8192_priv *priv, - struct rtllib_rx_stats *pprevious_stats); -u8 rtl819x_query_rxpwrpercentage(char antpower); -void rtl8192_record_rxdesc_forlateruse(struct rtllib_rx_stats *psrc_stats, - struct rtllib_rx_stats *ptarget_stats); -bool NicIFEnableNIC(struct net_device *dev); -bool NicIFDisableNIC(struct net_device *dev); - -bool MgntActSet_RF_State(struct net_device *dev, - enum rt_rf_power_state StateToSet, - RT_RF_CHANGE_SOURCE ChangeSource, - bool ProtectOrNot); -void ActUpdateChannelAccessSetting(struct net_device *dev, - enum wireless_mode WirelessMode, - struct channel_access_setting *ChnlAccessSetting); +void rtl92e_rx_enable(struct net_device *); +void rtl92e_tx_enable(struct net_device *); + +void rtl92e_hw_sleep_wq(void *data); +void rtl92e_commit(struct net_device *dev); + +void rtl92e_check_rfctrl_gpio_timer(unsigned long data); + +void rtl92e_hw_wakeup_wq(void *data); +void rtl92e_reset_desc_ring(struct net_device *dev); +void rtl92e_set_wireless_mode(struct net_device *dev, u8 wireless_mode); +void rtl92e_irq_enable(struct net_device *dev); +void rtl92e_config_rate(struct net_device *dev, u16 *rate_config); +void rtl92e_irq_disable(struct net_device *dev); + +void rtl92e_update_rx_pkt_timestamp(struct net_device *dev, + struct rtllib_rx_stats *stats); +long rtl92e_translate_to_dbm(struct r8192_priv *priv, u8 signal_strength_index); +void rtl92e_update_rx_statistics(struct r8192_priv *priv, + struct rtllib_rx_stats *pprevious_stats); +u8 rtl92e_evm_db_to_percent(char value); +u8 rtl92e_rx_db_to_percent(char antpower); +void rtl92e_copy_mpdu_stats(struct rtllib_rx_stats *psrc_stats, + struct rtllib_rx_stats *ptarget_stats); +bool rtl92e_enable_nic(struct net_device *dev); +bool rtl92e_disable_nic(struct net_device *dev); + +bool rtl92e_set_rf_state(struct net_device *dev, + enum rt_rf_power_state StateToSet, + RT_RF_CHANGE_SOURCE ChangeSource); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_dm.c b/drivers/staging/rtl8192e/rtl8192e/rtl_dm.c index 3de7cc549..1a0c690bf 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_dm.c +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_dm.c @@ -58,9 +58,6 @@ static u32 edca_setting_UL[HT_IOT_PEER_MAX] = { 0x5e4332 }; -#define RTK_UL_EDCA 0xa44f -#define RTK_DL_EDCA 0x5e4322 - const u32 dm_tx_bb_gain[TxBBGainTableLength] = { 0x7f8001fe, /* 12 dB */ 0x788001e2, /* 11 dB */ @@ -213,6 +210,9 @@ static void dm_deInit_fsync(struct net_device *dev); static void dm_check_txrateandretrycount(struct net_device *dev); static void dm_check_ac_dc_power(struct net_device *dev); +static void dm_check_fsync(struct net_device *dev); +static void dm_CheckRfCtrlGPIO(void *data); +static void dm_fsync_timer_callback(unsigned long data); /*---------------------Define local function prototype-----------------------*/ @@ -224,7 +224,7 @@ static void dm_send_rssi_tofw(struct net_device *dev); static void dm_ctstoself(struct net_device *dev); /*---------------------------Define function prototype------------------------*/ -void init_hal_dm(struct net_device *dev) +void rtl92e_dm_init(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -234,10 +234,10 @@ void init_hal_dm(struct net_device *dev) dm_init_dynamic_txpower(dev); - init_rate_adaptive(dev); + rtl92e_init_adaptive_rate(dev); dm_dig_init(dev); - dm_init_edca_turbo(dev); + rtl92e_dm_init_edca_turbo(dev); dm_init_bandwidth_autoswitch(dev); dm_init_fsync(dev); dm_init_rxpath_selection(dev); @@ -249,14 +249,14 @@ void init_hal_dm(struct net_device *dev) (void *)dm_CheckRfCtrlGPIO, dev); } -void deinit_hal_dm(struct net_device *dev) +void rtl92e_dm_deinit(struct net_device *dev) { dm_deInit_fsync(dev); } -void hal_dm_watchdog(struct net_device *dev) +void rtl92e_dm_watchdog(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -307,7 +307,7 @@ static void dm_check_ac_dc_power(struct net_device *dev) }; -void init_rate_adaptive(struct net_device *dev) +void rtl92e_init_adaptive_rate(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -444,7 +444,7 @@ static void dm_check_rate_adaptive(struct net_device *dev) if (priv->rtllib->GetHalfNmodeSupportByAPsHandler(dev)) targetRATR &= 0xf00fffff; - currentRATR = read_nic_dword(dev, RATR0); + currentRATR = rtl92e_readl(dev, RATR0); if (targetRATR != currentRATR) { u32 ratr_value; @@ -454,8 +454,8 @@ static void dm_check_rate_adaptive(struct net_device *dev) currentRATR, targetRATR); if (priv->rf_type == RF_1T2R) ratr_value &= ~(RATE_ALL_OFDM_2SS); - write_nic_dword(dev, RATR0, ratr_value); - write_nic_byte(dev, UFWP, 1); + rtl92e_writel(dev, RATR0, ratr_value); + rtl92e_writeb(dev, UFWP, 1); pra->last_ratr = targetRATR; } @@ -561,40 +561,40 @@ static void dm_tx_update_tssi_weak_signal(struct net_device *dev, u8 RF_Type) p->rfa_txpowertrackingindex--; if (p->rfa_txpowertrackingindex_real > 4) { p->rfa_txpowertrackingindex_real--; - rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[p->rfa_txpowertrackingindex_real]); + rtl92e_set_bb_reg(dev, rOFDM0_XATxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[p->rfa_txpowertrackingindex_real]); } p->rfc_txpowertrackingindex--; if (p->rfc_txpowertrackingindex_real > 4) { p->rfc_txpowertrackingindex_real--; - rtl8192_setBBreg(dev, - rOFDM0_XCTxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[p->rfc_txpowertrackingindex_real]); + rtl92e_set_bb_reg(dev, + rOFDM0_XCTxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[p->rfc_txpowertrackingindex_real]); } } else { - rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[4]); - rtl8192_setBBreg(dev, - rOFDM0_XCTxIQImbalance, - bMaskDWord, dm_tx_bb_gain[4]); + rtl92e_set_bb_reg(dev, rOFDM0_XATxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[4]); + rtl92e_set_bb_reg(dev, + rOFDM0_XCTxIQImbalance, + bMaskDWord, dm_tx_bb_gain[4]); } } else { if (p->rfa_txpowertrackingindex > 0) { p->rfa_txpowertrackingindex--; if (p->rfa_txpowertrackingindex_real > 4) { p->rfa_txpowertrackingindex_real--; - rtl8192_setBBreg(dev, - rOFDM0_XATxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[p->rfa_txpowertrackingindex_real]); + rtl92e_set_bb_reg(dev, + rOFDM0_XATxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[p->rfa_txpowertrackingindex_real]); } } else { - rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, - bMaskDWord, dm_tx_bb_gain[4]); + rtl92e_set_bb_reg(dev, rOFDM0_XATxIQImbalance, + bMaskDWord, dm_tx_bb_gain[4]); } } } @@ -608,36 +608,33 @@ static void dm_tx_update_tssi_strong_signal(struct net_device *dev, u8 RF_Type) (p->rfc_txpowertrackingindex < TxBBGainTableLength - 1)) { p->rfa_txpowertrackingindex++; p->rfa_txpowertrackingindex_real++; - rtl8192_setBBreg(dev, - rOFDM0_XATxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[p->rfa_txpowertrackingindex_real]); + rtl92e_set_bb_reg(dev, rOFDM0_XATxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[p->rfa_txpowertrackingindex_real]); p->rfc_txpowertrackingindex++; p->rfc_txpowertrackingindex_real++; - rtl8192_setBBreg(dev, - rOFDM0_XCTxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[p->rfc_txpowertrackingindex_real]); + rtl92e_set_bb_reg(dev, rOFDM0_XCTxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[p->rfc_txpowertrackingindex_real]); } else { - rtl8192_setBBreg(dev, - rOFDM0_XATxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[TxBBGainTableLength - 1]); - rtl8192_setBBreg(dev, rOFDM0_XCTxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[TxBBGainTableLength - 1]); + rtl92e_set_bb_reg(dev, rOFDM0_XATxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[TxBBGainTableLength - 1]); + rtl92e_set_bb_reg(dev, rOFDM0_XCTxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[TxBBGainTableLength - 1]); } } else { if (p->rfa_txpowertrackingindex < (TxBBGainTableLength - 1)) { p->rfa_txpowertrackingindex++; p->rfa_txpowertrackingindex_real++; - rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[p->rfa_txpowertrackingindex_real]); + rtl92e_set_bb_reg(dev, rOFDM0_XATxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[p->rfa_txpowertrackingindex_real]); } else { - rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, - bMaskDWord, - dm_tx_bb_gain[TxBBGainTableLength - 1]); + rtl92e_set_bb_reg(dev, rOFDM0_XATxIQImbalance, + bMaskDWord, + dm_tx_bb_gain[TxBBGainTableLength - 1]); } } } @@ -656,8 +653,8 @@ static void dm_TXPowerTrackingCallback_TSSI(struct net_device *dev) u32 delta = 0; RT_TRACE(COMP_POWER_TRACKING, "%s()\n", __func__); - write_nic_byte(dev, Pw_Track_Flag, 0); - write_nic_byte(dev, FW_Busy_Flag, 0); + rtl92e_writeb(dev, Pw_Track_Flag, 0); + rtl92e_writeb(dev, FW_Busy_Flag, 0); priv->rtllib->bdynamic_txpower_enable = false; bHighpowerstate = priv->bDynamicTxHighPower; @@ -674,12 +671,11 @@ static void dm_TXPowerTrackingCallback_TSSI(struct net_device *dev) tx_cmd.Op = TXCMD_SET_TX_PWR_TRACKING; tx_cmd.Length = 4; tx_cmd.Value = Value; - cmpk_message_handle_tx(dev, (u8 *)&tx_cmd, - DESC_PACKET_TYPE_INIT, - sizeof(struct dcmd_txcmd)); + rtl92e_send_cmd_pkt(dev, (u8 *)&tx_cmd, DESC_PACKET_TYPE_INIT, + sizeof(struct dcmd_txcmd)); mdelay(1); for (i = 0; i <= 30; i++) { - Pwr_Flag = read_nic_byte(dev, Pw_Track_Flag); + Pwr_Flag = rtl92e_readb(dev, Pw_Track_Flag); if (Pwr_Flag == 0) { mdelay(1); @@ -687,35 +683,35 @@ static void dm_TXPowerTrackingCallback_TSSI(struct net_device *dev) if (priv->bResetInProgress) { RT_TRACE(COMP_POWER_TRACKING, "we are in silent reset progress, so return\n"); - write_nic_byte(dev, Pw_Track_Flag, 0); - write_nic_byte(dev, FW_Busy_Flag, 0); + rtl92e_writeb(dev, Pw_Track_Flag, 0); + rtl92e_writeb(dev, FW_Busy_Flag, 0); return; } if (priv->rtllib->eRFPowerState != eRfOn) { RT_TRACE(COMP_POWER_TRACKING, "we are in power save, so return\n"); - write_nic_byte(dev, Pw_Track_Flag, 0); - write_nic_byte(dev, FW_Busy_Flag, 0); + rtl92e_writeb(dev, Pw_Track_Flag, 0); + rtl92e_writeb(dev, FW_Busy_Flag, 0); return; } continue; } - Avg_TSSI_Meas = read_nic_word(dev, Tssi_Mea_Value); + Avg_TSSI_Meas = rtl92e_readw(dev, Tssi_Mea_Value); if (Avg_TSSI_Meas == 0) { - write_nic_byte(dev, Pw_Track_Flag, 0); - write_nic_byte(dev, FW_Busy_Flag, 0); + rtl92e_writeb(dev, Pw_Track_Flag, 0); + rtl92e_writeb(dev, FW_Busy_Flag, 0); return; } for (k = 0; k < 5; k++) { if (k != 4) - tmp_report[k] = read_nic_byte(dev, + tmp_report[k] = rtl92e_readb(dev, Tssi_Report_Value1+k); else - tmp_report[k] = read_nic_byte(dev, + tmp_report[k] = rtl92e_readb(dev, Tssi_Report_Value2); RT_TRACE(COMP_POWER_TRACKING, @@ -729,7 +725,7 @@ static void dm_TXPowerTrackingCallback_TSSI(struct net_device *dev) } if (viviflag) { - write_nic_byte(dev, Pw_Track_Flag, 0); + rtl92e_writeb(dev, Pw_Track_Flag, 0); viviflag = false; RT_TRACE(COMP_POWER_TRACKING, "we filted this data\n"); @@ -756,8 +752,8 @@ static void dm_TXPowerTrackingCallback_TSSI(struct net_device *dev) if (delta <= E_FOR_TX_POWER_TRACK) { priv->rtllib->bdynamic_txpower_enable = true; - write_nic_byte(dev, Pw_Track_Flag, 0); - write_nic_byte(dev, FW_Busy_Flag, 0); + rtl92e_writeb(dev, Pw_Track_Flag, 0); + rtl92e_writeb(dev, FW_Busy_Flag, 0); RT_TRACE(COMP_POWER_TRACKING, "tx power track is done\n"); RT_TRACE(COMP_POWER_TRACKING, @@ -806,12 +802,12 @@ static void dm_TXPowerTrackingCallback_TSSI(struct net_device *dev) if (priv->rtllib->current_network.channel == 14 && !priv->bcck_in_ch14) { priv->bcck_in_ch14 = true; - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } else if (priv->rtllib->current_network.channel != 14 && priv->bcck_in_ch14) { priv->bcck_in_ch14 = false; - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } else - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); } RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex = %d\n", @@ -829,23 +825,23 @@ static void dm_TXPowerTrackingCallback_TSSI(struct net_device *dev) if (priv->CCKPresentAttentuation_difference <= -12 || priv->CCKPresentAttentuation_difference >= 24) { priv->rtllib->bdynamic_txpower_enable = true; - write_nic_byte(dev, Pw_Track_Flag, 0); - write_nic_byte(dev, FW_Busy_Flag, 0); + rtl92e_writeb(dev, Pw_Track_Flag, 0); + rtl92e_writeb(dev, FW_Busy_Flag, 0); RT_TRACE(COMP_POWER_TRACKING, "tx power track--->limited\n"); return; } - write_nic_byte(dev, Pw_Track_Flag, 0); + rtl92e_writeb(dev, Pw_Track_Flag, 0); Avg_TSSI_Meas_from_driver = 0; for (k = 0; k < 5; k++) tmp_report[k] = 0; break; } - write_nic_byte(dev, FW_Busy_Flag, 0); + rtl92e_writeb(dev, FW_Busy_Flag, 0); } priv->rtllib->bdynamic_txpower_enable = true; - write_nic_byte(dev, Pw_Track_Flag, 0); + rtl92e_writeb(dev, Pw_Track_Flag, 0); } static void dm_TXPowerTrackingCallback_ThermalMeter(struct net_device *dev) @@ -857,8 +853,8 @@ static void dm_TXPowerTrackingCallback_ThermalMeter(struct net_device *dev) int i = 0, CCKSwingNeedUpdate = 0; if (!priv->btxpower_trackingInit) { - tmpRegA = rtl8192_QueryBBReg(dev, rOFDM0_XATxIQImbalance, - bMaskDWord); + tmpRegA = rtl92e_get_bb_reg(dev, rOFDM0_XATxIQImbalance, + bMaskDWord); for (i = 0; i < OFDM_Table_Length; i++) { if (tmpRegA == OFDMSwingTable[i]) { priv->OFDM_index[0] = (u8)i; @@ -869,7 +865,7 @@ static void dm_TXPowerTrackingCallback_ThermalMeter(struct net_device *dev) } } - TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2); + TempCCk = rtl92e_get_bb_reg(dev, rCCK0_TxFilter1, bMaskByte2); for (i = 0; i < CCK_Table_length; i++) { if (TempCCk == (u32)CCKSwingTable_Ch1_Ch13[i][0]) { priv->CCK_index = (u8) i; @@ -884,7 +880,7 @@ static void dm_TXPowerTrackingCallback_ThermalMeter(struct net_device *dev) return; } - tmpRegA = rtl8192_phy_QueryRFReg(dev, RF90_PATH_A, 0x12, 0x078); + tmpRegA = rtl92e_get_rf_reg(dev, RF90_PATH_A, 0x12, 0x078); RT_TRACE(COMP_POWER_TRACKING, "Readback ThermalMeterA = %d\n", tmpRegA); if (tmpRegA < 3 || tmpRegA > 13) return; @@ -939,11 +935,11 @@ static void dm_TXPowerTrackingCallback_ThermalMeter(struct net_device *dev) } if (CCKSwingNeedUpdate) - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); if (priv->OFDM_index[0] != tmpOFDMindex) { priv->OFDM_index[0] = tmpOFDMindex; - rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, - OFDMSwingTable[priv->OFDM_index[0]]); + rtl92e_set_bb_reg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, + OFDMSwingTable[priv->OFDM_index[0]]); RT_TRACE(COMP_POWER_TRACKING, "Update OFDMSwing[%d] = 0x%x\n", priv->OFDM_index[0], OFDMSwingTable[priv->OFDM_index[0]]); @@ -951,7 +947,7 @@ static void dm_TXPowerTrackingCallback_ThermalMeter(struct net_device *dev) priv->txpower_count = 0; } -void dm_txpower_trackingcallback(void *data) +void rtl92e_dm_txpower_tracking_wq(void *data) { struct r8192_priv *priv = container_of_dwork_rsl(data, struct r8192_priv, txpower_tracking_wq); @@ -989,7 +985,7 @@ static void dm_InitializeTXPowerTracking_ThermalMeter(struct net_device *dev) priv->btxpower_tracking); } -void dm_initialize_txpower_tracking(struct net_device *dev) +void rtl92e_dm_init_txpower_tracking(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -1005,7 +1001,7 @@ static void dm_CheckTXPowerTracking_TSSI(struct net_device *dev) static u32 tx_power_track_counter; RT_TRACE(COMP_POWER_TRACKING, "%s()\n", __func__); - if (read_nic_byte(dev, 0x11e) == 1) + if (rtl92e_readb(dev, 0x11e) == 1) return; if (!priv->btxpower_tracking) return; @@ -1039,10 +1035,10 @@ static void dm_CheckTXPowerTracking_ThermalMeter(struct net_device *dev) if (!TM_Trigger) { { - rtl8192_phy_SetRFReg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4d); - rtl8192_phy_SetRFReg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4f); - rtl8192_phy_SetRFReg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4d); - rtl8192_phy_SetRFReg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4f); + rtl92e_set_rf_reg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4d); + rtl92e_set_rf_reg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4f); + rtl92e_set_rf_reg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4d); + rtl92e_set_rf_reg(dev, RF90_PATH_A, 0x02, bMask12Bits, 0x4f); } TM_Trigger = 1; return; @@ -1074,30 +1070,30 @@ static void dm_CCKTxPowerAdjust_TSSI(struct net_device *dev, bool bInCH14) TempVal = (u32)(dm_cck_tx_bb_gain[attenuation][0] + (dm_cck_tx_bb_gain[attenuation][1] << 8)); - rtl8192_setBBreg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal); TempVal = (u32)((dm_cck_tx_bb_gain[attenuation][2]) + (dm_cck_tx_bb_gain[attenuation][3] << 8) + (dm_cck_tx_bb_gain[attenuation][4] << 16)+ (dm_cck_tx_bb_gain[attenuation][5] << 24)); - rtl8192_setBBreg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal); TempVal = (u32)(dm_cck_tx_bb_gain[attenuation][6] + (dm_cck_tx_bb_gain[attenuation][7] << 8)); - rtl8192_setBBreg(dev, rCCK0_DebugPort, bMaskLWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_DebugPort, bMaskLWord, TempVal); } else { TempVal = (u32)((dm_cck_tx_bb_gain_ch14[attenuation][0]) + (dm_cck_tx_bb_gain_ch14[attenuation][1] << 8)); - rtl8192_setBBreg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal); TempVal = (u32)((dm_cck_tx_bb_gain_ch14[attenuation][2]) + (dm_cck_tx_bb_gain_ch14[attenuation][3] << 8) + (dm_cck_tx_bb_gain_ch14[attenuation][4] << 16)+ (dm_cck_tx_bb_gain_ch14[attenuation][5] << 24)); - rtl8192_setBBreg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal); TempVal = (u32)((dm_cck_tx_bb_gain_ch14[attenuation][6]) + (dm_cck_tx_bb_gain_ch14[attenuation][7] << 8)); - rtl8192_setBBreg(dev, rCCK0_DebugPort, bMaskLWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_DebugPort, bMaskLWord, TempVal); } } @@ -1111,7 +1107,7 @@ static void dm_CCKTxPowerAdjust_ThermalMeter(struct net_device *dev, if (!bInCH14) { TempVal = CCKSwingTable_Ch1_Ch13[priv->CCK_index][0] + (CCKSwingTable_Ch1_Ch13[priv->CCK_index][1] << 8); - rtl8192_setBBreg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal); RT_TRACE(COMP_POWER_TRACKING, "CCK not chnl 14, reg 0x%x = 0x%x\n", rCCK0_TxFilter1, TempVal); @@ -1119,14 +1115,14 @@ static void dm_CCKTxPowerAdjust_ThermalMeter(struct net_device *dev, (CCKSwingTable_Ch1_Ch13[priv->CCK_index][3] << 8) + (CCKSwingTable_Ch1_Ch13[priv->CCK_index][4] << 16)+ (CCKSwingTable_Ch1_Ch13[priv->CCK_index][5] << 24); - rtl8192_setBBreg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal); RT_TRACE(COMP_POWER_TRACKING, "CCK not chnl 14, reg 0x%x = 0x%x\n", rCCK0_TxFilter2, TempVal); TempVal = CCKSwingTable_Ch1_Ch13[priv->CCK_index][6] + (CCKSwingTable_Ch1_Ch13[priv->CCK_index][7] << 8); - rtl8192_setBBreg(dev, rCCK0_DebugPort, bMaskLWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_DebugPort, bMaskLWord, TempVal); RT_TRACE(COMP_POWER_TRACKING, "CCK not chnl 14, reg 0x%x = 0x%x\n", rCCK0_DebugPort, TempVal); @@ -1134,26 +1130,26 @@ static void dm_CCKTxPowerAdjust_ThermalMeter(struct net_device *dev, TempVal = CCKSwingTable_Ch14[priv->CCK_index][0] + (CCKSwingTable_Ch14[priv->CCK_index][1] << 8); - rtl8192_setBBreg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal); RT_TRACE(COMP_POWER_TRACKING, "CCK chnl 14, reg 0x%x = 0x%x\n", rCCK0_TxFilter1, TempVal); TempVal = CCKSwingTable_Ch14[priv->CCK_index][2] + (CCKSwingTable_Ch14[priv->CCK_index][3] << 8) + (CCKSwingTable_Ch14[priv->CCK_index][4] << 16)+ (CCKSwingTable_Ch14[priv->CCK_index][5] << 24); - rtl8192_setBBreg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal); RT_TRACE(COMP_POWER_TRACKING, "CCK chnl 14, reg 0x%x = 0x%x\n", rCCK0_TxFilter2, TempVal); TempVal = CCKSwingTable_Ch14[priv->CCK_index][6] + (CCKSwingTable_Ch14[priv->CCK_index][7]<<8); - rtl8192_setBBreg(dev, rCCK0_DebugPort, bMaskLWord, TempVal); + rtl92e_set_bb_reg(dev, rCCK0_DebugPort, bMaskLWord, TempVal); RT_TRACE(COMP_POWER_TRACKING, "CCK chnl 14, reg 0x%x = 0x%x\n", rCCK0_DebugPort, TempVal); } } -void dm_cck_txpower_adjust(struct net_device *dev, bool binch14) +void rtl92e_dm_cck_txpower_adjust(struct net_device *dev, bool binch14) { struct r8192_priv *priv = rtllib_priv(dev); @@ -1168,8 +1164,8 @@ static void dm_txpower_reset_recovery(struct net_device *dev) struct r8192_priv *priv = rtllib_priv(dev); RT_TRACE(COMP_POWER_TRACKING, "Start Reset Recovery ==>\n"); - rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, - dm_tx_bb_gain[priv->rfa_txpowertrackingindex]); + rtl92e_set_bb_reg(dev, rOFDM0_XATxIQImbalance, bMaskDWord, + dm_tx_bb_gain[priv->rfa_txpowertrackingindex]); RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: Fill in 0xc80 is %08x\n", dm_tx_bb_gain[priv->rfa_txpowertrackingindex]); RT_TRACE(COMP_POWER_TRACKING, @@ -1181,10 +1177,10 @@ static void dm_txpower_reset_recovery(struct net_device *dev) RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: CCK Attenuation is %d dB\n", priv->CCKPresentAttentuation); - dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); + rtl92e_dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); - rtl8192_setBBreg(dev, rOFDM0_XCTxIQImbalance, bMaskDWord, - dm_tx_bb_gain[priv->rfc_txpowertrackingindex]); + rtl92e_set_bb_reg(dev, rOFDM0_XCTxIQImbalance, bMaskDWord, + dm_tx_bb_gain[priv->rfc_txpowertrackingindex]); RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: Fill in 0xc90 is %08x\n", dm_tx_bb_gain[priv->rfc_txpowertrackingindex]); RT_TRACE(COMP_POWER_TRACKING, @@ -1195,7 +1191,7 @@ static void dm_txpower_reset_recovery(struct net_device *dev) dm_tx_bb_gain_idx_to_amplify(priv->rfc_txpowertrackingindex)); } -void dm_restore_dynamic_mechanism_state(struct net_device *dev) +void rtl92e_dm_restore_state(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); u32 reg_ratr = priv->rate_adaptive.last_ratr; @@ -1203,7 +1199,7 @@ void dm_restore_dynamic_mechanism_state(struct net_device *dev) if (!priv->up) { RT_TRACE(COMP_RATE, - "<---- dm_restore_dynamic_mechanism_state(): driver is going to unload\n"); + "<---- rtl92e_dm_restore_state(): driver is going to unload\n"); return; } @@ -1215,8 +1211,8 @@ void dm_restore_dynamic_mechanism_state(struct net_device *dev) ratr_value = reg_ratr; if (priv->rf_type == RF_1T2R) ratr_value &= ~(RATE_ALL_OFDM_2SS); - write_nic_dword(dev, RATR0, ratr_value); - write_nic_byte(dev, UFWP, 1); + rtl92e_writel(dev, RATR0, ratr_value); + rtl92e_writeb(dev, UFWP, 1); if (priv->btxpower_trackingInit && priv->btxpower_tracking) dm_txpower_reset_recovery(dev); @@ -1232,18 +1228,18 @@ static void dm_bb_initialgain_restore(struct net_device *dev) if (dm_digtable.dig_algorithm == DIG_ALGO_BY_RSSI) return; - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8); - rtl8192_setBBreg(dev, rOFDM0_XAAGCCore1, bit_mask, - (u32)priv->initgain_backup.xaagccore1); - rtl8192_setBBreg(dev, rOFDM0_XBAGCCore1, bit_mask, - (u32)priv->initgain_backup.xbagccore1); - rtl8192_setBBreg(dev, rOFDM0_XCAGCCore1, bit_mask, - (u32)priv->initgain_backup.xcagccore1); - rtl8192_setBBreg(dev, rOFDM0_XDAGCCore1, bit_mask, - (u32)priv->initgain_backup.xdagccore1); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8); + rtl92e_set_bb_reg(dev, rOFDM0_XAAGCCore1, bit_mask, + (u32)priv->initgain_backup.xaagccore1); + rtl92e_set_bb_reg(dev, rOFDM0_XBAGCCore1, bit_mask, + (u32)priv->initgain_backup.xbagccore1); + rtl92e_set_bb_reg(dev, rOFDM0_XCAGCCore1, bit_mask, + (u32)priv->initgain_backup.xcagccore1); + rtl92e_set_bb_reg(dev, rOFDM0_XDAGCCore1, bit_mask, + (u32)priv->initgain_backup.xdagccore1); bit_mask = bMaskByte2; - rtl8192_setBBreg(dev, rCCK0_CCA, bit_mask, - (u32)priv->initgain_backup.cca); + rtl92e_set_bb_reg(dev, rCCK0_CCA, bit_mask, + (u32)priv->initgain_backup.cca); RT_TRACE(COMP_DIG, "dm_BBInitialGainRestore 0xc50 is %x\n", priv->initgain_backup.xaagccore1); @@ -1255,12 +1251,12 @@ static void dm_bb_initialgain_restore(struct net_device *dev) priv->initgain_backup.xdagccore1); RT_TRACE(COMP_DIG, "dm_BBInitialGainRestore 0xa0a is %x\n", priv->initgain_backup.cca); - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x1); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x1); } -void dm_backup_dynamic_mechanism_state(struct net_device *dev) +void rtl92e_dm_backup_state(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -1279,13 +1275,13 @@ static void dm_bb_initialgain_backup(struct net_device *dev) if (dm_digtable.dig_algorithm == DIG_ALGO_BY_RSSI) return; - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8); - priv->initgain_backup.xaagccore1 = (u8)rtl8192_QueryBBReg(dev, rOFDM0_XAAGCCore1, bit_mask); - priv->initgain_backup.xbagccore1 = (u8)rtl8192_QueryBBReg(dev, rOFDM0_XBAGCCore1, bit_mask); - priv->initgain_backup.xcagccore1 = (u8)rtl8192_QueryBBReg(dev, rOFDM0_XCAGCCore1, bit_mask); - priv->initgain_backup.xdagccore1 = (u8)rtl8192_QueryBBReg(dev, rOFDM0_XDAGCCore1, bit_mask); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8); + priv->initgain_backup.xaagccore1 = (u8)rtl92e_get_bb_reg(dev, rOFDM0_XAAGCCore1, bit_mask); + priv->initgain_backup.xbagccore1 = (u8)rtl92e_get_bb_reg(dev, rOFDM0_XBAGCCore1, bit_mask); + priv->initgain_backup.xcagccore1 = (u8)rtl92e_get_bb_reg(dev, rOFDM0_XCAGCCore1, bit_mask); + priv->initgain_backup.xdagccore1 = (u8)rtl92e_get_bb_reg(dev, rOFDM0_XDAGCCore1, bit_mask); bit_mask = bMaskByte2; - priv->initgain_backup.cca = (u8)rtl8192_QueryBBReg(dev, rCCK0_CCA, bit_mask); + priv->initgain_backup.cca = (u8)rtl92e_get_bb_reg(dev, rCCK0_CCA, bit_mask); RT_TRACE(COMP_DIG, "BBInitialGainBackup 0xc50 is %x\n", priv->initgain_backup.xaagccore1); @@ -1376,7 +1372,7 @@ static void dm_ctrl_initgain_byrssi_by_driverrssi( fw_dig = 0; if (fw_dig <= 3) { for (i = 0; i < 3; i++) - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8); fw_dig++; dm_digtable.dig_state = DM_STA_DIG_OFF; } @@ -1410,7 +1406,7 @@ static void dm_ctrl_initgain_byrssi_by_fwfalse_alarm( if (dm_digtable.dig_algorithm_switch) { dm_digtable.dig_state = DM_STA_DIG_MAX; for (i = 0; i < 3; i++) - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x1); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x1); dm_digtable.dig_algorithm_switch = 0; } @@ -1429,19 +1425,19 @@ static void dm_ctrl_initgain_byrssi_by_fwfalse_alarm( dm_digtable.dig_highpwr_state = DM_STA_DIG_MAX; dm_digtable.dig_state = DM_STA_DIG_OFF; - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x8); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x8); - write_nic_byte(dev, rOFDM0_XAAGCCore1, 0x17); - write_nic_byte(dev, rOFDM0_XBAGCCore1, 0x17); - write_nic_byte(dev, rOFDM0_XCAGCCore1, 0x17); - write_nic_byte(dev, rOFDM0_XDAGCCore1, 0x17); + rtl92e_writeb(dev, rOFDM0_XAAGCCore1, 0x17); + rtl92e_writeb(dev, rOFDM0_XBAGCCore1, 0x17); + rtl92e_writeb(dev, rOFDM0_XCAGCCore1, 0x17); + rtl92e_writeb(dev, rOFDM0_XDAGCCore1, 0x17); if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) - write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x00); + rtl92e_writeb(dev, (rOFDM0_XATxAFE+3), 0x00); else - write_nic_byte(dev, rOFDM0_RxDetector1, 0x42); + rtl92e_writeb(dev, rOFDM0_RxDetector1, 0x42); - write_nic_byte(dev, 0xa0a, 0x08); + rtl92e_writeb(dev, 0xa0a, 0x08); return; } @@ -1462,25 +1458,25 @@ static void dm_ctrl_initgain_byrssi_by_fwfalse_alarm( dm_digtable.dig_state = DM_STA_DIG_ON; if (reset_flag == 1) { - write_nic_byte(dev, rOFDM0_XAAGCCore1, 0x2c); - write_nic_byte(dev, rOFDM0_XBAGCCore1, 0x2c); - write_nic_byte(dev, rOFDM0_XCAGCCore1, 0x2c); - write_nic_byte(dev, rOFDM0_XDAGCCore1, 0x2c); + rtl92e_writeb(dev, rOFDM0_XAAGCCore1, 0x2c); + rtl92e_writeb(dev, rOFDM0_XBAGCCore1, 0x2c); + rtl92e_writeb(dev, rOFDM0_XCAGCCore1, 0x2c); + rtl92e_writeb(dev, rOFDM0_XDAGCCore1, 0x2c); } else { - write_nic_byte(dev, rOFDM0_XAAGCCore1, 0x20); - write_nic_byte(dev, rOFDM0_XBAGCCore1, 0x20); - write_nic_byte(dev, rOFDM0_XCAGCCore1, 0x20); - write_nic_byte(dev, rOFDM0_XDAGCCore1, 0x20); + rtl92e_writeb(dev, rOFDM0_XAAGCCore1, 0x20); + rtl92e_writeb(dev, rOFDM0_XBAGCCore1, 0x20); + rtl92e_writeb(dev, rOFDM0_XCAGCCore1, 0x20); + rtl92e_writeb(dev, rOFDM0_XDAGCCore1, 0x20); } if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) - write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x20); + rtl92e_writeb(dev, (rOFDM0_XATxAFE+3), 0x20); else - write_nic_byte(dev, rOFDM0_RxDetector1, 0x44); + rtl92e_writeb(dev, rOFDM0_RxDetector1, 0x44); - write_nic_byte(dev, 0xa0a, 0xcd); + rtl92e_writeb(dev, 0xa0a, 0xcd); - rtl8192_setBBreg(dev, UFWP, bMaskByte1, 0x1); + rtl92e_set_bb_reg(dev, UFWP, bMaskByte1, 0x1); } dm_ctrl_initgain_byrssi_highpwr(dev); } @@ -1505,9 +1501,9 @@ static void dm_ctrl_initgain_byrssi_highpwr(struct net_device *dev) dm_digtable.dig_highpwr_state = DM_STA_DIG_ON; if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) - write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x10); + rtl92e_writeb(dev, (rOFDM0_XATxAFE+3), 0x10); else - write_nic_byte(dev, rOFDM0_RxDetector1, 0x43); + rtl92e_writeb(dev, rOFDM0_RxDetector1, 0x43); } else { if (dm_digtable.dig_highpwr_state == DM_STA_DIG_OFF && (priv->reset_count == reset_cnt_highpwr)) @@ -1519,9 +1515,9 @@ static void dm_ctrl_initgain_byrssi_highpwr(struct net_device *dev) (priv->undecorated_smoothed_pwdb >= dm_digtable.rssi_high_thresh)) { if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) - write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x20); + rtl92e_writeb(dev, (rOFDM0_XATxAFE+3), 0x20); else - write_nic_byte(dev, rOFDM0_RxDetector1, 0x44); + rtl92e_writeb(dev, rOFDM0_RxDetector1, 0x44); } } reset_cnt_highpwr = priv->reset_count; @@ -1568,16 +1564,16 @@ static void dm_initial_gain(struct net_device *dev) reset_cnt = priv->reset_count; } - if (dm_digtable.pre_ig_value != read_nic_byte(dev, rOFDM0_XAAGCCore1)) + if (dm_digtable.pre_ig_value != rtl92e_readb(dev, rOFDM0_XAAGCCore1)) force_write = 1; if ((dm_digtable.pre_ig_value != dm_digtable.cur_ig_value) || !initialized || force_write) { initial_gain = (u8)dm_digtable.cur_ig_value; - write_nic_byte(dev, rOFDM0_XAAGCCore1, initial_gain); - write_nic_byte(dev, rOFDM0_XBAGCCore1, initial_gain); - write_nic_byte(dev, rOFDM0_XCAGCCore1, initial_gain); - write_nic_byte(dev, rOFDM0_XDAGCCore1, initial_gain); + rtl92e_writeb(dev, rOFDM0_XAAGCCore1, initial_gain); + rtl92e_writeb(dev, rOFDM0_XBAGCCore1, initial_gain); + rtl92e_writeb(dev, rOFDM0_XCAGCCore1, initial_gain); + rtl92e_writeb(dev, rOFDM0_XDAGCCore1, initial_gain); dm_digtable.pre_ig_value = dm_digtable.cur_ig_value; initialized = 1; force_write = 0; @@ -1630,20 +1626,20 @@ static void dm_pd_th(struct net_device *dev) (initialized <= 3) || force_write) { if (dm_digtable.curpd_thstate == DIG_PD_AT_LOW_POWER) { if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) - write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x00); + rtl92e_writeb(dev, (rOFDM0_XATxAFE+3), 0x00); else - write_nic_byte(dev, rOFDM0_RxDetector1, 0x42); + rtl92e_writeb(dev, rOFDM0_RxDetector1, 0x42); } else if (dm_digtable.curpd_thstate == DIG_PD_AT_NORMAL_POWER) { if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) - write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x20); + rtl92e_writeb(dev, (rOFDM0_XATxAFE+3), 0x20); else - write_nic_byte(dev, rOFDM0_RxDetector1, 0x44); + rtl92e_writeb(dev, rOFDM0_RxDetector1, 0x44); } else if (dm_digtable.curpd_thstate == DIG_PD_AT_HIGH_POWER) { if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) - write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x10); + rtl92e_writeb(dev, (rOFDM0_XATxAFE+3), 0x10); else - write_nic_byte(dev, rOFDM0_RxDetector1, 0x43); + rtl92e_writeb(dev, rOFDM0_RxDetector1, 0x43); } dm_digtable.prepd_thstate = dm_digtable.curpd_thstate; if (initialized <= 3) @@ -1687,16 +1683,16 @@ static void dm_cs_ratio(struct net_device *dev) if ((dm_digtable.precs_ratio_state != dm_digtable.curcs_ratio_state) || !initialized || force_write) { if (dm_digtable.curcs_ratio_state == DIG_CS_RATIO_LOWER) - write_nic_byte(dev, 0xa0a, 0x08); + rtl92e_writeb(dev, 0xa0a, 0x08); else if (dm_digtable.curcs_ratio_state == DIG_CS_RATIO_HIGHER) - write_nic_byte(dev, 0xa0a, 0xcd); + rtl92e_writeb(dev, 0xa0a, 0xcd); dm_digtable.precs_ratio_state = dm_digtable.curcs_ratio_state; initialized = 1; force_write = 0; } } -void dm_init_edca_turbo(struct net_device *dev) +void rtl92e_dm_init_edca_turbo(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); @@ -1745,21 +1741,19 @@ static void dm_check_edca_turbo(struct net_device *dev) if (curTxOkCnt > 4*curRxOkCnt) { if (priv->bis_cur_rdlstate || !priv->bcurrent_turbo_EDCA) { - write_nic_dword(dev, EDCAPARA_BE, - edca_setting_UL[pHTInfo->IOTPeer]); + rtl92e_writel(dev, EDCAPARA_BE, + edca_setting_UL[pHTInfo->IOTPeer]); priv->bis_cur_rdlstate = false; } } else { if (!priv->bis_cur_rdlstate || !priv->bcurrent_turbo_EDCA) { if (priv->rtllib->mode == WIRELESS_MODE_G) - write_nic_dword(dev, - EDCAPARA_BE, - edca_setting_DL_GMode[pHTInfo->IOTPeer]); + rtl92e_writel(dev, EDCAPARA_BE, + edca_setting_DL_GMode[pHTInfo->IOTPeer]); else - write_nic_dword(dev, - EDCAPARA_BE, - edca_setting_DL[pHTInfo->IOTPeer]); + rtl92e_writel(dev, EDCAPARA_BE, + edca_setting_DL[pHTInfo->IOTPeer]); priv->bis_cur_rdlstate = true; } } @@ -1769,20 +1763,18 @@ static void dm_check_edca_turbo(struct net_device *dev) if (!priv->bis_cur_rdlstate || !priv->bcurrent_turbo_EDCA) { if (priv->rtllib->mode == WIRELESS_MODE_G) - write_nic_dword(dev, - EDCAPARA_BE, - edca_setting_DL_GMode[pHTInfo->IOTPeer]); + rtl92e_writel(dev, EDCAPARA_BE, + edca_setting_DL_GMode[pHTInfo->IOTPeer]); else - write_nic_dword(dev, - EDCAPARA_BE, - edca_setting_DL[pHTInfo->IOTPeer]); + rtl92e_writel(dev, EDCAPARA_BE, + edca_setting_DL[pHTInfo->IOTPeer]); priv->bis_cur_rdlstate = true; } } else { if (priv->bis_cur_rdlstate || !priv->bcurrent_turbo_EDCA) { - write_nic_dword(dev, EDCAPARA_BE, - edca_setting_UL[pHTInfo->IOTPeer]); + rtl92e_writel(dev, EDCAPARA_BE, + edca_setting_UL[pHTInfo->IOTPeer]); priv->bis_cur_rdlstate = false; } @@ -1854,7 +1846,7 @@ static void dm_check_pbc_gpio(struct net_device *dev) { } -void dm_CheckRfCtrlGPIO(void *data) +static void dm_CheckRfCtrlGPIO(void *data) { struct r8192_priv *priv = container_of_dwork_rsl(data, struct r8192_priv, gpio_change_rf_wq); @@ -1877,7 +1869,7 @@ void dm_CheckRfCtrlGPIO(void *data) return; } - tmp1byte = read_nic_byte(dev, GPI); + tmp1byte = rtl92e_readb(dev, GPI); eRfPowerStateToSet = (tmp1byte&BIT1) ? eRfOn : eRfOff; @@ -1896,8 +1888,7 @@ void dm_CheckRfCtrlGPIO(void *data) if (bActuallySet) { mdelay(1000); priv->bHwRfOffAction = 1; - MgntActSet_RF_State(dev, eRfPowerStateToSet, RF_CHANGE_BY_HW, - true); + rtl92e_set_rf_state(dev, eRfPowerStateToSet, RF_CHANGE_BY_HW); if (priv->bHwRadioOff) argv[1] = "RFOFF"; else @@ -1909,7 +1900,7 @@ void dm_CheckRfCtrlGPIO(void *data) } } -void dm_rf_pathcheck_workitemcallback(void *data) +void rtl92e_dm_rf_pathcheck_wq(void *data) { struct r8192_priv *priv = container_of_dwork_rsl(data, struct r8192_priv, @@ -1917,7 +1908,7 @@ void dm_rf_pathcheck_workitemcallback(void *data) struct net_device *dev = priv->rtllib->dev; u8 rfpath = 0, i; - rfpath = read_nic_byte(dev, 0xc04); + rfpath = rtl92e_readb(dev, 0xc04); for (i = 0; i < RF90_PATH_MAX; i++) { if (rfpath & (0x01<rtllib->mode == WIRELESS_MODE_B) DM_RxPathSelTable.cck_method = CCK_Rx_Version_2; @@ -2116,10 +2107,10 @@ static void dm_rxpath_sel_byrssi(struct net_device *dev) DM_RxPathSelTable.diff_TH) { DM_RxPathSelTable.rf_enable_rssi_th[min_rssi_index] = tmp_max_rssi+5; - rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, - 0x1<>i) & 0x1) { if (tmp_max_rssi >= DM_RxPathSelTable.rf_enable_rssi_th[i]) { - rtl8192_setBBreg(dev, - rOFDM0_TRxPathEnable, 0x1 << i, - 0x1); - rtl8192_setBBreg(dev, - rOFDM1_TRxPathEnable, - 0x1 << i, 0x1); + rtl92e_set_bb_reg(dev, + rOFDM0_TRxPathEnable, + 0x1 << i, 0x1); + rtl92e_set_bb_reg(dev, + rOFDM1_TRxPathEnable, + 0x1 << i, 0x1); DM_RxPathSelTable.rf_enable_rssi_th[i] = 100; disabled_rf_cnt--; @@ -2191,7 +2182,7 @@ static void dm_deInit_fsync(struct net_device *dev) del_timer_sync(&priv->fsync_timer); } -void dm_fsync_timer_callback(unsigned long data) +static void dm_fsync_timer_callback(unsigned long data) { struct net_device *dev = (struct net_device *)data; struct r8192_priv *priv = rtllib_priv((struct net_device *)data); @@ -2252,18 +2243,18 @@ void dm_fsync_timer_callback(unsigned long data) bDoubleTimeInterval = true; priv->bswitch_fsync = !priv->bswitch_fsync; if (priv->bswitch_fsync) { - write_nic_byte(dev, 0xC36, 0x1c); - write_nic_byte(dev, 0xC3e, 0x90); + rtl92e_writeb(dev, 0xC36, 0x1c); + rtl92e_writeb(dev, 0xC3e, 0x90); } else { - write_nic_byte(dev, 0xC36, 0x5c); - write_nic_byte(dev, 0xC3e, 0x96); + rtl92e_writeb(dev, 0xC36, 0x5c); + rtl92e_writeb(dev, 0xC3e, 0x96); } } else if (priv->undecorated_smoothed_pwdb <= priv->rtllib->fsync_rssi_threshold) { if (priv->bswitch_fsync) { priv->bswitch_fsync = false; - write_nic_byte(dev, 0xC36, 0x5c); - write_nic_byte(dev, 0xC3e, 0x96); + rtl92e_writeb(dev, 0xC36, 0x5c); + rtl92e_writeb(dev, 0xC3e, 0x96); } } if (bDoubleTimeInterval) { @@ -2283,11 +2274,11 @@ void dm_fsync_timer_callback(unsigned long data) } else { if (priv->bswitch_fsync) { priv->bswitch_fsync = false; - write_nic_byte(dev, 0xC36, 0x5c); - write_nic_byte(dev, 0xC3e, 0x96); + rtl92e_writeb(dev, 0xC36, 0x5c); + rtl92e_writeb(dev, 0xC3e, 0x96); } priv->ContinueDiffCount = 0; - write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c52cd); + rtl92e_writel(dev, rOFDM0_RxDetector2, 0x465c52cd); } RT_TRACE(COMP_HALDM, "ContinueDiffCount %d\n", priv->ContinueDiffCount); RT_TRACE(COMP_HALDM, @@ -2302,10 +2293,10 @@ static void dm_StartHWFsync(struct net_device *dev) struct r8192_priv *priv = rtllib_priv(dev); RT_TRACE(COMP_HALDM, "%s\n", __func__); - write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c12cf); + rtl92e_writel(dev, rOFDM0_RxDetector2, 0x465c12cf); priv->rtllib->SetHwRegHandler(dev, HW_VAR_RF_TIMING, (u8 *)(&rf_timing)); - write_nic_byte(dev, 0xc3b, 0x41); + rtl92e_writeb(dev, 0xc3b, 0x41); } static void dm_EndHWFsync(struct net_device *dev) @@ -2314,10 +2305,10 @@ static void dm_EndHWFsync(struct net_device *dev) struct r8192_priv *priv = rtllib_priv(dev); RT_TRACE(COMP_HALDM, "%s\n", __func__); - write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c52cd); + rtl92e_writel(dev, rOFDM0_RxDetector2, 0x465c52cd); priv->rtllib->SetHwRegHandler(dev, HW_VAR_RF_TIMING, (u8 *) (&rf_timing)); - write_nic_byte(dev, 0xc3b, 0x49); + rtl92e_writeb(dev, 0xc3b, 0x49); } static void dm_EndSWFsync(struct net_device *dev) @@ -2330,13 +2321,13 @@ static void dm_EndSWFsync(struct net_device *dev) if (priv->bswitch_fsync) { priv->bswitch_fsync = false; - write_nic_byte(dev, 0xC36, 0x5c); + rtl92e_writeb(dev, 0xC36, 0x5c); - write_nic_byte(dev, 0xC3e, 0x96); + rtl92e_writeb(dev, 0xC3e, 0x96); } priv->ContinueDiffCount = 0; - write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c52cd); + rtl92e_writel(dev, rOFDM0_RxDetector2, 0x465c52cd); } static void dm_StartSWFsync(struct net_device *dev) @@ -2371,11 +2362,11 @@ static void dm_StartSWFsync(struct net_device *dev) msecs_to_jiffies(priv->rtllib->fsync_time_interval); add_timer(&priv->fsync_timer); - write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c12cd); + rtl92e_writel(dev, rOFDM0_RxDetector2, 0x465c12cd); } -void dm_check_fsync(struct net_device *dev) +static void dm_check_fsync(struct net_device *dev) { #define RegC38_Default 0 #define RegC38_NonFsync_Other_AP 1 @@ -2431,7 +2422,7 @@ void dm_check_fsync(struct net_device *dev) } if (priv->framesyncMonitor) { if (reg_c38_State != RegC38_Fsync_AP_BCM) { - write_nic_byte(dev, rOFDM0_RxDetector3, 0x95); + rtl92e_writeb(dev, rOFDM0_RxDetector3, 0x95); reg_c38_State = RegC38_Fsync_AP_BCM; } @@ -2457,7 +2448,7 @@ void dm_check_fsync(struct net_device *dev) RegC38_TH) { if (reg_c38_State != RegC38_NonFsync_Other_AP) { - write_nic_byte(dev, + rtl92e_writeb(dev, rOFDM0_RxDetector3, 0x90); @@ -2467,7 +2458,7 @@ void dm_check_fsync(struct net_device *dev) } else if (priv->undecorated_smoothed_pwdb >= (RegC38_TH+5)) { if (reg_c38_State) { - write_nic_byte(dev, + rtl92e_writeb(dev, rOFDM0_RxDetector3, priv->framesync); reg_c38_State = RegC38_Default; @@ -2475,8 +2466,8 @@ void dm_check_fsync(struct net_device *dev) } } else { if (reg_c38_State) { - write_nic_byte(dev, rOFDM0_RxDetector3, - priv->framesync); + rtl92e_writeb(dev, rOFDM0_RxDetector3, + priv->framesync); reg_c38_State = RegC38_Default; } } @@ -2484,14 +2475,14 @@ void dm_check_fsync(struct net_device *dev) } if (priv->framesyncMonitor) { if (priv->reset_count != reset_cnt) { - write_nic_byte(dev, rOFDM0_RxDetector3, + rtl92e_writeb(dev, rOFDM0_RxDetector3, priv->framesync); reg_c38_State = RegC38_Default; reset_cnt = priv->reset_count; } } else { if (reg_c38_State) { - write_nic_byte(dev, rOFDM0_RxDetector3, + rtl92e_writeb(dev, rOFDM0_RxDetector3, priv->framesync); reg_c38_State = RegC38_Default; } @@ -2556,8 +2547,7 @@ static void dm_dynamic_txpower(struct net_device *dev) RT_TRACE(COMP_TXAGC, "SetTxPowerLevel8190() channel = %d\n", priv->rtllib->current_network.channel); - rtl8192_phy_setTxPower(dev, - priv->rtllib->current_network.channel); + rtl92e_set_tx_power(dev, priv->rtllib->current_network.channel); } priv->bLastDTPFlag_High = priv->bDynamicTxHighPower; priv->bLastDTPFlag_Low = priv->bDynamicTxLowPower; @@ -2569,13 +2559,13 @@ static void dm_check_txrateandretrycount(struct net_device *dev) struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_device *ieee = priv->rtllib; - ieee->softmac_stats.CurrentShowTxate = read_nic_byte(dev, + ieee->softmac_stats.CurrentShowTxate = rtl92e_readb(dev, Current_Tx_Rate_Reg); - ieee->softmac_stats.last_packet_rate = read_nic_byte(dev, + ieee->softmac_stats.last_packet_rate = rtl92e_readb(dev, Initial_Tx_Rate_Reg); - ieee->softmac_stats.txretrycount = read_nic_dword(dev, + ieee->softmac_stats.txretrycount = rtl92e_readl(dev, Tx_Retry_Count_Reg); } @@ -2583,5 +2573,5 @@ static void dm_send_rssi_tofw(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); - write_nic_byte(dev, DRIVER_RSSI, (u8)priv->undecorated_smoothed_pwdb); + rtl92e_writeb(dev, DRIVER_RSSI, (u8)priv->undecorated_smoothed_pwdb); } diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_dm.h b/drivers/staging/rtl8192e/rtl8192e/rtl_dm.h index b037451c3..097f0dc20 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_dm.h +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_dm.h @@ -27,26 +27,17 @@ #define DM_DIG_THRESH_HIGH 40 #define DM_DIG_THRESH_LOW 35 -#define DM_FALSEALARM_THRESH_LOW 40 -#define DM_FALSEALARM_THRESH_HIGH 1000 - #define DM_DIG_HIGH_PWR_THRESH_HIGH 75 #define DM_DIG_HIGH_PWR_THRESH_LOW 70 #define BW_AUTO_SWITCH_HIGH_LOW 25 #define BW_AUTO_SWITCH_LOW_HIGH 30 -#define DM_check_fsync_time_interval 500 - - #define DM_DIG_BACKOFF 12 #define DM_DIG_MAX 0x36 #define DM_DIG_MIN 0x1c #define DM_DIG_MIN_Netcore 0x12 -#define DM_DIG_BACKOFF_MAX 12 -#define DM_DIG_BACKOFF_MIN -4 - #define RxPathSelection_SS_TH_low 30 #define RxPathSelection_diff_TH 18 @@ -55,8 +46,6 @@ #define RateAdaptiveTH_Low_40M 10 #define VeryLowRSSI 15 -#define CTSToSelfTHVal 35 - #define WAIotTHVal 25 #define E_FOR_TX_POWER_TRACK 300 @@ -70,14 +59,6 @@ #define Tx_Retry_Count_Reg 0x1ac #define RegC38_TH 20 -#define TX_POWER_NEAR_FIELD_THRESH_LVL2 74 -#define TX_POWER_NEAR_FIELD_THRESH_LVL1 67 - -#define TxHighPwrLevel_Normal 0 -#define TxHighPwrLevel_Level1 1 -#define TxHighPwrLevel_Level2 2 - -#define DM_Type_ByFW 0 #define DM_Type_ByDriver 1 /*--------------------------Define Parameters-------------------------------*/ @@ -207,23 +188,20 @@ extern const u8 dm_cck_tx_bb_gain_ch14[CCKTxBBGainTableLength][8]; /*--------------------------Exported Function prototype---------------------*/ /*--------------------------Exported Function prototype---------------------*/ -extern void init_hal_dm(struct net_device *dev); -extern void deinit_hal_dm(struct net_device *dev); +void rtl92e_dm_init(struct net_device *dev); +void rtl92e_dm_deinit(struct net_device *dev); -extern void hal_dm_watchdog(struct net_device *dev); +void rtl92e_dm_watchdog(struct net_device *dev); -extern void init_rate_adaptive(struct net_device *dev); -extern void dm_txpower_trackingcallback(void *data); +void rtl92e_init_adaptive_rate(struct net_device *dev); +void rtl92e_dm_txpower_tracking_wq(void *data); -extern void dm_cck_txpower_adjust(struct net_device *dev, bool binch14); +void rtl92e_dm_cck_txpower_adjust(struct net_device *dev, bool binch14); -extern void dm_restore_dynamic_mechanism_state(struct net_device *dev); -extern void dm_backup_dynamic_mechanism_state(struct net_device *dev); -extern void dm_init_edca_turbo(struct net_device *dev); -extern void dm_rf_pathcheck_workitemcallback(void *data); -extern void dm_fsync_timer_callback(unsigned long data); -extern void dm_check_fsync(struct net_device *dev); -extern void dm_initialize_txpower_tracking(struct net_device *dev); -extern void dm_CheckRfCtrlGPIO(void *data); +void rtl92e_dm_restore_state(struct net_device *dev); +void rtl92e_dm_backup_state(struct net_device *dev); +void rtl92e_dm_init_edca_turbo(struct net_device *dev); +void rtl92e_dm_rf_pathcheck_wq(void *data); +void rtl92e_dm_init_txpower_tracking(struct net_device *dev); #endif /*__R8192UDM_H__ */ diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_eeprom.c b/drivers/staging/rtl8192e/rtl8192e/rtl_eeprom.c index a6778e085..039ccfd41 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_eeprom.c +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_eeprom.c @@ -25,115 +25,75 @@ #include "rtl_core.h" #include "rtl_eeprom.h" -static void eprom_cs(struct net_device *dev, short bit) +static void _rtl92e_gpio_write_bit(struct net_device *dev, int no, bool val) { - if (bit) - write_nic_byte(dev, EPROM_CMD, - (1 << EPROM_CS_SHIFT) | - read_nic_byte(dev, EPROM_CMD)); + u8 reg = rtl92e_readb(dev, EPROM_CMD); + + if (val) + reg |= 1 << no; else - write_nic_byte(dev, EPROM_CMD, read_nic_byte(dev, EPROM_CMD) - & ~(1<> no) & 0x1; +} -static void eprom_w(struct net_device *dev, short bit) +static void _rtl92e_eeprom_ck_cycle(struct net_device *dev) { - if (bit) - write_nic_byte(dev, EPROM_CMD, (1<> tx_len) & 0x1); + _rtl92e_eeprom_ck_cycle(dev); + } -static void eprom_send_bits_string(struct net_device *dev, short b[], int len) -{ - int i; + _rtl92e_gpio_write_bit(dev, EPROM_W_BIT, 0); - for (i = 0; i < len; i++) { - eprom_w(dev, b[i]); - eprom_ck_cycle(dev); + while (rx_len--) { + _rtl92e_eeprom_ck_cycle(dev); + ret |= _rtl92e_gpio_get_bit(dev, EPROM_R_BIT) << rx_len; } + + _rtl92e_gpio_write_bit(dev, EPROM_CS_BIT, 0); + _rtl92e_eeprom_ck_cycle(dev); + + return ret; } -u32 eprom_read(struct net_device *dev, u32 addr) +u32 rtl92e_eeprom_read(struct net_device *dev, u32 addr) { struct r8192_priv *priv = rtllib_priv(dev); - short read_cmd[] = {1, 1, 0}; - short addr_str[8]; - int i; - int addr_len; - u32 ret; - - ret = 0; - write_nic_byte(dev, EPROM_CMD, - (EPROM_CMD_PROGRAM << EPROM_CMD_OPERATING_MODE_SHIFT)); - udelay(EPROM_DELAY); + u32 ret = 0; - if (priv->epromtype == EEPROM_93C56) { - addr_str[7] = addr & 1; - addr_str[6] = addr & (1<<1); - addr_str[5] = addr & (1<<2); - addr_str[4] = addr & (1<<3); - addr_str[3] = addr & (1<<4); - addr_str[2] = addr & (1<<5); - addr_str[1] = addr & (1<<6); - addr_str[0] = addr & (1<<7); - addr_len = 8; - } else { - addr_str[5] = addr & 1; - addr_str[4] = addr & (1<<1); - addr_str[3] = addr & (1<<2); - addr_str[2] = addr & (1<<3); - addr_str[1] = addr & (1<<4); - addr_str[0] = addr & (1<<5); - addr_len = 6; - } - eprom_cs(dev, 1); - eprom_ck_cycle(dev); - eprom_send_bits_string(dev, read_cmd, 3); - eprom_send_bits_string(dev, addr_str, addr_len); - - eprom_w(dev, 0); - - for (i = 0; i < 16; i++) { - eprom_ck_cycle(dev); - ret |= (eprom_r(dev)<<(15-i)); - } + rtl92e_writeb(dev, EPROM_CMD, + (EPROM_CMD_PROGRAM << EPROM_CMD_OPERATING_MODE_SHIFT)); + udelay(EPROM_DELAY); - eprom_cs(dev, 0); - eprom_ck_cycle(dev); + /* EEPROM is configured as x16 */ + if (priv->epromtype == EEPROM_93C56) + ret = _rtl92e_eeprom_xfer(dev, (addr & 0xFF) | (0x6 << 8), 11); + else + ret = _rtl92e_eeprom_xfer(dev, (addr & 0x3F) | (0x6 << 6), 9); - write_nic_byte(dev, EPROM_CMD, - (EPROM_CMD_NORMAL< struct net_device; -bool rtl8192_pci_findadapter(struct pci_dev *pdev, struct net_device *dev); +bool rtl92e_check_adapter(struct pci_dev *pdev, struct net_device *dev); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_pm.c b/drivers/staging/rtl8192e/rtl8192e/rtl_pm.c index e49086724..b0268fdc1 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_pm.c +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_pm.c @@ -23,7 +23,7 @@ #include "rtl_pm.h" -int rtl8192E_suspend(struct pci_dev *pdev, pm_message_t state) +int rtl92e_suspend(struct pci_dev *pdev, pm_message_t state) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); @@ -45,16 +45,16 @@ int rtl8192E_suspend(struct pci_dev *pdev, pm_message_t state) netif_device_detach(dev); if (!priv->rtllib->bSupportRemoteWakeUp) { - MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_INIT, true); - ulRegRead = read_nic_dword(dev, CPU_GEN); + rtl92e_set_rf_state(dev, eRfOff, RF_CHANGE_BY_INIT); + ulRegRead = rtl92e_readl(dev, CPU_GEN); ulRegRead |= CPU_GEN_SYSTEM_RESET; - write_nic_dword(dev, CPU_GEN, ulRegRead); + rtl92e_writel(dev, CPU_GEN, ulRegRead); } else { - write_nic_dword(dev, WFCRC0, 0xffffffff); - write_nic_dword(dev, WFCRC1, 0xffffffff); - write_nic_dword(dev, WFCRC2, 0xffffffff); - write_nic_byte(dev, PMR, 0x5); - write_nic_byte(dev, MacBlkCtrl, 0xa); + rtl92e_writel(dev, WFCRC0, 0xffffffff); + rtl92e_writel(dev, WFCRC1, 0xffffffff); + rtl92e_writel(dev, WFCRC2, 0xffffffff); + rtl92e_writeb(dev, PMR, 0x5); + rtl92e_writeb(dev, MacBlkCtrl, 0xa); } out_pci_suspend: netdev_info(dev, "WOL is %s\n", priv->rtllib->bSupportRemoteWakeUp ? @@ -70,7 +70,7 @@ out_pci_suspend: return 0; } -int rtl8192E_resume(struct pci_dev *pdev) +int rtl92e_resume(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); @@ -95,7 +95,7 @@ int rtl8192E_resume(struct pci_dev *pdev) pci_enable_wake(pdev, PCI_D0, 0); if (priv->polling_timer_on == 0) - check_rfctrl_gpio_timer((unsigned long)dev); + rtl92e_check_rfctrl_gpio_timer((unsigned long)dev); if (!netif_running(dev)) { netdev_info(dev, @@ -108,7 +108,7 @@ int rtl8192E_resume(struct pci_dev *pdev) dev->netdev_ops->ndo_open(dev); if (!priv->rtllib->bSupportRemoteWakeUp) - MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_INIT, true); + rtl92e_set_rf_state(dev, eRfOn, RF_CHANGE_BY_INIT); out: RT_TRACE(COMP_POWER, "<================r8192E resume call.\n"); diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_pm.h b/drivers/staging/rtl8192e/rtl8192e/rtl_pm.h index 7bfe44817..cdc45f7fb 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_pm.h +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_pm.h @@ -23,7 +23,7 @@ #include #include -int rtl8192E_suspend(struct pci_dev *dev, pm_message_t state); -int rtl8192E_resume(struct pci_dev *dev); +int rtl92e_suspend(struct pci_dev *dev, pm_message_t state); +int rtl92e_resume(struct pci_dev *dev); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_ps.c b/drivers/staging/rtl8192e/rtl8192e/rtl_ps.c index 404cb8315..f09560d60 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_ps.c +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_ps.c @@ -45,10 +45,10 @@ static void rtl8192_hw_sleep_down(struct net_device *dev) spin_unlock_irqrestore(&priv->rf_ps_lock, flags); RT_TRACE(COMP_DBG, "%s()============>come to sleep down\n", __func__); - MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS, false); + rtl92e_set_rf_state(dev, eRfSleep, RF_CHANGE_BY_PS); } -void rtl8192_hw_sleep_wq(void *data) +void rtl92e_hw_sleep_wq(void *data) { struct rtllib_device *ieee = container_of_dwork_rsl(data, struct rtllib_device, hw_sleep_wq); @@ -57,7 +57,7 @@ void rtl8192_hw_sleep_wq(void *data) rtl8192_hw_sleep_down(dev); } -void rtl8192_hw_wakeup(struct net_device *dev) +void rtl92e_hw_wakeup(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); unsigned long flags = 0; @@ -66,7 +66,7 @@ void rtl8192_hw_wakeup(struct net_device *dev) if (priv->RFChangeInProgress) { spin_unlock_irqrestore(&priv->rf_ps_lock, flags); RT_TRACE(COMP_DBG, - "rtl8192_hw_wakeup(): RF Change in progress!\n"); + "rtl92e_hw_wakeup(): RF Change in progress!\n"); queue_delayed_work_rsl(priv->rtllib->wq, &priv->rtllib->hw_wakeup_wq, msecs_to_jiffies(10)); @@ -74,21 +74,21 @@ void rtl8192_hw_wakeup(struct net_device *dev) } spin_unlock_irqrestore(&priv->rf_ps_lock, flags); RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __func__); - MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS, false); + rtl92e_set_rf_state(dev, eRfOn, RF_CHANGE_BY_PS); } -void rtl8192_hw_wakeup_wq(void *data) +void rtl92e_hw_wakeup_wq(void *data) { struct rtllib_device *ieee = container_of_dwork_rsl(data, struct rtllib_device, hw_wakeup_wq); struct net_device *dev = ieee->dev; - rtl8192_hw_wakeup(dev); + rtl92e_hw_wakeup(dev); } #define MIN_SLEEP_TIME 50 #define MAX_SLEEP_TIME 10000 -void rtl8192_hw_to_sleep(struct net_device *dev, u64 time) +void rtl92e_enter_sleep(struct net_device *dev, u64 time) { struct r8192_priv *priv = rtllib_priv(dev); @@ -133,14 +133,13 @@ static void InactivePsWorkItemCallback(struct net_device *dev) RT_TRACE(COMP_PS, "InactivePsWorkItemCallback(): Set RF to %s.\n", pPSC->eInactivePowerState == eRfOff ? "OFF" : "ON"); - MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS, - false); + rtl92e_set_rf_state(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS); pPSC->bSwRfProcessing = false; RT_TRACE(COMP_PS, "InactivePsWorkItemCallback() <---------\n"); } -void IPSEnter(struct net_device *dev) +void rtl92e_ips_enter(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *) @@ -152,7 +151,7 @@ void IPSEnter(struct net_device *dev) if (rtState == eRfOn && !pPSC->bSwRfProcessing && (priv->rtllib->state != RTLLIB_LINKED) && (priv->rtllib->iw_mode != IW_MODE_MASTER)) { - RT_TRACE(COMP_PS, "IPSEnter(): Turn off RF.\n"); + RT_TRACE(COMP_PS, "rtl92e_ips_enter(): Turn off RF.\n"); pPSC->eInactivePowerState = eRfOff; priv->isRFOff = true; priv->bInPowerSaveMode = true; @@ -161,7 +160,7 @@ void IPSEnter(struct net_device *dev) } } -void IPSLeave(struct net_device *dev) +void rtl92e_ips_leave(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *) @@ -172,7 +171,7 @@ void IPSLeave(struct net_device *dev) rtState = priv->rtllib->eRFPowerState; if (rtState != eRfOn && !pPSC->bSwRfProcessing && priv->rtllib->RfOffReason <= RF_CHANGE_BY_IPS) { - RT_TRACE(COMP_PS, "IPSLeave(): Turn on RF.\n"); + RT_TRACE(COMP_PS, "rtl92e_ips_leave(): Turn on RF.\n"); pPSC->eInactivePowerState = eRfOn; priv->bInPowerSaveMode = false; InactivePsWorkItemCallback(dev); @@ -180,7 +179,7 @@ void IPSLeave(struct net_device *dev) } } -void IPSLeave_wq(void *data) +void rtl92e_ips_leave_wq(void *data) { struct rtllib_device *ieee = container_of_work_rsl(data, struct rtllib_device, ips_leave_wq); @@ -188,11 +187,11 @@ void IPSLeave_wq(void *data) struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); down(&priv->rtllib->ips_sem); - IPSLeave(dev); + rtl92e_ips_leave(dev); up(&priv->rtllib->ips_sem); } -void rtllib_ips_leave_wq(struct net_device *dev) +void rtl92e_rtllib_ips_leave_wq(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); enum rt_rf_power_state rtState; @@ -206,7 +205,7 @@ void rtllib_ips_leave_wq(struct net_device *dev) __func__); return; } - netdev_info(dev, "=========>%s(): IPSLeave\n", + netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n", __func__); queue_work_rsl(priv->rtllib->wq, &priv->rtllib->ips_leave_wq); @@ -214,12 +213,12 @@ void rtllib_ips_leave_wq(struct net_device *dev) } } -void rtllib_ips_leave(struct net_device *dev) +void rtl92e_rtllib_ips_leave(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); down(&priv->rtllib->ips_sem); - IPSLeave(dev); + rtl92e_ips_leave(dev); up(&priv->rtllib->ips_sem); } @@ -238,7 +237,7 @@ static bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev, rtPsMode == RTLLIB_PS_DISABLED) { unsigned long flags; - rtl8192_hw_wakeup(dev); + rtl92e_hw_wakeup(dev); priv->rtllib->sta_sleep = LPS_IS_WAKE; spin_lock_irqsave(&(priv->rtllib->mgmt_tx_lock), flags); @@ -251,13 +250,13 @@ static bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev, return true; } -void LeisurePSEnter(struct net_device *dev) +void rtl92e_leisure_ps_enter(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *) &(priv->rtllib->PowerSaveControl); - RT_TRACE(COMP_PS, "LeisurePSEnter()...\n"); + RT_TRACE(COMP_PS, "rtl92e_leisure_ps_enter()...\n"); RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n", pPSC->bLeisurePs, priv->rtllib->ps, pPSC->LpsIdleCount, @@ -275,7 +274,7 @@ void LeisurePSEnter(struct net_device *dev) if (priv->rtllib->ps == RTLLIB_PS_DISABLED) { RT_TRACE(COMP_LPS, - "LeisurePSEnter(): Enter 802.11 power save mode...\n"); + "rtl92e_leisure_ps_enter(): Enter 802.11 power save mode...\n"); if (!pPSC->bFwCtrlLPS) { if (priv->rtllib->SetFwCmdHandler) @@ -291,21 +290,21 @@ void LeisurePSEnter(struct net_device *dev) } } -void LeisurePSLeave(struct net_device *dev) +void rtl92e_leisure_ps_leave(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *) &(priv->rtllib->PowerSaveControl); - RT_TRACE(COMP_PS, "LeisurePSLeave()...\n"); + RT_TRACE(COMP_PS, "rtl92e_leisure_ps_leave()...\n"); RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d\n", pPSC->bLeisurePs, priv->rtllib->ps); if (pPSC->bLeisurePs) { if (priv->rtllib->ps != RTLLIB_PS_DISABLED) { RT_TRACE(COMP_LPS, - "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n"); + "rtl92e_leisure_ps_leave(): Busy Traffic , Leave 802.11 power save..\n"); MgntActSet_802_11_PowerSaveMode(dev, RTLLIB_PS_DISABLED); diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_ps.h b/drivers/staging/rtl8192e/rtl8192e/rtl_ps.h index 962f2e5b8..35fc9e2a3 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_ps.h +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_ps.h @@ -30,18 +30,17 @@ struct net_device; #define RT_CHECK_FOR_HANG_PERIOD 2 -#define INIT_DEFAULT_CHAN 1 -void rtl8192_hw_wakeup(struct net_device *dev); -void rtl8192_hw_to_sleep(struct net_device *dev, u64 time); -void rtllib_ips_leave_wq(struct net_device *dev); -void rtllib_ips_leave(struct net_device *dev); -void IPSLeave_wq(void *data); +void rtl92e_hw_wakeup(struct net_device *dev); +void rtl92e_enter_sleep(struct net_device *dev, u64 time); +void rtl92e_rtllib_ips_leave_wq(struct net_device *dev); +void rtl92e_rtllib_ips_leave(struct net_device *dev); +void rtl92e_ips_leave_wq(void *data); -void IPSEnter(struct net_device *dev); -void IPSLeave(struct net_device *dev); +void rtl92e_ips_enter(struct net_device *dev); +void rtl92e_ips_leave(struct net_device *dev); -void LeisurePSEnter(struct net_device *dev); -void LeisurePSLeave(struct net_device *dev); +void rtl92e_leisure_ps_enter(struct net_device *dev); +void rtl92e_leisure_ps_leave(struct net_device *dev); #endif diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_wx.c b/drivers/staging/rtl8192e/rtl8192e/rtl_wx.c index f5e496167..7e3ca7ef9 100644 --- a/drivers/staging/rtl8192e/rtl8192e/rtl_wx.c +++ b/drivers/staging/rtl8192e/rtl8192e/rtl_wx.c @@ -192,7 +192,7 @@ static int r8192_wx_adapter_power_status(struct net_device *dev, pPSC->bLeisurePs = true; } else { if (priv->rtllib->state == RTLLIB_LINKED) - LeisurePSLeave(dev); + rtl92e_leisure_ps_leave(dev); priv->ps_force = true; pPSC->bLeisurePs = false; @@ -282,10 +282,11 @@ static int r8192_wx_set_mode(struct net_device *dev, struct iw_request_info *a, up(&priv->wx_sem); return -1; } - netdev_info(dev, "=========>%s(): IPSLeave\n", + netdev_info(dev, + "=========>%s(): rtl92e_ips_leave\n", __func__); down(&priv->rtllib->ips_sem); - IPSLeave(dev); + rtl92e_ips_leave(dev); up(&priv->rtllib->ips_sem); } } @@ -442,10 +443,11 @@ static int r8192_wx_set_scan(struct net_device *dev, struct iw_request_info *a, up(&priv->wx_sem); return -1; } - RT_TRACE(COMP_PS, "=========>%s(): IPSLeave\n", + RT_TRACE(COMP_PS, + "=========>%s(): rtl92e_ips_leave\n", __func__); down(&priv->rtllib->ips_sem); - IPSLeave(dev); + rtl92e_ips_leave(dev); up(&priv->rtllib->ips_sem); } } @@ -700,7 +702,7 @@ static int r8192_wx_set_enc(struct net_device *dev, priv->rtllib->wx_set_enc = 1; down(&priv->rtllib->ips_sem); - IPSLeave(dev); + rtl92e_ips_leave(dev); up(&priv->rtllib->ips_sem); down(&priv->wx_sem); @@ -711,7 +713,7 @@ static int r8192_wx_set_enc(struct net_device *dev, if (wrqu->encoding.flags & IW_ENCODE_DISABLED) { ieee->pairwise_key_type = ieee->group_key_type = KEY_TYPE_NA; - CamResetAllEntry(dev); + rtl92e_cam_reset(dev); memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32); goto end_hw_sec; @@ -729,9 +731,6 @@ static int r8192_wx_set_enc(struct net_device *dev, hwkey[i] |= (key[4 * i + 3] & mask) << 24; } - #define CONF_WEP40 0x4 - #define CONF_WEP104 0x14 - switch (wrqu->encoding.flags & IW_ENCODE_INDEX) { case 0: key_idx = ieee->crypt_info.tx_keyidx; @@ -753,16 +752,16 @@ static int r8192_wx_set_enc(struct net_device *dev, } if (wrqu->encoding.length == 0x5) { ieee->pairwise_key_type = KEY_TYPE_WEP40; - EnableHWSecurityConfig8192(dev); + rtl92e_enable_hw_security_config(dev); } else if (wrqu->encoding.length == 0xd) { ieee->pairwise_key_type = KEY_TYPE_WEP104; - EnableHWSecurityConfig8192(dev); - setKey(dev, key_idx, key_idx, KEY_TYPE_WEP104, - zero_addr[key_idx], 0, hwkey); - set_swcam(dev, key_idx, key_idx, KEY_TYPE_WEP104, - zero_addr[key_idx], 0, hwkey, 0); + rtl92e_enable_hw_security_config(dev); + rtl92e_set_key(dev, key_idx, key_idx, KEY_TYPE_WEP104, + zero_addr[key_idx], 0, hwkey); + rtl92e_set_swcam(dev, key_idx, key_idx, KEY_TYPE_WEP104, + zero_addr[key_idx], 0, hwkey, 0); } else { netdev_info(dev, "wrong type in WEP, not WEP40 and WEP104\n"); @@ -821,17 +820,13 @@ static int r8192_wx_set_retry(struct net_device *dev, } if (wrqu->retry.flags & IW_RETRY_MAX) { priv->retry_rts = wrqu->retry.value; - DMESG("Setting retry for RTS/CTS data to %d", - wrqu->retry.value); } else { priv->retry_data = wrqu->retry.value; - DMESG("Setting retry for non RTS/CTS data to %d", - wrqu->retry.value); } - rtl8192_commit(dev); + rtl92e_commit(dev); exit: up(&priv->wx_sem); @@ -917,7 +912,7 @@ static int r8192_wx_set_enc_ext(struct net_device *dev, priv->rtllib->wx_set_enc = 1; down(&priv->rtllib->ips_sem); - IPSLeave(dev); + rtl92e_ips_leave(dev); up(&priv->rtllib->ips_sem); ret = rtllib_wx_set_encode_ext(ieee, info, wrqu, extra); @@ -933,7 +928,7 @@ static int r8192_wx_set_enc_ext(struct net_device *dev, ext->alg == IW_ENCODE_ALG_NONE) { ieee->pairwise_key_type = ieee->group_key_type = KEY_TYPE_NA; - CamResetAllEntry(dev); + rtl92e_cam_reset(dev); memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32); goto end_hw_sec; @@ -950,28 +945,29 @@ static int r8192_wx_set_enc_ext(struct net_device *dev, if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40)) alg = KEY_TYPE_WEP104; ieee->pairwise_key_type = alg; - EnableHWSecurityConfig8192(dev); + rtl92e_enable_hw_security_config(dev); } memcpy((u8 *)key, ext->key, 16); if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) { if (ext->key_len == 13) ieee->pairwise_key_type = alg = KEY_TYPE_WEP104; - setKey(dev, idx, idx, alg, zero, 0, key); - set_swcam(dev, idx, idx, alg, zero, 0, key, 0); + rtl92e_set_key(dev, idx, idx, alg, zero, 0, key); + rtl92e_set_swcam(dev, idx, idx, alg, zero, 0, key, 0); } else if (group) { ieee->group_key_type = alg; - setKey(dev, idx, idx, alg, broadcast_addr, 0, key); - set_swcam(dev, idx, idx, alg, broadcast_addr, 0, - key, 0); + rtl92e_set_key(dev, idx, idx, alg, broadcast_addr, 0, + key); + rtl92e_set_swcam(dev, idx, idx, alg, broadcast_addr, 0, + key, 0); } else { if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) && ieee->pHTInfo->bCurrentHTSupport) - write_nic_byte(dev, 0x173, 1); - setKey(dev, 4, idx, alg, (u8 *)ieee->ap_mac_addr, - 0, key); - set_swcam(dev, 4, idx, alg, (u8 *)ieee->ap_mac_addr, - 0, key, 0); + rtl92e_writeb(dev, 0x173, 1); + rtl92e_set_key(dev, 4, idx, alg, + (u8 *)ieee->ap_mac_addr, 0, key); + rtl92e_set_swcam(dev, 4, idx, alg, + (u8 *)ieee->ap_mac_addr, 0, key, 0); } @@ -1119,41 +1115,41 @@ static int r8192_wx_get_PromiscuousMode(struct net_device *dev, } -#define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT] +#define IW_IOCTL(x) ((x) - SIOCSIWCOMMIT) static iw_handler r8192_wx_handlers[] = { - IW_IOCTL(SIOCGIWNAME) = r8192_wx_get_name, - IW_IOCTL(SIOCSIWFREQ) = r8192_wx_set_freq, - IW_IOCTL(SIOCGIWFREQ) = r8192_wx_get_freq, - IW_IOCTL(SIOCSIWMODE) = r8192_wx_set_mode, - IW_IOCTL(SIOCGIWMODE) = r8192_wx_get_mode, - IW_IOCTL(SIOCSIWSENS) = r8192_wx_set_sens, - IW_IOCTL(SIOCGIWSENS) = r8192_wx_get_sens, - IW_IOCTL(SIOCGIWRANGE) = rtl8192_wx_get_range, - IW_IOCTL(SIOCSIWAP) = r8192_wx_set_wap, - IW_IOCTL(SIOCGIWAP) = r8192_wx_get_wap, - IW_IOCTL(SIOCSIWSCAN) = r8192_wx_set_scan, - IW_IOCTL(SIOCGIWSCAN) = r8192_wx_get_scan, - IW_IOCTL(SIOCSIWESSID) = r8192_wx_set_essid, - IW_IOCTL(SIOCGIWESSID) = r8192_wx_get_essid, - IW_IOCTL(SIOCSIWNICKN) = r8192_wx_set_nick, - IW_IOCTL(SIOCGIWNICKN) = r8192_wx_get_nick, - IW_IOCTL(SIOCSIWRATE) = r8192_wx_set_rate, - IW_IOCTL(SIOCGIWRATE) = r8192_wx_get_rate, - IW_IOCTL(SIOCSIWRTS) = r8192_wx_set_rts, - IW_IOCTL(SIOCGIWRTS) = r8192_wx_get_rts, - IW_IOCTL(SIOCSIWFRAG) = r8192_wx_set_frag, - IW_IOCTL(SIOCGIWFRAG) = r8192_wx_get_frag, - IW_IOCTL(SIOCSIWRETRY) = r8192_wx_set_retry, - IW_IOCTL(SIOCGIWRETRY) = r8192_wx_get_retry, - IW_IOCTL(SIOCSIWENCODE) = r8192_wx_set_enc, - IW_IOCTL(SIOCGIWENCODE) = r8192_wx_get_enc, - IW_IOCTL(SIOCSIWPOWER) = r8192_wx_set_power, - IW_IOCTL(SIOCGIWPOWER) = r8192_wx_get_power, - IW_IOCTL(SIOCSIWGENIE) = r8192_wx_set_gen_ie, - IW_IOCTL(SIOCGIWGENIE) = r8192_wx_get_gen_ie, - IW_IOCTL(SIOCSIWMLME) = r8192_wx_set_mlme, - IW_IOCTL(SIOCSIWAUTH) = r8192_wx_set_auth, - IW_IOCTL(SIOCSIWENCODEEXT) = r8192_wx_set_enc_ext, + [IW_IOCTL(SIOCGIWNAME)] = r8192_wx_get_name, + [IW_IOCTL(SIOCSIWFREQ)] = r8192_wx_set_freq, + [IW_IOCTL(SIOCGIWFREQ)] = r8192_wx_get_freq, + [IW_IOCTL(SIOCSIWMODE)] = r8192_wx_set_mode, + [IW_IOCTL(SIOCGIWMODE)] = r8192_wx_get_mode, + [IW_IOCTL(SIOCSIWSENS)] = r8192_wx_set_sens, + [IW_IOCTL(SIOCGIWSENS)] = r8192_wx_get_sens, + [IW_IOCTL(SIOCGIWRANGE)] = rtl8192_wx_get_range, + [IW_IOCTL(SIOCSIWAP)] = r8192_wx_set_wap, + [IW_IOCTL(SIOCGIWAP)] = r8192_wx_get_wap, + [IW_IOCTL(SIOCSIWSCAN)] = r8192_wx_set_scan, + [IW_IOCTL(SIOCGIWSCAN)] = r8192_wx_get_scan, + [IW_IOCTL(SIOCSIWESSID)] = r8192_wx_set_essid, + [IW_IOCTL(SIOCGIWESSID)] = r8192_wx_get_essid, + [IW_IOCTL(SIOCSIWNICKN)] = r8192_wx_set_nick, + [IW_IOCTL(SIOCGIWNICKN)] = r8192_wx_get_nick, + [IW_IOCTL(SIOCSIWRATE)] = r8192_wx_set_rate, + [IW_IOCTL(SIOCGIWRATE)] = r8192_wx_get_rate, + [IW_IOCTL(SIOCSIWRTS)] = r8192_wx_set_rts, + [IW_IOCTL(SIOCGIWRTS)] = r8192_wx_get_rts, + [IW_IOCTL(SIOCSIWFRAG)] = r8192_wx_set_frag, + [IW_IOCTL(SIOCGIWFRAG)] = r8192_wx_get_frag, + [IW_IOCTL(SIOCSIWRETRY)] = r8192_wx_set_retry, + [IW_IOCTL(SIOCGIWRETRY)] = r8192_wx_get_retry, + [IW_IOCTL(SIOCSIWENCODE)] = r8192_wx_set_enc, + [IW_IOCTL(SIOCGIWENCODE)] = r8192_wx_get_enc, + [IW_IOCTL(SIOCSIWPOWER)] = r8192_wx_set_power, + [IW_IOCTL(SIOCGIWPOWER)] = r8192_wx_get_power, + [IW_IOCTL(SIOCSIWGENIE)] = r8192_wx_set_gen_ie, + [IW_IOCTL(SIOCGIWGENIE)] = r8192_wx_get_gen_ie, + [IW_IOCTL(SIOCSIWMLME)] = r8192_wx_set_mlme, + [IW_IOCTL(SIOCSIWAUTH)] = r8192_wx_set_auth, + [IW_IOCTL(SIOCSIWENCODEEXT)] = r8192_wx_set_enc_ext, }; /* the following rule need to be following, diff --git a/drivers/staging/rtl8192e/rtl819x_BA.h b/drivers/staging/rtl8192e/rtl819x_BA.h index 613e14c12..894666465 100644 --- a/drivers/staging/rtl8192e/rtl819x_BA.h +++ b/drivers/staging/rtl8192e/rtl819x_BA.h @@ -19,11 +19,7 @@ #ifndef _BATYPE_H_ #define _BATYPE_H_ -#define TOTAL_TXBA_NUM 16 -#define TOTAL_RXBA_NUM 16 - #define BA_SETUP_TIMEOUT 200 -#define BA_INACT_TIMEOUT 60000 #define BA_POLICY_DELAYED 0 #define BA_POLICY_IMMEDIATE 1 @@ -32,7 +28,6 @@ #define ADDBA_STATUS_REFUSED 37 #define ADDBA_STATUS_INVALID_PARAM 38 -#define DELBA_REASON_QSTA_LEAVING 36 #define DELBA_REASON_END_BA 37 #define DELBA_REASON_UNKNOWN_BA 38 #define DELBA_REASON_TIMEOUT 39 diff --git a/drivers/staging/rtl8192e/rtl819x_BAProc.c b/drivers/staging/rtl8192e/rtl819x_BAProc.c index 60f536c29..78ede4a81 100644 --- a/drivers/staging/rtl8192e/rtl819x_BAProc.c +++ b/drivers/staging/rtl8192e/rtl819x_BAProc.c @@ -428,7 +428,6 @@ int rtllib_rx_DELBA(struct rtllib_device *ieee, struct sk_buff *skb) { struct rtllib_hdr_3addr *delba = NULL; union delba_param_set *pDelBaParamSet = NULL; - u16 *pReasonCode = NULL; u8 *dst = NULL; if (skb->len < sizeof(struct rtllib_hdr_3addr) + 6) { @@ -453,9 +452,7 @@ int rtllib_rx_DELBA(struct rtllib_device *ieee, struct sk_buff *skb) #endif delba = (struct rtllib_hdr_3addr *)skb->data; dst = (u8 *)(&delba->addr2[0]); - delba += sizeof(struct rtllib_hdr_3addr); - pDelBaParamSet = (union delba_param_set *)(delba+2); - pReasonCode = (u16 *)(delba+4); + pDelBaParamSet = (union delba_param_set *)&delba->payload[2]; if (pDelBaParamSet->field.Initiator == 1) { struct rx_ts_record *pRxTs; diff --git a/drivers/staging/rtl8192e/rtl819x_HT.h b/drivers/staging/rtl8192e/rtl819x_HT.h index 0c263d9f7..51711dcdc 100644 --- a/drivers/staging/rtl8192e/rtl819x_HT.h +++ b/drivers/staging/rtl8192e/rtl819x_HT.h @@ -20,8 +20,6 @@ #define _RTL819XU_HTTYPE_H_ #define MIMO_PS_STATIC 0 -#define MIMO_PS_DYNAMIC 1 -#define MIMO_PS_NOLIMIT 3 #define sHTCLng 4 diff --git a/drivers/staging/rtl8192e/rtl819x_HTProc.c b/drivers/staging/rtl8192e/rtl819x_HTProc.c index b5c3647b0..555745b2a 100644 --- a/drivers/staging/rtl8192e/rtl819x_HTProc.c +++ b/drivers/staging/rtl8192e/rtl819x_HTProc.c @@ -117,7 +117,7 @@ void HTUpdateDefaultSetting(struct rtllib_device *ieee) pHTInfo->RxReorderPendingTime = 30; } -u16 HTMcsToDataRate(struct rtllib_device *ieee, u8 nMcsRate) +static u16 HTMcsToDataRate(struct rtllib_device *ieee, u8 nMcsRate) { struct rt_hi_throughput *pHTInfo = ieee->pHTInfo; @@ -502,7 +502,8 @@ u8 HTGetHighestMCSRate(struct rtllib_device *ieee, u8 *pMCSRateSet, return mcsRate | 0x80; } -u8 HTFilterMCSRate(struct rtllib_device *ieee, u8 *pSupportMCS, u8 *pOperateMCS) +static u8 HTFilterMCSRate(struct rtllib_device *ieee, u8 *pSupportMCS, + u8 *pOperateMCS) { u8 i; diff --git a/drivers/staging/rtl8192e/rtl819x_Qos.h b/drivers/staging/rtl8192e/rtl819x_Qos.h index 3aa35ced2..fcc8fabbe 100644 --- a/drivers/staging/rtl8192e/rtl819x_Qos.h +++ b/drivers/staging/rtl8192e/rtl819x_Qos.h @@ -96,11 +96,6 @@ struct octet_string { u16 Length; }; -enum ack_policy { - eAckPlc0_ACK = 0x00, - eAckPlc1_NoACK = 0x01, -}; - #define AC0_BE 0 #define AC1_BK 1 #define AC2_VI 2 diff --git a/drivers/staging/rtl8192e/rtl819x_TS.h b/drivers/staging/rtl8192e/rtl819x_TS.h index b8fed5569..a93348c37 100644 --- a/drivers/staging/rtl8192e/rtl819x_TS.h +++ b/drivers/staging/rtl8192e/rtl819x_TS.h @@ -19,8 +19,6 @@ #ifndef _TSTYPE_H_ #define _TSTYPE_H_ #include "rtl819x_Qos.h" -#define TS_SETUP_TIMEOUT 60 -#define TS_INACT_TIMEOUT 60 #define TS_ADDBA_DELAY 60 #define TOTAL_TS_NUM 16 diff --git a/drivers/staging/rtl8192e/rtl819x_TSProc.c b/drivers/staging/rtl8192e/rtl819x_TSProc.c index 05aea4321..708795944 100644 --- a/drivers/staging/rtl8192e/rtl819x_TSProc.c +++ b/drivers/staging/rtl8192e/rtl819x_TSProc.c @@ -113,7 +113,7 @@ static void TsAddBaProcess(unsigned long data) static void ResetTsCommonInfo(struct ts_common_info *pTsCommonInfo) { - memset(pTsCommonInfo->Addr, 0, 6); + eth_zero_addr(pTsCommonInfo->Addr); memset(&pTsCommonInfo->TSpec, 0, sizeof(union tspec_body)); memset(&pTsCommonInfo->TClass, 0, sizeof(union qos_tclas)*TCLAS_NUM); pTsCommonInfo->TClasProc = 0; diff --git a/drivers/staging/rtl8192e/rtllib.h b/drivers/staging/rtl8192e/rtllib.h index fd38c6dd1..563ac12f0 100644 --- a/drivers/staging/rtl8192e/rtllib.h +++ b/drivers/staging/rtl8192e/rtllib.h @@ -84,9 +84,6 @@ #define iwe_stream_add_point_rsl(info, start, stop, iwe, p) \ iwe_stream_add_point(info, start, stop, iwe, p) -#define usb_alloc_urb_rsl(x, y) usb_alloc_urb(x, y) -#define usb_submit_urb_rsl(x, y) usb_submit_urb(x, y) - static inline void *netdev_priv_rsl(struct net_device *dev) { return netdev_priv(dev); @@ -110,27 +107,14 @@ static inline void *netdev_priv_rsl(struct net_device *dev) #define HIGH_QUEUE 7 #define BEACON_QUEUE 8 -#define LOW_QUEUE BE_QUEUE -#define NORMAL_QUEUE MGNT_QUEUE - #ifndef IW_MODE_MESH #define IW_MODE_MESH 7 #endif -#define AMSDU_SUBHEADER_LEN 14 -#define SWRF_TIMEOUT 50 #define IE_CISCO_FLAG_POSITION 0x08 #define SUPPORT_CKIP_MIC 0x08 #define SUPPORT_CKIP_PK 0x10 -#define RT_RF_OFF_LEVL_ASPM BIT0 -#define RT_RF_OFF_LEVL_CLK_REQ BIT1 -#define RT_RF_OFF_LEVL_PCI_D3 BIT2 #define RT_RF_OFF_LEVL_HALT_NIC BIT3 -#define RT_RF_OFF_LEVL_FREE_FW BIT4 -#define RT_RF_OFF_LEVL_FW_32K BIT5 -#define RT_RF_PS_LEVEL_ALWAYS_ASPM BIT6 -#define RT_RF_LPS_DISALBE_2R BIT30 -#define RT_RF_LPS_LEVEL_ASPM BIT31 #define RT_IN_PS_LEVEL(pPSC, _PS_FLAG) \ ((pPSC->CurPsLevel & _PS_FLAG) ? true : false) #define RT_CLEAR_PS_LEVEL(pPSC, _PS_FLAG) \ @@ -244,22 +228,6 @@ struct sw_chnl_cmd { #define MGN_MCS13 0x8d #define MGN_MCS14 0x8e #define MGN_MCS15 0x8f -#define MGN_MCS0_SG 0x90 -#define MGN_MCS1_SG 0x91 -#define MGN_MCS2_SG 0x92 -#define MGN_MCS3_SG 0x93 -#define MGN_MCS4_SG 0x94 -#define MGN_MCS5_SG 0x95 -#define MGN_MCS6_SG 0x96 -#define MGN_MCS7_SG 0x97 -#define MGN_MCS8_SG 0x98 -#define MGN_MCS9_SG 0x99 -#define MGN_MCS10_SG 0x9a -#define MGN_MCS11_SG 0x9b -#define MGN_MCS12_SG 0x9c -#define MGN_MCS13_SG 0x9d -#define MGN_MCS14_SG 0x9e -#define MGN_MCS15_SG 0x9f enum hw_variables { HW_VAR_ETHER_ADDR, @@ -722,42 +690,13 @@ struct rtllib_frag_entry { u8 dst_addr[ETH_ALEN]; }; -struct rtllib_stats { - unsigned int tx_unicast_frames; - unsigned int tx_multicast_frames; - unsigned int tx_fragments; - unsigned int tx_unicast_octets; - unsigned int tx_multicast_octets; - unsigned int tx_deferred_transmissions; - unsigned int tx_single_retry_frames; - unsigned int tx_multiple_retry_frames; - unsigned int tx_retry_limit_exceeded; - unsigned int tx_discards; - unsigned int rx_unicast_frames; - unsigned int rx_multicast_frames; - unsigned int rx_fragments; - unsigned int rx_unicast_octets; - unsigned int rx_multicast_octets; - unsigned int rx_fcs_errors; - unsigned int rx_discards_no_buffer; - unsigned int tx_discards_wrong_sa; - unsigned int rx_discards_undecryptable; - unsigned int rx_message_in_msg_fragments; - unsigned int rx_message_in_bad_msg_fragments; -}; - struct rtllib_device; -#define SEC_KEY_1 (1<<0) -#define SEC_KEY_2 (1<<1) -#define SEC_KEY_3 (1<<2) -#define SEC_KEY_4 (1<<3) #define SEC_ACTIVE_KEY (1<<4) #define SEC_AUTH_MODE (1<<5) #define SEC_UNICAST_GROUP (1<<6) #define SEC_LEVEL (1<<7) #define SEC_ENABLED (1<<8) -#define SEC_ENCRYPT (1<<9) #define SEC_LEVEL_0 0 /* None */ #define SEC_LEVEL_1 1 /* WEP 40 and 104 bit */ @@ -772,7 +711,6 @@ struct rtllib_device; #define WEP_KEY_LEN 13 #define SCM_KEY_LEN 32 -#define SCM_TEMPORAL_KEY_LENGTH 16 struct rtllib_security { u16 active_key:2, @@ -1187,8 +1125,6 @@ enum {WMM_all_frame, WMM_two_frame, WMM_four_frame, WMM_six_frame}; #define WME_AC_BE 0x01 #define WME_AC_VI 0x02 #define WME_AC_VO 0x03 -#define WME_ACI_MASK 0x03 -#define WME_AIFSN_MASK 0x03 #define WME_AC_PRAM_LEN 16 #define MAX_RECEIVE_BUFFER_SIZE 9100 @@ -1204,12 +1140,6 @@ enum {WMM_all_frame, WMM_two_frame, WMM_four_frame, WMM_six_frame}; #define ETHERNET_HEADER_SIZE 14 /* length of two Ethernet address * plus ether type*/ -struct ether_header { - u8 ether_dhost[ETHER_ADDR_LEN]; - u8 ether_shost[ETHER_ADDR_LEN]; - u16 ether_type; -} __packed; - enum erp_t { ERP_NonERPpresent = 0x01, ERP_UseProtection = 0x02, @@ -1591,7 +1521,6 @@ struct rtllib_device { /* Bookkeeping structures */ struct net_device_stats stats; - struct rtllib_stats ieee_stats; struct rtllib_softmac_stats softmac_stats; /* Probe / Beacon management */ @@ -1673,7 +1602,6 @@ struct rtllib_device { int short_slot; int mode; /* A, B, G */ int modulation; /* CCK, OFDM */ - int freq_band; /* 2.4Ghz, 5.2Ghz, Mixed */ /* used for forcing the ibss workqueue to terminate * without wait for the syncro scan to terminate @@ -2056,244 +1984,199 @@ static inline int rtllib_is_cck_rate(u8 rate) /* rtllib.c */ -extern void free_rtllib(struct net_device *dev); -extern struct net_device *alloc_rtllib(int sizeof_priv); +void free_rtllib(struct net_device *dev); +struct net_device *alloc_rtllib(int sizeof_priv); /* rtllib_tx.c */ -extern int rtllib_encrypt_fragment( +int rtllib_encrypt_fragment( struct rtllib_device *ieee, struct sk_buff *frag, int hdr_len); -extern int rtllib_xmit(struct sk_buff *skb, struct net_device *dev); -extern int rtllib_xmit_inter(struct sk_buff *skb, struct net_device *dev); -extern void rtllib_txb_free(struct rtllib_txb *); +int rtllib_xmit(struct sk_buff *skb, struct net_device *dev); +void rtllib_txb_free(struct rtllib_txb *); /* rtllib_rx.c */ -extern int rtllib_rx(struct rtllib_device *ieee, struct sk_buff *skb, - struct rtllib_rx_stats *rx_stats); -extern void rtllib_rx_mgt(struct rtllib_device *ieee, - struct sk_buff *skb, - struct rtllib_rx_stats *stats); -extern void rtllib_rx_probe_rq(struct rtllib_device *ieee, - struct sk_buff *skb); -extern int rtllib_legal_channel(struct rtllib_device *rtllib, u8 channel); +int rtllib_rx(struct rtllib_device *ieee, struct sk_buff *skb, + struct rtllib_rx_stats *rx_stats); +void rtllib_rx_probe_rq(struct rtllib_device *ieee, + struct sk_buff *skb); +int rtllib_legal_channel(struct rtllib_device *rtllib, u8 channel); /* rtllib_wx.c */ -extern int rtllib_wx_get_scan(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *key); -extern int rtllib_wx_set_encode(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *key); -extern int rtllib_wx_get_encode(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *key); -extern int rtllib_wx_set_encode_ext(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_set_auth(struct rtllib_device *ieee, - struct iw_request_info *info, - struct iw_param *data, char *extra); -extern int rtllib_wx_set_mlme(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_set_gen_ie(struct rtllib_device *ieee, u8 *ie, size_t len); +int rtllib_wx_get_scan(struct rtllib_device *ieee, + struct iw_request_info *info, + union iwreq_data *wrqu, char *key); +int rtllib_wx_set_encode(struct rtllib_device *ieee, + struct iw_request_info *info, + union iwreq_data *wrqu, char *key); +int rtllib_wx_get_encode(struct rtllib_device *ieee, + struct iw_request_info *info, + union iwreq_data *wrqu, char *key); +int rtllib_wx_set_encode_ext(struct rtllib_device *ieee, + struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); +int rtllib_wx_set_auth(struct rtllib_device *ieee, + struct iw_request_info *info, + struct iw_param *data, char *extra); +int rtllib_wx_set_mlme(struct rtllib_device *ieee, + struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); +int rtllib_wx_set_gen_ie(struct rtllib_device *ieee, u8 *ie, size_t len); /* rtllib_softmac.c */ -extern short rtllib_is_54g(struct rtllib_network *net); -extern int rtllib_rx_frame_softmac(struct rtllib_device *ieee, - struct sk_buff *skb, - struct rtllib_rx_stats *rx_stats, u16 type, - u16 stype); -extern void rtllib_softmac_new_net(struct rtllib_device *ieee, - struct rtllib_network *net); +int rtllib_rx_frame_softmac(struct rtllib_device *ieee, struct sk_buff *skb, + struct rtllib_rx_stats *rx_stats, u16 type, + u16 stype); +void rtllib_softmac_new_net(struct rtllib_device *ieee, + struct rtllib_network *net); void SendDisassociation(struct rtllib_device *ieee, bool deauth, u16 asRsn); -extern void rtllib_softmac_xmit(struct rtllib_txb *txb, - struct rtllib_device *ieee); - -extern void rtllib_stop_send_beacons(struct rtllib_device *ieee); -extern void notify_wx_assoc_event(struct rtllib_device *ieee); -extern void rtllib_softmac_check_all_nets(struct rtllib_device *ieee); -extern void rtllib_start_bss(struct rtllib_device *ieee); -extern void rtllib_start_master_bss(struct rtllib_device *ieee); -extern void rtllib_start_ibss(struct rtllib_device *ieee); -extern void rtllib_softmac_init(struct rtllib_device *ieee); -extern void rtllib_softmac_free(struct rtllib_device *ieee); -extern void rtllib_associate_abort(struct rtllib_device *ieee); -extern void rtllib_disassociate(struct rtllib_device *ieee); -extern void rtllib_stop_scan(struct rtllib_device *ieee); -extern bool rtllib_act_scanning(struct rtllib_device *ieee, bool sync_scan); -extern void rtllib_stop_scan_syncro(struct rtllib_device *ieee); -extern void rtllib_start_scan_syncro(struct rtllib_device *ieee, u8 is_mesh); -extern void rtllib_sta_ps_send_null_frame(struct rtllib_device *ieee, - short pwr); -extern void rtllib_sta_wakeup(struct rtllib_device *ieee, short nl); -extern void rtllib_sta_ps_send_pspoll_frame(struct rtllib_device *ieee); -extern void rtllib_start_protocol(struct rtllib_device *ieee); -extern void rtllib_stop_protocol(struct rtllib_device *ieee, u8 shutdown); - -extern void rtllib_EnableNetMonitorMode(struct net_device *dev, +void rtllib_softmac_xmit(struct rtllib_txb *txb, struct rtllib_device *ieee); + +void rtllib_stop_send_beacons(struct rtllib_device *ieee); +void notify_wx_assoc_event(struct rtllib_device *ieee); +void rtllib_start_ibss(struct rtllib_device *ieee); +void rtllib_softmac_init(struct rtllib_device *ieee); +void rtllib_softmac_free(struct rtllib_device *ieee); +void rtllib_disassociate(struct rtllib_device *ieee); +void rtllib_stop_scan(struct rtllib_device *ieee); +bool rtllib_act_scanning(struct rtllib_device *ieee, bool sync_scan); +void rtllib_stop_scan_syncro(struct rtllib_device *ieee); +void rtllib_start_scan_syncro(struct rtllib_device *ieee, u8 is_mesh); +void rtllib_sta_ps_send_null_frame(struct rtllib_device *ieee, short pwr); +void rtllib_sta_ps_send_pspoll_frame(struct rtllib_device *ieee); +void rtllib_start_protocol(struct rtllib_device *ieee); +void rtllib_stop_protocol(struct rtllib_device *ieee, u8 shutdown); + +void rtllib_EnableNetMonitorMode(struct net_device *dev, bool bInitState); +void rtllib_DisableNetMonitorMode(struct net_device *dev, bool bInitState); +void rtllib_EnableIntelPromiscuousMode(struct net_device *dev, bool bInitState); +void rtllib_DisableIntelPromiscuousMode(struct net_device *dev, bool bInitState); -extern void rtllib_DisableNetMonitorMode(struct net_device *dev, - bool bInitState); -extern void rtllib_EnableIntelPromiscuousMode(struct net_device *dev, - bool bInitState); -extern void rtllib_DisableIntelPromiscuousMode(struct net_device *dev, - bool bInitState); -extern void rtllib_send_probe_requests(struct rtllib_device *ieee, u8 is_mesh); - -extern void rtllib_softmac_stop_protocol(struct rtllib_device *ieee, - u8 mesh_flag, u8 shutdown); -extern void rtllib_softmac_start_protocol(struct rtllib_device *ieee, - u8 mesh_flag); - -extern void rtllib_reset_queue(struct rtllib_device *ieee); -extern void rtllib_wake_all_queues(struct rtllib_device *ieee); -extern void rtllib_stop_all_queues(struct rtllib_device *ieee); -extern struct sk_buff *rtllib_get_beacon(struct rtllib_device *ieee); -extern void rtllib_start_send_beacons(struct rtllib_device *ieee); -extern void rtllib_stop_send_beacons(struct rtllib_device *ieee); -extern int rtllib_wpa_supplicant_ioctl(struct rtllib_device *ieee, - struct iw_point *p, u8 is_mesh); - -extern void notify_wx_assoc_event(struct rtllib_device *ieee); -extern void rtllib_ps_tx_ack(struct rtllib_device *ieee, short success); - -extern void softmac_mgmt_xmit(struct sk_buff *skb, - struct rtllib_device *ieee); -extern u16 rtllib_query_seqnum(struct rtllib_device *ieee, - struct sk_buff *skb, u8 *dst); -extern u8 rtllib_ap_sec_type(struct rtllib_device *ieee); +void rtllib_softmac_stop_protocol(struct rtllib_device *ieee, + u8 mesh_flag, u8 shutdown); +void rtllib_softmac_start_protocol(struct rtllib_device *ieee, u8 mesh_flag); + +void rtllib_reset_queue(struct rtllib_device *ieee); +void rtllib_wake_all_queues(struct rtllib_device *ieee); +void rtllib_stop_all_queues(struct rtllib_device *ieee); +struct sk_buff *rtllib_get_beacon(struct rtllib_device *ieee); +void rtllib_start_send_beacons(struct rtllib_device *ieee); +void rtllib_stop_send_beacons(struct rtllib_device *ieee); +int rtllib_wpa_supplicant_ioctl(struct rtllib_device *ieee, + struct iw_point *p, u8 is_mesh); + +void notify_wx_assoc_event(struct rtllib_device *ieee); +void rtllib_ps_tx_ack(struct rtllib_device *ieee, short success); + +void softmac_mgmt_xmit(struct sk_buff *skb, struct rtllib_device *ieee); +u8 rtllib_ap_sec_type(struct rtllib_device *ieee); /* rtllib_softmac_wx.c */ -extern int rtllib_wx_get_wap(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *ext); +int rtllib_wx_get_wap(struct rtllib_device *ieee, struct iw_request_info *info, + union iwreq_data *wrqu, char *ext); -extern int rtllib_wx_set_wap(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *awrq, - char *extra); +int rtllib_wx_set_wap(struct rtllib_device *ieee, struct iw_request_info *info, + union iwreq_data *awrq, char *extra); -extern int rtllib_wx_get_essid(struct rtllib_device *ieee, - struct iw_request_info *a, - union iwreq_data *wrqu, char *b); +int rtllib_wx_get_essid(struct rtllib_device *ieee, struct iw_request_info *a, + union iwreq_data *wrqu, char *b); -extern int rtllib_wx_set_rate(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); +int rtllib_wx_set_rate(struct rtllib_device *ieee, struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_get_rate(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); +int rtllib_wx_get_rate(struct rtllib_device *ieee, struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_set_mode(struct rtllib_device *ieee, - struct iw_request_info *a, - union iwreq_data *wrqu, char *b); +int rtllib_wx_set_mode(struct rtllib_device *ieee, struct iw_request_info *a, + union iwreq_data *wrqu, char *b); -extern int rtllib_wx_set_scan(struct rtllib_device *ieee, - struct iw_request_info *a, - union iwreq_data *wrqu, char *b); +int rtllib_wx_set_scan(struct rtllib_device *ieee, struct iw_request_info *a, + union iwreq_data *wrqu, char *b); -extern int rtllib_wx_set_essid(struct rtllib_device *ieee, - struct iw_request_info *a, - union iwreq_data *wrqu, char *extra); +int rtllib_wx_set_essid(struct rtllib_device *ieee, struct iw_request_info *a, + union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_get_mode(struct rtllib_device *ieee, - struct iw_request_info *a, - union iwreq_data *wrqu, char *b); +int rtllib_wx_get_mode(struct rtllib_device *ieee, struct iw_request_info *a, + union iwreq_data *wrqu, char *b); -extern int rtllib_wx_set_freq(struct rtllib_device *ieee, - struct iw_request_info *a, - union iwreq_data *wrqu, char *b); +int rtllib_wx_set_freq(struct rtllib_device *ieee, struct iw_request_info *a, + union iwreq_data *wrqu, char *b); -extern int rtllib_wx_get_freq(struct rtllib_device *ieee, - struct iw_request_info *a, - union iwreq_data *wrqu, char *b); -extern void rtllib_wx_sync_scan_wq(void *data); +int rtllib_wx_get_freq(struct rtllib_device *ieee, struct iw_request_info *a, + union iwreq_data *wrqu, char *b); +void rtllib_wx_sync_scan_wq(void *data); -extern int rtllib_wx_set_rawtx(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); +int rtllib_wx_set_rawtx(struct rtllib_device *ieee, + struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_get_name(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); +int rtllib_wx_get_name(struct rtllib_device *ieee, struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_set_power(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); +int rtllib_wx_set_power(struct rtllib_device *ieee, + struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_get_power(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); +int rtllib_wx_get_power(struct rtllib_device *ieee, + struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_set_rts(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); +int rtllib_wx_set_rts(struct rtllib_device *ieee, struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); -extern int rtllib_wx_get_rts(struct rtllib_device *ieee, - struct iw_request_info *info, - union iwreq_data *wrqu, char *extra); +int rtllib_wx_get_rts(struct rtllib_device *ieee, struct iw_request_info *info, + union iwreq_data *wrqu, char *extra); #define MAX_RECEIVE_BUFFER_SIZE 9100 void HTSetConnectBwMode(struct rtllib_device *ieee, enum ht_channel_width Bandwidth, enum ht_extchnl_offset Offset); -extern void HTUpdateDefaultSetting(struct rtllib_device *ieee); -extern void HTConstructCapabilityElement(struct rtllib_device *ieee, - u8 *posHTCap, u8 *len, - u8 isEncrypt, bool bAssoc); -extern void HTConstructInfoElement(struct rtllib_device *ieee, - u8 *posHTInfo, u8 *len, u8 isEncrypt); -extern void HTConstructRT2RTAggElement(struct rtllib_device *ieee, - u8 *posRT2RTAgg, u8 *len); -extern void HTOnAssocRsp(struct rtllib_device *ieee); -extern void HTInitializeHTInfo(struct rtllib_device *ieee); -extern void HTInitializeBssDesc(struct bss_ht *pBssHT); -extern void HTResetSelfAndSavePeerSetting(struct rtllib_device *ieee, - struct rtllib_network *pNetwork); -extern void HT_update_self_and_peer_setting(struct rtllib_device *ieee, - struct rtllib_network *pNetwork); -extern u8 HTGetHighestMCSRate(struct rtllib_device *ieee, u8 *pMCSRateSet, - u8 *pMCSFilter); +void HTUpdateDefaultSetting(struct rtllib_device *ieee); +void HTConstructCapabilityElement(struct rtllib_device *ieee, + u8 *posHTCap, u8 *len, + u8 isEncrypt, bool bAssoc); +void HTConstructInfoElement(struct rtllib_device *ieee, + u8 *posHTInfo, u8 *len, u8 isEncrypt); +void HTConstructRT2RTAggElement(struct rtllib_device *ieee, + u8 *posRT2RTAgg, u8 *len); +void HTOnAssocRsp(struct rtllib_device *ieee); +void HTInitializeHTInfo(struct rtllib_device *ieee); +void HTInitializeBssDesc(struct bss_ht *pBssHT); +void HTResetSelfAndSavePeerSetting(struct rtllib_device *ieee, + struct rtllib_network *pNetwork); +void HT_update_self_and_peer_setting(struct rtllib_device *ieee, + struct rtllib_network *pNetwork); +u8 HTGetHighestMCSRate(struct rtllib_device *ieee, u8 *pMCSRateSet, + u8 *pMCSFilter); extern u8 MCS_FILTER_ALL[]; extern u16 MCS_DATA_RATE[2][2][77]; -extern u8 HTCCheck(struct rtllib_device *ieee, u8 *pFrame); -extern void HTResetIOTSetting(struct rt_hi_throughput *pHTInfo); -extern bool IsHTHalfNmodeAPs(struct rtllib_device *ieee); -extern u16 HTMcsToDataRate(struct rtllib_device *ieee, u8 nMcsRate); -extern u16 TxCountToDataRate(struct rtllib_device *ieee, u8 nDataRate); -extern int rtllib_rx_ADDBAReq(struct rtllib_device *ieee, struct sk_buff *skb); -extern int rtllib_rx_ADDBARsp(struct rtllib_device *ieee, struct sk_buff *skb); -extern int rtllib_rx_DELBA(struct rtllib_device *ieee, struct sk_buff *skb); -extern void TsInitAddBA(struct rtllib_device *ieee, struct tx_ts_record *pTS, - u8 Policy, u8 bOverwritePending); -extern void TsInitDelBA(struct rtllib_device *ieee, - struct ts_common_info *pTsCommonInfo, - enum tr_select TxRxSelect); -extern void BaSetupTimeOut(unsigned long data); -extern void TxBaInactTimeout(unsigned long data); -extern void RxBaInactTimeout(unsigned long data); -extern void ResetBaEntry(struct ba_record *pBA); -extern bool GetTs( - struct rtllib_device *ieee, - struct ts_common_info **ppTS, - u8 *Addr, - u8 TID, - enum tr_select TxRxSelect, - bool bAddNewTs -); -extern void TSInitialize(struct rtllib_device *ieee); -extern void TsStartAddBaProcess(struct rtllib_device *ieee, - struct tx_ts_record *pTxTS); -extern void RemovePeerTS(struct rtllib_device *ieee, u8 *Addr); -extern void RemoveAllTS(struct rtllib_device *ieee); -void rtllib_softmac_scan_syncro(struct rtllib_device *ieee, u8 is_mesh); +u8 HTCCheck(struct rtllib_device *ieee, u8 *pFrame); +void HTResetIOTSetting(struct rt_hi_throughput *pHTInfo); +bool IsHTHalfNmodeAPs(struct rtllib_device *ieee); +u16 TxCountToDataRate(struct rtllib_device *ieee, u8 nDataRate); +int rtllib_rx_ADDBAReq(struct rtllib_device *ieee, struct sk_buff *skb); +int rtllib_rx_ADDBARsp(struct rtllib_device *ieee, struct sk_buff *skb); +int rtllib_rx_DELBA(struct rtllib_device *ieee, struct sk_buff *skb); +void TsInitAddBA(struct rtllib_device *ieee, struct tx_ts_record *pTS, + u8 Policy, u8 bOverwritePending); +void TsInitDelBA(struct rtllib_device *ieee, + struct ts_common_info *pTsCommonInfo, + enum tr_select TxRxSelect); +void BaSetupTimeOut(unsigned long data); +void TxBaInactTimeout(unsigned long data); +void RxBaInactTimeout(unsigned long data); +void ResetBaEntry(struct ba_record *pBA); +bool GetTs(struct rtllib_device *ieee, struct ts_common_info **ppTS, u8 *Addr, + u8 TID, enum tr_select TxRxSelect, bool bAddNewTs); +void TSInitialize(struct rtllib_device *ieee); +void TsStartAddBaProcess(struct rtllib_device *ieee, + struct tx_ts_record *pTxTS); +void RemovePeerTS(struct rtllib_device *ieee, u8 *Addr); +void RemoveAllTS(struct rtllib_device *ieee); extern const long rtllib_wlan_frequencies[]; @@ -2317,23 +2200,19 @@ bool rtllib_MgntDisconnect(struct rtllib_device *rtllib, u8 asRsn); /* For the function is more related to hardware setting, it's better to use the * ieee handler to refer to it. */ -extern void rtllib_update_active_chan_map(struct rtllib_device *ieee); -extern void rtllib_FlushRxTsPendingPkts(struct rtllib_device *ieee, - struct rx_ts_record *pTS); -extern int rtllib_parse_info_param(struct rtllib_device *ieee, - struct rtllib_info_element *info_element, - u16 length, - struct rtllib_network *network, - struct rtllib_rx_stats *stats); +void rtllib_FlushRxTsPendingPkts(struct rtllib_device *ieee, + struct rx_ts_record *pTS); +int rtllib_parse_info_param(struct rtllib_device *ieee, + struct rtllib_info_element *info_element, + u16 length, + struct rtllib_network *network, + struct rtllib_rx_stats *stats); void rtllib_indicate_packets(struct rtllib_device *ieee, struct rtllib_rxb **prxbIndicateArray, u8 index); -extern u8 HTFilterMCSRate(struct rtllib_device *ieee, u8 *pSupportMCS, - u8 *pOperateMCS); -extern void HTUseDefaultSetting(struct rtllib_device *ieee); +void HTUseDefaultSetting(struct rtllib_device *ieee); #define RT_ASOC_RETRY_LIMIT 5 u8 MgntQuery_TxRateExcludeCCKRates(struct rtllib_device *ieee); -extern void rtllib_TURBO_Info(struct rtllib_device *ieee, u8 **tag_p); #define SEM_DOWN_IEEE_WX(psem) down(psem) #define SEM_UP_IEEE_WX(psem) up(psem) diff --git a/drivers/staging/rtl8192e/rtllib_debug.h b/drivers/staging/rtl8192e/rtllib_debug.h index 42e88d69a..17c276d71 100644 --- a/drivers/staging/rtl8192e/rtllib_debug.h +++ b/drivers/staging/rtl8192e/rtllib_debug.h @@ -30,8 +30,6 @@ #define DRV_NAME "rtllib_92e" #endif -#define DMESG(x, a...) - extern u32 rt_global_debug_component; /* These are the defines for rt_global_debug_component */ @@ -40,10 +38,7 @@ enum RTL_DEBUG { COMP_DBG = (1 << 1), COMP_INIT = (1 << 2), COMP_RECV = (1 << 3), - COMP_SEND = (1 << 4), - COMP_CMD = (1 << 5), COMP_POWER = (1 << 6), - COMP_EPROM = (1 << 7), COMP_SWBW = (1 << 8), COMP_SEC = (1 << 9), COMP_LPS = (1 << 10), @@ -58,15 +53,12 @@ enum RTL_DEBUG { COMP_CH = (1 << 19), COMP_RF = (1 << 20), COMP_FIRMWARE = (1 << 21), - COMP_HT = (1 << 22), COMP_RESET = (1 << 23), COMP_CMDPKT = (1 << 24), COMP_SCAN = (1 << 25), COMP_PS = (1 << 26), COMP_DOWN = (1 << 27), COMP_INTR = (1 << 28), - COMP_LED = (1 << 29), - COMP_MLME = (1 << 30), COMP_ERR = (1 << 31) }; diff --git a/drivers/staging/rtl8192e/rtllib_rx.c b/drivers/staging/rtl8192e/rtllib_rx.c index da862c3da..09f0820fb 100644 --- a/drivers/staging/rtl8192e/rtllib_rx.c +++ b/drivers/staging/rtl8192e/rtllib_rx.c @@ -44,6 +44,9 @@ #include "rtllib.h" #include "dot11d.h" +static void rtllib_rx_mgt(struct rtllib_device *ieee, struct sk_buff *skb, + struct rtllib_rx_stats *stats); + static inline void rtllib_monitor_rx(struct rtllib_device *ieee, struct sk_buff *skb, struct rtllib_rx_stats *rx_status, @@ -317,7 +320,6 @@ rtllib_rx_frame_decrypt(struct rtllib_device *ieee, struct sk_buff *skb, netdev_dbg(ieee->dev, "Decryption failed ICV mismatch (key %d)\n", skb->data[hdrlen + 3] >> 6); - ieee->ieee_stats.rx_discards_undecryptable++; return -1; } @@ -1077,7 +1079,6 @@ static int rtllib_rx_get_crypt(struct rtllib_device *ieee, struct sk_buff *skb, netdev_dbg(ieee->dev, "Decryption failed (not set) (SA= %pM)\n", hdr->addr2); - ieee->ieee_stats.rx_discards_undecryptable++; return -1; } } @@ -1743,37 +1744,61 @@ static int rtllib_parse_qos_info_param_IE(struct rtllib_device *ieee, return rc; } -#define MFIE_STRING(x) case MFIE_TYPE_ ##x: return #x - static const char *get_info_element_string(u16 id) { switch (id) { - MFIE_STRING(SSID); - MFIE_STRING(RATES); - MFIE_STRING(FH_SET); - MFIE_STRING(DS_SET); - MFIE_STRING(CF_SET); - MFIE_STRING(TIM); - MFIE_STRING(IBSS_SET); - MFIE_STRING(COUNTRY); - MFIE_STRING(HOP_PARAMS); - MFIE_STRING(HOP_TABLE); - MFIE_STRING(REQUEST); - MFIE_STRING(CHALLENGE); - MFIE_STRING(POWER_CONSTRAINT); - MFIE_STRING(POWER_CAPABILITY); - MFIE_STRING(TPC_REQUEST); - MFIE_STRING(TPC_REPORT); - MFIE_STRING(SUPP_CHANNELS); - MFIE_STRING(CSA); - MFIE_STRING(MEASURE_REQUEST); - MFIE_STRING(MEASURE_REPORT); - MFIE_STRING(QUIET); - MFIE_STRING(IBSS_DFS); - MFIE_STRING(RSN); - MFIE_STRING(RATES_EX); - MFIE_STRING(GENERIC); - MFIE_STRING(QOS_PARAMETER); + case MFIE_TYPE_SSID: + return "SSID"; + case MFIE_TYPE_RATES: + return "RATES"; + case MFIE_TYPE_FH_SET: + return "FH_SET"; + case MFIE_TYPE_DS_SET: + return "DS_SET"; + case MFIE_TYPE_CF_SET: + return "CF_SET"; + case MFIE_TYPE_TIM: + return "TIM"; + case MFIE_TYPE_IBSS_SET: + return "IBSS_SET"; + case MFIE_TYPE_COUNTRY: + return "COUNTRY"; + case MFIE_TYPE_HOP_PARAMS: + return "HOP_PARAMS"; + case MFIE_TYPE_HOP_TABLE: + return "HOP_TABLE"; + case MFIE_TYPE_REQUEST: + return "REQUEST"; + case MFIE_TYPE_CHALLENGE: + return "CHALLENGE"; + case MFIE_TYPE_POWER_CONSTRAINT: + return "POWER_CONSTRAINT"; + case MFIE_TYPE_POWER_CAPABILITY: + return "POWER_CAPABILITY"; + case MFIE_TYPE_TPC_REQUEST: + return "TPC_REQUEST"; + case MFIE_TYPE_TPC_REPORT: + return "TPC_REPORT"; + case MFIE_TYPE_SUPP_CHANNELS: + return "SUPP_CHANNELS"; + case MFIE_TYPE_CSA: + return "CSA"; + case MFIE_TYPE_MEASURE_REQUEST: + return "MEASURE_REQUEST"; + case MFIE_TYPE_MEASURE_REPORT: + return "MEASURE_REPORT"; + case MFIE_TYPE_QUIET: + return "QUIET"; + case MFIE_TYPE_IBSS_DFS: + return "IBSS_DFS"; + case MFIE_TYPE_RSN: + return "RSN"; + case MFIE_TYPE_RATES_EX: + return "RATES_EX"; + case MFIE_TYPE_GENERIC: + return "GENERIC"; + case MFIE_TYPE_QOS_PARAMETER: + return "QOS_PARAMETER"; default: return "UNKNOWN"; } @@ -2717,9 +2742,9 @@ free_network: kfree(network); } -void rtllib_rx_mgt(struct rtllib_device *ieee, - struct sk_buff *skb, - struct rtllib_rx_stats *stats) +static void rtllib_rx_mgt(struct rtllib_device *ieee, + struct sk_buff *skb, + struct rtllib_rx_stats *stats) { struct rtllib_hdr_4addr *header = (struct rtllib_hdr_4addr *)skb->data; diff --git a/drivers/staging/rtl8192e/rtllib_softmac.c b/drivers/staging/rtl8192e/rtllib_softmac.c index d320c3173..1503cbb35 100644 --- a/drivers/staging/rtl8192e/rtllib_softmac.c +++ b/drivers/staging/rtl8192e/rtllib_softmac.c @@ -23,7 +23,10 @@ #include #include "dot11d.h" -short rtllib_is_54g(struct rtllib_network *net) +static void rtllib_sta_wakeup(struct rtllib_device *ieee, short nl); + + +static short rtllib_is_54g(struct rtllib_network *net) { return (net->rates_ex_len > 0) || (net->rates_len > 4); } @@ -107,7 +110,7 @@ static void rtllib_WMM_Info(struct rtllib_device *ieee, u8 **tag_p) *tag_p = tag; } -void rtllib_TURBO_Info(struct rtllib_device *ieee, u8 **tag_p) +static void rtllib_TURBO_Info(struct rtllib_device *ieee, u8 **tag_p) { u8 *tag = *tag_p; @@ -369,7 +372,7 @@ static inline struct sk_buff *rtllib_probe_req(struct rtllib_device *ieee) return skb; } -struct sk_buff *rtllib_get_beacon_(struct rtllib_device *ieee); +static struct sk_buff *rtllib_get_beacon_(struct rtllib_device *ieee); static void rtllib_send_beacon(struct rtllib_device *ieee) { @@ -483,7 +486,7 @@ static void rtllib_send_probe(struct rtllib_device *ieee, u8 is_mesh) } -void rtllib_send_probe_requests(struct rtllib_device *ieee, u8 is_mesh) +static void rtllib_send_probe_requests(struct rtllib_device *ieee, u8 is_mesh) { if (ieee->active_scan && (ieee->softmac_features & IEEE_SOFTMAC_PROBERQ)) { @@ -492,7 +495,7 @@ void rtllib_send_probe_requests(struct rtllib_device *ieee, u8 is_mesh) } } -void rtllib_update_active_chan_map(struct rtllib_device *ieee) +static void rtllib_update_active_chan_map(struct rtllib_device *ieee) { memcpy(ieee->active_channel_map, GET_DOT11D_INFO(ieee)->channel_map, MAX_CHANNEL_NUMBER+1); @@ -501,7 +504,7 @@ void rtllib_update_active_chan_map(struct rtllib_device *ieee) /* this performs syncro scan blocking the caller until all channels * in the allowed channel map has been checked. */ -void rtllib_softmac_scan_syncro(struct rtllib_device *ieee, u8 is_mesh) +static void rtllib_softmac_scan_syncro(struct rtllib_device *ieee, u8 is_mesh) { union iwreq_data wrqu; short ch = 0; @@ -1401,7 +1404,7 @@ inline struct sk_buff *rtllib_association_req(struct rtllib_network *beacon, return skb; } -void rtllib_associate_abort(struct rtllib_device *ieee) +static void rtllib_associate_abort(struct rtllib_device *ieee) { unsigned long flags; @@ -1511,7 +1514,6 @@ static void rtllib_associate_step2(struct rtllib_device *ieee) } } -#define CANCELLED 2 static void rtllib_associate_complete_wq(void *data) { struct rtllib_device *ieee = (struct rtllib_device *) @@ -1753,7 +1755,7 @@ inline void rtllib_softmac_new_net(struct rtllib_device *ieee, } } -void rtllib_softmac_check_all_nets(struct rtllib_device *ieee) +static void rtllib_softmac_check_all_nets(struct rtllib_device *ieee) { unsigned long flags; struct rtllib_network *target; @@ -2109,7 +2111,7 @@ out: } -void rtllib_sta_wakeup(struct rtllib_device *ieee, short nl) +static void rtllib_sta_wakeup(struct rtllib_device *ieee, short nl) { if (ieee->sta_sleep == LPS_IS_WAKE) { if (nl) { @@ -2545,7 +2547,7 @@ inline void rtllib_randomize_cell(struct rtllib_device *ieee) } /* called in user context only */ -void rtllib_start_master_bss(struct rtllib_device *ieee) +static void rtllib_start_master_bss(struct rtllib_device *ieee) { ieee->assoc_id = 1; @@ -2720,7 +2722,7 @@ inline void rtllib_start_ibss(struct rtllib_device *ieee) } /* this is called only in user context, with wx_sem held */ -void rtllib_start_bss(struct rtllib_device *ieee) +static void rtllib_start_bss(struct rtllib_device *ieee) { unsigned long flags; @@ -2817,7 +2819,7 @@ exit: up(&ieee->wx_sem); } -struct sk_buff *rtllib_get_beacon_(struct rtllib_device *ieee) +static struct sk_buff *rtllib_get_beacon_(struct rtllib_device *ieee) { const u8 broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; @@ -3084,7 +3086,7 @@ static int rtllib_wpa_enable(struct rtllib_device *ieee, int value) */ netdev_info(ieee->dev, "%s WPA\n", value ? "enabling" : "disabling"); ieee->wpa_enabled = value; - memset(ieee->ap_mac_addr, 0, 6); + eth_zero_addr(ieee->ap_mac_addr); return 0; } diff --git a/drivers/staging/rtl8192e/rtllib_tx.c b/drivers/staging/rtl8192e/rtllib_tx.c index e99ea5e67..b992e4612 100644 --- a/drivers/staging/rtl8192e/rtllib_tx.c +++ b/drivers/staging/rtl8192e/rtllib_tx.c @@ -151,7 +151,7 @@ static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 }; static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 }; -inline int rtllib_put_snap(u8 *data, u16 h_proto) +static int rtllib_put_snap(u8 *data, u16 h_proto) { struct rtllib_snap_hdr *snap; u8 *oui; @@ -205,7 +205,6 @@ int rtllib_encrypt_fragment(struct rtllib_device *ieee, struct sk_buff *frag, if (res < 0) { netdev_info(ieee->dev, "%s: Encryption failed: len=%d.\n", ieee->dev->name, frag->len); - ieee->ieee_stats.tx_discards++; return -1; } @@ -515,8 +514,8 @@ static void rtllib_txrate_selectmode(struct rtllib_device *ieee, } } -u16 rtllib_query_seqnum(struct rtllib_device *ieee, struct sk_buff *skb, - u8 *dst) +static u16 rtllib_query_seqnum(struct rtllib_device *ieee, struct sk_buff *skb, + u8 *dst) { u16 seqnum = 0; @@ -566,7 +565,7 @@ static u8 rtllib_current_rate(struct rtllib_device *ieee) return ieee->rate & 0x7F; } -int rtllib_xmit_inter(struct sk_buff *skb, struct net_device *dev) +static int rtllib_xmit_inter(struct sk_buff *skb, struct net_device *dev) { struct rtllib_device *ieee = (struct rtllib_device *) netdev_priv_rsl(dev); -- cgit v1.2.3-54-g00ecf