mt_wifi: update to 5.1.0.0 (#552)

This commit is contained in:
skbeh 2022-01-10 23:01:12 +08:00 committed by GitHub
parent 7d409270a9
commit 7ebc77027e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
687 changed files with 282136 additions and 253908 deletions

View File

@ -7,62 +7,89 @@ include $(TOPDIR)/rules.mk
include $(INCLUDE_DIR)/kernel.mk
PKG_NAME:=mt7615d
P4REV:=8
PKG_VERSION:=5.0.4.0
P4REV:=9
PKG_VERSION:=5.1.0.0
PKG_BUILD_DIR:=$(KERNEL_BUILD_DIR)/$(PKG_NAME)
PKG_KCONFIG:= \
AP_SUPPORT \
SUPPORT_OPENWRT \
WIFI_DRIVER \
FIRST_IF_MT7615E \
FIRST_IF_MT7622 \
FIRST_IF_MT7626 \
FIRST_IF_NONE \
SECOND_IF_NONE \
SECOND_IF_MT7615E \
THIRD_IF_NONE \
THIRD_IF_MT7615E \
RT_FIRST_CARD \
RT_SECOND_CARD \
RT_THIRD_CARD \
RT_FIRST_IF_RF_OFFSET \
RT_SECOND_IF_RF_OFFSET \
RT_THIRD_IF_RF_OFFSET \
MT_WIFI \
WIFI_BASIC_FUNC \
MT_WIFI_PATH \
FIRST_IF_NONE \
FIRST_IF_EEPROM_FLASH \
FIRST_IF_EEPROM_PROM \
FIRST_IF_EEPROM_EFUSE \
RT_FIRST_CARD_EEPROM \
SECOND_IF_NONE \
SECOND_IF_EEPROM_FLASH \
SECOND_IF_EEPROM_PROM \
SECOND_IF_EEPROM_EFUSE \
RT_SECOND_CARD_EEPROM \
THIRD_IF_EEPROM_FLASH \
THIRD_IF_EEPROM_PROM \
THIRD_IF_EEPROM_EFUSE \
RT_THIRD_CARD_EEPROM \
MULTI_INF_SUPPORT \
WIFI_BASIC_FUNC \
WIRELESS_EXT \
WEXT_SPY \
WEXT_PRIV \
DOT11_N_SUPPORT \
DOT11_VHT_AC \
WIFI_DRIVER \
G_BAND_256QAM_SUPPORT \
BRCM_256QAM_SUPPORT \
TPC_SUPPORT \
ICAP_SUPPORT \
MT_AP_SUPPORT \
SPECTRUM_SUPPORT \
BACKGROUND_SCAN_SUPPORT \
SMART_CARRIER_SENSE_SUPPORT \
MT_DFS_SUPPORT \
OFFCHANNEL_SCAN_FEATURE \
DPP_SUPPORT \
HDR_TRANS_TX_SUPPORT \
CHIP_MT7615E \
HDR_TRANS_RX_SUPPORT \
DBDC_MODE \
MULTI_PROFILE_SUPPORT \
DEFAULT_5G_PROFILE \
SUPPORT_DYNAMIC_TXOP \
WSC_INCLUDED \
MT_STA_SUPPORT \
WSC_V2_SUPPORT \
DOT11W_PMF_SUPPORT \
PASSPOINT_R2 \
TXBF_SUPPORT \
FAST_NAT_SUPPORT \
WHNAT_SUPPORT \
FTM_SUPPORT \
MBO_SUPPORT \
IGMP_SNOOP_SUPPORT \
RATE_ADAPTION \
RATE_ADAPT_AGBS_SUPPORT \
RTMP_FLASH_SUPPORT \
PRE_CAL_TRX_SET1_SUPPORT \
RLM_CAL_CACHE_SUPPORT \
PRE_CAL_TRX_SET2_SUPPORT \
RF_LOCKDOWN_SUPPORT \
LINK_TEST_SUPPORT \
ATE_SUPPORT \
PASSPOINT_R2 \
UAPSD \
TCP_RACK_SUPPORT \
RED_SUPPORT \
FDB_SUPPORT \
FIRST_IF_IPAILNA \
FIRST_IF_IPAELNA \
FIRST_IF_EPAELNA \
SECOND_IF_IPAILNA \
SECOND_IF_IPAELNA \
SECOND_IF_EPAELNA \
THIRD_IF_EPAELNA \
THIRD_IF_IPAILNA \
THIRD_IF_IPAELNA \
RLT_MAC \
RLT_BBP \
RLT_RF \
@ -74,102 +101,80 @@ PKG_KCONFIG:= \
RTMP_RBUS_SUPPORT \
WIFI_MODE_AP \
WIFI_MODE_STA \
WIRELESS_EXT \
WEXT_SPY \
WEXT_PRIV \
WIFI_MODE_BOTH \
MT_AP_SUPPORT \
WDS_SUPPORT \
WIFI_EAP_FEATURE \
VLAN_SUPPORT \
MLME_MULTI_QUEUE_SUPPORT \
TXRX_STAT_SUPPORT \
SNIFFER_SUPPORT \
ANTENNA_CONTROL_SUPPORT \
MGMT_TXPWR_CTRL \
CHUTIL_SUPPORT \
NF_SUPPORT \
RA_PHY_RATE_SUPPORT \
AMPDU_CONF_SUPPORT \
ACK_CTS_TIMEOUT_SUPPORT \
MBSS_SUPPORT \
APCLI_SUPPORT \
APCLI_CERT_SUPPORT \
MAC_REPEATER_SUPPORT \
RALINK_RT6352 \
RALINK_MT7620 \
RALINK_MT7603E \
CON_WPS_SUPPORT \
VOW_SUPPORT \
BAND_STEERING \
TXOP_ARBITER \
CFG_SUPPORT_DYNAMIC_TXOP \
WIFI_MODE_BOTH \
WIFI_RLT_MAC \
RLT_MAC \
WIFI_RTMP_MAC \
RTMP_MAC \
WIFI_MT_MAC \
CHIP_MT7603E \
CHIP_MT7615E \
MT_MAC \
RATE_ADAPTION \
SUPPORT_OPENWRT \
SDK_USER_LIGHTY \
MWDS \
MUMIMO_SUPPORT \
MU_RA_SUPPORT \
LED_CONTROL_SUPPORT \
RA_HW_NAT \
RA_HW_NAT_WIFI_NEW_ARCH \
CFG80211_SUPPORT \
SER_SUPPORT \
GREENAP_SUPPORT \
RADIUS_ACCOUNTING_SUPPORT \
TPC_SUPPORT \
RLM_CAL_CACHE_SUPPORT \
RF_LOCKDOWN_SUPPORT \
PASSPOINT_R2 \
RED_SUPPORT \
FIRST_IF_EPAELNA \
FIRST_IF_IPAILNA \
FIRST_IF_IPAELNA \
FIRST_IF_EPAILNA \
SECOND_IF_EPAELNA \
SECOND_IF_IPAILNA \
SECOND_IF_IPAELNA \
SECOND_IF_EPAILNA \
THIRD_IF_EPAELNA \
THIRD_IF_IPAILNA \
THIRD_IF_IPAELNA \
THIRD_IF_EPAILNA \
WIFI_PKT_FWD \
DOT11K_RRM_SUPPORT \
DOT11R_FT_SUPPORT \
MBO_SUPPORT \
WIFI_PKT_FWD_V1 \
FIRST_IF_MT7615E \
FIRST_IF_MT7622 \
FIRST_IF_MT7626 \
SECOND_IF_MT7615E \
THIRD_IF_NONE \
THIRD_IF_MT7615E \
RT_THIRD_CARD \
RT_THIRD_IF_RF_OFFSET \
THIRD_IF_EEPROM_FLASH \
THIRD_IF_EEPROM_PROM \
THIRD_IF_EEPROM_EFUSE \
RT_THIRD_CARD_EEPROM \
SPECTRUM_SUPPORT \
MULTI_PROFILE_SUPPORT \
PRE_CAL_TRX_SET1_SUPPORT \
MWDS \
DOT11K_RRM_SUPPORT \
INTERWORKING \
MAP_SUPPORT \
MAP_R2_VER_SUPPORT \
OFFCHANNEL_SCAN_FEATURE \
OCE_SUPPORT \
DPP_FEATURE \
ENTERPRISE_AP_SUPPORT \
DYNAMIC_VLAN_SUPPORT \
CFG80211_SUPPORT \
CUSTOMISED_HOSTAPD_SUPPORT \
APCLI_STA_SUPPORT \
WDS_STA_SUPPORT \
MBSS_AS_WDS_AP_SUPPORT \
DSCP_QOS_MAP_SUPPORT \
DSCP_PRI_SUPPORT \
HOSTAPD_MAP_SUPPORT \
MIN_PHY_RATE_SUPPORT \
FAST_UP_RATE_SUPPORT \
RADIUS_MAC_AUTH_SUPPORT \
CON_WPS_SUPPORT \
MCAST_RATE_SPECIFIC \
VOW_SUPPORT \
FQ_SCH_SUPPORT \
BAND_STEERING \
LED_CONTROL_SUPPORT \
WLAN_HOOK \
RADIUS_ACCOUNTING_SUPPORT \
GREENAP_SUPPORT \
PCIE_ASPM_DYM_CTRL_SUPPORT \
COEX_SUPPORT \
EASY_SETUP_SUPPORT \
EVENT_NOTIFIER_SUPPORT \
AIR_MONITOR \
WNM_SUPPORT \
INTERWORKING \
LINUX_NET_TXQ_SUPPORT \
WIFI_MSI_SUPPORT \
WPA3_SUPPORT \
OWE_SUPPORT \
VENDOR_FEATURE10_SUPPORT \
VENDOR_FEATURE11_SUPPORT \
RCSA_SUPPORT \
ETH_CONVERT_SUPPORT \
WIFI_MT_MAC \
RLT_MAC \
RTMP_MAC \
MT_MAC \
CHIP_MT7603E \
CHIP_MT7615E \
CHIP_MT7622 \
CHIP_MT7626 \
WHNAT_SUPPORT \
FAST_NAT_SUPPORT \
PRE_CAL_TRX_SET2_SUPPORT \
LINK_TEST_SUPPORT \
TCP_RACK_SUPPORT \
FQ_SCH_SUPPORT \
BRCM_256QAM_SUPPORT \
VHT_TXBF_2G_EPIGRAM_IE_SUPPORT \
DSCP_PRI_SUPPORT \
PCIE_ASPM_DYM_CTRL_SUPPORT \
CHIP_MT7663E \
CHIP_MT7626
PKG_CONFIG_DEPENDS:=$(foreach c, $(PKG_KCONFIG),$(if $(CONFIG_MTK_$c),CONFIG_$(c)))
@ -178,17 +183,20 @@ include $(INCLUDE_DIR)/package.mk
TAR_CMD=$(HOST_TAR) -C $(1)/ $(TAR_OPTIONS)
define KernelPackage/mt7615d
CATEGORY:=Kernel modules
TITLE:=MTK wifi AP driver
DEPENDS:=@TARGET_ramips
ifneq ($(CONFIG_MTK_WHNAT_SUPPORT), )
FILES:=$(PKG_BUILD_DIR)/mt_wifi_ap/mt_wifi.ko \
$(PKG_BUILD_DIR)/mt_wifi/embedded/tools/plug_in/whnat/mt_whnat.ko
CATEGORY:=Kernel modules
TITLE:=MTK wifi AP driver
DEPENDS:=@TARGET_ramips
KCONFIG:= \
CONFIG_PCI_MSI=y \
CONFIG_NET_SCH_FQ=y
ifneq ($(CONFIG_MTK_WHNAT_SUPPORT),)
FILES:=$(PKG_BUILD_DIR)/mt_wifi_ap/mt_wifi.ko \
$(PKG_BUILD_DIR)/mt_wifi/embedded/plug_in/whnat/mt_whnat.ko
else
FILES:=$(PKG_BUILD_DIR)/mt_wifi_ap/mt_wifi.ko
FILES:=$(PKG_BUILD_DIR)/mt_wifi_ap/mt_wifi.ko
endif
SUBMENU:=Wireless Drivers
MENU:=1
SUBMENU:=Wireless Drivers
MENU:=1
endef
define KernelPackage/mt7615d/config
@ -196,7 +204,7 @@ define KernelPackage/mt7615d/config
endef
define Build/Compile
$(MAKE) -C "$(LINUX_DIR)" V=1 \
$(MAKE) -j12 -C "$(LINUX_DIR)" \
CROSS_COMPILE="$(TARGET_CROSS)" \
ARCH="$(LINUX_KARCH)" \
M="$(PKG_BUILD_DIR)/mt_wifi_ap" \

View File

@ -210,17 +210,6 @@ config MTK_G_BAND_256QAM_SUPPORT
depends on MTK_DOT11_VHT_AC
default y
config MTK_BRCM_256QAM_SUPPORT
bool "BRCM 2.4G 256QAM support"
depends on MTK_WIFI_DRIVER
depends on MTK_G_BAND_256QAM_SUPPORT
default y
config MTK_VHT_TXBF_2G_EPIGRAM_IE_SUPPORT
bool "BRCM 2.4G VHT Sounding support"
depends on MTK_WIFI_DRIVER
default y
config MTK_TPC_SUPPORT
bool "802.11h TPC Support"
depends on MTK_WIFI_DRIVER
@ -253,10 +242,23 @@ config MTK_MT_DFS_SUPPORT
depends on MTK_WIFI_DRIVER
default y
#config WFA_VHT_R2_PF
# bool "WFA VHT R2 Plugfest"
# depends on DOT11_VHT_AC
# default n
config MTK_OFFCHANNEL_SCAN_FEATURE
bool "Channel Quality Monitor"
depends on MTK_WIFI_DRIVER
depends on MTK_MT_AP_SUPPORT
default n
config MTK_DPP_SUPPORT
bool "DPP Support"
depends on MTK_WIFI_DRIVER
depends on MTK_MT_AP_SUPPORT
select DOT11W_PMF_SUPPORT
default n
#config MTK_WFA_VHT_R2_PF
# bool "WFA VHT R2 Plugfest"
# depends on MTK_DOT11_VHT_AC
# default n
config MTK_HDR_TRANS_TX_SUPPORT
bool "Tx Header Translation"
@ -270,11 +272,10 @@ config MTK_HDR_TRANS_RX_SUPPORT
config MTK_DBDC_MODE
bool "dbdc mode support"
depends on MTK_CHIP_MT7615E || MTK_CHIP_MT7626
select MULTI_PROFILE_SUPPORT
select DEFAULT_5G_PROFILE
default y if TARGET_ramips_mt7621_DEVICE_phicomm_k2p
default n
depends on MTK_CHIP_MT7615E
select MTK_MULTI_PROFILE_SUPPORT
# select MTK_DEFAULT_5G_PROFILE
default y
config MTK_MULTI_PROFILE_SUPPORT
bool "Multi Profile Support"
@ -285,7 +286,6 @@ config MTK_MULTI_PROFILE_SUPPORT
config MTK_DEFAULT_5G_PROFILE
bool "5G default profile for DBDC"
depends on MTK_DBDC_MODE
# depends on MTK_MULTI_PROFILE_SUPPORT
default y if TARGET_ramips_mt7621_DEVICE_phicomm_k2p
default n
@ -313,33 +313,33 @@ config MTK_TXBF_SUPPORT
default y
config MTK_FAST_NAT_SUPPORT
bool "Fast-NAT support"
# depends on RA_HW_NAT_WIFI
default n
bool "Fast-NAT support"
# depends on MTK_RA_HW_NAT_WIFI
default n
config MTK_WHNAT_SUPPORT
tristate "Wifi Hardware NAT support"
depends on MTK_CHIP_MT7615E
depends on MTK_WLAN_HOOK
depends on MTK_FAST_NAT_SUPPORT
select PACKAGE_kmod-hw_nat
select PACKAGE_kmod-hw_nat
default n
#config LLTD_SUPPORT
#config MTK_LLTD_SUPPORT
# bool "LLTD (Link Layer Topology Discovery Protocol)"
# depends on WIFI_DRIVER
# depends on MT_AP_SUPPORT
# depends on MTK_WIFI_DRIVER
# depends on MTK_MT_AP_SUPPORT
# default n
#config QOS_DLS_SUPPORT
#config MTK_QOS_DLS_SUPPORT
# bool "802.11e DLS ((Direct-Link Setup) Support"
# depends on WIFI_DRIVER
# depends on MT_AP_SUPPORT
# depends on MTK_WIFI_DRIVER
# depends on MTK_MT_AP_SUPPORT
# default n
#config WAPI_SUPPORT
#config MTK_WAPI_SUPPORT
# bool "WAPI Support"
# depends on WIFI_DRIVER
# depends on MTK_WIFI_DRIVER
# default n
config MTK_FTM_SUPPORT
@ -348,9 +348,19 @@ config MTK_FTM_SUPPORT
select MTK_PASSPOINT_R2
default n
#config CARRIER_DETECTION_SUPPORT
config MTK_MBO_SUPPORT
bool "MBO Support"
depends on MTK_WIFI_DRIVER
select MTK_INTERWORKING
select MTK_WNM_SUPPORT
select MTK_DOT11K_RRM_SUPPORT
select MTK_DOT11R_FT_SUPPORT
select MTK_DOT11W_PMF_SUPPORT
default n
#config MTK_CARRIER_DETECTION_SUPPORT
# bool "Carrier Detect"
# depends on WIFI_DRIVER
# depends on MTK_WIFI_DRIVER
# default n
config MTK_IGMP_SNOOP_SUPPORT
@ -359,51 +369,51 @@ config MTK_IGMP_SNOOP_SUPPORT
depends on MTK_MT_AP_SUPPORT
default y
#config BLOCK_NET_IF
#config MTK_BLOCK_NET_IF
# bool "NETIF Block"
# depends on WIFI_DRIVER
# depends on MT_AP_SUPPORT
# depends on MTK_WIFI_DRIVER
# depends on MTK_MT_AP_SUPPORT
# default n
# help
# Support Net interface block while Tx-Sw queue full
#config RATE_ADAPTION
#config MTK_RATE_ADAPTION
# bool "New Rate Adaptation support"
# depends on WIFI_DRIVER
# depends on MTK_WIFI_DRIVER
# default y
#config NEW_RATE_ADAPT_SUPPORT
#config MTK_NEW_RATE_ADAPT_SUPPORT
# bool "Intelligent Rate Adaption"
# depends on WIFI_DRIVER && RATE_ADAPTION
# depends on MTK_WIFI_DRIVER && MTK_RATE_ADAPTION
# default y
#config AGS_SUPPORT
#config MTK_AGS_SUPPORT
# bool "Adaptive Group Switching"
# depends on WIFI_DRIVER && RATE_ADAPTION
# depends on MT_AP_SUPPORT || MT_STA_SUPPORT
# depends on MTK_WIFI_DRIVER && MTK_RATE_ADAPTION
# depends on MTK_MT_AP_SUPPORT || MTK_MT_STA_SUPPORT
# default n
#config RATE_ADAPT_AGBS_SUPPORT
#config MTK_RATE_ADAPT_AGBS_SUPPORT
# bool "Adaptive AGBS Mode"
# depends on WIFI_DRIVER && RATE_ADAPTION
# depends on MT_AP_SUPPORT || MT_STA_SUPPORT
# depends on MTK_WIFI_DRIVER && MTK_RATE_ADAPTION
# depends on MTK_MT_AP_SUPPORT || MTK_MT_STA_SUPPORT
# default y
#config IDS_SUPPORT
#config MTK_IDS_SUPPORT
# bool "IDS (Intrusion Detection System) Support"
# depends on WIFI_DRIVER
# depends on MT_AP_SUPPORT
# depends on MTK_WIFI_DRIVER
# depends on MTK_MT_AP_SUPPORT
# default n
#config WIFI_WORK_QUEUE
#config MTK_WIFI_WORK_QUEUE
# bool "Work Queue"
# depends on WIFI_DRIVER
# depends on MTK_WIFI_DRIVER
# default n
#config WIFI_SKB_RECYCLE
#config MTK_WIFI_SKB_RECYCLE
# bool "SKB Recycle(Linux)"
# depends on WIFI_DRIVER
# depends on MT_AP_SUPPORT
# depends on MTK_WIFI_DRIVER
# depends on MTK_MT_AP_SUPPORT
# default n
config MTK_RTMP_FLASH_SUPPORT
@ -459,19 +469,9 @@ config MTK_PASSPOINT_R2
depends on MTK_MT_AP_SUPPORT
default n
config MTK_MBO_SUPPORT
bool "MBO Support"
depends on MTK_WIFI_DRIVER
select MTK_INTERWORKING
select MTK_WNM_SUPPORT
select MTK_DOT11K_RRM_SUPPORT
select MTK_DOT11R_FT_SUPPORT
select MTK_DOT11W_PMF_SUPPORT
default n
#config TRACE_TCP_PKT
#config MTK_TRACE_TCP_PKT
# bool "TCP DATA/ACK packets trace log"
# depends on WIFI_DRIVER
# depends on MTK_WIFI_DRIVER
# default n
config MTK_UAPSD
@ -489,15 +489,8 @@ config MTK_TCP_RACK_SUPPORT
config MTK_RED_SUPPORT
bool "RED(Random Early Drop) support"
depends on MTK_WIFI_DRIVER
depends on MTK_MT_AP_SUPPORT || MTK_MT_STA_SUPPORT
default y
config MTK_FQ_SCH_SUPPORT
bool "Fair Queueing support"
depends on MTK_WIFI_DRIVER
depends on MTK_MT_AP_SUPPORT && MTK_VOW_SUPPORT
depends on MTK_CHIP_MT7622
depends on MTK_MT_AP_SUPPORT || MTK_MT_STA_SUPPORT
default y
config MTK_FDB_SUPPORT
@ -617,20 +610,79 @@ config MTK_WDS_SUPPORT
depends on MTK_MT_AP_SUPPORT
default y
config MTK_WIFI_EAP_FEATURE
bool "EAP Feature"
depends on MTK_WIFI_DRIVER
default y
config MTK_VLAN_SUPPORT
bool "VLAN Support"
depends on MT_AP_SUPPORT && WIFI_EAP_FEATURE
default y
config MTK_MLME_MULTI_QUEUE_SUPPORT
bool "Mlme Multi Queue Support"
default n
config MTK_TXRX_STAT_SUPPORT
bool "TxRx Stats Support"
depends on WIFI_DRIVER && WIFI_EAP_FEATURE
default y
config MTK_SNIFFER_SUPPORT
bool "SNIFFER"
depends on MT_AP_SUPPORT && WIFI_EAP_FEATURE
default y
config MTK_ANTENNA_CONTROL_SUPPORT
bool "Antenna Control"
depends on MT_AP_SUPPORT && WIFI_EAP_FEATURE
default y
config MTK_MGMT_TXPWR_CTRL
bool "Mgmt TxPower Control"
depends on MT_AP_SUPPORT && WIFI_EAP_FEATURE
default y
config MTK_CHUTIL_SUPPORT
bool "Channel Utilization Support"
depends on MT_AP_SUPPORT && WIFI_EAP_FEATURE
default y
config MTK_NF_SUPPORT
bool "Noise Floor Support"
depends on MT_AP_SUPPORT && WIFI_EAP_FEATURE
default y
config MTK_RA_PHY_RATE_SUPPORT
bool "RA PHY RATE Support"
depends on MT_AP_SUPPORT && WIFI_EAP_FEATURE
default y
config MTK_AMPDU_CONF_SUPPORT
bool "AMPDU Config retry & agglimit Support"
depends on MT_AP_SUPPORT && WIFI_EAP_FEATURE
default y
config MTK_ACK_CTS_TIMEOUT_SUPPORT
bool "ACK CTS Timeout cck & ofdm Support"
depends on MT_AP_SUPPORT && WIFI_EAP_FEATURE
default y
config MTK_MBSS_SUPPORT
bool "MBSSID"
depends on MTK_MT_AP_SUPPORT
default y
#config NEW_MBSSID_MODE
#config MTK_NEW_MBSSID_MODE
# bool "New MBSSID MODE"
# depends on MT_AP_SUPPORT && MBSS_SUPPORT
# depends on RALINK_RT3883 || RALINK_RT3352 || RALINK_RT5350 || RALINK_RT6352 || RALINK_MT7620
# depends on MTK_MT_AP_SUPPORT && MTK_MBSS_SUPPORT
# depends on MTK_RALINK_RT3883 || MTK_RALINK_RT3352 || MTK_RALINK_RT5350 || MTK_RALINK_RT6352 || MTK_RALINK_MT7620
# default y
#config ENHANCE_NEW_MBSSID_MODE
#config MTK_ENHANCE_NEW_MBSSID_MODE
# bool "Enhanced MBSSID mode"
# depends on NEW_MBSSID_MODE
# depends on MTK_NEW_MBSSID_MODE
# default y
config MTK_APCLI_SUPPORT
@ -677,21 +729,107 @@ config MTK_DOT11K_RRM_SUPPORT
depends on MTK_MT_AP_SUPPORT
default n
#config SNIFFER_SUPPORT
# bool "SNIFFER"
# depends on MT_AP_SUPPORT
# default n
config MTK_INTERWORKING
bool "802.11u Interworking"
depends on MTK_MT_AP_SUPPORT
default n
config MTK_MAP_SUPPORT
bool "Multi-AP Support"
depends on MTK_MT_AP_SUPPORT
select MTK_MBO_SUPPORT
default n
config MTK_MAP_R2_VER_SUPPORT
bool "Multi-AP R2 version support"
depends on MTK_MAP_SUPPORT
default n
config MTK_OCE_SUPPORT
bool "Optimized Connectivity Experience Support"
depends on MTK_MT_AP_SUPPORT
depends on MTK_CHIP_MT7615E
select MTK_WAPP_SUPPORT
default y
config MTK_ENTERPRISE_AP_SUPPORT
bool "Enterprise AP Support"
depends on MTK_MT_AP_SUPPORT
default n
config MTK_DYNAMIC_VLAN_SUPPORT
bool "Dynamic VLAN Support"
depends on MTK_MT_AP_SUPPORT
depends on MTK_ENTERPRISE_AP_SUPPORT
default n
config MTK_CFG80211_SUPPORT
bool "CFG80211"
depends on MTK_MT_AP_SUPPORT
default n
#CUSTOMISED HOSTAPD
config MTK_CUSTOMISED_HOSTAPD_SUPPORT
bool "Customised Hostapd Support"
depends on MTK_MT_AP_SUPPORT
depends on MTK_CFG80211_SUPPORT
default n
#APCLI STA
config MTK_APCLI_STA_SUPPORT
bool "APCLI STA Support"
depends on MTK_APCLI_SUPPORT
depends on MTK_CFG80211_SUPPORT
default n
#WDS STA
config MTK_WDS_STA_SUPPORT
bool "WDS STA Support"
depends on MTK_APCLI_SUPPORT
depends on MTK_CFG80211_SUPPORT
default n
#WDS AP
config MTK_MBSS_AS_WDS_AP_SUPPORT
bool "MBSS AS WDS AP Support"
depends on MTK_MT_AP_SUPPORT
depends on MTK_MBSS_SUPPORT
default n
config MTK_DSCP_QOS_MAP_SUPPORT
bool "Dscp Qos Mapping Support"
depends on MTK_MT_AP_SUPPORT
default n
config MTK_DSCP_PRI_SUPPORT
bool "Dscp Priority Mapping Support"
depends on MTK_MT_AP_SUPPORT
default n
#HOSTAPD_MAP_SUPPORT
config MTK_HOSTAPD_MAP_SUPPORT
bool "MAP with Hostapd Support"
depends on MTK_MT_AP_SUPPORT
depends on MTK_CFG80211_SUPPORT
depends on MTK_MAP_SUPPORT
default n
config MTK_MIN_PHY_RATE_SUPPORT
bool "Minimum PHY rate support"
depends on MTK_MT_AP_SUPPORT
default n
config MTK_FAST_UP_RATE_SUPPORT
bool "Fast UP rate support"
depends on MTK_MT_AP_SUPPORT
default n
config MTK_RADIUS_MAC_AUTH_SUPPORT
bool "RADIUS MAC Auth Support"
depends on MTK_ENTERPRISE_AP_SUPPORT
depends on MTK_CFG80211_SUPPORT
default n
config MTK_CON_WPS_SUPPORT
bool "Concurrent WPS Support"
depends on MTK_MT_AP_SUPPORT
@ -701,40 +839,43 @@ config MTK_CON_WPS_SUPPORT
# depends on MTK_MULTI_INF_SUPPORT
default n
#config LLTD_SUPPORT
#config MTK_LLTD_SUPPORT
# bool "LLTD (Link Layer Topology Discovery Protocol)"
# depends on MT_AP_SUPPORT
# depends on MTK_MT_AP_SUPPORT
#config COC_SUPPORT
#config MTK_COC_SUPPORT
# bool "CoC Support"
# depends on MT_AP_SUPPORT
# depends on MTK_MT_AP_SUPPORT
# default n
#config RT2860V2_SNMP
# bool "Net-SNMP Support"
# depends on MT_AP_SUPPORT
config MTK_MCAST_RATE_SPECIFIC
bool "User specific tx rate of mcast pkt"
depends on MTK_MT_AP_SUPPORT
default y
#config EXT_BUILD_CHANNEL_LIST
#config MTK_EXT_BUILD_CHANNEL_LIST
# bool "Extension Channel List"
# depends on MT_AP_SUPPORT
# depends on MTK_MT_AP_SUPPORT
#config AUTO_CH_SELECT_ENHANCE
#config MTK_AUTO_CH_SELECT_ENHANCE
# bool "Auto Channel Selection Enhancement"
# depends on MT_AP_SUPPORT
# depends on MTK_MT_AP_SUPPORT
config MTK_VOW_SUPPORT
bool "MediaAir(VOW) support"
depends on MTK_MT_AP_SUPPORT
default y
#config AIRPLAY_SUPPORT
config MTK_FQ_SCH_SUPPORT
bool "Fair Queueing support"
depends on MTK_WIFI_DRIVER
depends on MTK_MT_AP_SUPPORT && MTK_VOW_SUPPORT
depends on MTK_CHIP_MT7615E || MTK_CHIP_MT7622
default y
#config MTK_AIRPLAY_SUPPORT
# bool "AIRPLAY Support"
# depends on MT_AP_SUPPORT
# depends on MTK_MT_AP_SUPPORT
# default n
config MTK_BAND_STEERING
@ -743,8 +884,8 @@ config MTK_BAND_STEERING
default y
config MTK_LED_CONTROL_SUPPORT
bool "LED Control Support"
default y
bool "LED Control Support"
default n
config MTK_WLAN_HOOK
bool "WLAN hook Support"
@ -759,7 +900,7 @@ config MTK_RADIUS_ACCOUNTING_SUPPORT
config MTK_GREENAP_SUPPORT
bool "GreenAP Support"
depends on MTK_MT_AP_SUPPORT
default n
default y
config MTK_PCIE_ASPM_DYM_CTRL_SUPPORT
bool "Pcie Aspm Dynamic Control Support"
@ -791,25 +932,55 @@ config MTK_WNM_SUPPORT
depends on MTK_MT_AP_SUPPORT
default n
config MTK_INTERWORKING
bool "802.11u Interworking"
depends on MTK_MT_AP_SUPPORT
default n
config MTK_WIFI_MSI_SUPPORT
bool "MSI support"
depends on MTK_CHIP_MT7615E
default y
#config ROAMING_ENHANCE_SUPPORT
#config MTK_ROAMING_ENHANCE_SUPPORT
# bool "Roaming Enhance Support"
# depends on MT_AP_SUPPORT
# depends on APCLI_SUPPORT
# depends on MTK_MT_AP_SUPPORT
# depends on MTK_APCLI_SUPPORT
# default n
config MTK_LINUX_NET_TXQ_SUPPORT
bool "NET TX Queue Support"
default y
#config WIFI_FWD_SUPPORT
#config MTK_WIFI_FWD_SUPPORT
# bool "WiFi Forwarding Support"
# default n
config MTK_WPA3_SUPPORT
bool "WPA3 support"
depends on MTK_MT_AP_SUPPORT
default y
config MTK_OWE_SUPPORT
bool "Enhance OPEN(OWE) support"
depends on MTK_MT_AP_SUPPORT
depends on MTK_WPA3_SUPPORT
default y
config MTK_VENDOR_FEATURE10_SUPPORT
bool "Vendor10 Feature Enable"
depends on MTK_WIFI_DRIVER
depends on MTK_MT_AP_SUPPORT
default n
config MTK_VENDOR_FEATURE11_SUPPORT
bool "Vendor11 Feature Enable"
depends on MTK_WIFI_DRIVER
depends on MTK_MT_AP_SUPPORT
default n
config MTK_RCSA_SUPPORT
bool "Reverse-CSA"
depends on MTK_WIFI_DRIVER
depends on MTK_MT_DFS_SUPPORT
depends on MTK_APCLI_SUPPORT
default n
config MTK_ETH_CONVERT_SUPPORT
bool "Ethernet Convert Mode Support"
depends on MTK_MT_STA_SUPPORT
default y
endmenu
endif
@ -832,10 +1003,6 @@ if MTK_WIFI_RTMP_MAC
endif
if MTK_WIFI_MT_MAC
config MTK_MT_MAC
bool
default y
config MTK_CHIP_MT7603E
bool
default n

View File

@ -0,0 +1,503 @@
# SPDX-License-Identifier: GPL-2.0
#
# clang-format configuration file. Intended for clang-format >= 4.
#
# For more information, see:
#
# Documentation/process/clang-format.rst
# https://clang.llvm.org/docs/ClangFormat.html
# https://clang.llvm.org/docs/ClangFormatStyleOptions.html
#
---
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
#AlignEscapedNewlines: Left # Unknown to clang-format-4.0
AlignOperands: true
AlignTrailingComments: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: None
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: false
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: true
AfterNamespace: true
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
#AfterExternBlock: false # Unknown to clang-format-5.0
BeforeCatch: false
BeforeElse: false
IndentBraces: false
#SplitEmptyFunction: true # Unknown to clang-format-4.0
#SplitEmptyRecord: true # Unknown to clang-format-4.0
#SplitEmptyNamespace: true # Unknown to clang-format-4.0
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
#BreakBeforeInheritanceComma: false # Unknown to clang-format-4.0
BreakBeforeTernaryOperators: false
BreakConstructorInitializersBeforeComma: false
#BreakConstructorInitializers: BeforeComma # Unknown to clang-format-4.0
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: false
ColumnLimit: 80
CommentPragmas: "^ IWYU pragma:"
#CompactNamespaces: false # Unknown to clang-format-4.0
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 8
ContinuationIndentWidth: 8
Cpp11BracedListStyle: false
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
#FixNamespaceComments: false # Unknown to clang-format-4.0
# Taken from:
# git grep -h '^#define [^[:space:]]*for_each[^[:space:]]*(' include/ \
# | sed "s,^#define \([^[:space:]]*for_each[^[:space:]]*\)(.*$, - '\1'," \
# | sort | uniq
ForEachMacros:
- "apei_estatus_for_each_section"
- "ata_for_each_dev"
- "ata_for_each_link"
- "__ata_qc_for_each"
- "ata_qc_for_each"
- "ata_qc_for_each_raw"
- "ata_qc_for_each_with_internal"
- "ax25_for_each"
- "ax25_uid_for_each"
- "__bio_for_each_bvec"
- "bio_for_each_bvec"
- "bio_for_each_integrity_vec"
- "__bio_for_each_segment"
- "bio_for_each_segment"
- "bio_for_each_segment_all"
- "bio_list_for_each"
- "bip_for_each_vec"
- "blkg_for_each_descendant_post"
- "blkg_for_each_descendant_pre"
- "blk_queue_for_each_rl"
- "bond_for_each_slave"
- "bond_for_each_slave_rcu"
- "bpf_for_each_spilled_reg"
- "btree_for_each_safe128"
- "btree_for_each_safe32"
- "btree_for_each_safe64"
- "btree_for_each_safel"
- "card_for_each_dev"
- "cgroup_taskset_for_each"
- "cgroup_taskset_for_each_leader"
- "cpufreq_for_each_entry"
- "cpufreq_for_each_entry_idx"
- "cpufreq_for_each_valid_entry"
- "cpufreq_for_each_valid_entry_idx"
- "css_for_each_child"
- "css_for_each_descendant_post"
- "css_for_each_descendant_pre"
- "device_for_each_child_node"
- "dma_fence_chain_for_each"
- "drm_atomic_crtc_for_each_plane"
- "drm_atomic_crtc_state_for_each_plane"
- "drm_atomic_crtc_state_for_each_plane_state"
- "drm_atomic_for_each_plane_damage"
- "drm_client_for_each_connector_iter"
- "drm_client_for_each_modeset"
- "drm_connector_for_each_possible_encoder"
- "drm_for_each_connector_iter"
- "drm_for_each_crtc"
- "drm_for_each_encoder"
- "drm_for_each_encoder_mask"
- "drm_for_each_fb"
- "drm_for_each_legacy_plane"
- "drm_for_each_plane"
- "drm_for_each_plane_mask"
- "drm_for_each_privobj"
- "drm_mm_for_each_hole"
- "drm_mm_for_each_node"
- "drm_mm_for_each_node_in_range"
- "drm_mm_for_each_node_safe"
- "flow_action_for_each"
- "for_each_active_dev_scope"
- "for_each_active_drhd_unit"
- "for_each_active_iommu"
- "for_each_available_child_of_node"
- "for_each_bio"
- "for_each_board_func_rsrc"
- "for_each_bvec"
- "for_each_card_components"
- "for_each_card_links"
- "for_each_card_links_safe"
- "for_each_card_prelinks"
- "for_each_card_rtds"
- "for_each_card_rtds_safe"
- "for_each_cgroup_storage_type"
- "for_each_child_of_node"
- "for_each_clear_bit"
- "for_each_clear_bit_from"
- "for_each_cmsghdr"
- "for_each_compatible_node"
- "for_each_component_dais"
- "for_each_component_dais_safe"
- "for_each_comp_order"
- "for_each_console"
- "for_each_cpu"
- "for_each_cpu_and"
- "for_each_cpu_not"
- "for_each_cpu_wrap"
- "for_each_dev_addr"
- "for_each_dev_scope"
- "for_each_displayid_db"
- "for_each_dma_cap_mask"
- "for_each_dpcm_be"
- "for_each_dpcm_be_rollback"
- "for_each_dpcm_be_safe"
- "for_each_dpcm_fe"
- "for_each_drhd_unit"
- "for_each_dss_dev"
- "for_each_efi_memory_desc"
- "for_each_efi_memory_desc_in_map"
- "for_each_element"
- "for_each_element_extid"
- "for_each_element_id"
- "for_each_endpoint_of_node"
- "for_each_evictable_lru"
- "for_each_fib6_node_rt_rcu"
- "for_each_fib6_walker_rt"
- "for_each_free_mem_pfn_range_in_zone"
- "for_each_free_mem_pfn_range_in_zone_from"
- "for_each_free_mem_range"
- "for_each_free_mem_range_reverse"
- "for_each_func_rsrc"
- "for_each_hstate"
- "for_each_if"
- "for_each_iommu"
- "for_each_ip_tunnel_rcu"
- "for_each_irq_nr"
- "for_each_link_codecs"
- "for_each_link_platforms"
- "for_each_lru"
- "for_each_matching_node"
- "for_each_matching_node_and_match"
- "for_each_memblock"
- "for_each_memblock_type"
- "for_each_memcg_cache_index"
- "for_each_mem_pfn_range"
- "for_each_mem_range"
- "for_each_mem_range_rev"
- "for_each_migratetype_order"
- "for_each_msi_entry"
- "for_each_msi_entry_safe"
- "for_each_net"
- "for_each_netdev"
- "for_each_netdev_continue"
- "for_each_netdev_continue_rcu"
- "for_each_netdev_feature"
- "for_each_netdev_in_bond_rcu"
- "for_each_netdev_rcu"
- "for_each_netdev_reverse"
- "for_each_netdev_safe"
- "for_each_net_rcu"
- "for_each_new_connector_in_state"
- "for_each_new_crtc_in_state"
- "for_each_new_mst_mgr_in_state"
- "for_each_new_plane_in_state"
- "for_each_new_private_obj_in_state"
- "for_each_node"
- "for_each_node_by_name"
- "for_each_node_by_type"
- "for_each_node_mask"
- "for_each_node_state"
- "for_each_node_with_cpus"
- "for_each_node_with_property"
- "for_each_of_allnodes"
- "for_each_of_allnodes_from"
- "for_each_of_cpu_node"
- "for_each_of_pci_range"
- "for_each_old_connector_in_state"
- "for_each_old_crtc_in_state"
- "for_each_old_mst_mgr_in_state"
- "for_each_oldnew_connector_in_state"
- "for_each_oldnew_crtc_in_state"
- "for_each_oldnew_mst_mgr_in_state"
- "for_each_oldnew_plane_in_state"
- "for_each_oldnew_plane_in_state_reverse"
- "for_each_oldnew_private_obj_in_state"
- "for_each_old_plane_in_state"
- "for_each_old_private_obj_in_state"
- "for_each_online_cpu"
- "for_each_online_node"
- "for_each_online_pgdat"
- "for_each_pci_bridge"
- "for_each_pci_dev"
- "for_each_pci_msi_entry"
- "for_each_populated_zone"
- "for_each_possible_cpu"
- "for_each_present_cpu"
- "for_each_prime_number"
- "for_each_prime_number_from"
- "for_each_process"
- "for_each_process_thread"
- "for_each_property_of_node"
- "for_each_registered_fb"
- "for_each_reserved_mem_region"
- "for_each_rtd_codec_dai"
- "for_each_rtd_codec_dai_rollback"
- "for_each_rtdcom"
- "for_each_rtdcom_safe"
- "for_each_set_bit"
- "for_each_set_bit_from"
- "for_each_sg"
- "for_each_sg_dma_page"
- "for_each_sg_page"
- "for_each_sibling_event"
- "for_each_subelement"
- "for_each_subelement_extid"
- "for_each_subelement_id"
- "__for_each_thread"
- "for_each_thread"
- "for_each_zone"
- "for_each_zone_zonelist"
- "for_each_zone_zonelist_nodemask"
- "fwnode_for_each_available_child_node"
- "fwnode_for_each_child_node"
- "fwnode_graph_for_each_endpoint"
- "gadget_for_each_ep"
- "genradix_for_each"
- "genradix_for_each_from"
- "hash_for_each"
- "hash_for_each_possible"
- "hash_for_each_possible_rcu"
- "hash_for_each_possible_rcu_notrace"
- "hash_for_each_possible_safe"
- "hash_for_each_rcu"
- "hash_for_each_safe"
- "hctx_for_each_ctx"
- "hlist_bl_for_each_entry"
- "hlist_bl_for_each_entry_rcu"
- "hlist_bl_for_each_entry_safe"
- "hlist_for_each"
- "hlist_for_each_entry"
- "hlist_for_each_entry_continue"
- "hlist_for_each_entry_continue_rcu"
- "hlist_for_each_entry_continue_rcu_bh"
- "hlist_for_each_entry_from"
- "hlist_for_each_entry_from_rcu"
- "hlist_for_each_entry_rcu"
- "hlist_for_each_entry_rcu_bh"
- "hlist_for_each_entry_rcu_notrace"
- "hlist_for_each_entry_safe"
- "__hlist_for_each_rcu"
- "hlist_for_each_safe"
- "hlist_nulls_for_each_entry"
- "hlist_nulls_for_each_entry_from"
- "hlist_nulls_for_each_entry_rcu"
- "hlist_nulls_for_each_entry_safe"
- "i3c_bus_for_each_i2cdev"
- "i3c_bus_for_each_i3cdev"
- "ide_host_for_each_port"
- "ide_port_for_each_dev"
- "ide_port_for_each_present_dev"
- "idr_for_each_entry"
- "idr_for_each_entry_continue"
- "idr_for_each_entry_continue_ul"
- "idr_for_each_entry_ul"
- "in_dev_for_each_ifa_rcu"
- "in_dev_for_each_ifa_rtnl"
- "inet_bind_bucket_for_each"
- "inet_lhash2_for_each_icsk_rcu"
- "key_for_each"
- "key_for_each_safe"
- "klp_for_each_func"
- "klp_for_each_func_safe"
- "klp_for_each_func_static"
- "klp_for_each_object"
- "klp_for_each_object_safe"
- "klp_for_each_object_static"
- "kvm_for_each_memslot"
- "kvm_for_each_vcpu"
- "list_for_each"
- "list_for_each_codec"
- "list_for_each_codec_safe"
- "list_for_each_entry"
- "list_for_each_entry_continue"
- "list_for_each_entry_continue_rcu"
- "list_for_each_entry_continue_reverse"
- "list_for_each_entry_from"
- "list_for_each_entry_from_rcu"
- "list_for_each_entry_from_reverse"
- "list_for_each_entry_lockless"
- "list_for_each_entry_rcu"
- "list_for_each_entry_reverse"
- "list_for_each_entry_safe"
- "list_for_each_entry_safe_continue"
- "list_for_each_entry_safe_from"
- "list_for_each_entry_safe_reverse"
- "list_for_each_prev"
- "list_for_each_prev_safe"
- "list_for_each_safe"
- "llist_for_each"
- "llist_for_each_entry"
- "llist_for_each_entry_safe"
- "llist_for_each_safe"
- "media_device_for_each_entity"
- "media_device_for_each_intf"
- "media_device_for_each_link"
- "media_device_for_each_pad"
- "nanddev_io_for_each_page"
- "netdev_for_each_lower_dev"
- "netdev_for_each_lower_private"
- "netdev_for_each_lower_private_rcu"
- "netdev_for_each_mc_addr"
- "netdev_for_each_uc_addr"
- "netdev_for_each_upper_dev_rcu"
- "netdev_hw_addr_list_for_each"
- "nft_rule_for_each_expr"
- "nla_for_each_attr"
- "nla_for_each_nested"
- "nlmsg_for_each_attr"
- "nlmsg_for_each_msg"
- "nr_neigh_for_each"
- "nr_neigh_for_each_safe"
- "nr_node_for_each"
- "nr_node_for_each_safe"
- "of_for_each_phandle"
- "of_property_for_each_string"
- "of_property_for_each_u32"
- "pci_bus_for_each_resource"
- "ping_portaddr_for_each_entry"
- "plist_for_each"
- "plist_for_each_continue"
- "plist_for_each_entry"
- "plist_for_each_entry_continue"
- "plist_for_each_entry_safe"
- "plist_for_each_safe"
- "pnp_for_each_card"
- "pnp_for_each_dev"
- "protocol_for_each_card"
- "protocol_for_each_dev"
- "queue_for_each_hw_ctx"
- "radix_tree_for_each_slot"
- "radix_tree_for_each_tagged"
- "rbtree_postorder_for_each_entry_safe"
- "rdma_for_each_block"
- "rdma_for_each_port"
- "resource_list_for_each_entry"
- "resource_list_for_each_entry_safe"
- "rhl_for_each_entry_rcu"
- "rhl_for_each_rcu"
- "rht_for_each"
- "rht_for_each_entry"
- "rht_for_each_entry_from"
- "rht_for_each_entry_rcu"
- "rht_for_each_entry_rcu_from"
- "rht_for_each_entry_safe"
- "rht_for_each_from"
- "rht_for_each_rcu"
- "rht_for_each_rcu_from"
- "__rq_for_each_bio"
- "rq_for_each_bvec"
- "rq_for_each_segment"
- "scsi_for_each_prot_sg"
- "scsi_for_each_sg"
- "sctp_for_each_hentry"
- "sctp_skb_for_each"
- "shdma_for_each_chan"
- "__shost_for_each_device"
- "shost_for_each_device"
- "sk_for_each"
- "sk_for_each_bound"
- "sk_for_each_entry_offset_rcu"
- "sk_for_each_from"
- "sk_for_each_rcu"
- "sk_for_each_safe"
- "sk_nulls_for_each"
- "sk_nulls_for_each_from"
- "sk_nulls_for_each_rcu"
- "snd_array_for_each"
- "snd_pcm_group_for_each_entry"
- "snd_soc_dapm_widget_for_each_path"
- "snd_soc_dapm_widget_for_each_path_safe"
- "snd_soc_dapm_widget_for_each_sink_path"
- "snd_soc_dapm_widget_for_each_source_path"
- "tb_property_for_each"
- "tcf_exts_for_each_action"
- "udp_portaddr_for_each_entry"
- "udp_portaddr_for_each_entry_rcu"
- "usb_hub_for_each_child"
- "v4l2_device_for_each_subdev"
- "v4l2_m2m_for_each_dst_buf"
- "v4l2_m2m_for_each_dst_buf_safe"
- "v4l2_m2m_for_each_src_buf"
- "v4l2_m2m_for_each_src_buf_safe"
- "virtio_device_for_each_vq"
- "xa_for_each"
- "xa_for_each_marked"
- "xa_for_each_start"
- "xas_for_each"
- "xas_for_each_conflict"
- "xas_for_each_marked"
- "zorro_for_each_dev"
#IncludeBlocks: Preserve # Unknown to clang-format-5.0
IncludeCategories:
- Regex: ".*"
Priority: 1
IncludeIsMainRegex: "(Test)?$"
IndentCaseLabels: false
#IndentPPDirectives: None # Unknown to clang-format-5.0
IndentWidth: 8
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ""
MacroBlockEnd: ""
MaxEmptyLinesToKeep: 1
NamespaceIndentation: Inner
#ObjCBinPackProtocolList: Auto # Unknown to clang-format-5.0
ObjCBlockIndentWidth: 8
ObjCSpaceAfterProperty: true
ObjCSpaceBeforeProtocolList: true
# Taken from git's rules
#PenaltyBreakAssignment: 10 # Unknown to clang-format-4.0
PenaltyBreakBeforeFirstCallParameter: 30
PenaltyBreakComment: 10
PenaltyBreakFirstLessLess: 0
PenaltyBreakString: 10
PenaltyExcessCharacter: 100
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
ReflowComments: false
SortIncludes: false
#SortUsingDeclarations: false # Unknown to clang-format-4.0
SpaceAfterCStyleCast: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
#SpaceBeforeCtorInitializerColon: true # Unknown to clang-format-5.0
#SpaceBeforeInheritanceColon: true # Unknown to clang-format-5.0
SpaceBeforeParens: ControlStatements
#SpaceBeforeRangeBasedForLoopColon: true # Unknown to clang-format-5.0
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp03
TabWidth: 8
UseTab: Always

View File

@ -4,7 +4,8 @@
#include "rt_config.h"
#endif
#if defined(RTMP_USB_SUPPORT) || defined(RTMP_PCI_SUPPORT) || defined(MTK_UART_SUPPORT)
#if defined(RTMP_USB_SUPPORT) || defined(RTMP_PCI_SUPPORT) || \
defined(MTK_UART_SUPPORT)
INT32 ATECheckFWROMWiFiSysOn(RTMP_ADAPTER *pAd)
{
INT32 ntStatus = STATUS_SUCCESS;
@ -25,12 +26,16 @@ INT32 ATECheckFWROMWiFiSysOn(RTMP_ADAPTER *pAd)
} while (loop <= 500);
if (loop > 500) {
MTWF_LOG(DBG_CAT_FW, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s: 2. SW_SYN0 is not at init. state (SW_SYN0 = %d)\n", __func__, value));
MTWF_LOG(
DBG_CAT_FW, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s: 2. SW_SYN0 is not at init. state (SW_SYN0 = %d)\n",
__func__, value));
ntStatus = STATUS_UNSUCCESSFUL;
}
/* power on WiFi SYS*/
MTWF_LOG(DBG_CAT_FW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s: 2. power on WiFi SYS\n", __func__));
MTWF_LOG(DBG_CAT_FW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s: 2. power on WiFi SYS\n", __func__));
ntStatus = MtCmdPowerOnWiFiSys(pAd);
if (ntStatus)
@ -50,7 +55,9 @@ INT32 ATECheckFWROMWiFiSysOn(RTMP_ADAPTER *pAd)
} while (loop <= 500);
if (loop > 500) {
MTWF_LOG(DBG_CAT_FW, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s: SW_SYN0 is not at init. state (SW_SYN0 = %d)\n", __func__, value));
MTWF_LOG(DBG_CAT_FW, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s: SW_SYN0 is not at init. state (SW_SYN0 = %d)\n",
__func__, value));
ntStatus = STATUS_UNSUCCESSFUL;
}
@ -58,25 +65,26 @@ INT32 ATECheckFWROMWiFiSysOn(RTMP_ADAPTER *pAd)
}
#endif
INT32 CheckFWROMWiFiSysOn(IN RTMP_ADAPTER *pAd)
INT32 CheckFWROMWiFiSysOn(IN RTMP_ADAPTER *pAd)
{
INT32 ntStatus = STATUS_SUCCESS;
#if defined(RTMP_USB_SUPPORT) || defined(RTMP_PCI_SUPPORT) || defined(MTK_UART_SUPPORT)
#if defined(RTMP_USB_SUPPORT) || defined(RTMP_PCI_SUPPORT) || \
defined(MTK_UART_SUPPORT)
ntStatus = ATECheckFWROMWiFiSysOn(pAd);
#endif
return ntStatus;
}
INT32 FWSwitchToROM(
IN RTMP_ADAPTER *pAd
)
INT32 FWSwitchToROM(IN RTMP_ADAPTER *pAd)
{
INT32 ntStatus = STATUS_SUCCESS;
INT32 ntStatus = STATUS_SUCCESS;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s\n", __func__));
#ifdef COMPOS_TESTMODE_WIN /* Linux ready in FWRAM */
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s\n", __func__));
#ifdef COMPOS_TESTMODE_WIN /* Linux ready in FWRAM */
if (pAd->FWMode == FWROM)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s: FWMode is already ROM\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s: FWMode is already ROM\n", __func__));
else if (pAd->FWMode == FWRAM)
#endif
{
@ -90,7 +98,9 @@ INT32 FWSwitchToROM(
ntStatus = CheckFWROMWiFiSysOn(pAd);
if (ntStatus != STATUS_SUCCESS)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s, CheckFWROMWiFiSysOn failed\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s, CheckFWROMWiFiSysOn failed\n",
__func__));
}
return ntStatus;
@ -99,22 +109,28 @@ void LoopBack_Start(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
/* UINT16 BreakCount = 0; */
#ifdef COMPOS_TESTMODE_WIN /* TODO::Fix the strcture */
#ifdef COMPOS_TESTMODE_WIN /* TODO::Fix the strcture */
#endif
/* UINT32 Length = 0; */
/* UINT32 RepeatIdx = 0; */
UINT32 RxQ = 1;
UINT32 RxQ = 1;
/* RtlCopyMemory(&pAd->LoopBackSetting, pSetting,sizeof(struct _LOOPBACK_SETTING)); */
os_move_mem(&pAd->LbCtrl.LoopBackSetting, pSetting, sizeof(struct _LOOPBACK_SETTING));
os_move_mem(&pAd->LbCtrl.LoopBackSetting, pSetting,
sizeof(struct _LOOPBACK_SETTING));
/* RtlZeroMemory(&pAd->LoopBackTxRaw, LOOPBACK_SIZE); */
os_zero_mem(&pAd->LbCtrl.LoopBackTxRaw, LOOPBACK_SIZE);
/* RtlZeroMemory(&pAd->LoopBackRxRaw, LOOPBACK_SIZE); */
os_zero_mem(&pAd->LbCtrl.LoopBackRxRaw, LOOPBACK_SIZE);
/* RtlZeroMemory(&pAd->LoopBackResult, sizeof(struct _LOOPBACK_RESULT)); */
os_zero_mem(&pAd->LbCtrl.LoopBackResult, sizeof(struct _LOOPBACK_RESULT));
os_zero_mem(&pAd->LbCtrl.LoopBackResult,
sizeof(struct _LOOPBACK_RESULT));
if (pSetting->StartLen < sizeof(TMAC_TXD_L)) {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_WARN, ("%s startLength(0x%x) is shorter than sizeof(TMAC_TXD_L) (0x%lx)\n", __func__, pSetting->StartLen, (ULONG)sizeof(TMAC_TXD_L)));
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("%s startLength(0x%x) is shorter than sizeof(TMAC_TXD_L) (0x%lx)\n",
__func__, pSetting->StartLen,
(ULONG)sizeof(TMAC_TXD_L)));
return;
}
@ -123,15 +139,23 @@ void LoopBack_Start(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting)
OS_SPIN_UNLOCK(&pAd->LbCtrl.LoopBackLock);
pAd->LbCtrl.LoopBackRunning = TRUE;
pAd->LbCtrl.LoopBackResult.Status = RUNNING;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("IsDefaultPattern %d\n", pSetting->IsDefaultPattern));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("RepeatTimes %u, %u\n", pSetting->RepeatTimes, pAd->LbCtrl.LoopBackSetting.RepeatTimes));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("StartLen %d\n", pSetting->StartLen));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("StopLen %d\n", pSetting->StopLen));
pAd->LbCtrl.LoopBackDefaultPattern = (BOOLEAN)pSetting->IsDefaultPattern;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("IsDefaultPattern %d\n", pSetting->IsDefaultPattern));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("RepeatTimes %u, %u\n", pSetting->RepeatTimes,
pAd->LbCtrl.LoopBackSetting.RepeatTimes));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("StartLen %d\n", pSetting->StartLen));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("StopLen %d\n", pSetting->StopLen));
pAd->LbCtrl.LoopBackDefaultPattern =
(BOOLEAN)pSetting->IsDefaultPattern;
if (pAd->LbCtrl.DebugMode) {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("In LoopBack Debug Mode\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("In LoopBack Debug Mode\n"));
goto ATE_LPBK_DEBUG;
}
@ -139,17 +163,22 @@ void LoopBack_Start(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting)
ntStatus = FWSwitchToROM(pAd);
if (ntStatus != STATUS_SUCCESS)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s, Switch to ROM failed (0x%x)\n", __func__, ntStatus));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s, Switch to ROM failed (0x%x)\n", __func__,
ntStatus));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s FWSwitchToROM\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s FWSwitchToROM\n", __func__));
}
if (!pAd->LbCtrl.LoopBackUDMA)
MtCmdHIFLoopBackTest(pAd, 1, (UINT8)RxQ);
ATE_LPBK_DEBUG:
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("***************************************%s @#@# Rx[%d]***************************************\n", __func__, RxQ));
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("***************************************%s @#@# Rx[%d]***************************************\n",
__func__, RxQ));
/* pAd->LbCtrl.LoopBackTxThread = NULL; */
/*
* ntStatus = PsCreateSystemThread(&pAd->LbCtrl.LoopBackTxTask.hThread,
@ -160,17 +189,21 @@ ATE_LPBK_DEBUG:
* LoopBack_TxThread,
* pAd);
*/
ntStatus = RtmpOSTaskAttach(&pAd->LbCtrl.LoopBackTxTask, LoopBack_TxThread, (ULONG)&pAd->LbCtrl.LoopBackTxTask);
ntStatus =
RtmpOSTaskAttach(&pAd->LbCtrl.LoopBackTxTask, LoopBack_TxThread,
(ULONG)&pAd->LbCtrl.LoopBackTxTask);
if (ntStatus != STATUS_SUCCESS)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s, thread create fail\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s, thread create fail\n", __func__));
}
void LoopBack_Stop(RTMP_ADAPTER *pAd)
{
UINT32 BreakCount = 0;
while (pAd->LbCtrl.LoopBackWaitRx == TRUE) {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, @#@#BreakCount = %d\n", __func__, BreakCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, @#@#BreakCount = %d\n", __func__, BreakCount));
if (BreakCount > 100)
break;
@ -184,42 +217,62 @@ void LoopBack_Stop(RTMP_ADAPTER *pAd)
}
if (RtmpOSTaskKill(&pAd->LbCtrl.LoopBackTxTask) == NDIS_STATUS_FAILURE)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("kill LoopBackTxTask task failed!\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("kill LoopBackTxTask task failed!\n"));
if (pAd->LbCtrl.LoopBackResult.Status == RUNNING) {
pAd->LbCtrl.LoopBackResult.Status = PASS;
pAd->LbCtrl.LoopBackResult.FailReason = NO_ERROR;
}
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("***************************************%s @#@#***************************************\n", __func__));
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("***************************************%s @#@#***************************************\n",
__func__));
pAd->LbCtrl.LoopBackRunning = FALSE;
if (pAd->LbCtrl.DebugMode)
goto ATE_LB_DEBUG_STOP;
if (!pAd->LbCtrl.LoopBackUDMA)
MtCmdHIFLoopBackTest(pAd, 0, 0);
ATE_LB_DEBUG_STOP:
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s,\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s,\n", __func__));
}
void LoopBack_Status(RTMP_ADAPTER *pAd, struct _LOOPBACK_RESULT *pResult)
{
os_move_mem(pResult, &pAd->LbCtrl.LoopBackResult, sizeof(struct _LOOPBACK_RESULT));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, Status: %d\n", __func__, pAd->LbCtrl.LoopBackResult.Status));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, FailReason: %d\n", __func__, pAd->LbCtrl.LoopBackResult.FailReason));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, RxByteCount: %d\n", __func__, pAd->LbCtrl.LoopBackResult.RxByteCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, RxPktCount: %d\n", __func__, pAd->LbCtrl.LoopBackResult.RxPktCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, TxByteCount: %d\n", __func__, pAd->LbCtrl.LoopBackResult.TxByteCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, TxPktCount: %d\n", __func__, pAd->LbCtrl.LoopBackResult.TxPktCount));
os_move_mem(pResult, &pAd->LbCtrl.LoopBackResult,
sizeof(struct _LOOPBACK_RESULT));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, Status: %d\n", __func__,
pAd->LbCtrl.LoopBackResult.Status));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, FailReason: %d\n", __func__,
pAd->LbCtrl.LoopBackResult.FailReason));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, RxByteCount: %d\n", __func__,
pAd->LbCtrl.LoopBackResult.RxByteCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, RxPktCount: %d\n", __func__,
pAd->LbCtrl.LoopBackResult.RxPktCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, TxByteCount: %d\n", __func__,
pAd->LbCtrl.LoopBackResult.TxByteCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, TxPktCount: %d\n", __func__,
pAd->LbCtrl.LoopBackResult.TxPktCount));
}
void LoopBack_RawData(RTMP_ADAPTER *pAd, UINT32 *pLength, BOOLEAN IsTx, UCHAR *RawData)
void LoopBack_RawData(RTMP_ADAPTER *pAd, UINT32 *pLength, BOOLEAN IsTx,
UCHAR *RawData)
{
if (*pLength > LOOPBACK_SIZE) {
*pLength = LOOPBACK_SIZE;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, max length is %d\n", __func__, LOOPBACK_SIZE));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, max length is %d\n", __func__, LOOPBACK_SIZE));
}
if (IsTx) {
@ -232,18 +285,24 @@ void LoopBack_RawData(RTMP_ADAPTER *pAd, UINT32 *pLength, BOOLEAN IsTx, UCHAR *
os_move_mem(RawData, &pAd->LbCtrl.LoopBackRxRaw, *pLength);
}
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, Length = 0x%x\n", __func__, *pLength));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, LoopBackRxRawLen = 0x%x\n", __func__, pAd->LbCtrl.LoopBackRxRawLen));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, LoopBackTxRawLen = 0x%x\n", __func__, pAd->LbCtrl.LoopBackTxRawLen));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, Length = 0x%x\n", __func__, *pLength));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, LoopBackRxRawLen = 0x%x\n", __func__,
pAd->LbCtrl.LoopBackRxRawLen));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, LoopBackTxRawLen = 0x%x\n", __func__,
pAd->LbCtrl.LoopBackTxRawLen));
}
void LoopBack_ExpectRx(RTMP_ADAPTER *pAd, UINT32 Length, UINT8 *pRawData)
{
PULONG ptr;
UINT8 i = 0;
UINT8 i = 0;
if (Length > LOOPBACK_SIZE) {
Length = LOOPBACK_SIZE;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, max length is %d\n", __func__, LOOPBACK_SIZE));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, max length is %d\n", __func__, LOOPBACK_SIZE));
}
/* (&pAd->LbCtrl.LoopBackExpectRx, pRawData, Length); */
@ -251,22 +310,26 @@ void LoopBack_ExpectRx(RTMP_ADAPTER *pAd, UINT32 Length, UINT8 *pRawData)
ptr = (PULONG)(&pAd->LbCtrl.LoopBackExpectRx);
/* Length = ptr[0] & 0xffff; */
pAd->LbCtrl.LoopBackExpectRxLen = Length;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, Length = %d\n", __func__, Length));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, Length = %d\n", __func__, Length));
for (i = 0; i < 20; i++)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("TXD(TXWI) %d 0x%08lX\n", i, *(ptr + i)));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("TXD(TXWI) %d 0x%08lX\n", i, *(ptr + i)));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s,\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s,\n", __func__));
}
void LoopBack_ExpectTx(RTMP_ADAPTER *pAd, UINT32 Length, UINT8 *pRawData)
{
PULONG ptr;
UINT8 i = 0;
UINT8 i = 0;
if (Length > LOOPBACK_SIZE) {
Length = LOOPBACK_SIZE;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, max length is %d\n", __func__, LOOPBACK_SIZE));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, max length is %d\n", __func__, LOOPBACK_SIZE));
}
/* RtlCopyMemory(&pAd->LoopBackExpectTx, pRawData, Length); */
@ -274,18 +337,23 @@ void LoopBack_ExpectTx(RTMP_ADAPTER *pAd, UINT32 Length, UINT8 *pRawData)
ptr = (PULONG)(&pAd->LbCtrl.LoopBackExpectTx);
/* Length = ptr[0] & 0xffff; */
pAd->LbCtrl.LoopBackExpectTxLen = Length;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, Length = %d\n", __func__, Length));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, Length = %d\n", __func__, Length));
for (i = 0; i < 20; i++)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("TXD(TXWI) %d 0x%08lX\n", i, *(ptr + i)));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("TXD(TXWI) %d 0x%08lX\n", i, *(ptr + i)));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s,\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s,\n", __func__));
}
void LoopBack_Run(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting, UINT32 Length)
void LoopBack_Run(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting,
UINT32 Length)
{
if (Length > LOOPBACK_SIZE) {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, LOOPBACK length too long\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, LOOPBACK length too long\n", __func__));
return;
}
@ -296,60 +364,120 @@ void LoopBack_Run(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting, UINT32
void LoopBack_BitTrueCheck(RTMP_ADAPTER *pAd)
{
if (!pAd->LbCtrl.LoopBackDefaultPattern) { /* Rx compare expect Rx */
if (pAd->LbCtrl.LoopBackExpectRxLen != pAd->LbCtrl.LoopBackRxRawLen) {
if (pAd->LbCtrl.LoopBackExpectRxLen !=
pAd->LbCtrl.LoopBackRxRawLen) {
LoopBack_Fail(pAd, BIT_TRUE_FAIL);
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, ####################### TX/RX Length not equal ####################\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, ExpectRxLen = %d, RxRawLen = %d\n", __func__, pAd->LbCtrl.LoopBackExpectRxLen, pAd->LbCtrl.LoopBackRxRawLen));
} else if (RTMPEqualMemory((PVOID)&pAd->LbCtrl.LoopBackExpectRx, (PVOID)&pAd->LbCtrl.LoopBackRxRaw, pAd->LbCtrl.LoopBackRxRawLen) == 0) {
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, ####################### TX/RX Length not equal ####################\n",
__func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, ExpectRxLen = %d, RxRawLen = %d\n",
__func__, pAd->LbCtrl.LoopBackExpectRxLen,
pAd->LbCtrl.LoopBackRxRawLen));
} else if (RTMPEqualMemory((PVOID)&pAd->LbCtrl.LoopBackExpectRx,
(PVOID)&pAd->LbCtrl.LoopBackRxRaw,
pAd->LbCtrl.LoopBackRxRawLen) == 0) {
if (pAd->LbCtrl.DebugMode) {
UINT32 j = 0;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("RxExpect Dump(%u): ", pAd->LbCtrl.LoopBackRxRawLen));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_OFF,
("RxExpect Dump(%u): ",
pAd->LbCtrl.LoopBackRxRawLen));
for (j = 0; j < pAd->LbCtrl.LoopBackRxRawLen; j++)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%02x", pAd->LbCtrl.LoopBackExpectRx[j]));
for (j = 0; j < pAd->LbCtrl.LoopBackRxRawLen;
j++)
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_OFF,
("%02x",
pAd->LbCtrl
.LoopBackExpectRx[j]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("RxBackRaw Dump: "));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_OFF, ("\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_OFF, ("RxBackRaw Dump: "));
for (j = 0; j < pAd->LbCtrl.LoopBackRxRawLen; j++)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%02x", pAd->LbCtrl.LoopBackRxRaw[j]));
for (j = 0; j < pAd->LbCtrl.LoopBackRxRawLen;
j++)
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_OFF,
("%02x",
pAd->LbCtrl.LoopBackRxRaw[j]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_OFF, ("\n"));
}
LoopBack_Fail(pAd, BIT_TRUE_FAIL);
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, ####################### BIT_TRUE_FAIL ####################\n", __func__));
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, ####################### BIT_TRUE_FAIL ####################\n",
__func__));
} else
pAd->LbCtrl.LoopBackResult.FailReason = NO_ERROR;
} else { /* Rx compare Tx */
if (pAd->LbCtrl.LoopBackTxRawLen != pAd->LbCtrl.LoopBackRxRawLen) {
if (pAd->LbCtrl.LoopBackTxRawLen !=
pAd->LbCtrl.LoopBackRxRawLen) {
LoopBack_Fail(pAd, BIT_TRUE_FAIL);
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, ####################### TX/RX Length not equal ####################\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, TxRawLen = %d, RxRawLen = %d\n", __func__, pAd->LbCtrl.LoopBackTxRawLen, pAd->LbCtrl.LoopBackRxRawLen));
} else if (RTMPEqualMemory((PVOID)&pAd->LbCtrl.LoopBackTxRaw, (PVOID)&pAd->LbCtrl.LoopBackRxRaw, pAd->LbCtrl.LoopBackTxRawLen) == 0) {
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, ####################### TX/RX Length not equal ####################\n",
__func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, TxRawLen = %d, RxRawLen = %d\n",
__func__, pAd->LbCtrl.LoopBackTxRawLen,
pAd->LbCtrl.LoopBackRxRawLen));
} else if (RTMPEqualMemory((PVOID)&pAd->LbCtrl.LoopBackTxRaw,
(PVOID)&pAd->LbCtrl.LoopBackRxRaw,
pAd->LbCtrl.LoopBackTxRawLen) == 0) {
if (pAd->LbCtrl.DebugMode) {
UINT32 j = 0;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("TxExpect Dump(%u): ", pAd->LbCtrl.LoopBackTxRawLen));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_TRACE,
("TxExpect Dump(%u): ",
pAd->LbCtrl.LoopBackTxRawLen));
for (j = 0; j < pAd->LbCtrl.LoopBackRxRawLen; j++)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%02x", pAd->LbCtrl.LoopBackTxRaw[j]));
for (j = 0; j < pAd->LbCtrl.LoopBackRxRawLen;
j++)
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_TRACE,
("%02x",
pAd->LbCtrl.LoopBackTxRaw[j]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("RxBackRaw Dump: "));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_TRACE, ("\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_TRACE, ("RxBackRaw Dump: "));
for (j = 0; j < pAd->LbCtrl.LoopBackRxRawLen; j++)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%02x", pAd->LbCtrl.LoopBackRxRaw[j]));
for (j = 0; j < pAd->LbCtrl.LoopBackRxRawLen;
j++)
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_TRACE,
("%02x",
pAd->LbCtrl.LoopBackRxRaw[j]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_TRACE, ("\n"));
}
LoopBack_Fail(pAd, BIT_TRUE_FAIL);
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, ####################### BIT_TRUE_FAIL ####################\n", __func__));
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, ####################### BIT_TRUE_FAIL ####################\n",
__func__));
} else {
pAd->LbCtrl.LoopBackResult.FailReason = NO_ERROR;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, ####################### BIT_TRUE OK ####################\n", __func__));
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, ####################### BIT_TRUE OK ####################\n",
__func__));
}
}
}
@ -359,7 +487,8 @@ void LoopBack_Fail(RTMP_ADAPTER *pAd, enum _LOOPBACK_FAIL FailNum)
if (pAd->LbCtrl.LoopBackResult.Status == RUNNING) {
pAd->LbCtrl.LoopBackResult.FailReason = FailNum;
pAd->LbCtrl.LoopBackResult.Status = FAIL;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, FailReason = %d\n", __func__, FailNum));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, FailReason = %d\n", __func__, FailNum));
}
}
@ -370,7 +499,7 @@ INT LoopBack_TxThread(ULONG Context)
#endif
{
#ifdef COMPOS_TESTMODE_WIN
RTMP_ADAPTER *pAd = (RTMP_ADAPTER *)Context;
RTMP_ADAPTER *pAd = (RTMP_ADAPTER *)Context;
#else
RTMP_OS_TASK *pTask = (RTMP_OS_TASK *)Context;
RTMP_ADAPTER *pAd = (PRTMP_ADAPTER)RTMP_OS_TASK_DATA_GET(pTask);
@ -381,16 +510,18 @@ INT LoopBack_TxThread(ULONG Context)
UINT32 BreakCount = 0;
UINT32 DbgCount = 0;
/* KIRQL Irql; */
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, Repeat:%u\n", __func__, pSetting->RepeatTimes));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, Repeat:%u\n", __func__, pSetting->RepeatTimes));
if (pSetting->RepeatTimes == 0)
pSetting->RepeatTimes = 0xffffffff;
for (RepeatIdx = 0; RepeatIdx < pSetting->RepeatTimes ; RepeatIdx++) {
for (RepeatIdx = 0; RepeatIdx < pSetting->RepeatTimes; RepeatIdx++) {
if (pSetting->RepeatTimes == 0xffffffff)
RepeatIdx = 0;
for (Length = pSetting->StartLen; Length <= pSetting->StopLen; Length++) {
for (Length = pSetting->StartLen; Length <= pSetting->StopLen;
Length++) {
while (pAd->LbCtrl.LoopBackWaitRx) {
BreakCount++;
#ifdef COMPOS_TESTMODE_WIN
@ -400,23 +531,35 @@ INT LoopBack_TxThread(ULONG Context)
#endif
if (BreakCount > 2000) {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s, no Rx come back Stop1!!!\n", __func__));
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_ERROR,
("%s, no Rx come back Stop1!!!\n",
__func__));
break;
}
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s, no Rx BreakCount = %d\n", __func__, BreakCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_ERROR,
("%s, no Rx BreakCount = %d\n",
__func__, BreakCount));
}
if (BreakCount > 2000) {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s, no Rx come back Stop2!!!\n", __func__));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_ERROR,
("%s, no Rx come back Stop2!!!\n",
__func__));
LoopBack_Fail(pAd, RX_TIMEOUT);
break;
}
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s, Length = %d\n", __func__, Length));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s, Length = %d\n", __func__, Length));
BreakCount = 0;
if (pAd->LbCtrl.LoopBackRunning == FALSE || pAd->LbCtrl.LoopBackResult.Status != RUNNING)
if (pAd->LbCtrl.LoopBackRunning == FALSE ||
pAd->LbCtrl.LoopBackResult.Status != RUNNING)
break;
if (!pSetting->IsDefaultPattern)
@ -430,7 +573,9 @@ INT LoopBack_TxThread(ULONG Context)
OS_SPIN_UNLOCK(&pAd->LbCtrl.LoopBackLock);
LoopBack_Run(pAd, pSetting, Length);
if (pAd->LbCtrl.LoopBackRunning == FALSE || pAd->LbCtrl.LoopBackResult.Status != RUNNING)
if (pAd->LbCtrl.LoopBackRunning == FALSE ||
pAd->LbCtrl.LoopBackResult.Status !=
RUNNING)
break;
}
@ -440,7 +585,8 @@ INT LoopBack_TxThread(ULONG Context)
RtmpusecDelay(200);
#endif
DbgCount++;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s, DbgCount = %d\n", __func__, DbgCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s, DbgCount = %d\n", __func__, DbgCount));
if (!pSetting->IsDefaultPattern) {
/* use script file does not need to auto increase length */
@ -448,7 +594,8 @@ INT LoopBack_TxThread(ULONG Context)
}
}
if (pAd->LbCtrl.LoopBackRunning == FALSE || pAd->LbCtrl.LoopBackResult.Status != RUNNING)
if (pAd->LbCtrl.LoopBackRunning == FALSE ||
pAd->LbCtrl.LoopBackResult.Status != RUNNING)
break;
}
@ -456,7 +603,8 @@ INT LoopBack_TxThread(ULONG Context)
LoopBack_Stop(pAd);
/* pAd->LbCtrl.LoopBackTxThread = NULL; */
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_INFO, ("+ + + + Control Thread Terminated + + + +\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_INFO,
("+ + + + Control Thread Terminated + + + +\n"));
/* DecrementIoCount(pAd); */
/* PsTerminateSystemThread(STATUS_SUCCESS); */
RtmpOSTaskNotifyToExit(&pAd->LbCtrl.LoopBackTxTask);
@ -471,15 +619,18 @@ VOID LoopBack_Rx(RTMP_ADAPTER *pAd, UINT32 pktlen, UINT8 *pData)
{
UINT32 LPLength = 0;
INT32 TotalLength = (INT32)pktlen;
UINT8 *ptr = pData;
UINT8 *ptr = pData;
EVENT_RXD EvnRxD;
/* FwCMDRspTxD_STRUC FwCMDRspTxD; */
if (pAd->LbCtrl.DebugMode) {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, Debug Mode, Total Len:%d\n", __func__, TotalLength));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, Debug Mode, Total Len:%d\n", __func__,
TotalLength));
LPLength = pktlen;
} else {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Driver Rx LoopBackRunning\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("Driver Rx LoopBackRunning\n"));
/* os_move_mem(&FwCMDRspTxD,ptr,sizeof(FwCMDRspTxD)); */
os_move_mem(&EvnRxD, ptr, sizeof(EvnRxD));
/* LPLength = FwCMDRspTxD.FwEventTxD.u2RxByteCount; */
@ -487,20 +638,26 @@ VOID LoopBack_Rx(RTMP_ADAPTER *pAd, UINT32 pktlen, UINT8 *pData)
if (LPLength > LOOPBACK_SIZE) {
LPLength = LOOPBACK_SIZE;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, max length is %d\n", __func__, LOOPBACK_SIZE));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_TRACE,
("%s, max length is %d\n", __func__,
LOOPBACK_SIZE));
}
}
{
#ifdef COMPOS_TESTMODE_WIN /* Windows First -4 for padding bits and then add back here,Linux(?) */
#ifdef COMPOS_TESTMODE_WIN /* Windows First -4 for padding bits and then add back here,Linux(?) */
if (!pAd->LbCtrl.LoopBackSetting.IsDefaultPattern)
LPLength = TotalLength + 4;
#endif
/* RtlCopyMemory(&FwCMDRspTxD,ptr,sizeof(FwCMDRspTxD)); */
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, Total Length = %d, LPLength is %d, bytecount = %d\n",
__func__, TotalLength, LPLength, EvnRxD.fw_rxd_0.field.length));
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, Total Length = %d, LPLength is %d, bytecount = %d\n",
__func__, TotalLength, LPLength,
EvnRxD.fw_rxd_0.field.length));
/* LPLength = FwCMDRspTxD.FwEventTxD.u2RxByteCount; */
pAd->LbCtrl.LoopBackResult.RxByteCount += LPLength;
pAd->LbCtrl.LoopBackResult.RxPktCount++;
@ -516,14 +673,16 @@ VOID LoopBack_Rx(RTMP_ADAPTER *pAd, UINT32 pktlen, UINT8 *pData)
pAd->LbCtrl.LoopBackWaitRx = FALSE;
/* KeReleaseSpinLock(&pAdapter->LoopBackLock, Irql); */
OS_SPIN_UNLOCK(&pAd->LbCtrl.LoopBackLock);
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, RxPktCount = %d\n", __func__, pAd->LbCtrl.LoopBackResult.RxPktCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, RxPktCount = %d\n", __func__,
pAd->LbCtrl.LoopBackResult.RxPktCount));
}
}
/* currently not implement PCIE loopback */
#ifdef _RTMP_PCI_SUPPORT
void PCILoopBack_Run(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting, UINT32 length)
void PCILoopBack_Run(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting,
UINT32 length)
{
UINT32 count = 0;
TMAC_TXD_L TxD;
@ -563,19 +722,43 @@ void PCILoopBack_Run(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting, UINT
TxD.TxD1.HdrFmt = 1;
#endif
os_move_mem(TxDataBuffer, &TxD, sizeof(TxD));
os_move_mem(&pAd->LbCtrl.LoopBackTxRaw, TxDataBuffer, LOOPBACK_SIZE);
os_move_mem(&pAd->LbCtrl.LoopBackTxRaw, TxDataBuffer,
LOOPBACK_SIZE);
pAd->LbCtrl.LoopBackTxRawLen = length;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, length = %d\n", __func__, length));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, length = %d\n", __func__, length));
if (length > 32) {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("===buffer===\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[3], TxDataBuffer[2], TxDataBuffer[1], TxDataBuffer[0]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[7], TxDataBuffer[6], TxDataBuffer[5], TxDataBuffer[4]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[11], TxDataBuffer[10], TxDataBuffer[9], TxDataBuffer[8]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[15], TxDataBuffer[14], TxDataBuffer[13], TxDataBuffer[12]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[19], TxDataBuffer[18], TxDataBuffer[17], TxDataBuffer[16]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[23], TxDataBuffer[22], TxDataBuffer[21], TxDataBuffer[20]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[27], TxDataBuffer[26], TxDataBuffer[25], TxDataBuffer[24]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("===buffer===\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[3],
TxDataBuffer[2], TxDataBuffer[1],
TxDataBuffer[0]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[7],
TxDataBuffer[6], TxDataBuffer[5],
TxDataBuffer[4]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[11],
TxDataBuffer[10], TxDataBuffer[9],
TxDataBuffer[8]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[15],
TxDataBuffer[14], TxDataBuffer[13],
TxDataBuffer[12]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[19],
TxDataBuffer[18], TxDataBuffer[17],
TxDataBuffer[16]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[23],
TxDataBuffer[22], TxDataBuffer[21],
TxDataBuffer[20]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("0x%x 0x%x 0x%x 0x%x\n", TxDataBuffer[27],
TxDataBuffer[26], TxDataBuffer[25],
TxDataBuffer[24]));
}
if (length % 4 != 0)
@ -584,28 +767,38 @@ void PCILoopBack_Run(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting, UINT
if (pAd->LbCtrl.DebugMode) {
int j = 0;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Tx Dump: "));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("Tx Dump: "));
for (j = 0; j < length; j++)
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%02x", TxDataBuffer[j]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL,
DBG_LVL_TRACE,
("%02x", TxDataBuffer[j]));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("\n"));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("\n"));
}
/* pAd->TxDataBufferLength = length + alignment + 4 ; */
*TxDataBufferLength = length + alignment + 4;
} else {
os_move_mem(TxDataBuffer, &pAd->LbCtrl.LoopBackExpectTx, pAd->LbCtrl.LoopBackExpectTxLen);
os_zero_mem(TxDataBuffer + length, pAd->LbCtrl.LoopBackExpectTxLen - length);
os_move_mem(TxDataBuffer, &pAd->LbCtrl.LoopBackExpectTx,
pAd->LbCtrl.LoopBackExpectTxLen);
os_zero_mem(TxDataBuffer + length,
pAd->LbCtrl.LoopBackExpectTxLen - length);
os_move_mem(&pAd->LbCtrl.LoopBackTxRaw, TxDataBuffer, length);
pAd->LbCtrl.LoopBackTxRawLen = pAd->LbCtrl.LoopBackExpectTxLen;
/* pAd->LoopBackExpectRxLen = length; */
}
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, LP length = %d, alignment = %d\n", __func__, length, alignment));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, LP length = %d, alignment = %d\n", __func__, length,
alignment));
pAd->LbCtrl.LoopBackResult.TxByteCount += length;
pAd->LbCtrl.LoopBackResult.TxPktCount++;
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, RxPktCount = %d\n", __func__, pAd->LbCtrl.LoopBackResult.RxPktCount));
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, RxPktCount = %d\n", __func__,
pAd->LbCtrl.LoopBackResult.RxPktCount));
#ifdef COMPOS_TESTMODE_WIN
StartTx(pAd, 1, 0);
#else
@ -615,10 +808,14 @@ void PCILoopBack_Run(RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting, UINT
/* cannot pass UINT32 TimeOut1Second = 100; to wait_event, it will not wait.. workaround use 0 (1second instead of TimeOut1Second) */
if (!pAd->LbCtrl.DebugMode)
if (RTMP_OS_WAIT_FOR_COMPLETION_TIMEOUT(&pAd->LbCtrl.LoopBackPCITxEvent, 0) != STATUS_SUCCESS) {
if (RTMP_OS_WAIT_FOR_COMPLETION_TIMEOUT(
&pAd->LbCtrl.LoopBackPCITxEvent, 0) !=
STATUS_SUCCESS) {
LoopBack_Fail(pAd, TX_TIMEOUT);
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s, ####################### TX_TIMEOUT ####################3\n", __func__));
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s, ####################### TX_TIMEOUT ####################3\n",
__func__));
}
}
#endif

File diff suppressed because it is too large Load Diff

View File

@ -2,21 +2,11 @@
#ifndef _LOOPBACK_H_
#define _LOOPBACK_H_
#define LOOPBACK_SIZE (10240*6)
#define LOOPBACK_SIZE (10240 * 6)
enum _LOOPBACK_STATUS { RUNNING = 0, PASS, FAIL };
enum _LOOPBACK_STATUS {
RUNNING = 0,
PASS,
FAIL
};
enum _LOOPBACK_FAIL {
NO_ERROR = 0,
TX_TIMEOUT,
RX_TIMEOUT,
BIT_TRUE_FAIL
};
enum _LOOPBACK_FAIL { NO_ERROR = 0, TX_TIMEOUT, RX_TIMEOUT, BIT_TRUE_FAIL };
struct _LOOPBACK_SETTING {
UINT32 StartLen;
@ -27,9 +17,9 @@ struct _LOOPBACK_SETTING {
UINT32 BulkOutNumber;
UINT32 BulkInNumber;
UINT32 TxAggNumber;
UINT32 RxAggPktLmt;/* pkt numbers */
UINT32 RxAggLmt;/* pkt size */
UINT32 RxAggTO;/* timeout (us) */
UINT32 RxAggPktLmt; /* pkt numbers */
UINT32 RxAggLmt; /* pkt size */
UINT32 RxAggTO; /* timeout (us) */
UINT32 RxAggEnable;
/* #endif */
};
@ -50,25 +40,25 @@ struct _LOOPBACK_RESULT {
/* #endif */
};
struct _LOOPBACK_CTRL {
BOOLEAN DebugMode;
BOOLEAN LoopBackRunning;
BOOLEAN LoopBackWaitRx;
struct _LOOPBACK_RESULT LoopBackResult;
struct _LOOPBACK_SETTING LoopBackSetting;
UINT8 LoopBackBulkoutNumber;
UCHAR LoopBackTxRaw[LOOPBACK_SIZE];
UCHAR LoopBackRxRaw[LOOPBACK_SIZE];
UINT32 LoopBackTxRawLen;
UINT32 LoopBackRxRawLen;
UINT32 LoopBackExpectTxLen;
UINT32 LoopBackExpectRxLen;
UCHAR LoopBackExpectTx[LOOPBACK_SIZE];
UCHAR LoopBackExpectRx[LOOPBACK_SIZE];
NDIS_SPIN_LOCK LoopBackLock;
BOOLEAN LoopBackDefaultPattern;
RTMP_OS_TASK LoopBackTxTask;
RTMP_OS_COMPLETION LoopBackEvent;
BOOLEAN LoopBackUDMA;
BOOLEAN DebugMode;
BOOLEAN LoopBackRunning;
BOOLEAN LoopBackWaitRx;
struct _LOOPBACK_RESULT LoopBackResult;
struct _LOOPBACK_SETTING LoopBackSetting;
UINT8 LoopBackBulkoutNumber;
UCHAR LoopBackTxRaw[LOOPBACK_SIZE];
UCHAR LoopBackRxRaw[LOOPBACK_SIZE];
UINT32 LoopBackTxRawLen;
UINT32 LoopBackRxRawLen;
UINT32 LoopBackExpectTxLen;
UINT32 LoopBackExpectRxLen;
UCHAR LoopBackExpectTx[LOOPBACK_SIZE];
UCHAR LoopBackExpectRx[LOOPBACK_SIZE];
NDIS_SPIN_LOCK LoopBackLock;
BOOLEAN LoopBackDefaultPattern;
RTMP_OS_TASK LoopBackTxTask;
RTMP_OS_COMPLETION LoopBackEvent;
BOOLEAN LoopBackUDMA;
#ifdef RTMP_PCI_SUPPORT
RTMP_OS_COMPLETION LoopBackPCITxEvent;
#endif
@ -76,23 +66,30 @@ struct _LOOPBACK_CTRL {
INT32 CheckFWROMWiFiSysOn(struct _RTMP_ADAPTER *pAd);
void LoopBack_Start(struct _RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting);
void LoopBack_Start(struct _RTMP_ADAPTER *pAd,
struct _LOOPBACK_SETTING *pSetting);
void LoopBack_Stop(struct _RTMP_ADAPTER *pAd);
void LoopBack_Status(struct _RTMP_ADAPTER *pAd, struct _LOOPBACK_RESULT *pResult);
void LoopBack_RawData(struct _RTMP_ADAPTER *pAd, UINT32 *pLength, BOOLEAN IsTx, UINT8 *pRawData);
void LoopBack_ExpectRx(struct _RTMP_ADAPTER *pAd, UINT32 Length, UINT8 *pRawData);
void LoopBack_ExpectTx(struct _RTMP_ADAPTER *pAd, UINT32 Length, UINT8 *pRawData);
void LoopBack_Run(struct _RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting, UINT32 length);
void LoopBack_Status(struct _RTMP_ADAPTER *pAd,
struct _LOOPBACK_RESULT *pResult);
void LoopBack_RawData(struct _RTMP_ADAPTER *pAd, UINT32 *pLength, BOOLEAN IsTx,
UINT8 *pRawData);
void LoopBack_ExpectRx(struct _RTMP_ADAPTER *pAd, UINT32 Length,
UINT8 *pRawData);
void LoopBack_ExpectTx(struct _RTMP_ADAPTER *pAd, UINT32 Length,
UINT8 *pRawData);
void LoopBack_Run(struct _RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting,
UINT32 length);
void LoopBack_BitTrueCheck(struct _RTMP_ADAPTER *pAd);
void LoopBack_Fail(struct _RTMP_ADAPTER *pAd, enum _LOOPBACK_FAIL FailNum);
#ifdef COMPOS_TESTMODE_WIN /* TODO::Unify thread parameter */
void LoopBack_Fail(struct _RTMP_ADAPTER *pAd, enum _LOOPBACK_FAIL FailNum);
#ifdef COMPOS_TESTMODE_WIN /* TODO::Unify thread parameter */
INT LoopBack_TxThread(IN OUT PVOID Context);
#else
INT LoopBack_TxThread(ULONG Context);
#endif
void LoopBack_Rx(struct _RTMP_ADAPTER *pAd, UINT32 pktlen, UINT8 *pData);
#ifdef RTMP_PCI_SUPPORT
void PCILoopBack_Run(struct _RTMP_ADAPTER *pAd, struct _LOOPBACK_SETTING *pSetting, UINT32 length);
void PCILoopBack_Run(struct _RTMP_ADAPTER *pAd,
struct _LOOPBACK_SETTING *pSetting, UINT32 length);
INT32 ATECheckFWROMWiFiSysOn(struct _RTMP_ADAPTER *pAd);
#endif

View File

@ -30,8 +30,8 @@
INT32 ATEInit(struct _RTMP_ADAPTER *pAd);
INT32 ATEExit(struct _RTMP_ADAPTER *pAd);
#define FREQ_OFFSET_MANUAL_ENABLE 0x81021238
#define FREQ_OFFSET_MANUAL_VALUE 0x81021234
#define FREQ_OFFSET_MANUAL_ENABLE 0x81021238
#define FREQ_OFFSET_MANUAL_VALUE 0x81021234
/* For CA53 GPIO CR remap usage */
#define CA53_GPIO_REMAP_SIZE 0x10
@ -50,95 +50,97 @@ INT32 ATEExit(struct _RTMP_ADAPTER *pAd);
* Use bitmap to allow coexist of ATE_TXFRAME
* and ATE_RXFRAME(i.e.,to support LoopBack mode).
*/
#define fATE_IDLE (1 << 0)
#define fATE_TX_ENABLE (1 << 1)
#define fATE_RX_ENABLE (1 << 2)
#define fATE_TXCONT_ENABLE (1 << 3)
#define fATE_TXCARR_ENABLE (1 << 4)
#define fATE_TXCARRSUPP_ENABLE (1 << 5)
#define fATE_MPS (1 << 6)
#define fATE_FFT_ENABLE (1 << 7)
#define fATE_EXIT (1 << 8)
#define fATE_IN_RFTEST (1 << 9)
#define fATE_IN_BF (1 << 10)
#define fATE_IN_ICAPOVERLAP (1 << 11)
#define fATE_IDLE (1 << 0)
#define fATE_TX_ENABLE (1 << 1)
#define fATE_RX_ENABLE (1 << 2)
#define fATE_TXCONT_ENABLE (1 << 3)
#define fATE_TXCARR_ENABLE (1 << 4)
#define fATE_TXCARRSUPP_ENABLE (1 << 5)
#define fATE_MPS (1 << 6)
#define fATE_FFT_ENABLE (1 << 7)
#define fATE_EXIT (1 << 8)
#define fATE_IN_RFTEST (1 << 9)
#define fATE_IN_BF (1 << 10)
#define fATE_IN_ICAPOVERLAP (1 << 11)
/* Stop Transmission */
#define ATE_TXSTOP ((~(fATE_TX_ENABLE))&(~(fATE_TXCONT_ENABLE))&(~(fATE_TXCARR_ENABLE))&(~(fATE_TXCARRSUPP_ENABLE))&(~(fATE_MPS)))
#define ATE_TXSTOP \
((~(fATE_TX_ENABLE)) & (~(fATE_TXCONT_ENABLE)) & \
(~(fATE_TXCARR_ENABLE)) & (~(fATE_TXCARRSUPP_ENABLE)) & \
(~(fATE_MPS)))
/* Stop Receiving Frames */
#define ATE_RXSTOP (~(fATE_RX_ENABLE))
#define ATE_RXSTOP (~(fATE_RX_ENABLE))
/* Enter/Reset ATE */
#define ATE_START (fATE_IDLE)
#define ATE_START (fATE_IDLE)
/* Stop/Exit ATE */
#define ATE_STOP (fATE_EXIT)
#define ATE_STOP (fATE_EXIT)
/* Continuous Transmit Frames (without time gap) */
#define ATE_TXCONT ((fATE_TX_ENABLE)|(fATE_TXCONT_ENABLE))
#define ATE_TXCONT ((fATE_TX_ENABLE) | (fATE_TXCONT_ENABLE))
/* Transmit Carrier */
#define ATE_TXCARR ((fATE_TX_ENABLE)|(fATE_TXCARR_ENABLE))
#define ATE_TXCARR ((fATE_TX_ENABLE) | (fATE_TXCARR_ENABLE))
/* Transmit Carrier Suppression (information without carrier) */
#define ATE_TXCARRSUPP ((fATE_TX_ENABLE)|(fATE_TXCARRSUPP_ENABLE))
#define ATE_TXCARRSUPP ((fATE_TX_ENABLE) | (fATE_TXCARRSUPP_ENABLE))
/* Transmit Frames */
#define ATE_TXFRAME (fATE_TX_ENABLE)
#define ATE_TXFRAME (fATE_TX_ENABLE)
/* Receive Frames */
#define ATE_RXFRAME (fATE_RX_ENABLE)
#define ATE_RXFRAME (fATE_RX_ENABLE)
/* MPS */
#define ATE_MPS ((fATE_TX_ENABLE)|(fATE_MPS))
#define ATE_MPS ((fATE_TX_ENABLE) | (fATE_MPS))
#define ATE_FFT ((fATE_FFT_ENABLE)|(fATE_IN_RFTEST))
#define ATE_FFT ((fATE_FFT_ENABLE) | (fATE_IN_RFTEST))
#define BULK_OUT_LOCK(pLock, IrqFlags) \
RTMP_IRQ_LOCK((pLock), IrqFlags)
#define BULK_OUT_LOCK(pLock, IrqFlags) RTMP_IRQ_LOCK((pLock), IrqFlags)
#define BULK_OUT_UNLOCK(pLock, IrqFlags) \
RTMP_IRQ_UNLOCK((pLock), IrqFlags)
#define BULK_OUT_UNLOCK(pLock, IrqFlags) RTMP_IRQ_UNLOCK((pLock), IrqFlags)
/* WiFi PHY mode capability */
#define PHYMODE_CAP_24G (WMODE_B | WMODE_G | WMODE_GN)
#define PHYMODE_CAP_5G (WMODE_A | WMODE_AN | WMODE_AC)
#define PHYMODE_CAP_DUAL_BAND (PHYMODE_CAP_24G | PHYMODE_CAP_5G)
#define PHYMODE_CAP_24G (WMODE_B | WMODE_G | WMODE_GN)
#define PHYMODE_CAP_5G (WMODE_A | WMODE_AN | WMODE_AC)
#define PHYMODE_CAP_DUAL_BAND (PHYMODE_CAP_24G | PHYMODE_CAP_5G)
/* ContiTxTone */
#define WF0_TX_ONE_TONE_5M 0x0
#define WF0_TX_TWO_TONE_5M 0x1
#define WF1_TX_ONE_TONE_5M 0x2
#define WF1_TX_TWO_TONE_5M 0x3
#define WF0_TX_ONE_TONE_10M 0x4
#define WF1_TX_ONE_TONE_10M 0x5
#define WF0_TX_ONE_TONE_DC 0x6
#define WF1_TX_ONE_TONE_DC 0x7
#define WF0_TX_ONE_TONE_5M 0x0
#define WF0_TX_TWO_TONE_5M 0x1
#define WF1_TX_ONE_TONE_5M 0x2
#define WF1_TX_TWO_TONE_5M 0x3
#define WF0_TX_ONE_TONE_10M 0x4
#define WF1_TX_ONE_TONE_10M 0x5
#define WF0_TX_ONE_TONE_DC 0x6
#define WF1_TX_ONE_TONE_DC 0x7
#define MAX_TEST_PKT_LEN 1496
#define MIN_TEST_PKT_LEN 25
#define MAX_TEST_BKCR_NUM 30
#define MAX_TEST_PKT_LEN 1496
#define MIN_TEST_PKT_LEN 25
#define MAX_TEST_BKCR_NUM 30
/* For packet tx time, in unit of byte */
#define MAX_HT_AMPDU_LEN 65000
#define MAX_VHT_MPDU_LEN 6700 /* 11454 */
#define DEFAULT_MPDU_LEN 4096
#define MAX_MSDU_LEN 2304
#define MIN_MSDU_LEN 22
#define DEFAULT_MAC_HDR_LEN 24
#define QOS_MAC_HDR_LEN 26
#define MAX_HT_AMPDU_LEN 65000
#define MAX_VHT_MPDU_LEN 6700 /* 11454 */
#define DEFAULT_MPDU_LEN 4096
#define MAX_MSDU_LEN 2304
#define MIN_MSDU_LEN 22
#define DEFAULT_MAC_HDR_LEN 24
#define QOS_MAC_HDR_LEN 26
/* For ipg and duty cycle, in unit of us */
#define SIG_EXTENSION 6
#define DEFAULT_SLOT_TIME 9
#define DEFAULT_SIFS_TIME 10
#define MAX_SIFS_TIME 127 /* ICR has 7-bit only */ /* For the ATCR/TRCR limitation 8-bit/9-bit only*/
#define MAX_AIFSN 0xF
#define MIN_AIFSN 0x1
#define MAX_CW 0x10
#define MIN_CW 0x0
#define NORMAL_CLOCK_TIME 50 /* in uint of ns */
#define BBP_PROCESSING_TIME 1500 /* in uint of ns */
#define SIG_EXTENSION 6
#define DEFAULT_SLOT_TIME 9
#define DEFAULT_SIFS_TIME 10
#define MAX_SIFS_TIME \
127 /* ICR has 7-bit only */ /* For the ATCR/TRCR limitation 8-bit/9-bit only*/
#define MAX_AIFSN 0xF
#define MIN_AIFSN 0x1
#define MAX_CW 0x10
#define MIN_CW 0x0
#define NORMAL_CLOCK_TIME 50 /* in uint of ns */
#define BBP_PROCESSING_TIME 1500 /* in uint of ns */
/* The expected enqueue packet number in one time RX event trigger */
#define ATE_ENQUEUE_PACKET_NUM 100
#define ATE_ENQUEUE_PACKET_NUM 100
#if defined(MT7615) || defined(MT7622)
#define ATE_TESTPKT_LEN 13311 /* Setting max packet length to 13311 on MT7615 */
#define ATE_TESTPKT_LEN 13311 /* Setting max packet length to 13311 on MT7615 */
#else
#define ATE_TESTPKT_LEN 4095 /* AMPDU delimiter 12 bit, maximum 4095 */
#define ATE_TESTPKT_LEN 4095 /* AMPDU delimiter 12 bit, maximum 4095 */
#endif
#define ATE_MAX_PATTERN_SIZE 128
#define TESTMODE_BAND0 0
@ -163,18 +165,14 @@ struct _RX_BLK;
#if !defined(COMPOS_TESTMODE_WIN)
/* Allow Sleep */
#define TESTMODE_SEM struct semaphore
#define TESTMODE_SEM_INIT(_psem, _val) sema_init(_psem, _val)
#define TESTMODE_SEM_INIT(_psem, _val) sema_init(_psem, _val)
#define TESTMODE_SEM_DOWN(_psem) down(_psem)
#define TESTMODE_SEM_DOWN_INTERRUPTIBLE(_psem) down_interruptible(_psem)
#define TESTMODE_SEM_DOWN_TRYLOCK(_psem) down_trylock(_psem)
#define TESTMODE_SEM_UP(_psem) up(_psem)
#endif
enum _TESTMODE_MODE {
HQA_VERIFY,
ATE_LOOPBACK,
MODE_NUM
};
enum _TESTMODE_MODE { HQA_VERIFY, ATE_LOOPBACK, MODE_NUM };
enum _MPS_PARAM_TYPE {
MPS_SEQDATA,
@ -198,78 +196,126 @@ struct _ATE_OPERATION {
INT32 (*StopRx)(struct _RTMP_ADAPTER *pAd);
INT32 (*SetTxPath)(struct _RTMP_ADAPTER *pAd);
INT32 (*SetRxPath)(struct _RTMP_ADAPTER *pAd);
INT32 (*SetTxPower0)(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32 (*SetTxPower1)(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32 (*SetTxPower2)(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32 (*SetTxPower3)(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32 (*SetTxForceTxPower)(struct _RTMP_ADAPTER *pAd, INT8 cTxPower, UINT8 ucPhyMode, UINT8 ucTxRate, UINT8 ucBW);
INT32 (*SetTxPowerX)(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32(*SetTxPower0)
(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32(*SetTxPower1)
(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32(*SetTxPower2)
(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32(*SetTxPower3)
(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32(*SetTxForceTxPower)
(struct _RTMP_ADAPTER *pAd, INT8 cTxPower, UINT8 ucPhyMode,
UINT8 ucTxRate, UINT8 ucBW);
INT32(*SetTxPowerX)
(struct _RTMP_ADAPTER *pAd, struct _ATE_TXPOWER TxPower);
INT32 (*SetTxAntenna)(struct _RTMP_ADAPTER *pAd, UINT32 Ant);
INT32 (*SetRxAntenna)(struct _RTMP_ADAPTER *pAd, UINT32 Ant);
INT32 (*SetTxFreqOffset)(struct _RTMP_ADAPTER *pAd, UINT32 FreqOffset);
INT32 (*GetTxFreqOffset)(struct _RTMP_ADAPTER *pAd, UINT32 *FreqOffset);
INT32 (*SetChannel)(struct _RTMP_ADAPTER *pAd, INT16 Value, UINT32 pri_sel, UINT32 reason, UINT32 Ch_Band);
INT32 (*SetBW)(struct _RTMP_ADAPTER *pAd, UINT16 system_bw, UINT16 per_pkt_bw);
INT32(*SetChannel)
(struct _RTMP_ADAPTER *pAd, INT16 Value, UINT32 pri_sel, UINT32 reason,
UINT32 Ch_Band);
INT32(*SetBW)
(struct _RTMP_ADAPTER *pAd, UINT16 system_bw, UINT16 per_pkt_bw);
INT32 (*SetDutyCycle)(struct _RTMP_ADAPTER *pAd, UINT32 value);
INT32 (*SetPktTxTime)(struct _RTMP_ADAPTER *pAd, UINT32 value);
INT32 (*SampleRssi)(struct _RTMP_ADAPTER *pAd, struct _RX_BLK *pRxBlk);
INT32 (*SetIPG)(struct _RTMP_ADAPTER *pAd, UINT32 value);
INT32 (*SetSlotTime)(struct _RTMP_ADAPTER *pAd, UINT32 SlotTime, UINT32 SifsTime);
INT32(*SetSlotTime)
(struct _RTMP_ADAPTER *pAd, UINT32 SlotTime, UINT32 SifsTime);
INT32 (*SetAIFS)(struct _RTMP_ADAPTER *pAd, CHAR Value);
INT32 (*SetPowerDropLevel)(struct _RTMP_ADAPTER *pAd, UINT32 PowerDropLevel);
INT32(*SetPowerDropLevel)
(struct _RTMP_ADAPTER *pAd, UINT32 PowerDropLevel);
INT32 (*SetTSSI)(struct _RTMP_ADAPTER *pAd, CHAR WFSel, CHAR Setting);
INT32 (*LowPower)(struct _RTMP_ADAPTER *pAd, UINT32 Control);
INT32 (*SetDPD)(struct _RTMP_ADAPTER *pAd, CHAR WFSel, CHAR Setting);
INT32 (*StartTxTone)(struct _RTMP_ADAPTER *pAd, UINT32 Mode);
INT32 (*SetTxTonePower)(struct _RTMP_ADAPTER *pAd, INT32 pwr1, INT pwr2);
INT32 (*SetDBDCTxTonePower)(struct _RTMP_ADAPTER *pAd, INT32 pwr1, INT pwr2, UINT32 AntIdx);
INT32(*SetTxTonePower)
(struct _RTMP_ADAPTER *pAd, INT32 pwr1, INT pwr2);
INT32(*SetDBDCTxTonePower)
(struct _RTMP_ADAPTER *pAd, INT32 pwr1, INT pwr2, UINT32 AntIdx);
INT32 (*StopTxTone)(struct _RTMP_ADAPTER *pAd);
INT32 (*StartContinousTx)(struct _RTMP_ADAPTER *pAd, CHAR WFSel, UINT32 TxfdMode);
INT32(*StartContinousTx)
(struct _RTMP_ADAPTER *pAd, CHAR WFSel, UINT32 TxfdMode);
INT32 (*StopContinousTx)(struct _RTMP_ADAPTER *pAd, UINT32 TxfdMode);
INT32 (*EfuseGetFreeBlock)(struct _RTMP_ADAPTER *pAd, UINT32 GetFreeBlock, UINT32 *Value);
INT32 (*EfuseAccessCheck)(struct _RTMP_ADAPTER *pAd, UINT32 offset, PUCHAR pData);
INT32 (*RfRegWrite)(struct _RTMP_ADAPTER *pAd, UINT32 WFSel, UINT32 Offset, UINT32 Value);
INT32 (*RfRegRead)(struct _RTMP_ADAPTER *pAd, UINT32 WFSel, UINT32 Offset, UINT32 *Value);
INT32(*EfuseGetFreeBlock)
(struct _RTMP_ADAPTER *pAd, UINT32 GetFreeBlock, UINT32 *Value);
INT32(*EfuseAccessCheck)
(struct _RTMP_ADAPTER *pAd, UINT32 offset, PUCHAR pData);
INT32(*RfRegWrite)
(struct _RTMP_ADAPTER *pAd, UINT32 WFSel, UINT32 Offset, UINT32 Value);
INT32(*RfRegRead)
(struct _RTMP_ADAPTER *pAd, UINT32 WFSel, UINT32 Offset, UINT32 *Value);
INT32 (*GetFWInfo)(struct _RTMP_ADAPTER *pAd, UCHAR *FWInfo);
#ifdef PRE_CAL_MT7622_SUPPORT
INT32 (*TxDPDTest7622)(struct _RTMP_ADAPTER *pAd, RTMP_STRING * arg);
INT32 (*TxDPDTest7622)(struct _RTMP_ADAPTER *pAd, RTMP_STRING *arg);
#endif /*PRE_CAL_MT7622_SUPPORT*/
#ifdef PRE_CAL_TRX_SET1_SUPPORT
INT32 (*RxSelfTest)(struct _RTMP_ADAPTER *pAd, RTMP_STRING *arg);
INT32 (*TxDPDTest)(struct _RTMP_ADAPTER *pAd, RTMP_STRING *arg);
#endif /* PRE_CAL_TRX_SET1_SUPPORT */
#ifdef PRE_CAL_TRX_SET2_SUPPORT
INT32 (*PreCalTest)(struct _RTMP_ADAPTER *pAd, UINT8 CalId, UINT32 ChGrpId);
INT32(*PreCalTest)
(struct _RTMP_ADAPTER *pAd, UINT8 CalId, UINT32 ChGrpId);
#endif /* PRE_CAL_TRX_SET2_SUPPORT */
#if defined(CAL_BIN_FILE_SUPPORT) && defined(MT7615)
INT32 (*PATrim)(struct _RTMP_ADAPTER *pAd, PUINT32 pData);
#endif /* CAL_BIN_FILE_SUPPORT */
#if defined(TXBF_SUPPORT) && defined(MT_MAC)
INT32 (*SetATETxSoundingProc)(struct _RTMP_ADAPTER *pAd, UCHAR SoundingMode);
INT32(*SetATETxSoundingProc)
(struct _RTMP_ADAPTER *pAd, UCHAR SoundingMode);
INT32 (*StartTxSKB)(struct _RTMP_ADAPTER *pAd);
#endif /* TXBF_SUPPORT && MT_MAC */
INT32 (*MPSSetParm)(struct _RTMP_ADAPTER *pAd, enum _MPS_PARAM_TYPE data_type, INT32 items, UINT32 *data);
INT32(*MPSSetParm)
(struct _RTMP_ADAPTER *pAd, enum _MPS_PARAM_TYPE data_type, INT32 items,
UINT32 *data);
INT32 (*MPSTxStart)(struct _RTMP_ADAPTER *pAd);
INT32 (*MPSTxStop)(struct _RTMP_ADAPTER *pAd);
INT32 (*SetAutoResp)(struct _RTMP_ADAPTER *pAd, UCHAR *mac, UCHAR mode);
INT32 (*SetFFTMode)(struct _RTMP_ADAPTER *pAd, UINT32 mode);
INT32 (*onOffRDD)(struct _RTMP_ADAPTER *pAd, UINT32 rdd_num, UINT32 rdd_in_sel, UINT32 is_start);
INT32 (*SetCfgOnOff)(struct _RTMP_ADAPTER *pAd, UINT32 Type, UINT32 Enable);
INT32 (*GetCfgOnOff)(struct _RTMP_ADAPTER *pAd, UINT32 Type, UINT32 *Result);
INT32 (*SetRXFilterPktLen)(struct _RTMP_ADAPTER *pAd, UINT32 Enable, UINT32 RxPktLen);
INT32(*onOffRDD)
(struct _RTMP_ADAPTER *pAd, UINT32 rdd_num, UINT32 rdd_in_sel,
UINT32 is_start);
INT32(*SetCfgOnOff)
(struct _RTMP_ADAPTER *pAd, UINT32 Type, UINT32 Enable);
INT32(*GetCfgOnOff)
(struct _RTMP_ADAPTER *pAd, UINT32 Type, UINT32 *Result);
INT32(*SetRXFilterPktLen)
(struct _RTMP_ADAPTER *pAd, UINT32 Enable, UINT32 RxPktLen);
#ifdef TXPWRMANUAL
INT32 (*SetTxPwrManual)(struct _RTMP_ADAPTER *pAd, BOOLEAN fgPwrManCtrl, UINT8 u1TxPwrModeManual, UINT8 u1TxPwrBwManual, UINT8 u1TxPwrRateManual, INT8 i1TxPwrValueManual, UCHAR Band);
INT32(*SetTxPwrManual)
(struct _RTMP_ADAPTER *pAd, BOOLEAN fgPwrManCtrl,
UINT8 u1TxPwrModeManual, UINT8 u1TxPwrBwManual,
UINT8 u1TxPwrRateManual, INT8 i1TxPwrValueManual, UCHAR Band);
#endif
INT32 (*DBDCTxTone)(struct _RTMP_ADAPTER *pAd, UINT32 Control, UINT32 AntIndex, UINT32 ToneType, UINT32 ToneFreq, INT32 DcOffset_I, INT32 DcOffset_Q, UINT32 Band);
INT32(*DBDCTxTone)
(struct _RTMP_ADAPTER *pAd, UINT32 Control, UINT32 AntIndex,
UINT32 ToneType, UINT32 ToneFreq, INT32 DcOffset_I, INT32 DcOffset_Q,
UINT32 Band);
INT32 (*TxCWTone)(struct _RTMP_ADAPTER *pAd, UINT32 Control);
INT32 (*GetTxPower)(struct _RTMP_ADAPTER *pAd, UINT32 Enable, UINT32 Ch_Band, UINT32 *EfuseAddr, UINT32 *Power);
INT32 (*BssInfoUpdate)(struct _RTMP_ADAPTER *pAd, UINT32 OwnMacIdx, UINT32 BssIdx, UCHAR *Bssid);
INT32 (*DevInfoUpdate)(struct _RTMP_ADAPTER *pAd, UINT32 OwnMacIdx, UCHAR *Bssid);
INT32 (*LogOnOff)(struct _RTMP_ADAPTER *pAd, UINT32 type, UINT32 on_off, UINT32 num_log);
INT32 (*SetICapStart)(struct _RTMP_ADAPTER *pAd, BOOLEAN Trigger, BOOLEAN RingCapEn, UINT32 Event, UINT32 Node, UINT32 Len, UINT32 StopCycle, UINT32 BW, UINT32 MACTriggerEvent, UINT32 SourceAddrLSB, UINT32 SourceAddrMSB, UINT32 Band);
INT32(*GetTxPower)
(struct _RTMP_ADAPTER *pAd, UINT32 Enable, UINT32 Ch_Band,
UINT32 *EfuseAddr, UINT32 *Power);
INT32(*BssInfoUpdate)
(struct _RTMP_ADAPTER *pAd, UINT32 OwnMacIdx, UINT32 BssIdx,
UCHAR *Bssid);
INT32(*DevInfoUpdate)
(struct _RTMP_ADAPTER *pAd, UINT32 OwnMacIdx, UCHAR *Bssid);
INT32(*LogOnOff)
(struct _RTMP_ADAPTER *pAd, UINT32 type, UINT32 on_off, UINT32 num_log);
INT32(*SetICapStart)
(struct _RTMP_ADAPTER *pAd, BOOLEAN Trigger, BOOLEAN RingCapEn,
UINT32 Event, UINT32 Node, UINT32 Len, UINT32 StopCycle, UINT32 BW,
UINT32 MACTriggerEvent, UINT32 SourceAddrLSB, UINT32 SourceAddrMSB,
UINT32 Band);
INT32 (*GetICapStatus)(struct _RTMP_ADAPTER *pAd);
INT32 (*GetICapIQData)(struct _RTMP_ADAPTER *pAd, PINT32 pData, PINT32 pDataLen, UINT32 IQ_Type, UINT32 WF_Num);
INT32 (*SetAntennaPort)(struct _RTMP_ADAPTER *pAd, UINT32 RfModeMask, UINT32 RfPortMask, UINT32 AntPortMask);
INT32(*GetICapIQData)
(struct _RTMP_ADAPTER *pAd, PINT32 pData, PINT32 pDataLen,
UINT32 IQ_Type, UINT32 WF_Num);
INT32(*SetAntennaPort)
(struct _RTMP_ADAPTER *pAd, UINT32 RfModeMask, UINT32 RfPortMask,
UINT32 AntPortMask);
INT32 (*ClockSwitchDisable)(struct _RTMP_ADAPTER *pAd, UINT8 isDisable);
};
@ -352,12 +398,12 @@ enum {
ATE_LOG_CTRL_NUM,
};
#define fATE_LOG_RXV (1 << ATE_LOG_RXV)
#define fATE_LOG_RDD (1 << ATE_LOG_RDD)
#define fATE_LOG_RE_CAL (1 << ATE_LOG_RE_CAL)
#define fATE_LOG_RXINFO (1 << ATE_LOG_RXINFO)
#define fATE_LOG_TXDUMP (1 << ATE_LOG_TXDUMP)
#define fATE_LOG_TEST (1 << ATE_LOG_TEST)
#define fATE_LOG_RXV (1 << ATE_LOG_RXV)
#define fATE_LOG_RDD (1 << ATE_LOG_RDD)
#define fATE_LOG_RE_CAL (1 << ATE_LOG_RE_CAL)
#define fATE_LOG_RXINFO (1 << ATE_LOG_RXINFO)
#define fATE_LOG_TXDUMP (1 << ATE_LOG_TXDUMP)
#define fATE_LOG_TEST (1 << ATE_LOG_TEST)
struct _ATE_LOG_DUMP_ENTRY {
UINT32 log_type;
@ -384,7 +430,7 @@ struct _ATE_LOG_DUMP_CB {
struct _ATE_LOG_DUMP_ENTRY *entry;
};
#define ATE_MPS_ITEM_RUNNING (1<<0)
#define ATE_MPS_ITEM_RUNNING (1 << 0)
struct _HQA_MPS_CB {
NDIS_SPIN_LOCK lock;
UINT32 mps_cnt;
@ -402,8 +448,8 @@ struct _ATE_PFMU_INFO {
UCHAR addr[MAC_ADDR_LEN];
};
#define ATE_RXV_SIZE 9
#define ATE_ANT_NUM 4
#define ATE_RXV_SIZE 9
#define ATE_ANT_NUM 4
struct _ATE_RX_STATISTIC {
INT32 FreqOffsetFromRx;
@ -413,12 +459,12 @@ struct _ATE_RX_STATISTIC {
UINT32 RxMacMdrdyCount;
UINT32 RxMacFCSErrCount_band1;
UINT32 RxMacMdrdyCount_band1;
CHAR LastSNR[ATE_ANT_NUM]; /* last received SNR */
CHAR LastRssi[ATE_ANT_NUM]; /* last received RSSI */
CHAR AvgRssi[ATE_ANT_NUM]; /* last 8 frames' average RSSI */
CHAR LastSNR[ATE_ANT_NUM]; /* last received SNR */
CHAR LastRssi[ATE_ANT_NUM]; /* last received RSSI */
CHAR AvgRssi[ATE_ANT_NUM]; /* last 8 frames' average RSSI */
CHAR MaxRssi[ATE_ANT_NUM];
CHAR MinRssi[ATE_ANT_NUM];
SHORT AvgRssiX8[ATE_ANT_NUM]; /* sum of last 8 frames' RSSI */
SHORT AvgRssiX8[ATE_ANT_NUM]; /* sum of last 8 frames' RSSI */
UINT32 RSSI[ATE_ANT_NUM];
UINT32 SNR[ATE_ANT_NUM];
UINT32 RCPI[ATE_ANT_NUM];
@ -433,8 +479,8 @@ struct _ATE_RX_STATISTIC {
};
struct _ATE_TX_TIME_PARAM {
BOOLEAN pkt_tx_time_en; /* The packet transmission time feature enable or disable */
UINT32 pkt_tx_time; /* The target packet transmission time */
BOOLEAN pkt_tx_time_en; /* The packet transmission time feature enable or disable */
UINT32 pkt_tx_time; /* The target packet transmission time */
UINT32 pkt_tx_len;
UINT32 pkt_msdu_len;
UINT32 pkt_hdr_len;
@ -445,11 +491,11 @@ struct _ATE_TX_TIME_PARAM {
};
struct _ATE_IPG_PARAM {
UINT32 ipg; /* The target idle time */
UINT8 sig_ext; /* Only OFDM/HT/VHT need to consider sig_ext */
UINT32 ipg; /* The target idle time */
UINT8 sig_ext; /* Only OFDM/HT/VHT need to consider sig_ext */
UINT16 slot_time;
UINT16 sifs_time;
UINT8 ac_num; /* 0: AC_BK, 1: AC_BE, 2: AC_VI, 3: AC_VO */
UINT8 ac_num; /* 0: AC_BK, 1: AC_BE, 2: AC_VI, 3: AC_VO */
UINT8 aifsn;
UINT16 cw;
UINT16 txop;
@ -457,11 +503,11 @@ struct _ATE_IPG_PARAM {
#ifdef DBDC_MODE
struct _BAND_INFO {
UCHAR *pate_pkt; /* Buffer for TestPkt */
UCHAR *pate_pkt; /* Buffer for TestPkt */
PNDIS_PACKET pkt_skb;
UINT32 is_alloc_skb;
RTMP_OS_COMPLETION tx_wait;
UCHAR TxStatus; /* TxStatus : 0 --> task is idle, 1 --> task is running */
UCHAR TxStatus; /* TxStatus : 0 --> task is idle, 1 --> task is running */
UINT32 Mode;
UINT32 TxAntennaSel;
UINT32 RxAntennaSel;
@ -481,14 +527,14 @@ struct _BAND_INFO {
UCHAR PrimaryBWSel;
UCHAR PhyMode;
UCHAR Stbc;
UCHAR Ldpc; /* 0:BCC 1:LDPC */
UCHAR Ldpc; /* 0:BCC 1:LDPC */
UCHAR Sgi;
UCHAR Mcs;
UCHAR Preamble;
UINT32 FixedPayload; /* Normal:0,Repeat:1,Random:2 */
UINT32 FixedPayload; /* Normal:0,Repeat:1,Random:2 */
UINT32 TxLength;
UINT32 TxCount;
UINT32 TxDoneCount; /* Tx DMA Done */
UINT32 TxDoneCount; /* Tx DMA Done */
UINT32 TxedCount;
UINT32 RFFreqOffset;
UINT32 thermal_val;
@ -510,17 +556,17 @@ struct _BAND_INFO {
UCHAR Addr3[MAC_ADDR_LEN];
UCHAR payload[ATE_MAX_PATTERN_SIZE];
UINT32 pl_len;
USHORT HLen; /* Header Length */
USHORT HLen; /* Header Length */
USHORT seq;
struct _HQA_MPS_CB mps_cb;
BOOLEAN fgTxPowerSKUEn; /* SKU On/Off status */
BOOLEAN fgTxPowerPercentageEn; /* Power Percentage On/Off status */
BOOLEAN fgTxPowerBFBackoffEn; /* BF Backoff On/Off status */
UINT32 PercentageLevel; /* TxPower Percentage Level */
INT32 RF_Power;
INT32 Digital_Power;
INT32 DcOffset_I;
INT32 DcOffset_Q;
BOOLEAN fgTxPowerSKUEn; /* SKU On/Off status */
BOOLEAN fgTxPowerPercentageEn; /* Power Percentage On/Off status */
BOOLEAN fgTxPowerBFBackoffEn; /* BF Backoff On/Off status */
UINT32 PercentageLevel; /* TxPower Percentage Level */
INT32 RF_Power;
INT32 Digital_Power;
INT32 DcOffset_I;
INT32 DcOffset_Q;
};
#endif
@ -550,7 +596,7 @@ struct _ATE_CTRL {
#ifdef DBDC_MODE
struct _BAND_INFO band_ext[1];
#endif
UCHAR *pate_pkt; /* Buffer for TestPkt */
UCHAR *pate_pkt; /* Buffer for TestPkt */
PNDIS_PACKET pkt_skb;
UINT32 is_alloc_skb;
UINT32 Mode;
@ -558,10 +604,10 @@ struct _ATE_CTRL {
CHAR TxPower1;
CHAR TxPower2;
CHAR TxPower3;
UINT32 TxAntennaSel; /* band0 => TX0/TX1 , band1 => TX2/TX3 */
UINT32 TxAntennaSel; /* band0 => TX0/TX1 , band1 => TX2/TX3 */
UINT32 RxAntennaSel;
UCHAR backup_channel; /* Backup normal driver's channel for recovering */
UCHAR backup_phymode; /* Backup normal driver's phymode for recovering */
UCHAR backup_channel; /* Backup normal driver's channel for recovering */
UCHAR backup_phymode; /* Backup normal driver's phymode for recovering */
UCHAR wdev_idx;
UCHAR wmm_idx;
USHORT QID;
@ -576,15 +622,15 @@ struct _ATE_CTRL {
UCHAR PrimaryBWSel;
UCHAR PhyMode;
UCHAR Stbc;
UCHAR Ldpc; /* 0:BCC 1:LDPC */
UCHAR Ldpc; /* 0:BCC 1:LDPC */
UCHAR Sgi;
UCHAR Mcs;
UCHAR Preamble;
UCHAR Payload; /* Payload pattern */
UCHAR Payload; /* Payload pattern */
UINT32 FixedPayload;
UINT32 TxLength;
UINT32 TxCount;
UINT32 TxDoneCount; /* Tx DMA Done */
UINT32 TxDoneCount; /* Tx DMA Done */
UINT32 TxedCount;
UINT32 RFFreqOffset;
UINT32 thermal_val;
@ -615,7 +661,7 @@ struct _ATE_CTRL {
UCHAR Addr3[MAC_ADDR_LEN];
UCHAR payload[ATE_MAX_PATTERN_SIZE];
UINT32 pl_len;
USHORT HLen; /* Header Length */
USHORT HLen; /* Header Length */
USHORT seq;
/* MU Related */
BOOLEAN mu_enable;
@ -632,11 +678,11 @@ struct _ATE_CTRL {
UCHAR FAGC_Path;
/* Flag */
BOOLEAN txs_enable;
BOOLEAN bQAEnabled; /* QA is used. */
BOOLEAN bQATxStart; /* Have compiled QA in and use it to ATE tx. */
BOOLEAN bQARxStart; /* Have compiled QA in and use it to ATE rx. */
BOOLEAN need_set_pwr; /* For MPS switch power in right context */
UCHAR TxStatus; /* TxStatus : 0 --> task is idle, 1 --> task is running */
BOOLEAN bQAEnabled; /* QA is used. */
BOOLEAN bQATxStart; /* Have compiled QA in and use it to ATE tx. */
BOOLEAN bQARxStart; /* Have compiled QA in and use it to ATE rx. */
BOOLEAN need_set_pwr; /* For MPS switch power in right context */
UCHAR TxStatus; /* TxStatus : 0 --> task is idle, 1 --> task is running */
UCHAR did_tx;
UCHAR did_rx;
UCHAR en_man_set_freq;
@ -652,27 +698,25 @@ struct _ATE_CTRL {
ULONG PeriodicRound;
OS_NDIS_SPIN_LOCK TssiSemLock;
#endif
BOOLEAN fgTxPowerSKUEn; /* SKU On/Off status */
BOOLEAN fgTxPowerPercentageEn; /* Power Percentage On/Off status */
BOOLEAN fgTxPowerBFBackoffEn; /* BF Backoff On/Off status */
UINT32 PercentageLevel; /* TxPower Percentage Level */
INT32 RF_Power;
INT32 Digital_Power;
INT32 DcOffset_I;
INT32 DcOffset_Q;
BOOLEAN fgTxPowerSKUEn; /* SKU On/Off status */
BOOLEAN fgTxPowerPercentageEn; /* Power Percentage On/Off status */
BOOLEAN fgTxPowerBFBackoffEn; /* BF Backoff On/Off status */
UINT32 PercentageLevel; /* TxPower Percentage Level */
INT32 RF_Power;
INT32 Digital_Power;
INT32 DcOffset_I;
INT32 DcOffset_Q;
};
#if !defined(COMPOS_TESTMODE_WIN)
VOID RtmpDmaEnable(RTMP_ADAPTER *pAd, INT Enable);
VOID ATE_RTUSBBulkOutDataPacket(
IN PRTMP_ADAPTER pAd,
IN UCHAR BulkOutPipeId);
VOID ATE_RTUSBBulkOutDataPacket(IN PRTMP_ADAPTER pAd, IN UCHAR BulkOutPipeId);
VOID ATE_RTUSBCancelPendingBulkInIRP(
IN PRTMP_ADAPTER pAd);
VOID ATE_RTUSBCancelPendingBulkInIRP(IN PRTMP_ADAPTER pAd);
#endif
INT MtATESetMacTxRx(struct _RTMP_ADAPTER *pAd, INT32 TxRx, BOOLEAN Enable, UCHAR BandIdx);
INT MtATESetMacTxRx(struct _RTMP_ADAPTER *pAd, INT32 TxRx, BOOLEAN Enable,
UCHAR BandIdx);
#if defined(TXBF_SUPPORT) && defined(MT_MAC)
INT SetATEApplyStaToMacTblEntry(RTMP_ADAPTER *pAd);
INT SetATEApplyStaToAsic(RTMP_ADAPTER *pAd);

View File

@ -22,12 +22,15 @@ struct _RTMP_ADAPTER;
INT32 SetTxStop(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetRxStop(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
#ifdef DBG
VOID ATE_QA_Statistics(struct _RTMP_ADAPTER *pAd, RXWI_STRUC *pRxWI, RXINFO_STRUC *pRxInfo, PHEADER_802_11 pHeader);
VOID ATE_QA_Statistics(struct _RTMP_ADAPTER *pAd, RXWI_STRUC *pRxWI,
RXINFO_STRUC *pRxInfo, PHEADER_802_11 pHeader);
#ifdef CONFIG_QA
INT32 RtmpDoAte(struct _RTMP_ADAPTER *pAd, RTMP_IOCTL_INPUT_STRUCT *wrq, RTMP_STRING *wrq_name);
INT32 RtmpDoAte(struct _RTMP_ADAPTER *pAd, RTMP_IOCTL_INPUT_STRUCT *wrq,
RTMP_STRING *wrq_name);
#endif
#ifdef WCX_SUPPORT
INT32 do_meta_cmd(int ioctl_cmd, PRTMP_ADAPTER pAd, RTMP_IOCTL_INPUT_STRUCT *WRQ, RTMP_STRING *wrq_name);
INT32 do_meta_cmd(int ioctl_cmd, PRTMP_ADAPTER pAd,
RTMP_IOCTL_INPUT_STRUCT *WRQ, RTMP_STRING *wrq_name);
#endif
INT32 SetEERead(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetEEWrite(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
@ -37,7 +40,8 @@ INT32 SetRFWrite(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
#endif /* DBG */
VOID rt_ee_read_all(struct _RTMP_ADAPTER *pAd, UINT16 *Data);
VOID rt_ee_write_all(struct _RTMP_ADAPTER pAd, UINT16 *Data);
VOID rt_ee_write_bulk(struct _RTMP_ADAPTER pAd, UINT16 *Data, UINT16 offset, UINT16 length);
VOID rt_ee_write_bulk(struct _RTMP_ADAPTER pAd, UINT16 *Data, UINT16 offset,
UINT16 length);
INT32 SetATEQid(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetATEDeqCnt(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetATEMPSDump(struct _RTMP_ADAPTER *pAd, RTMP_STRING *arg);
@ -75,7 +79,8 @@ INT32 SetATERFPower(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetATEDigitalPower(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetATEDCOffset_I(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetATEDCOffset_Q(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 Default_Set_ATE_TX_FREQ_OFFSET_Proc(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 Default_Set_ATE_TX_FREQ_OFFSET_Proc(struct _RTMP_ADAPTER *pAd,
RTMP_STRING *Arg);
INT32 SetATETxFreqOffset(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 Default_Set_ATE_TX_BW_Proc(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetATETxLength(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
@ -129,7 +134,8 @@ INT32 SetATETtr(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetATEShow(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetATEHelp(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 ATESampleRssi(struct _RTMP_ADAPTER *pAd, RXWI_STRUC *pRxWI);
VOID ATEPeriodicExec(PVOID SystemSpecific1, PVOID FunctionContext, PVOID SystemSpecific2, PVOID SystemSpecific3);
VOID ATEPeriodicExec(PVOID SystemSpecific1, PVOID FunctionContext,
PVOID SystemSpecific2, PVOID SystemSpecific3);
INT32 SetATE(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 SetATEChannel(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);
INT32 set_ate_duty_cycle(struct _RTMP_ADAPTER *pAd, RTMP_STRING *Arg);

View File

@ -24,35 +24,37 @@ extern int CH_HZ_ID_MAP_NUM;
* struct for command formats
*/
struct GNU_PACKED _META_CMD_HDR {
UINT32 oid;
UINT32 len_in; /* For set */
UINT32 len_out; /* For query */
UCHAR data[2048];
UINT32 oid;
UINT32 len_in; /* For set */
UINT32 len_out; /* For query */
UCHAR data[2048];
};
struct GNU_PACKED _PARAM_MTK_WIFI_TEST {
UINT32 idx;
UINT32 data;
UINT32 idx;
UINT32 data;
};
struct GNU_PACKED _PARAM_CUSTOM_EFUSE_RW {
UINT32 offset;
UINT32 data;
UINT32 offset;
UINT32 data;
};
struct GNU_PACKED _PARAM_CUSTOM_EEPROM_RW {
UINT8 method;
UINT8 idx;
UINT8 reserved;
UINT16 data;
UINT8 method;
UINT8 idx;
UINT8 reserved;
UINT16 data;
};
struct GNU_PACKED _PARAM_CUSTOM_MCR_RW {
UINT32 offset;
UINT32 data;
UINT32 offset;
UINT32 data;
};
typedef INT32 (*META_CMD_HANDLER)(int ioctl_cmd, struct _RTMP_ADAPTER *pAd, RTMP_IOCTL_INPUT_STRUCT * wrq, META_CMD_HDR * cmd_hdr);
typedef INT32 (*META_CMD_HANDLER)(int ioctl_cmd, struct _RTMP_ADAPTER *pAd,
RTMP_IOCTL_INPUT_STRUCT *wrq,
META_CMD_HDR *cmd_hdr);
INT Set_Sdio_Bist_Write(struct _RTMP_ADAPTER *pAd, RTMP_STRING *arg);
INT Set_Sdio_Bist_Read(struct _RTMP_ADAPTER *pAd, RTMP_STRING *arg);
@ -61,32 +63,31 @@ INT Set_Sdio_Bist_Read(struct _RTMP_ADAPTER *pAd, RTMP_STRING *arg);
*/
#define MT_META_WIFI_TEST_TABLE_VER 0x01180000
#define OID_CUSTOM_IF_VER 0xFFA0C000
#define OID_CUSTOM_MCR_RW 0xFFA0C801
#define OID_CUSTOM_EEPROM_RW 0xFFA0C803
#define OID_CUSTOM_EFUSE_RW 0xFFA0C805
#define OID_CUSTOM_TEST_MODE 0xFFA0C901
#define OID_CUSTOM_ABORT_TEST_MODE 0xFFA0C906
#define OID_CUSTOM_MTK_WIFI_TEST 0xFFA0C911
#define OID_CUSTOM_IF_VER 0xFFA0C000
#define OID_CUSTOM_MCR_RW 0xFFA0C801
#define OID_CUSTOM_EEPROM_RW 0xFFA0C803
#define OID_CUSTOM_EFUSE_RW 0xFFA0C805
#define OID_CUSTOM_TEST_MODE 0xFFA0C901
#define OID_CUSTOM_ABORT_TEST_MODE 0xFFA0C906
#define OID_CUSTOM_MTK_WIFI_TEST 0xFFA0C911
/* NVRAM */
#define OID_CUSTOM_MTK_NVRAM_RW 0xFFA0C941
#define OID_CUSTOM_CFG_SRC_TYPE 0xFFA0C942
#define OID_CUSTOM_EEPROM_TYPE 0xFFA0C943
#define OID_CUSTOM_MTK_NVRAM_RW 0xFFA0C941
#define OID_CUSTOM_CFG_SRC_TYPE 0xFFA0C942
#define OID_CUSTOM_EEPROM_TYPE 0xFFA0C943
#define MT_META_WIFI_TEST_CMD_MASK 0x0000001F /* 32 cmd for 1 set, 0x1F=31*/
#define MT_META_WIFI_TEST_SET_MASK 0x0EFFFFFF /* 32 bits width, rest 27 bits*/
#define MT_META_WIFI_TEST_CMD_MASK 0x0000001F /* 32 cmd for 1 set, 0x1F=31*/
#define MT_META_WIFI_TEST_SET_MASK 0x0EFFFFFF /* 32 bits width, rest 27 bits*/
#define SLOT_TIME_SHORT 9
#define PARAM_EEPROM_READ_METHOD_READ 1
#define PARAM_EEPROM_READ_METHOD_GETSIZE 0
#define PARAM_EEPROM_READ_METHOD_READ 1
#define PARAM_EEPROM_READ_METHOD_GETSIZE 0
/*
* MACRO
*/
#define FUNC_IDX_GET_IDX(__idx, __func_idx) \
(__func_idx = __idx & 0x000000FF)
#define FUNC_IDX_GET_SUBFIELD(__idx, __sub) \
(__sub = ((__idx & 0xff000000)>>24)&0x000000ff)
#define FUNC_IDX_GET_IDX(__idx, __func_idx) (__func_idx = __idx & 0x000000FF)
#define FUNC_IDX_GET_SUBFIELD(__idx, __sub) \
(__sub = ((__idx & 0xff000000) >> 24) & 0x000000ff)
/* TODO: Need to put into include/rt_os.h when merge the file */
#define MTPRIV_IOCTL_META_SET (SIOCIWFIRSTPRIV + 0x08)
#define MTPRIV_IOCTL_META_QUERY (SIOCIWFIRSTPRIV + 0x09)

View File

@ -4,22 +4,21 @@
#include "mt_testmode_dmac.h"
#define TESTMODE_WCID_BAND0 2
#define TESTMODE_WCID_BAND1 3
#define ATE_SINGLE_BAND 1
#define ATE_DUAL_BAND 2
#define ATE_GBAND_TYPE 1
#define ATE_ABAND_TYPE 2
#define ATE_SINGLE_BAND 1
#define ATE_DUAL_BAND 2
#define ATE_GBAND_TYPE 1
#define ATE_ABAND_TYPE 2
#define ATE_BAND_WIDTH_20 0
#define ATE_BAND_WIDTH_40 1
#define ATE_BAND_WIDTH_80 2
#define ATE_BAND_WIDTH_10 3
#define ATE_BAND_WIDTH_5 4
#define ATE_BAND_WIDTH_160 5
#define ATE_BAND_WIDTH_8080 6
#define ATE_BAND_WIDTH_20 0
#define ATE_BAND_WIDTH_40 1
#define ATE_BAND_WIDTH_80 2
#define ATE_BAND_WIDTH_10 3
#define ATE_BAND_WIDTH_5 4
#define ATE_BAND_WIDTH_160 5
#define ATE_BAND_WIDTH_8080 6
enum {
ATE_USER_PAYLOAD,
@ -28,8 +27,8 @@ enum {
};
struct _ATE_DATA_RATE_MAP {
UCHAR mcs; /* MCS index */
UINT32 tx_data_rate; /* Data rate in K Bit */
UCHAR mcs; /* MCS index */
UINT32 tx_data_rate; /* Data rate in K Bit */
};
struct _ATE_ANT_MAP {
@ -48,23 +47,24 @@ struct _ATE_CH_KHZ_MAP {
UINT32 Freq;
};
#if defined(COMPOS_TESTMODE_WIN)/* for MT_testmode.c */
#if defined(COMPOS_TESTMODE_WIN) /* for MT_testmode.c */
#define INC_RING_INDEX(_idx, _RingSize) \
do {\
(_idx)++; \
if ((_idx) >= (_RingSize)) \
_idx = 0; \
#define INC_RING_INDEX(_idx, _RingSize) \
do { \
(_idx)++; \
if ((_idx) >= (_RingSize)) \
_idx = 0; \
} while (0)
#define BAND_WIDTH_20 0
#define BAND_WIDTH_40 1
#define BAND_WIDTH_80 2
#define BAND_WIDTH_160 3
#define BAND_WIDTH_10 4 /* 802.11j has 10MHz. This definition is for internal usage. doesn't fill in the IE or other field. */
#define BAND_WIDTH_BOTH 5 /* BW20 + BW40 */
#define BAND_WIDTH_5 6
#define BAND_WIDTH_8080 7
#define BAND_WIDTH_20 0
#define BAND_WIDTH_40 1
#define BAND_WIDTH_80 2
#define BAND_WIDTH_160 3
#define BAND_WIDTH_10 \
4 /* 802.11j has 10MHz. This definition is for internal usage. doesn't fill in the IE or other field. */
#define BAND_WIDTH_BOTH 5 /* BW20 + BW40 */
#define BAND_WIDTH_5 6
#define BAND_WIDTH_8080 7
#define TX1_G_BAND_TARGET_PWR 0x5E
#define TX0_G_BAND_TARGET_PWR 0x58
@ -75,54 +75,60 @@ enum {
};
#define TESTMODE_GET_PADDR(_pstruct, _band, _member) (&_pstruct->_member)
#define TESTMODE_GET_PARAM(_pstruct, _band, _member) (_pstruct->_member)
#define TESTMODE_SET_PARAM(_pstruct, _band, _member, _val) (_pstruct->_member = _val)
#ifndef COMPOS_TESTMODE_WIN/* NDIS only */
#define MAC_ADDR_LEN 6
#define TESTMODE_SET_PARAM(_pstruct, _band, _member, _val) \
(_pstruct->_member = _val)
#ifndef COMPOS_TESTMODE_WIN /* NDIS only */
#define MAC_ADDR_LEN 6
/* 2-byte Frame control field */
struct _QAFRAME_CONTROL {
UINT16 Ver : 2;
UINT16 Type : 2;
UINT16 SubType : 4;
UINT16 ToDs : 1;
UINT16 FrDs : 1;
UINT16 MoreFrag : 1;
UINT16 Retry : 1;
UINT16 PwrMgmt : 1;
UINT16 MoreData : 1;
UINT16 Wep : 1;
UINT16 Order : 1;
UINT16 Ver : 2;
UINT16 Type : 2;
UINT16 SubType : 4;
UINT16 ToDs : 1;
UINT16 FrDs : 1;
UINT16 MoreFrag : 1;
UINT16 Retry : 1;
UINT16 PwrMgmt : 1;
UINT16 MoreData : 1;
UINT16 Wep : 1;
UINT16 Order : 1;
};
struct _QAHEADER_802_11 {
struct _QAFRAME_CONTROL FC;
UINT16 Duration;
UCHAR Addr1[MAC_ADDR_LEN];
UCHAR Addr2[MAC_ADDR_LEN];
UCHAR Addr3[MAC_ADDR_LEN];
UINT16 Frag: 4;
UINT16 Sequence: 12;
struct _QAFRAME_CONTROL FC;
UINT16 Duration;
UCHAR Addr1[MAC_ADDR_LEN];
UCHAR Addr2[MAC_ADDR_LEN];
UCHAR Addr3[MAC_ADDR_LEN];
UINT16 Frag : 4;
UINT16 Sequence : 12;
};
#endif /* NOT COMPOS_TESTMODE_WIN */
#else
#ifdef DBDC_MODE
#define TESTMODE_GET_PARAM(_pstruct, _band, _member) ((_band)?_pstruct->band_ext[_band-1]._member:_pstruct->_member)
#define TESTMODE_GET_PADDR(_pstruct, _band, _member) ((_band) ? &_pstruct->band_ext[_band-1]._member : &_pstruct->_member)
#define TESTMODE_SET_PARAM(_pstruct, _band, _member, _val) ({ \
UINT32 _ret = _val; \
if (_band) { \
struct _BAND_INFO *_info = &(_pstruct->band_ext[_band-1]); \
_info->_member = _val; \
} else \
_pstruct->_member = _val; \
_ret; \
#define TESTMODE_GET_PARAM(_pstruct, _band, _member) \
((_band) ? _pstruct->band_ext[_band - 1]._member : _pstruct->_member)
#define TESTMODE_GET_PADDR(_pstruct, _band, _member) \
((_band) ? &_pstruct->band_ext[_band - 1]._member : &_pstruct->_member)
#define TESTMODE_SET_PARAM(_pstruct, _band, _member, _val) \
({ \
UINT32 _ret = _val; \
if (_band) { \
struct _BAND_INFO *_info = \
&(_pstruct->band_ext[_band - 1]); \
_info->_member = _val; \
} else \
_pstruct->_member = _val; \
_ret; \
})
#else
#define TESTMODE_GET_PADDR(_pstruct, _band, _member) (&_pstruct->_member)
#define TESTMODE_GET_PARAM(_pstruct, _band, _member) (_pstruct->_member)
#define TESTMODE_SET_PARAM(_pstruct, _band, _member, _val) ({ \
UINT32 _ret = _val; \
_pstruct->_member = _val; \
_ret; \
#define TESTMODE_SET_PARAM(_pstruct, _band, _member, _val) \
({ \
UINT32 _ret = _val; \
_pstruct->_member = _val; \
_ret; \
})
#endif /* DBDC_MODE */
#endif /* defined(COMPOS_TESTMODE_WIN) */
@ -136,11 +142,11 @@ enum _TESTMODE_STAT_TYPE {
};
struct _RATE_TO_BE_FIX {
UINT32 TXRate: 6;
UINT32 TXMode: 3;
UINT32 Nsts: 2;
UINT32 STBC: 1;
UINT32 Reserved: 20;
UINT32 TXRate : 6;
UINT32 TXMode : 3;
UINT32 Nsts : 2;
UINT32 STBC : 1;
UINT32 Reserved : 20;
};
struct rssi_offset_eeprom {
@ -153,27 +159,39 @@ INT32 MT_ATERFTestCB(struct _RTMP_ADAPTER *pAd, UINT8 *Data, UINT32 Length);
INT32 MT_SetATEMPSDump(struct _RTMP_ADAPTER *pAd, UINT32 band_idx);
INT32 MtTestModeInit(struct _RTMP_ADAPTER *pAd);
INT32 MtTestModeExit(struct _RTMP_ADAPTER *pAd);
INT MtTestModeBkCr(struct _RTMP_ADAPTER *pAd, ULONG offset, enum _TEST_BK_CR_TYPE type);
INT MtTestModeBkCr(struct _RTMP_ADAPTER *pAd, ULONG offset,
enum _TEST_BK_CR_TYPE type);
INT MtTestModeRestoreCr(struct _RTMP_ADAPTER *pAd, ULONG offset);
INT32 MT_ATETxControl(struct _RTMP_ADAPTER *pAd, UINT32 band_idx, PNDIS_PACKET pkt);
VOID MT_ATEUpdateRxStatistic(struct _RTMP_ADAPTER *pAd, enum _TESTMODE_STAT_TYPE type, VOID *data);
INT Mt_TestModeInsertPeer(struct _RTMP_ADAPTER *pAd, UINT32 band_ext, CHAR *da, CHAR *sa, CHAR *bss);
INT32 MT_ATETxPkt(struct _RTMP_ADAPTER *pAd, UINT32 band_idx); /* Export for Loopback */
INT MtATESetMacTxRx(struct _RTMP_ADAPTER *pAd, INT32 TxRx, BOOLEAN Enable, UCHAR BandIdx);
INT MtATESetTxStream(struct _RTMP_ADAPTER *pAd, UINT32 StreamNums, UCHAR BandIdx);
INT32 MT_ATETxControl(struct _RTMP_ADAPTER *pAd, UINT32 band_idx,
PNDIS_PACKET pkt);
VOID MT_ATEUpdateRxStatistic(struct _RTMP_ADAPTER *pAd,
enum _TESTMODE_STAT_TYPE type, VOID *data);
INT Mt_TestModeInsertPeer(struct _RTMP_ADAPTER *pAd, UINT32 band_ext, CHAR *da,
CHAR *sa, CHAR *bss);
INT32 MT_ATETxPkt(struct _RTMP_ADAPTER *pAd,
UINT32 band_idx); /* Export for Loopback */
INT MtATESetMacTxRx(struct _RTMP_ADAPTER *pAd, INT32 TxRx, BOOLEAN Enable,
UCHAR BandIdx);
INT MtATESetTxStream(struct _RTMP_ADAPTER *pAd, UINT32 StreamNums,
UCHAR BandIdx);
INT MtATESetRxPath(struct _RTMP_ADAPTER *pAd, UINT32 RxPathSel, UCHAR BandIdx);
INT MtATESetRxFilter(struct _RTMP_ADAPTER *pAd, MT_RX_FILTER_CTRL_T filter);
INT MtATESetCleanPerStaTxQueue(struct _RTMP_ADAPTER *pAd, BOOLEAN sta_pause_enable);
INT32 MT_ATEDumpLog(struct _RTMP_ADAPTER *pAd, struct _ATE_LOG_DUMP_CB *log_cb, UINT32 log_type);
INT MtATESetCleanPerStaTxQueue(struct _RTMP_ADAPTER *pAd,
BOOLEAN sta_pause_enable);
INT32 MT_ATEDumpLog(struct _RTMP_ADAPTER *pAd, struct _ATE_LOG_DUMP_CB *log_cb,
UINT32 log_type);
VOID MtCmdATETestResp(struct cmd_msg *msg, char *data, UINT16 len);
INT32 MtATECh2Freq(UINT32 Channel, UINT32 band_idx);
INT32 MtATEGetTxPwrGroup(UINT32 Channel, UINT32 band_idx, UINT32 Ant_idx);
INT32 MT_ATEInsertLog(struct _RTMP_ADAPTER *pAd, UCHAR *log, UINT32 log_type, UINT32 len);
#if !defined(COMPOS_TESTMODE_WIN)/* for MT_testmode.c */
INT32 MT_ATEInsertLog(struct _RTMP_ADAPTER *pAd, UCHAR *log, UINT32 log_type,
UINT32 len);
#if !defined(COMPOS_TESTMODE_WIN) /* for MT_testmode.c */
INT MT_ATERxDoneHandle(struct _RTMP_ADAPTER *pAd, RX_BLK *pRxBlk);
#endif
INT32 MtATERSSIOffset(struct _RTMP_ADAPTER *pAd, INT32 RSSI_org, UINT32 RSSI_idx, INT32 Ch_Band);
INT32 MtATETssiTrainingProc(struct _RTMP_ADAPTER *pAd, UCHAR ucBW, UCHAR ucBandIdx);
INT32 MtATERSSIOffset(struct _RTMP_ADAPTER *pAd, INT32 RSSI_org,
UINT32 RSSI_idx, INT32 Ch_Band);
INT32 MtATETssiTrainingProc(struct _RTMP_ADAPTER *pAd, UCHAR ucBW,
UCHAR ucBandIdx);
#ifdef PRE_CAL_MT7622_SUPPORT
INT MtATE_DPD_Cal_Store_Proc_7622(RTMP_ADAPTER *pAd, RTMP_STRING *arg);
#endif /*PRE_CAL_MT7622_SUPPORT*/
@ -186,8 +204,12 @@ INT MtATE_DCOC_Cal_Store_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg);
INT MtATE_Pre_Cal_Proc(RTMP_ADAPTER *pAd, UINT8 CalId, UINT32 ChGrpId);
#endif /* PRE_CAL_TRX_SET2_SUPPORT */
INT32 mt_ate_tx(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, struct _TX_BLK *tx_blk);
INT TxPowerManualCtrl(PRTMP_ADAPTER pAd, BOOLEAN fgPwrManCtrl, UINT8 u1TxPwrModeManual, UINT8 u1TxPwrBwManual, UINT8 u1TxPwrRateManual, INT8 i1TxPwrValueManual, UCHAR ucBandIdx);
INT32 mt_ate_tx(RTMP_ADAPTER *pAd, struct wifi_dev *wdev,
struct _TX_BLK *tx_blk);
INT TxPowerManualCtrl(PRTMP_ADAPTER pAd, BOOLEAN fgPwrManCtrl,
UINT8 u1TxPwrModeManual, UINT8 u1TxPwrBwManual,
UINT8 u1TxPwrRateManual, INT8 i1TxPwrValueManual,
UCHAR ucBandIdx);
#if defined(COMPOS_TESTMODE_WIN)
#endif
@ -196,15 +218,17 @@ INT TxPowerManualCtrl(PRTMP_ADAPTER pAd, BOOLEAN fgPwrManCtrl, UINT8 u1TxPwrMode
INT MtATE_PA_Trim_Proc(RTMP_ADAPTER *pAd, PUINT32 pData);
#endif /* CAL_BIN_FILE_SUPPORT */
#define MT_ATEInit(_pAd) ({ \
UINT32 _ret; \
_ret = MtTestModeInit(_pAd); \
_ret; \
#define MT_ATEInit(_pAd) \
({ \
UINT32 _ret; \
_ret = MtTestModeInit(_pAd); \
_ret; \
})
#define MT_ATEExit(_pAd) ({ \
UINT32 _ret; \
_ret = MtTestModeExit(_pAd); \
_ret; \
#define MT_ATEExit(_pAd) \
({ \
UINT32 _ret; \
_ret = MtTestModeExit(_pAd); \
_ret; \
})
#endif /* _MT_TESTMODE_H */

View File

@ -17,11 +17,10 @@
#ifndef __MT_TESTMODE_DMAC_H__
#define __MT_TESTMODE_DMAC_H__
INT mt_ate_mac_cr_restore(struct _RTMP_ADAPTER *pAd);
INT mt_ate_mac_cr_backup_and_set(struct _RTMP_ADAPTER *pAd);
INT mt_ate_ampdu_ba_limit(struct _RTMP_ADAPTER *pAd, UINT32 band_idx, UINT8 agg_limit);
INT mt_ate_ampdu_ba_limit(struct _RTMP_ADAPTER *pAd, UINT32 band_idx,
UINT8 agg_limit);
INT mt_ate_set_sta_pause_cr(struct _RTMP_ADAPTER *pAd, UINT32 band_idx);
#endif /* __MT_TESTMODE_DMAC_H__ */

View File

@ -17,9 +17,7 @@
#ifndef __MT_TESTMODE_SMAC_H__
#define __MT_TESTMODE_SMAC_H__
INT mt_ate_mac_cr_restore(struct _RTMP_ADAPTER *pAd);
INT mt_ate_mac_cr_backup_and_set(struct _RTMP_ADAPTER *pAd);
#endif /* __MT_TESTMODE_SMAC_H__ */

View File

@ -20,39 +20,37 @@
#define HQA_CMD_MAGIC_NO 0x18142880
/* RX STAT */
#define HQA_RX_STAT_MACFCSERRCNT 0x1
#define HQA_RX_STAT_MAC_MDRDYCNT 0x2
#define HQA_RX_STAT_PHY_MDRDYCNT 0x3
#define HQA_RX_STAT_PHY_FCSERRCNT 0x4
#define HQA_RX_STAT_PD 0x5
#define HQA_RX_STAT_CCK_SIG_SFD 0x6
#define HQA_RX_STAT_OFDM_SIG_TAG 0x7
#define HQA_RX_STAT_RSSI 0x8
#define HQA_RX_RESET_PHY_COUNT 0x9
#define HQA_RX_RESET_MAC_COUNT 0xa
#define HQA_RX_STAT_MACFCSERRCNT 0x1
#define HQA_RX_STAT_MAC_MDRDYCNT 0x2
#define HQA_RX_STAT_PHY_MDRDYCNT 0x3
#define HQA_RX_STAT_PHY_FCSERRCNT 0x4
#define HQA_RX_STAT_PD 0x5
#define HQA_RX_STAT_CCK_SIG_SFD 0x6
#define HQA_RX_STAT_OFDM_SIG_TAG 0x7
#define HQA_RX_STAT_RSSI 0x8
#define HQA_RX_RESET_PHY_COUNT 0x9
#define HQA_RX_RESET_MAC_COUNT 0xa
/* FW Event Callback */
VOID HQA_GetThermalValue_CB(struct cmd_msg *msg, char *Data, UINT16 Len);
struct GNU_PACKED _HQA_CMD_FRAME {
UINT32 MagicNo;
UINT16 Type;
UINT16 Id;
UINT16 Length;
UINT16 Sequence;
UCHAR Data[2048];
UINT32 MagicNo;
UINT16 Type;
UINT16 Id;
UINT16 Length;
UINT16 Sequence;
UCHAR Data[2048];
};
typedef INT32(*HQA_CMD_HANDLER)(
struct _RTMP_ADAPTER *pAd,
RTMP_IOCTL_INPUT_STRUCT * wrq,
struct GNU_PACKED _HQA_CMD_FRAME * HqaCmdFrame);
typedef INT32 (*HQA_CMD_HANDLER)(struct _RTMP_ADAPTER *pAd,
RTMP_IOCTL_INPUT_STRUCT *wrq,
struct GNU_PACKED _HQA_CMD_FRAME *HqaCmdFrame);
struct _HQA_CMD_TABLE {
HQA_CMD_HANDLER *CmdSet;
UINT32 CmdSetSize;
UINT32 CmdOffset;
UINT32 CmdSetSize;
UINT32 CmdOffset;
};
struct GNU_PACKED _HQA_RX_STAT {

View File

@ -20,26 +20,26 @@ enum _EPQID {
/* 1. DW : double word */
/* */
union _SCHEDULER_REGISTER4 {
struct {
struct {
/* DW0 */
ULONG ForceQid : 4;
ULONG ForceMode : 1;
ULONG BypassMode : 1;
ULONG HybridMode : 1;
ULONG RgPredictNoMask : 1;
ULONG RgResetScheduler : 1;
ULONG RgDoneClearHeader : 1;
ULONG SwMode : 1;
ULONG Reserves0 : 5;
ULONG RgRateMap : 14;
ULONG Reserves1 : 2;
} Default;
ULONG word;
ULONG ForceQid : 4;
ULONG ForceMode : 1;
ULONG BypassMode : 1;
ULONG HybridMode : 1;
ULONG RgPredictNoMask : 1;
ULONG RgResetScheduler : 1;
ULONG RgDoneClearHeader : 1;
ULONG SwMode : 1;
ULONG Reserves0 : 5;
ULONG RgRateMap : 14;
ULONG Reserves1 : 2;
} Default;
ULONG word;
};
/* MT7637 for Band display */
#define MT7367_RO_AGC_DEBUG_2 (WF_PHY_BASE + 0x0584)
#define CR_ACI_HIT (WF_PHY_BASE + 0x0594)
#define MT7367_RO_AGC_DEBUG_2 (WF_PHY_BASE + 0x0584)
#define CR_ACI_HIT (WF_PHY_BASE + 0x0594)
/* MT7637 for Band display end */
/*~test mode common*/

View File

@ -18,35 +18,42 @@
#define PKTL_TRAN_TO_HOST(_Val) OS_NTOHL(_Val)
#define PKTS_TRAN_TO_NET(_Val) OS_HTONS(_Val)
#define PKTS_TRAN_TO_HOST(_Val) OS_NTOHS(_Val)
#define PKTLA_TRAN_TO_HOST(_len, _byte_array) ({ \
INT _cnt = 0; \
UINT32 *_arr = (UINT32 *)_byte_array; \
for (_cnt = 0; _cnt < _len; _cnt++) \
_arr[_cnt] = OS_NTOHL(_arr[_cnt]); \
_byte_array; \
#define PKTLA_TRAN_TO_HOST(_len, _byte_array) \
({ \
INT _cnt = 0; \
UINT32 *_arr = (UINT32 *)_byte_array; \
for (_cnt = 0; _cnt < _len; _cnt++) \
_arr[_cnt] = OS_NTOHL(_arr[_cnt]); \
_byte_array; \
});
#define PKTLA_TRAN_TO_NET(_len, _byte_array) ({ \
INT _cnt = 0; \
UINT32 *_arr = (UINT32 *)_byte_array; \
for (_cnt = 0; _cnt < _len; _cnt++) \
_arr[_cnt] = OS_HTONL(_arr[_cnt]); \
_byte_array; \
#define PKTLA_TRAN_TO_NET(_len, _byte_array) \
({ \
INT _cnt = 0; \
UINT32 *_arr = (UINT32 *)_byte_array; \
for (_cnt = 0; _cnt < _len; _cnt++) \
_arr[_cnt] = OS_HTONL(_arr[_cnt]); \
_byte_array; \
});
#define PKTLA_DUMP(_lvl, _len, _byte_array)({ \
INT _cnt = 0; \
UINT32 *_arr = (UINT32 *)_byte_array; \
for (_cnt = 0; _cnt < _len; _cnt++) \
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, _lvl, ("DWORD%d:%08x\n", _cnt, _arr[_cnt])); \
_len; \
#define PKTLA_DUMP(_lvl, _len, _byte_array) \
({ \
INT _cnt = 0; \
UINT32 *_arr = (UINT32 *)_byte_array; \
for (_cnt = 0; _cnt < _len; _cnt++) \
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, _lvl, \
("DWORD%d:%08x\n", _cnt, _arr[_cnt])); \
_len; \
});
#define PKTUC_DUMP(_lvl, _len, _byte_array)({ \
INT _cnt = 0; \
UCHAR *_arr = (UCHAR *)_byte_array; \
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, _lvl, ("PKTUC_DUMP(%x): ", _len)); \
for (_cnt = 0; _cnt < _len; _cnt++) \
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, _lvl, ("%02x", _arr[_cnt])); \
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, _lvl, ("\n")); \
_len; \
#define PKTUC_DUMP(_lvl, _len, _byte_array) \
({ \
INT _cnt = 0; \
UCHAR *_arr = (UCHAR *)_byte_array; \
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, _lvl, \
("PKTUC_DUMP(%x): ", _len)); \
for (_cnt = 0; _cnt < _len; _cnt++) \
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, _lvl, \
("%02x", _arr[_cnt])); \
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, _lvl, ("\n")); \
_len; \
});
#endif
@ -65,8 +72,8 @@ typedef struct __RTMP_IOCTL_INPUT_STRUCT {
BOOLEAN mt_mac_cr_range_mapping(struct _RTMP_ADAPTER *pAd, UINT32 *mac_addr);
UINT32 mt_physical_addr_map(UINT32 addr);
#define RTMP_IO_EFAULT 30002
#define EFAULT (-RTMP_IO_EFAULT)
#define RTMP_IO_EFAULT 30002
#define EFAULT (-RTMP_IO_EFAULT)
#endif /* TODO: Add lack of structure for Linux temporarily, fix during merge */
VOID HQA_GetThermalValue_CB(struct cmd_msg *msg, char *Data, UINT16 Len);
#ifdef TXBF_SUPPORT
@ -136,53 +143,53 @@ struct GNU_PACKED _HQA_BF_TAG_MCS_THRD {
struct GNU_PACKED _HQA_BF_TAG_INFO {
/* Tag 1 */
UINT32 profile; /* [6:0] : 0 ~ 63 */
UINT32 tx_bf; /* [7] : 0: iBF, 1: eBF */
UINT32 dbw; /* [9:8] : 0/1/2/3: DW20/40/80/160NC */
UINT32 su_mu; /* [10] : 0:SU, 1: MU */
UINT32 invalid; /* [11] : 0:default, 1: This profile number is invalid by SW */
UINT32 rmsd; /* [14:12] : RMSD value from CE */
UINT32 addr1_col_idx; /* [17 : 15] : column index : 0 ~ 5 */
UINT32 addr1_row_idx; /* [23 : 18] : row index : 0 ~ 63 */
UINT32 addr2_col_idx; /* [26 : 24] : column index : 0 ~ 5 */
UINT32 addr2_row_idx; /* [31 : 27] : row index : 0 ~ 63, [32]: MSB of row index */
UINT32 addr3_col_idx; /* [35 : 33] : column index : 0 ~ 5 */
UINT32 addr3_row_idx; /* [41 : 36] : row index : 0 ~ 63 */
UINT32 addr4_col_idx; /* [44 : 42] : column index : 0 ~ 5 */
UINT32 addr4_row_idx; /* [50 : 45] : row index : 0 ~ 63 */
UINT32 reserved1; /* [51] : Reserved */
UINT32 nrow; /* [53 : 52] : Nrow */
UINT32 ncol; /* [55 : 54] : Ncol */
UINT32 ngroup; /* [57 : 56] : Ngroup */
UINT32 LM; /* [59 : 58] : 0/1/2 */
UINT32 code_book; /* [61:60] : Code book */
UINT32 htc_exist; /* [62] : HtcExist */
UINT32 reserved2; /* [63] : Reserved */
UINT32 snr_sts0; /* [71:64] : SNR_STS0 */
UINT32 snr_sts1; /* [79:72] : SNR_STS1 */
UINT32 snr_sts2; /* [87:80] : SNR_STS2 */
UINT32 snr_sts3; /* [95:88] : SNR_STS3 */
UINT32 ibf_lanidx; /* [103:96] : iBF LNA index */
UINT32 profile; /* [6:0] : 0 ~ 63 */
UINT32 tx_bf; /* [7] : 0: iBF, 1: eBF */
UINT32 dbw; /* [9:8] : 0/1/2/3: DW20/40/80/160NC */
UINT32 su_mu; /* [10] : 0:SU, 1: MU */
UINT32 invalid; /* [11] : 0:default, 1: This profile number is invalid by SW */
UINT32 rmsd; /* [14:12] : RMSD value from CE */
UINT32 addr1_col_idx; /* [17 : 15] : column index : 0 ~ 5 */
UINT32 addr1_row_idx; /* [23 : 18] : row index : 0 ~ 63 */
UINT32 addr2_col_idx; /* [26 : 24] : column index : 0 ~ 5 */
UINT32 addr2_row_idx; /* [31 : 27] : row index : 0 ~ 63, [32]: MSB of row index */
UINT32 addr3_col_idx; /* [35 : 33] : column index : 0 ~ 5 */
UINT32 addr3_row_idx; /* [41 : 36] : row index : 0 ~ 63 */
UINT32 addr4_col_idx; /* [44 : 42] : column index : 0 ~ 5 */
UINT32 addr4_row_idx; /* [50 : 45] : row index : 0 ~ 63 */
UINT32 reserved1; /* [51] : Reserved */
UINT32 nrow; /* [53 : 52] : Nrow */
UINT32 ncol; /* [55 : 54] : Ncol */
UINT32 ngroup; /* [57 : 56] : Ngroup */
UINT32 LM; /* [59 : 58] : 0/1/2 */
UINT32 code_book; /* [61:60] : Code book */
UINT32 htc_exist; /* [62] : HtcExist */
UINT32 reserved2; /* [63] : Reserved */
UINT32 snr_sts0; /* [71:64] : SNR_STS0 */
UINT32 snr_sts1; /* [79:72] : SNR_STS1 */
UINT32 snr_sts2; /* [87:80] : SNR_STS2 */
UINT32 snr_sts3; /* [95:88] : SNR_STS3 */
UINT32 ibf_lanidx; /* [103:96] : iBF LNA index */
/* Tag 2 */
UINT32 smt_ant; /* [11:0] : Smart Ant config */
UINT32 reserved3; /* [14:12] : Reserved */
UINT32 se_idx; /* [19:15] : SE index */
UINT32 rmsd_thrd; /* [22:20] : RMSD Threshold */
UINT32 reserved4; /* [23] : Reserved */
UINT32 mcs_thrd_l1ss; /* [27:24] : MCS TH long 1SS */
UINT32 mcs_thrd_s1ss; /* [31:28] : MCS TH short 1SS */
UINT32 mcs_thrd_l2ss; /* [35:32] : MCS TH long 2SS */
UINT32 mcs_thrd_s2ss; /* [39:36] : MCS TH short 2SS */
UINT32 mcs_thrd_l3ss; /* [43:40] : MCS TH long 3SS */
UINT32 mcs_thrd_s3ss; /* [47:44] : MCS TH short 3SS */
UINT32 bf_tout; /* [55:48] : iBF timeout limit */
UINT32 reserved5; /* [63:56] : Reserved */
UINT32 reserved6; /* [71:64] : Reserved */
UINT32 reserved7; /* [79:72] : Reserved */
UINT32 ibf_dbw; /* [81:80] : iBF desired DBW 0/1/2/3 : BW20/40/80/160NC */
UINT32 ibf_ncol; /* [83:82] : iBF desired Ncol = 1 ~ 3 */
UINT32 ibf_nrow; /* [85:84] : iBF desired Nrow = 1 ~ 4 */
UINT32 reserved8; /* [95:86] : Reserved */
UINT32 smt_ant; /* [11:0] : Smart Ant config */
UINT32 reserved3; /* [14:12] : Reserved */
UINT32 se_idx; /* [19:15] : SE index */
UINT32 rmsd_thrd; /* [22:20] : RMSD Threshold */
UINT32 reserved4; /* [23] : Reserved */
UINT32 mcs_thrd_l1ss; /* [27:24] : MCS TH long 1SS */
UINT32 mcs_thrd_s1ss; /* [31:28] : MCS TH short 1SS */
UINT32 mcs_thrd_l2ss; /* [35:32] : MCS TH long 2SS */
UINT32 mcs_thrd_s2ss; /* [39:36] : MCS TH short 2SS */
UINT32 mcs_thrd_l3ss; /* [43:40] : MCS TH long 3SS */
UINT32 mcs_thrd_s3ss; /* [47:44] : MCS TH short 3SS */
UINT32 bf_tout; /* [55:48] : iBF timeout limit */
UINT32 reserved5; /* [63:56] : Reserved */
UINT32 reserved6; /* [71:64] : Reserved */
UINT32 reserved7; /* [79:72] : Reserved */
UINT32 ibf_dbw; /* [81:80] : iBF desired DBW 0/1/2/3 : BW20/40/80/160NC */
UINT32 ibf_ncol; /* [83:82] : iBF desired Ncol = 1 ~ 3 */
UINT32 ibf_nrow; /* [85:84] : iBF desired Nrow = 1 ~ 4 */
UINT32 reserved8; /* [95:86] : Reserved */
};
struct GNU_PACKED _HQA_BF_STA_CMM_REC {
@ -281,9 +288,9 @@ struct GNU_PACKED _HQA_BF_MANUAL_CONN {
UINT32 marate_mcs;
UINT32 nss;
UINT32 spe_idx;
UINT32 rca2;
UINT32 rv;
UINT32 aid;
UINT32 rca2;
UINT32 rv;
UINT32 aid;
};
struct GNU_PACKED _HQA_PWR_MANUAL {
@ -307,14 +314,14 @@ struct _HQA_MU_TBL {
UCHAR tbl[0];
};
struct GNU_PACKED _HQA_MU_USR_INIT_MCS {
struct GNU_PACKED _HQA_MU_USR_INIT_MCS {
UINT32 user0;
UINT32 user1;
UINT32 user2;
UINT32 user3;
};
struct GNU_PACKED _HQA_MU_USR_LQ {
struct GNU_PACKED _HQA_MU_USR_LQ {
UINT32 usr0_bpsk;
UINT32 usr0_qpsk;
UINT32 usr0_16qam;
@ -337,7 +344,7 @@ struct GNU_PACKED _HQA_MU_USR_LQ {
UINT32 usr3_256qam;
};
struct GNU_PACKED _HQA_MU_GRP_INFO {
struct GNU_PACKED _HQA_MU_GRP_INFO {
UINT32 grp_idx;
UINT32 num_usr;
UINT32 usr0_ldpc;
@ -366,13 +373,13 @@ struct GNU_PACKED _HQA_MU_GRP_INFO {
UCHAR usr2_mac[MAC_ADDR_LEN];
UCHAR usr3_mac[MAC_ADDR_LEN];
};
#endif/* CFG_SUPPORT_MU_MIMO */
#endif /* CFG_SUPPORT_MU_MIMO */
#endif /* TXBF_SUPPORT */
#pragma pack()
/* DBDC Tx Ext */
#pragma pack(1)
struct GNU_PACKED _HQA_EXT_SET_CH {
struct GNU_PACKED _HQA_EXT_SET_CH {
UINT32 ext_id;
UINT32 num_param;
UINT32 band_idx;
@ -383,7 +390,7 @@ struct GNU_PACKED _HQA_EXT_SET_CH {
UINT32 pri_sel;
UINT32 reason;
UINT32 ch_band;
UINT32 out_band_freq;
UINT32 out_band_freq;
};
struct GNU_PACKED _HQA_EXT_TX_CONTENT {
@ -393,7 +400,7 @@ struct GNU_PACKED _HQA_EXT_TX_CONTENT {
UINT32 FC;
UINT32 dur;
UINT32 seq;
UINT32 gen_payload_rule; /* Normal:0,Repeat:1,Random:2 */
UINT32 gen_payload_rule; /* Normal:0,Repeat:1,Random:2 */
UINT32 txlen;
UINT32 payload_len;
UCHAR addr1[MAC_ADDR_LEN];
@ -422,24 +429,23 @@ struct GNU_PACKED _HQA_EXT_TXV {
};
struct GNU_PACKED _HQA_CMD_FRAME {
UINT32 MagicNo;
UINT16 Type;
UINT16 Id;
UINT16 Length;
UINT16 Sequence;
UINT8 Data[IOCTLBUFF];
UINT32 MagicNo;
UINT16 Type;
UINT16 Id;
UINT16 Length;
UINT16 Sequence;
UINT8 Data[IOCTLBUFF];
};
#pragma pack()
typedef INT32(*HQA_CMD_HANDLER)(
struct _RTMP_ADAPTER *pAd,
struct __RTMP_IOCTL_INPUT_STRUCT *wrq,
struct _HQA_CMD_FRAME *HqaCmdFrame);
typedef INT32 (*HQA_CMD_HANDLER)(struct _RTMP_ADAPTER *pAd,
struct __RTMP_IOCTL_INPUT_STRUCT *wrq,
struct _HQA_CMD_FRAME *HqaCmdFrame);
struct _HQA_CMD_TABLE {
HQA_CMD_HANDLER *CmdSet;
UINT32 CmdSetSize;
UINT32 CmdOffset;
UINT32 CmdSetSize;
UINT32 CmdOffset;
};
struct GNU_PACKED _HQA_RX_STAT {
@ -502,23 +508,24 @@ struct GNU_PACKED _HQA_RX_STAT {
UINT32 SINR;
UINT32 RXVRSSI;
/* #endif */
UINT32 mac_rx_fcs_ok_cnt; /* MT7622 only */
UINT32 mac_rx_fcs_ok_cnt; /* MT7622 only */
};
UINT32 HQA_CMDHandler(struct _RTMP_ADAPTER *pAd, struct __RTMP_IOCTL_INPUT_STRUCT *Wrq, struct _HQA_CMD_FRAME *HqaCmdFrame);
UINT32 HQA_CMDHandler(struct _RTMP_ADAPTER *pAd,
struct __RTMP_IOCTL_INPUT_STRUCT *Wrq,
struct _HQA_CMD_FRAME *HqaCmdFrame);
#define TM_CMDREQ 0x0008
#define TM_CMDRSP 0x8008
#define HQA_CMD_MAGIC_NO 0x18142880
#define TM_CMDREQ 0x0008
#define TM_CMDRSP 0x8008
#define HQA_CMD_MAGIC_NO 0x18142880
#define HQA_CMD_REQ 0x0005
#define HQA_CMD_RSP 0x8005
#define TMR_HW_VER_100 100
#define TMR_HW_VER_150 150
#define TMR_HW_VER_200 200
#define HQA_CMD_REQ 0x0005
#define HQA_CMD_RSP 0x8005
#define TMR_HW_VER_100 100
#define TMR_HW_VER_150 150
#define TMR_HW_VER_200 200
#define HQA_CMD_MAGIC_NO 0x18142880
#define EFUSE_ADDR_FREQUENCY_OFFSET_MT7637 0xF4/* MT7637 */
#define HQA_CMD_MAGIC_NO 0x18142880
#define EFUSE_ADDR_FREQUENCY_OFFSET_MT7637 0xF4 /* MT7637 */
#endif /* _TESTMODE_IOCTL_H */

View File

@ -20,7 +20,6 @@
#include "rt_config.h"
#endif
INT mt_ate_mac_cr_restore(RTMP_ADAPTER *pAd)
{
#if defined(MT7615) || defined(MT7622)
@ -71,12 +70,12 @@ INT mt_ate_mac_cr_restore(RTMP_ADAPTER *pAd)
return 0;
}
INT mt_ate_mac_cr_backup_and_set(RTMP_ADAPTER *pAd)
{
struct _ATE_CTRL *ATECtrl = &pAd->ATECtrl;
NdisZeroMemory(&ATECtrl->bk_cr, sizeof(struct _TESTMODE_BK_CR)*MAX_TEST_BKCR_NUM);
NdisZeroMemory(&ATECtrl->bk_cr,
sizeof(struct _TESTMODE_BK_CR) * MAX_TEST_BKCR_NUM);
#if defined(MT7615) || defined(MT7622)
/* TODO: check if following operation also need to do for other chips */
if (IS_MT7615(pAd) || IS_MT7622(pAd)) {
@ -123,8 +122,12 @@ INT mt_ate_mac_cr_backup_and_set(RTMP_ADAPTER *pAd)
MAC_IO_WRITE32(pAd, AGG_MRCR, val);
/* IPG related CR back up */
MtTestModeBkCr(pAd, TMAC_TRCR0, TEST_MAC_BKCR);
MtTestModeBkCr(pAd, TMAC_ICR_BAND_0, TEST_MAC_BKCR); /* IFS CR, for SIFS/SLOT time control */
MtTestModeBkCr(pAd, ARB_DRNGR0, TEST_MAC_BKCR); /* For fixing backoff random number */
MtTestModeBkCr(
pAd, TMAC_ICR_BAND_0,
TEST_MAC_BKCR); /* IFS CR, for SIFS/SLOT time control */
MtTestModeBkCr(
pAd, ARB_DRNGR0,
TEST_MAC_BKCR); /* For fixing backoff random number */
MtTestModeBkCr(pAd, ARB_DRNGR1, TEST_MAC_BKCR);
MtTestModeBkCr(pAd, ARB_WMMAC01, TEST_MAC_BKCR);
MtTestModeBkCr(pAd, ARB_WMMAC11, TEST_MAC_BKCR);
@ -143,8 +146,7 @@ INT mt_ate_mac_cr_backup_and_set(RTMP_ADAPTER *pAd)
return 0;
}
UINT32 agg_cnt_array[] = {AGG_AALCR0, AGG_AALCR1, AGG_AALCR2, AGG_AALCR3};
UINT32 agg_cnt_array[] = { AGG_AALCR0, AGG_AALCR1, AGG_AALCR2, AGG_AALCR3 };
INT mt_ate_ampdu_ba_limit(RTMP_ADAPTER *pAd, UINT32 band_idx, UINT8 agg_limit)
{
struct _ATE_CTRL *ATECtrl = &pAd->ATECtrl;
@ -161,25 +163,23 @@ INT mt_ate_ampdu_ba_limit(RTMP_ADAPTER *pAd, UINT32 band_idx, UINT8 agg_limit)
WmmIdx = TESTMODE_GET_PARAM(ATECtrl, band_idx, wmm_idx);
if (WmmIdx > 3) {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
MTWF_LOG(
DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s: wdev_idx=%d, invalid WmmIdx=%d, reset to 0!\n",
__func__, wdev_idx, WmmIdx));
__func__, wdev_idx, WmmIdx));
WmmIdx = 0xFF;
}
} else {
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s: invalid WDEV, reset WmmIdx to 0!\n", __func__));
("%s: invalid WDEV, reset WmmIdx to 0!\n", __func__));
WmmIdx = 0xFF;
}
#endif
MTWF_LOG(DBG_CAT_TEST, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s: wdev_idx=%d, WmmIdx=%d\n",
__func__, wdev_idx, WmmIdx));
value = ((agg_limit & 0x3F) << 24)
| ((agg_limit & 0x3F) << 16)
| ((agg_limit & 0x3F) << 8)
| ((agg_limit & 0x3F) << 0);
("%s: wdev_idx=%d, WmmIdx=%d\n", __func__, wdev_idx, WmmIdx));
value = ((agg_limit & 0x3F) << 24) | ((agg_limit & 0x3F) << 16) |
((agg_limit & 0x3F) << 8) | ((agg_limit & 0x3F) << 0);
if (WmmIdx <= 3)
MAC_IO_WRITE32(pAd, agg_cnt_array[WmmIdx], value);
@ -196,7 +196,6 @@ INT mt_ate_ampdu_ba_limit(RTMP_ADAPTER *pAd, UINT32 band_idx, UINT8 agg_limit)
return 0;
}
INT mt_ate_set_sta_pause_cr(RTMP_ADAPTER *pAd, UINT32 band_idx)
{
INT32 ret = 0;

View File

@ -20,7 +20,6 @@
#include "rt_config.h"
#endif
INT mt_ate_mac_cr_restore(RTMP_ADAPTER *pAd)
{
/* Data frame protection CR recover */
@ -31,13 +30,13 @@ INT mt_ate_mac_cr_restore(RTMP_ADAPTER *pAd)
return 0;
}
INT mt_ate_mac_cr_backup_and_set(RTMP_ADAPTER *pAd)
{
struct _ATE_CTRL *ATECtrl = &pAd->ATECtrl;
UINT32 val = 0;
NdisZeroMemory(&ATECtrl->bk_cr, sizeof(struct _TESTMODE_BK_CR)*MAX_TEST_BKCR_NUM);
NdisZeroMemory(&ATECtrl->bk_cr,
sizeof(struct _TESTMODE_BK_CR) * MAX_TEST_BKCR_NUM);
/* Enable data frame protection for test mode */
MtTestModeBkCr(pAd, AGG_PCR, TEST_MAC_BKCR);
MAC_IO_READ32(pAd, AGG_PCR, &val);

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -26,7 +26,6 @@
-------- ---------- ----------------------------------------------
*/
#include "rt_config.h"
/*
@ -47,15 +46,11 @@ Return Value:
Note:
========================================================================
*/
VOID RtmpChipWriteHighMemory(
IN RTMP_ADAPTER *pAd,
IN USHORT Offset,
IN UINT32 Value,
IN UINT8 Unit)
VOID RtmpChipWriteHighMemory(IN RTMP_ADAPTER *pAd, IN USHORT Offset,
IN UINT32 Value, IN UINT8 Unit)
{
}
/*
========================================================================
Routine Description:
@ -72,11 +67,8 @@ Return Value:
Note:
========================================================================
*/
VOID RtmpChipWriteMemory(
IN RTMP_ADAPTER *pAd,
IN USHORT Offset,
IN UINT32 Value,
IN UINT8 Unit)
VOID RtmpChipWriteMemory(IN RTMP_ADAPTER *pAd, IN USHORT Offset,
IN UINT32 Value, IN UINT8 Unit)
{
switch (Unit) {
case 1:
@ -109,15 +101,15 @@ Return Value:
Note:
========================================================================
*/
VOID RtmpChipBcnInit(
IN RTMP_ADAPTER *pAd)
VOID RtmpChipBcnInit(IN RTMP_ADAPTER *pAd)
{
RTMP_CHIP_CAP *pChipCap = hc_get_chip_cap(pAd->hdev_ctrl);
struct _RTMP_CHIP_OP *ops = hc_get_chip_ops(pAd->hdev_ctrl);
pChipCap->FlgIsSupSpecBcnBuf = FALSE;
pChipCap->BcnMaxHwNum = 8;
pChipCap->BcnMaxNum = (pChipCap->BcnMaxHwNum - MAX_MESH_NUM - MAX_APCLI_NUM);
pChipCap->BcnMaxNum =
(pChipCap->BcnMaxHwNum - MAX_MESH_NUM - MAX_APCLI_NUM);
pChipCap->BcnMaxHwSize = 0x1000;
pChipCap->BcnBase[0] = 0x7800;
pChipCap->BcnBase[1] = 0x7A00;
@ -156,13 +148,11 @@ UINT8 NICGetBandSupported(RTMP_ADAPTER *pAd)
return RFIC_24GHZ;
}
INT WaitForAsicReady(RTMP_ADAPTER *pAd)
{
return TRUE;
}
INT AsicGetMacVersion(RTMP_ADAPTER *pAd)
{
UINT32 reg = 0;
@ -170,23 +160,25 @@ INT AsicGetMacVersion(RTMP_ADAPTER *pAd)
/* TODO: shiang-7603 */
if (cap->hif_type == HIF_MT) {
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s(%d): Not support for HIF_MT yet!\n",
__func__, __LINE__));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s(%d): Not support for HIF_MT yet!\n", __func__,
__LINE__));
return FALSE;
}
if (WaitForAsicReady(pAd) == TRUE) {
RTMP_IO_READ32(pAd, reg, &pAd->MACVersion);
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("MACVersion[Ver:Rev]=0x%08x : 0x%08x\n",
pAd->MACVersion, pAd->ChipID));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("MACVersion[Ver:Rev]=0x%08x : 0x%08x\n",
pAd->MACVersion, pAd->ChipID));
return TRUE;
} else {
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s() failed!\n", __func__));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s() failed!\n", __func__));
return FALSE;
}
}
/*
========================================================================
Routine Description:
@ -217,10 +209,12 @@ int RtmpChipOpsHook(VOID *pCB)
return -1;
/* TODO: shiang-7603 */
if (IS_MT7603(pAd) || IS_MT7628(pAd) || IS_MT76x6(pAd) || IS_MT7637(pAd) || IS_MT7615(pAd)) {
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s(%d): Not support for HIF_MT yet! MACVersion=0x%x\n",
__func__, __LINE__, pAd->MACVersion));
if (IS_MT7603(pAd) || IS_MT7628(pAd) || IS_MT76x6(pAd) ||
IS_MT7637(pAd) || IS_MT7615(pAd)) {
MTWF_LOG(
DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s(%d): Not support for HIF_MT yet! MACVersion=0x%x\n",
__func__, __LINE__, pAd->MACVersion));
}
if (pAd->MACVersion == 0xffffffff)
@ -236,20 +230,23 @@ int RtmpChipOpsHook(VOID *pCB)
RTMP_SYS_IO_READ32(0xb000000c, &pAd->CommonCfg.CID);
RTMP_SYS_IO_READ32(0xb0000000, &pAd->CommonCfg.CN);
#endif
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("CN: %lx\tCID = %lx\n",
pAd->CommonCfg.CN, pAd->CommonCfg.CID));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("CN: %lx\tCID = %lx\n", pAd->CommonCfg.CN,
pAd->CommonCfg.CID));
}
#endif /* RTMP_RBUS_SUPPORT */
/*initial chip hook function*/
WfSysPreInit(pAd);
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Chip specific bbpRegTbSize=%d!\n", pChipCap->bbpRegTbSize));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Chip VCO calibration mode = %d!\n", pChipCap->FlgIsVcoReCalMode));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("Chip specific bbpRegTbSize=%d!\n", pChipCap->bbpRegTbSize));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("Chip VCO calibration mode = %d!\n",
pChipCap->FlgIsVcoReCalMode));
#ifdef DOT11W_PMF_SUPPORT
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("[PMF] Encryption mode = %d\n", pChipCap->FlgPMFEncrtptMode));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("[PMF] Encryption mode = %d\n", pChipCap->FlgPMFEncrtptMode));
#endif /* DOT11W_PMF_SUPPORT */
return ret;
}

View File

@ -100,11 +100,6 @@ config TPC_SUPPORT
depends on WIFI_DRIVER
default y
config TXRX_STAT_SUPPORT
bool "TxRx Stats Support"
depends on WIFI_DRIVER
default n
config ICAP_SUPPORT
bool "ICAP Support"
depends on WIFI_DRIVER
@ -136,6 +131,13 @@ config MTK_OFFCHANNEL_SCAN_FEATURE
depends on MTK_WIFI_DRIVER
depends on MTK_MT_AP_SUPPORT
default n
config MTK_DPP_SUPPORT
bool "DPP Support"
depends on MTK_WIFI_DRIVER
depends on MTK_MT_AP_SUPPORT
select DOT11W_PMF_SUPPORT
default n
#config WFA_VHT_R2_PF
# bool "WFA VHT R2 Plugfest"
# depends on DOT11_VHT_AC
@ -328,11 +330,6 @@ config LINK_TEST_SUPPORT
bool "Link Test Support"
depends on WIFI_DRIVER
default y
config WIFI_EAP_FEATURE
bool "EAP Feature Support"
depends on WIFI_DRIVER
default y
#config LED_CONTROL_SUPPORT
# bool "LED Support"

View File

@ -241,10 +241,12 @@ endif
ifeq ($(PLATFORM),PC)
# Linux 2.6
LINUX_SRC = /lib/modules/$(shell uname -r)/build
#LINUX_SRC = /lib/modules/$(shell uname -r)/build
# Linux 2.4 Change to your local setting
#LINUX_SRC = /usr/src/linux-2.4
LINUX_SRC_MODULE = /lib/modules/$(shell uname -r)/kernel/drivers/net/wireless/
#LINUX_SRC_MODULE = /lib/modules/$(shell uname -r)/kernel/drivers/net/wireless/
LINUX_SRC = /lib/modules/3.16.0-30-generic/build
LINUX_SRC_MODULE = /lib/modules/3.16.0-30-generic/kernel/drivers/net/wireless/
CROSS_COMPILE =
endif
@ -406,7 +408,11 @@ endif
build_sku_tables:
$(MAKE) -C $(RT28xx_DIR)/txpwr
$(RT28xx_DIR)/txpwr/dat2h
$(RT28xx_DIR)/txpwr/data2h
build_power_limit_tables:
$(MAKE) -C $(RT28xx_DIR)/txpwr
$(RT28xx_DIR)/txpwr/data2h
build_tools:
$(MAKE) -C tools

File diff suppressed because it is too large Load Diff

View File

@ -81,8 +81,8 @@ VOID RT28xx_ApCli_Init(VOID *pAd, PNET_DEV main_dev_p)
netDevOpHook.xmit = rt28xx_send_packets;
netDevOpHook.ioctl = rt28xx_ioctl;
netDevOpHook.get_stats = RT28xx_get_ether_stats;
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_APC_INIT,
0, &netDevOpHook, 0);
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_APC_INIT, 0,
&netDevOpHook, 0);
}
/*
@ -106,8 +106,8 @@ INT apcli_virtual_if_open(PNET_DEV pDev)
pAd = RTMP_OS_NETDEV_GET_PRIV(pDev);
ASSERT(pAd);
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_OFF, ("%s: ===> %s\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_OFF,
("%s: ===> %s\n", RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
if (VIRTUAL_IF_INIT(pAd, pDev) != 0)
return -1;
@ -119,10 +119,13 @@ INT apcli_virtual_if_open(PNET_DEV pDev)
RT_MOD_INC_USE_COUNT();
RT_MOD_HNAT_REG(pDev);
RTMP_OS_NETDEV_START_QUEUE(pDev);
#ifdef MTFWD
RTMP_OS_NETDEV_CARRIER_OFF(pDev);
#endif
return 0;
}
/*
========================================================================
Routine Description:
@ -144,8 +147,8 @@ INT apcli_virtual_if_close(PNET_DEV pDev)
pAd = RTMP_OS_NETDEV_GET_PRIV(pDev);
ASSERT(pAd);
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_OFF, ("%s: ===> %s\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_OFF,
("%s: ===> %s\n", RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
VIRTUAL_IF_DOWN(pAd, pDev);
@ -156,7 +159,6 @@ INT apcli_virtual_if_close(PNET_DEV pDev)
return 0;
}
/*
========================================================================
Routine Description:
@ -177,4 +179,3 @@ VOID RT28xx_ApCli_Remove(VOID *pAd)
}
#endif /* APCLI_SUPPORT */

View File

@ -27,11 +27,9 @@
#include "rt_config.h"
#define IDS_EXEC_INTV 1000 /* 1 sec */
#define IDS_EXEC_INTV 1000 /* 1 sec */
VOID RTMPIdsStart(
IN PRTMP_ADAPTER pAd)
VOID RTMPIdsStart(IN PRTMP_ADAPTER pAd)
{
if (pAd->ApCfg.IDSTimerRunning == FALSE) {
RTMPSetTimer(&pAd->ApCfg.IDSTimer, IDS_EXEC_INTV);
@ -39,10 +37,9 @@ VOID RTMPIdsStart(
}
}
VOID RTMPIdsStop(
IN PRTMP_ADAPTER pAd)
VOID RTMPIdsStop(IN PRTMP_ADAPTER pAd)
{
BOOLEAN Cancelled;
BOOLEAN Cancelled;
if (pAd->ApCfg.IDSTimerRunning == TRUE) {
RTMPCancelTimer(&pAd->ApCfg.IDSTimer, &Cancelled);
@ -51,12 +48,11 @@ VOID RTMPIdsStop(
}
#ifdef SYSTEM_LOG_SUPPORT
VOID RTMPHandleIdsEvent(
IN PRTMP_ADAPTER pAd)
VOID RTMPHandleIdsEvent(IN PRTMP_ADAPTER pAd)
{
INT i, j;
UINT32 FloodFrameCount[IW_FLOOD_EVENT_TYPE_NUM];
UINT32 FloodFrameThreshold[IW_FLOOD_EVENT_TYPE_NUM];
UINT32 FloodFrameCount[IW_FLOOD_EVENT_TYPE_NUM];
UINT32 FloodFrameThreshold[IW_FLOOD_EVENT_TYPE_NUM];
FloodFrameCount[0] = pAd->ApCfg.RcvdAuthCount;
FloodFrameCount[1] = pAd->ApCfg.RcvdAssocReqCount;
@ -75,42 +71,66 @@ VOID RTMPHandleIdsEvent(
/* trigger flooding traffic event */
for (j = 0; j < IW_FLOOD_EVENT_TYPE_NUM; j++) {
if ((FloodFrameThreshold[j] > 0) && (FloodFrameCount[j] > FloodFrameThreshold[j])) {
RTMPSendWirelessEvent(pAd, IW_FLOOD_AUTH_EVENT_FLAG + j, NULL, MAIN_MBSSID, 0);
if ((FloodFrameThreshold[j] > 0) &&
(FloodFrameCount[j] > FloodFrameThreshold[j])) {
RTMPSendWirelessEvent(pAd, IW_FLOOD_AUTH_EVENT_FLAG + j,
NULL, MAIN_MBSSID, 0);
/*MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("flooding traffic event(%d) - %d\n", IW_FLOOD_AUTH_EVENT_FLAG + j, FloodFrameCount[j])); */
}
}
for (i = 0; i < pAd->ApCfg.BssidNum; i++) {
UINT32 SpoofedFrameCount[IW_SPOOF_EVENT_TYPE_NUM];
CHAR RssiOfSpoofedFrame[IW_SPOOF_EVENT_TYPE_NUM];
INT k;
UINT32 SpoofedFrameCount[IW_SPOOF_EVENT_TYPE_NUM];
CHAR RssiOfSpoofedFrame[IW_SPOOF_EVENT_TYPE_NUM];
INT k;
SpoofedFrameCount[0] = pAd->ApCfg.MBSSID[i].RcvdConflictSsidCount;
SpoofedFrameCount[1] = pAd->ApCfg.MBSSID[i].RcvdSpoofedAssocRespCount;
SpoofedFrameCount[2] = pAd->ApCfg.MBSSID[i].RcvdSpoofedReassocRespCount;
SpoofedFrameCount[3] = pAd->ApCfg.MBSSID[i].RcvdSpoofedProbeRespCount;
SpoofedFrameCount[4] = pAd->ApCfg.MBSSID[i].RcvdSpoofedBeaconCount;
SpoofedFrameCount[5] = pAd->ApCfg.MBSSID[i].RcvdSpoofedDisassocCount;
SpoofedFrameCount[6] = pAd->ApCfg.MBSSID[i].RcvdSpoofedAuthCount;
SpoofedFrameCount[7] = pAd->ApCfg.MBSSID[i].RcvdSpoofedDeauthCount;
SpoofedFrameCount[8] = pAd->ApCfg.MBSSID[i].RcvdSpoofedUnknownMgmtCount;
SpoofedFrameCount[9] = pAd->ApCfg.MBSSID[i].RcvdReplayAttackCount;
RssiOfSpoofedFrame[0] = pAd->ApCfg.MBSSID[i].RssiOfRcvdConflictSsid;
RssiOfSpoofedFrame[1] = pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedAssocResp;
RssiOfSpoofedFrame[2] = pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedReassocResp;
RssiOfSpoofedFrame[3] = pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedProbeResp;
RssiOfSpoofedFrame[4] = pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedBeacon;
RssiOfSpoofedFrame[5] = pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedDisassoc;
RssiOfSpoofedFrame[6] = pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedAuth;
RssiOfSpoofedFrame[7] = pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedDeauth;
RssiOfSpoofedFrame[8] = pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedUnknownMgmt;
RssiOfSpoofedFrame[9] = pAd->ApCfg.MBSSID[i].RssiOfRcvdReplayAttack;
SpoofedFrameCount[0] =
pAd->ApCfg.MBSSID[i].RcvdConflictSsidCount;
SpoofedFrameCount[1] =
pAd->ApCfg.MBSSID[i].RcvdSpoofedAssocRespCount;
SpoofedFrameCount[2] =
pAd->ApCfg.MBSSID[i].RcvdSpoofedReassocRespCount;
SpoofedFrameCount[3] =
pAd->ApCfg.MBSSID[i].RcvdSpoofedProbeRespCount;
SpoofedFrameCount[4] =
pAd->ApCfg.MBSSID[i].RcvdSpoofedBeaconCount;
SpoofedFrameCount[5] =
pAd->ApCfg.MBSSID[i].RcvdSpoofedDisassocCount;
SpoofedFrameCount[6] =
pAd->ApCfg.MBSSID[i].RcvdSpoofedAuthCount;
SpoofedFrameCount[7] =
pAd->ApCfg.MBSSID[i].RcvdSpoofedDeauthCount;
SpoofedFrameCount[8] =
pAd->ApCfg.MBSSID[i].RcvdSpoofedUnknownMgmtCount;
SpoofedFrameCount[9] =
pAd->ApCfg.MBSSID[i].RcvdReplayAttackCount;
RssiOfSpoofedFrame[0] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdConflictSsid;
RssiOfSpoofedFrame[1] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedAssocResp;
RssiOfSpoofedFrame[2] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedReassocResp;
RssiOfSpoofedFrame[3] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedProbeResp;
RssiOfSpoofedFrame[4] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedBeacon;
RssiOfSpoofedFrame[5] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedDisassoc;
RssiOfSpoofedFrame[6] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedAuth;
RssiOfSpoofedFrame[7] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedDeauth;
RssiOfSpoofedFrame[8] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedUnknownMgmt;
RssiOfSpoofedFrame[9] =
pAd->ApCfg.MBSSID[i].RssiOfRcvdReplayAttack;
/* trigger spoofed attack event */
for (k = 0; k < IW_SPOOF_EVENT_TYPE_NUM; k++) {
if (SpoofedFrameCount[k] > 0) {
RTMPSendWirelessEvent(pAd, IW_CONFLICT_SSID_EVENT_FLAG + k, NULL, i, RssiOfSpoofedFrame[k]);
RTMPSendWirelessEvent(
pAd, IW_CONFLICT_SSID_EVENT_FLAG + k,
NULL, i, RssiOfSpoofedFrame[k]);
/*MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("spoofed attack event(%d) - %d\n", IW_CONFLICT_SSID_EVENT_FLAG + k, SpoofedFrameCount[k])); */
}
}
@ -118,10 +138,9 @@ VOID RTMPHandleIdsEvent(
}
#endif /* SYSTEM_LOG_SUPPORT */
VOID RTMPClearAllIdsCounter(
IN PRTMP_ADAPTER pAd)
VOID RTMPClearAllIdsCounter(IN PRTMP_ADAPTER pAd)
{
INT i;
INT i;
pAd->ApCfg.RcvdAuthCount = 0;
pAd->ApCfg.RcvdAssocReqCount = 0;
@ -156,13 +175,10 @@ VOID RTMPClearAllIdsCounter(
}
}
VOID RTMPIdsPeriodicExec(
IN PVOID SystemSpecific1,
IN PVOID FunctionContext,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3)
VOID RTMPIdsPeriodicExec(IN PVOID SystemSpecific1, IN PVOID FunctionContext,
IN PVOID SystemSpecific2, IN PVOID SystemSpecific3)
{
PRTMP_ADAPTER pAd = (RTMP_ADAPTER *)FunctionContext;
PRTMP_ADAPTER pAd = (RTMP_ADAPTER *)FunctionContext;
pAd->ApCfg.IDSTimerRunning = FALSE;
#ifdef SYSTEM_LOG_SUPPORT
@ -182,7 +198,6 @@ VOID RTMPIdsPeriodicExec(
}
}
/*
========================================================================
Routine Description:
@ -199,16 +214,16 @@ VOID RTMPIdsPeriodicExec(
========================================================================
*/
BOOLEAN RTMPSpoofedMgmtDetection(
IN RTMP_ADAPTER *pAd,
IN RX_BLK * rxblk)
BOOLEAN RTMPSpoofedMgmtDetection(IN RTMP_ADAPTER *pAd, IN RX_BLK *rxblk)
{
INT i;
INT i;
FRAME_CONTROL *FC = (FRAME_CONTROL *)rxblk->FC;
for (i = 0; i < pAd->ApCfg.BssidNum; i++) {
/* Spoofed BSSID detection */
if (NdisEqualMemory(rxblk->Addr2, pAd->ApCfg.MBSSID[i].wdev.bssid, MAC_ADDR_LEN)) {
if (NdisEqualMemory(rxblk->Addr2,
pAd->ApCfg.MBSSID[i].wdev.bssid,
MAC_ADDR_LEN)) {
CHAR RcvdRssi;
struct raw_rssi_info rssi_info;
@ -218,55 +233,68 @@ BOOLEAN RTMPSpoofedMgmtDetection(
#if defined(CUSTOMER_DCC_FEATURE) || defined(CONFIG_MAP_SUPPORT)
rssi_info.raw_rssi[3] = rxblk->rx_signal.raw_rssi[3];
#endif
RcvdRssi = RTMPMaxRssi(pAd,
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_0),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_1),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_2)
RcvdRssi = RTMPMaxRssi(
pAd, ConvertToRssi(pAd, &rssi_info, RSSI_IDX_0),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_1),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_2)
#if defined(CUSTOMER_DCC_FEATURE) || defined(CONFIG_MAP_SUPPORT)
, ConvertToRssi(pAd, &rssi_info, RSSI_IDX_3)
,
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_3)
#endif
);
);
switch (FC->SubType) {
case SUBTYPE_ASSOC_RSP:
pAd->ApCfg.MBSSID[i].RcvdSpoofedAssocRespCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedAssocResp = RcvdRssi;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedAssocResp =
RcvdRssi;
break;
case SUBTYPE_REASSOC_RSP:
pAd->ApCfg.MBSSID[i].RcvdSpoofedReassocRespCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedReassocResp = RcvdRssi;
pAd->ApCfg.MBSSID[i]
.RcvdSpoofedReassocRespCount++;
pAd->ApCfg.MBSSID[i]
.RssiOfRcvdSpoofedReassocResp =
RcvdRssi;
break;
case SUBTYPE_PROBE_RSP:
pAd->ApCfg.MBSSID[i].RcvdSpoofedProbeRespCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedProbeResp = RcvdRssi;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedProbeResp =
RcvdRssi;
break;
case SUBTYPE_BEACON:
pAd->ApCfg.MBSSID[i].RcvdSpoofedBeaconCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedBeacon = RcvdRssi;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedBeacon =
RcvdRssi;
break;
case SUBTYPE_DISASSOC:
pAd->ApCfg.MBSSID[i].RcvdSpoofedDisassocCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedDisassoc = RcvdRssi;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedDisassoc =
RcvdRssi;
break;
case SUBTYPE_AUTH:
pAd->ApCfg.MBSSID[i].RcvdSpoofedAuthCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedAuth = RcvdRssi;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedAuth =
RcvdRssi;
break;
case SUBTYPE_DEAUTH:
pAd->ApCfg.MBSSID[i].RcvdSpoofedDeauthCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedDeauth = RcvdRssi;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedDeauth =
RcvdRssi;
break;
default:
pAd->ApCfg.MBSSID[i].RcvdSpoofedUnknownMgmtCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdSpoofedUnknownMgmt = RcvdRssi;
pAd->ApCfg.MBSSID[i]
.RcvdSpoofedUnknownMgmtCount++;
pAd->ApCfg.MBSSID[i]
.RssiOfRcvdSpoofedUnknownMgmt =
RcvdRssi;
break;
}
@ -277,24 +305,21 @@ BOOLEAN RTMPSpoofedMgmtDetection(
return FALSE;
}
VOID RTMPConflictSsidDetection(
IN PRTMP_ADAPTER pAd,
IN PUCHAR pSsid,
IN UCHAR SsidLen,
IN CHAR Rssi0,
IN CHAR Rssi1,
IN CHAR Rssi2
VOID RTMPConflictSsidDetection(IN PRTMP_ADAPTER pAd, IN PUCHAR pSsid,
IN UCHAR SsidLen, IN CHAR Rssi0, IN CHAR Rssi1,
IN CHAR Rssi2
#if defined(CUSTOMER_DCC_FEATURE) || defined(CONFIG_MAP_SUPPORT)
, IN CHAR Rssi3
,
IN CHAR Rssi3
#endif
)
{
INT i;
INT i;
for (i = 0; i < pAd->ApCfg.BssidNum; i++) {
/* Conflict SSID detection */
if (SSID_EQUAL(pSsid, SsidLen, pAd->ApCfg.MBSSID[i].Ssid, pAd->ApCfg.MBSSID[i].SsidLen)) {
if (SSID_EQUAL(pSsid, SsidLen, pAd->ApCfg.MBSSID[i].Ssid,
pAd->ApCfg.MBSSID[i].SsidLen)) {
CHAR RcvdRssi;
struct raw_rssi_info rssi_info;
@ -305,13 +330,15 @@ VOID RTMPConflictSsidDetection(
rssi_info.raw_rssi[3] = Rssi3;
#endif
RcvdRssi = RTMPMaxRssi(pAd, ConvertToRssi(pAd, &rssi_info, RSSI_IDX_0),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_1),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_2)
RcvdRssi = RTMPMaxRssi(
pAd, ConvertToRssi(pAd, &rssi_info, RSSI_IDX_0),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_1),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_2)
#if defined(CUSTOMER_DCC_FEATURE) || defined(CONFIG_MAP_SUPPORT)
, ConvertToRssi(pAd, &rssi_info, RSSI_IDX_3)
,
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_3)
#endif
);
);
pAd->ApCfg.MBSSID[i].RcvdConflictSsidCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdConflictSsid = RcvdRssi;
return;
@ -319,17 +346,15 @@ VOID RTMPConflictSsidDetection(
}
}
BOOLEAN RTMPReplayAttackDetection(
IN RTMP_ADAPTER *pAd,
IN UCHAR * pAddr2,
IN RX_BLK * rxblk)
BOOLEAN RTMPReplayAttackDetection(IN RTMP_ADAPTER *pAd, IN UCHAR *pAddr2,
IN RX_BLK *rxblk)
{
INT i;
INT i;
for (i = 0; i < pAd->ApCfg.BssidNum; i++) {
/* Conflict SSID detection */
if (NdisEqualMemory(pAddr2, pAd->ApCfg.MBSSID[i].wdev.bssid, MAC_ADDR_LEN)) {
if (NdisEqualMemory(pAddr2, pAd->ApCfg.MBSSID[i].wdev.bssid,
MAC_ADDR_LEN)) {
CHAR RcvdRssi;
struct raw_rssi_info rssi_info;
@ -339,14 +364,16 @@ BOOLEAN RTMPReplayAttackDetection(
#if defined(CUSTOMER_DCC_FEATURE) || defined(CONFIG_MAP_SUPPORT)
rssi_info.raw_rssi[3] = rxblk->rx_signal.raw_rssi[3];
#endif
RcvdRssi = RTMPMaxRssi(pAd, ConvertToRssi(pAd, &rssi_info, RSSI_IDX_0),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_1),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_2)
RcvdRssi = RTMPMaxRssi(
pAd, ConvertToRssi(pAd, &rssi_info, RSSI_IDX_0),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_1),
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_2)
#if defined(CUSTOMER_DCC_FEATURE) || defined(CONFIG_MAP_SUPPORT)
, ConvertToRssi(pAd, &rssi_info, RSSI_IDX_3)
,
ConvertToRssi(pAd, &rssi_info, RSSI_IDX_3)
#endif
);
);
pAd->ApCfg.MBSSID[i].RcvdReplayAttackCount++;
pAd->ApCfg.MBSSID[i].RssiOfRcvdReplayAttack = RcvdRssi;
return TRUE;
@ -394,10 +421,8 @@ VOID RTMPUpdateStaMgmtCounter(RTMP_ADAPTER *pAd, USHORT type)
*/
}
VOID rtmp_read_ids_from_file(
IN PRTMP_ADAPTER pAd,
RTMP_STRING *tmpbuf,
RTMP_STRING *buffer)
VOID rtmp_read_ids_from_file(IN PRTMP_ADAPTER pAd, RTMP_STRING *tmpbuf,
RTMP_STRING *buffer)
{
/*IdsEnable */
if (RTMPGetKeyParameter("IdsEnable", tmpbuf, 10, buffer, TRUE)) {
@ -406,55 +431,81 @@ VOID rtmp_read_ids_from_file(
else
pAd->ApCfg.IdsEnable = FALSE;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("IDS is %s\n", pAd->ApCfg.IdsEnable ? "enabled" : "disabled"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("IDS is %s\n",
pAd->ApCfg.IdsEnable ? "enabled" : "disabled"));
}
/*AuthFloodThreshold */
if (RTMPGetKeyParameter("AuthFloodThreshold", tmpbuf, 10, buffer, TRUE)) {
if (RTMPGetKeyParameter("AuthFloodThreshold", tmpbuf, 10, buffer,
TRUE)) {
pAd->ApCfg.AuthFloodThreshold = os_str_tol(tmpbuf, 0, 10);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("AuthFloodThreshold = %d\n", pAd->ApCfg.AuthFloodThreshold));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("AuthFloodThreshold = %d\n",
pAd->ApCfg.AuthFloodThreshold));
}
/*AssocReqFloodThreshold */
if (RTMPGetKeyParameter("AssocReqFloodThreshold", tmpbuf, 10, buffer, TRUE)) {
if (RTMPGetKeyParameter("AssocReqFloodThreshold", tmpbuf, 10, buffer,
TRUE)) {
pAd->ApCfg.AssocReqFloodThreshold = os_str_tol(tmpbuf, 0, 10);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("AssocReqFloodThreshold = %d\n", pAd->ApCfg.AssocReqFloodThreshold));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("AssocReqFloodThreshold = %d\n",
pAd->ApCfg.AssocReqFloodThreshold));
}
/*ReassocReqFloodThreshold */
if (RTMPGetKeyParameter("ReassocReqFloodThreshold", tmpbuf, 10, buffer, TRUE)) {
if (RTMPGetKeyParameter("ReassocReqFloodThreshold", tmpbuf, 10, buffer,
TRUE)) {
pAd->ApCfg.ReassocReqFloodThreshold = os_str_tol(tmpbuf, 0, 10);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("ReassocReqFloodThreshold = %d\n", pAd->ApCfg.ReassocReqFloodThreshold));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("ReassocReqFloodThreshold = %d\n",
pAd->ApCfg.ReassocReqFloodThreshold));
}
/*ProbeReqFloodThreshold */
if (RTMPGetKeyParameter("ProbeReqFloodThreshold", tmpbuf, 10, buffer, TRUE)) {
if (RTMPGetKeyParameter("ProbeReqFloodThreshold", tmpbuf, 10, buffer,
TRUE)) {
pAd->ApCfg.ProbeReqFloodThreshold = os_str_tol(tmpbuf, 0, 10);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("ProbeReqFloodThreshold = %d\n", pAd->ApCfg.ProbeReqFloodThreshold));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("ProbeReqFloodThreshold = %d\n",
pAd->ApCfg.ProbeReqFloodThreshold));
}
/*DisassocFloodThreshold */
if (RTMPGetKeyParameter("DisassocFloodThreshold", tmpbuf, 10, buffer, TRUE)) {
if (RTMPGetKeyParameter("DisassocFloodThreshold", tmpbuf, 10, buffer,
TRUE)) {
pAd->ApCfg.DisassocFloodThreshold = os_str_tol(tmpbuf, 0, 10);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("DisassocFloodThreshold = %d\n", pAd->ApCfg.DisassocFloodThreshold));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("DisassocFloodThreshold = %d\n",
pAd->ApCfg.DisassocFloodThreshold));
}
/*DeauthFloodThreshold */
if (RTMPGetKeyParameter("DeauthFloodThreshold", tmpbuf, 10, buffer, TRUE)) {
if (RTMPGetKeyParameter("DeauthFloodThreshold", tmpbuf, 10, buffer,
TRUE)) {
pAd->ApCfg.DeauthFloodThreshold = os_str_tol(tmpbuf, 0, 10);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("DeauthFloodThreshold = %d\n", pAd->ApCfg.DeauthFloodThreshold));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("DeauthFloodThreshold = %d\n",
pAd->ApCfg.DeauthFloodThreshold));
}
/*EapReqFloodThreshold */
if (RTMPGetKeyParameter("EapReqFloodThreshold", tmpbuf, 10, buffer, TRUE)) {
if (RTMPGetKeyParameter("EapReqFloodThreshold", tmpbuf, 10, buffer,
TRUE)) {
pAd->ApCfg.EapReqFloodThreshold = os_str_tol(tmpbuf, 0, 10);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("EapReqFloodThreshold = %d\n", pAd->ApCfg.EapReqFloodThreshold));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("EapReqFloodThreshold = %d\n",
pAd->ApCfg.EapReqFloodThreshold));
}
/* DataFloodThreshold */
if (RTMPGetKeyParameter("DataFloodThreshold", tmpbuf, 10, buffer, TRUE)) {
if (RTMPGetKeyParameter("DataFloodThreshold", tmpbuf, 10, buffer,
TRUE)) {
pAd->ApCfg.DataFloodThreshold = os_str_tol(tmpbuf, 0, 10);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("DataFloodThreshold = %d\n", pAd->ApCfg.DataFloodThreshold));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("DataFloodThreshold = %d\n",
pAd->ApCfg.DataFloodThreshold));
}
}

View File

@ -40,16 +40,16 @@
***************************************************************************/
#ifdef MBSS_SUPPORT
#include "rt_config.h"
#ifdef VENDOR_FEATURE7_SUPPORT
#ifndef ARRIS_MODULE_PRESENT
void (*f)(int, int, int, char*, int) = arris_event_send_hook_fn;
void (*f)(int, int, int, char *, int) = arris_event_send_hook_fn;
#endif /* !ARRIS_MODULE_PRESENT */
#endif
#ifdef MULTI_PROFILE
INT multi_profile_devname_req(struct _RTMP_ADAPTER *ad, UCHAR *final_name, UCHAR *ifidx);
INT multi_profile_devname_req(struct _RTMP_ADAPTER *ad, UCHAR *final_name,
UCHAR *ifidx);
#endif /*MULTI_PROFILE*/
extern struct wifi_dev_ops ap_wdev_ops;
@ -76,7 +76,7 @@ Note:
*/
VOID MBSS_Init(RTMP_ADAPTER *pAd, RTMP_OS_NETDEV_OP_HOOK *pNetDevOps)
{
#define MBSS_MAX_DEV_NUM 32
#define MBSS_MAX_DEV_NUM 32
PNET_DEV pDevNew;
INT32 IdBss, MaxNumBss;
INT status;
@ -114,7 +114,7 @@ VOID MBSS_Init(RTMP_ADAPTER *pAd, RTMP_OS_NETDEV_OP_HOOK *pNetDevOps)
INT32 Ret;
BSS_STRUCT *pMbss = NULL;
UCHAR ifidx = IdBss;
UCHAR final_name[32]="";
UCHAR final_name[32] = "";
BOOLEAN autoSuffix = TRUE;
#ifdef MULTIPLE_CARD_SUPPORT
MC_RowID = pAd->MC_RowID;
@ -125,56 +125,67 @@ VOID MBSS_Init(RTMP_ADAPTER *pAd, RTMP_OS_NETDEV_OP_HOOK *pNetDevOps)
dev_name = get_dev_name_prefix(pAd, INT_MBSSID);
if(dev_name == NULL){
if (dev_name == NULL) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("get_dev_name_prefix error!\n"));
("get_dev_name_prefix error!\n"));
break;
}
snprintf(final_name,sizeof(final_name),"%s",dev_name);
snprintf(final_name, sizeof(final_name), "%s", dev_name);
#ifdef MULTI_PROFILE
multi_profile_devname_req(pAd,final_name,&ifidx);
multi_profile_devname_req(pAd, final_name, &ifidx);
if (ifidx == 0)
autoSuffix = FALSE;
#endif /*MULTI_PROFILE*/
#ifdef INTELP6_SUPPORT
#ifdef CONFIG_RT_SECOND_CARD
if (pAd->dev_idx == 1)
pDevNew = RtmpOSNetDevCreate(MC_RowID, &IoctlIF, INT_MBSSID, IdBss + MAX_MBSS_NUM,
sizeof(struct mt_dev_priv), dev_name, autoSuffix);
pDevNew = RtmpOSNetDevCreate(MC_RowID, &IoctlIF,
INT_MBSSID,
IdBss + MAX_MBSS_NUM,
sizeof(struct mt_dev_priv),
dev_name, autoSuffix);
else
#endif
#endif
pDevNew = RtmpOSNetDevCreate(MC_RowID, &IoctlIF, INT_MBSSID, ifidx,
sizeof(struct mt_dev_priv), final_name, autoSuffix);
pDevNew = RtmpOSNetDevCreate(MC_RowID, &IoctlIF,
INT_MBSSID, ifidx,
sizeof(struct mt_dev_priv),
final_name, autoSuffix);
#ifdef HOSTAPD_SUPPORT
pAd->IoctlIF = IoctlIF;
#endif /* HOSTAPD_SUPPORT */
if (pDevNew == NULL) {
pAd->ApCfg.BssidNum = IdBss; /* re-assign new MBSS number */
pAd->ApCfg.BssidNum =
IdBss; /* re-assign new MBSS number */
break;
}
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Register MBSSID IF (%s)\n", RTMP_OS_NETDEV_GET_DEVNAME(pDevNew)));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("Register MBSSID IF (%s)\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDevNew)));
pMbss = &pAd->ApCfg.MBSSID[IdBss];
wdev = &pAd->ApCfg.MBSSID[IdBss].wdev;
Ret = wdev_init(pAd, wdev, WDEV_TYPE_AP, pDevNew, IdBss,
(VOID *)&pAd->ApCfg.MBSSID[IdBss], (void *)pAd);
(VOID *)&pAd->ApCfg.MBSSID[IdBss], (void *)pAd);
if (!Ret) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("Assign wdev idx for %s failed, free net device!\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDevNew)));
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("Assign wdev idx for %s failed, free net device!\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDevNew)));
RtmpOSNetDevFree(pDevNew);
break;
}
Ret = wdev_ops_register(wdev, WDEV_TYPE_AP, &ap_wdev_ops,
cap->wmm_detect_method);
cap->wmm_detect_method);
if (!Ret) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("register wdev_ops %s failed, free net device!\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDevNew)));
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("register wdev_ops %s failed, free net device!\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDevNew)));
RtmpOSNetDevFree(pDevNew);
break;
}
@ -191,30 +202,52 @@ VOID MBSS_Init(RTMP_ADAPTER *pAd, RTMP_OS_NETDEV_OP_HOOK *pNetDevOps)
#endif
netDevHook.wdev = wdev;
/* Init MAC address of virtual network interface */
NdisMoveMemory(&netDevHook.devAddr[0], &wdev->bssid[0], MAC_ADDR_LEN);
NdisMoveMemory(&netDevHook.devAddr[0], &wdev->bssid[0],
MAC_ADDR_LEN);
#ifdef RT_CFG80211_SUPPORT
{
struct wireless_dev *pWdev;
CFG80211_CB *p80211CB = pAd->pCfg80211_CB;
UINT32 DevType = RT_CMD_80211_IFTYPE_AP;
pWdev = kzalloc(sizeof(*pWdev), GFP_KERNEL);
pDevNew->ieee80211_ptr = pWdev;
pWdev->wiphy = p80211CB->pCfg80211_Wdev->wiphy;
SET_NETDEV_DEV(pDevNew, wiphy_dev(pWdev->wiphy));
pWdev->netdev = pDevNew;
pWdev->iftype = DevType;
}
{
struct wireless_dev *pWdev;
CFG80211_CB *p80211CB = pAd->pCfg80211_CB;
UINT32 DevType = RT_CMD_80211_IFTYPE_AP;
os_alloc_mem_suspend(NULL, (UCHAR **)&pWdev,
sizeof(*pWdev));
if (!pWdev) {
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL,
DBG_LVL_ERROR,
("mem alloc failed for %s, free net device!\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDevNew)));
RtmpOSNetDevFree(pDevNew);
break;
}
os_zero_mem((PUCHAR)pWdev, sizeof(*pWdev));
pDevNew->ieee80211_ptr = pWdev;
pWdev->wiphy = p80211CB->pCfg80211_Wdev->wiphy;
SET_NETDEV_DEV(pDevNew, wiphy_dev(pWdev->wiphy));
pWdev->netdev = pDevNew;
pWdev->iftype = DevType;
}
#endif /* RT_CFG80211_SUPPORT */
/* register this device to OS */
status = RtmpOSNetDevAttach(pAd->OpMode, pDevNew, &netDevHook);
#ifdef CONFIG_MAP_SUPPORT
if (IS_MAP_TURNKEY_ENABLE(pAd)) {
if (wdev && wdev->wdev_type == WDEV_TYPE_AP)
map_make_vend_ie(pAd, IdBss);
}
#endif /* CONFIG_MAP_SUPPORT */
}
pAd->FlgMbssInit = TRUE;
#ifdef MAP_R2
if (IS_MAP_ENABLE(pAd))
MtCmdSetRxTxAirtimeEn(
pAd, ENUM_RX_AT_FEATURE_SUB_TYPE_AIRTIME_EN, TRUE);
#endif
}
/*
========================================================================
Routine Description:
@ -246,7 +279,6 @@ VOID MBSS_Remove(RTMP_ADAPTER *pAd)
if (MaxNumBss > HW_BEACON_MAX_NUM)
MaxNumBss = HW_BEACON_MAX_NUM;
for (IdBss = FIRST_MBSSID; IdBss < MaxNumBss; IdBss++) {
wdev = &pAd->ApCfg.MBSSID[IdBss].wdev;
pMbss = &pAd->ApCfg.MBSSID[IdBss];
@ -259,13 +291,16 @@ VOID MBSS_Remove(RTMP_ADAPTER *pAd)
RtmpOSNetDevDetach(wdev->if_dev);
RtmpOSNetDevProtect(0);
wdev_deinit(pAd, wdev);
#ifdef RT_CFG80211_SUPPORT
os_free_mem(wdev->if_dev->ieee80211_ptr);
wdev->if_dev->ieee80211_ptr = NULL;
#endif /* RT_CFG80211_SUPPORT */
RtmpOSNetDevFree(wdev->if_dev);
wdev->if_dev = NULL;
}
}
}
/*
========================================================================
Routine Description:
@ -308,7 +343,8 @@ INT32 ext_mbss_hw_cr_enable(PNET_DEV pDev)
pAd = RTMP_OS_NETDEV_GET_PRIV(pDev);
BssId = RT28xx_MBSS_IdxGet(pAd, pDev);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("##### %s, BssId = %d\n", __func__, BssId));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("##### %s, BssId = %d\n", __func__, BssId));
if (BssId < 0)
return -1;
@ -316,12 +352,12 @@ INT32 ext_mbss_hw_cr_enable(PNET_DEV pDev)
if (!IS_HIF_TYPE(pAd, HIF_MT))
return 0;
AsicSetExtMbssEnableCR(pAd, BssId, TRUE);/* enable rmac 0_1~0_15 bit */
AsicSetMbssHwCRSetting(pAd, BssId, TRUE);/* enable lp timing setting for 0_1~0_15 */
AsicSetExtMbssEnableCR(pAd, BssId, TRUE); /* enable rmac 0_1~0_15 bit */
AsicSetMbssHwCRSetting(
pAd, BssId, TRUE); /* enable lp timing setting for 0_1~0_15 */
return 0;
}
INT ext_mbss_hw_cr_disable(PNET_DEV pDev)
{
PRTMP_ADAPTER pAd;
@ -343,6 +379,3 @@ INT ext_mbss_hw_cr_disable(PNET_DEV pDev)
#endif /* MT_MAC */
#endif /* MBSS_SUPPORT */

View File

@ -47,7 +47,6 @@
#include "rt_os_util.h"
#include "rt_os_net.h"
/* --------------------------------- Public -------------------------------- */
NET_DEV_STATS *RT28xx_get_ether_stats(PNET_DEV net_dev);
@ -75,16 +74,15 @@ VOID RT28xx_MBSS_Init(VOID *pAd, PNET_DEV pDevMain)
RTMP_OS_NETDEV_OP_HOOK netDevHook;
NdisZeroMemory(&netDevHook, sizeof(netDevHook));
netDevHook.open = mbss_virtual_if_open; /* device opem hook point */
netDevHook.stop = mbss_virtual_if_close; /* device close hook point */
netDevHook.xmit = rt28xx_send_packets; /* hard transmit hook point */
netDevHook.ioctl = rt28xx_ioctl; /* ioctl hook point */
netDevHook.open = mbss_virtual_if_open; /* device opem hook point */
netDevHook.stop = mbss_virtual_if_close; /* device close hook point */
netDevHook.xmit = rt28xx_send_packets; /* hard transmit hook point */
netDevHook.ioctl = rt28xx_ioctl; /* ioctl hook point */
netDevHook.get_stats = RT28xx_get_ether_stats;
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_MBSS_INIT,
0, &netDevHook, 0);
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_MBSS_INIT, 0,
&netDevHook, 0);
}
/*
========================================================================
Routine Description:
@ -103,11 +101,10 @@ Note:
*/
VOID RT28xx_MBSS_Remove(VOID *pAd)
{
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_MBSS_REMOVE, 0, NULL, 0);
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_MBSS_REMOVE, 0, NULL,
0);
}
/* --------------------------------- Private -------------------------------- */
/*
========================================================================
@ -128,8 +125,8 @@ INT mbss_virtual_if_open(PNET_DEV pDev)
{
VOID *pAd;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s: ===> %s\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s: ===> %s\n", RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
pAd = RTMP_OS_NETDEV_GET_PRIV(pDev);
@ -146,7 +143,6 @@ INT mbss_virtual_if_open(PNET_DEV pDev)
return 0;
}
/*
========================================================================
Routine Description:
@ -166,8 +162,8 @@ INT mbss_virtual_if_close(PNET_DEV pDev)
{
VOID *pAd;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s: ===> %s\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s: ===> %s\n", RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
pAd = RTMP_OS_NETDEV_GET_PRIV(pDev);
@ -183,4 +179,3 @@ INT mbss_virtual_if_close(PNET_DEV pDev)
}
#endif /* MBSS_SUPPORT */

View File

@ -32,7 +32,7 @@
#ifdef APCLI_SUPPORT
#ifdef APCLI_CERT_SUPPORT
extern UCHAR ZeroSsid[32];
extern UCHAR ZeroSsid[32];
#endif /* APCLI_CERT_SUPPORT */
#endif /* APCLI_SUPPORT */
@ -40,45 +40,42 @@ extern UCHAR ZeroSsid[32];
int DetectOverlappingPeriodicRound;
#ifdef DOT11N_DRAFT3
VOID Bss2040CoexistTimeOut(
IN PVOID SystemSpecific1,
IN PVOID FunctionContext,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3)
VOID Bss2040CoexistTimeOut(IN PVOID SystemSpecific1, IN PVOID FunctionContext,
IN PVOID SystemSpecific2, IN PVOID SystemSpecific3)
{
int apidx;
PRTMP_ADAPTER pAd = (RTMP_ADAPTER *)FunctionContext;
PRTMP_ADAPTER pAd = (RTMP_ADAPTER *)FunctionContext;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Bss2040CoexistTimeOut(): Recovery to original setting!\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("Bss2040CoexistTimeOut(): Recovery to original setting!\n"));
/* Recovery to original setting when next DTIM Interval. */
pAd->CommonCfg.Bss2040CoexistFlag &= (~BSS_2040_COEXIST_TIMER_FIRED);
NdisZeroMemory(&pAd->CommonCfg.LastBSSCoexist2040, sizeof(BSS_2040_COEXIST_IE));
NdisZeroMemory(&pAd->CommonCfg.LastBSSCoexist2040,
sizeof(BSS_2040_COEXIST_IE));
pAd->CommonCfg.Bss2040CoexistFlag |= BSS_2040_COEXIST_INFO_SYNC;
if (pAd->CommonCfg.bBssCoexEnable == FALSE) {
/* TODO: Find a better way to handle this when the timer is fired and we disable the bBssCoexEable support!! */
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Bss2040CoexistTimeOut(): bBssCoexEnable is FALSE, return directly!\n"));
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("Bss2040CoexistTimeOut(): bBssCoexEnable is FALSE, return directly!\n"));
return;
}
for (apidx = 0; apidx < pAd->ApCfg.BssidNum; apidx++)
SendBSS2040CoexistMgmtAction(pAd, MCAST_WCID_TO_REMOVE, apidx, 0);
SendBSS2040CoexistMgmtAction(pAd, MCAST_WCID_TO_REMOVE, apidx,
0);
}
#endif /* DOT11N_DRAFT3 */
#endif /* DOT11_N_SUPPORT */
VOID APDetectOverlappingExec(
IN PVOID SystemSpecific1,
IN PVOID FunctionContext,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3)
VOID APDetectOverlappingExec(IN PVOID SystemSpecific1, IN PVOID FunctionContext,
IN PVOID SystemSpecific2, IN PVOID SystemSpecific3)
{
#ifdef DOT11_N_SUPPORT
PRTMP_ADAPTER pAd = (RTMP_ADAPTER *)FunctionContext;
PRTMP_ADAPTER pAd = (RTMP_ADAPTER *)FunctionContext;
struct freq_oper oper;
BOOLEAN bSupport2G = HcIsRfSupport(pAd, RFIC_24GHZ);
int i;
@ -92,15 +89,20 @@ VOID APDetectOverlappingExec(
for (i = 0; i < pAd->ApCfg.BssidNum; i++) {
wdev = &pAd->ApCfg.MBSSID[i].wdev;
cfg_ht_bw = wlan_config_get_ht_bw(wdev);
if (wmode_2_rfic(wdev->PhyMode) == RFIC_24GHZ && (cfg_ht_bw == HT_BW_40)) {
cfg_ext_cha = wlan_config_get_ext_cha(wdev);
wlan_operate_set_ht_bw(wdev, HT_BW_40, cfg_ext_cha);
if (wmode_2_rfic(wdev->PhyMode) == RFIC_24GHZ &&
(cfg_ht_bw == HT_BW_40)) {
cfg_ext_cha =
wlan_config_get_ext_cha(wdev);
wlan_operate_set_ht_bw(wdev, HT_BW_40,
cfg_ext_cha);
}
}
}
} else {
if ((DetectOverlappingPeriodicRound == 25) || (DetectOverlappingPeriodicRound == 1)) {
if (hc_radio_query_by_rf(pAd, RFIC_24GHZ, &oper) != HC_STATUS_OK) {
if ((DetectOverlappingPeriodicRound == 25) ||
(DetectOverlappingPeriodicRound == 1)) {
if (hc_radio_query_by_rf(pAd, RFIC_24GHZ, &oper) !=
HC_STATUS_OK) {
return;
}
if (oper.ht_bw == HT_BW_40) {
@ -126,8 +128,7 @@ VOID APDetectOverlappingExec(
and release packet buffer in PSQ is fail to TX in time.
==========================================================================
*/
VOID APMlmePeriodicExec(
PRTMP_ADAPTER pAd)
VOID APMlmePeriodicExec(PRTMP_ADAPTER pAd)
{
#ifdef A_BAND_SUPPORT
BOOLEAN bSupport5G = HcIsRfSupport(pAd, RFIC_5GHZ);
@ -149,7 +150,7 @@ VOID APMlmePeriodicExec(
RemoveOldBssEntry(pAd);
#endif
/*
/*
Reqeust by David 2005/05/12
It make sense to disable Adjust Tx Power on AP mode, since we can't
take care all of the client's situation
@ -158,22 +159,26 @@ VOID APMlmePeriodicExec(
#ifdef CARRIER_DETECTION_SUPPORT
if (isCarrierDetectExist(pAd) == TRUE) {
PCARRIER_DETECTION_STRUCT pCarrierDetect = &pAd->CommonCfg.CarrierDetect;
PCARRIER_DETECTION_STRUCT pCarrierDetect =
&pAd->CommonCfg.CarrierDetect;
if (pCarrierDetect->OneSecIntCount < pCarrierDetect->CarrierGoneThreshold) {
if (pCarrierDetect->OneSecIntCount <
pCarrierDetect->CarrierGoneThreshold) {
pCarrierDetect->CD_State = CD_NORMAL;
pCarrierDetect->recheck = pCarrierDetect->recheck1;
if (pCarrierDetect->Debug != DBG_LVL_TRACE) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Carrier gone\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL,
DBG_LVL_TRACE, ("Carrier gone\n"));
/* start all TX actions. */
UpdateBeaconHandler(
pAd,
NULL,
BCN_UPDATE_AP_RENEW);
AsicSetSyncModeAndEnable(pAd, pAd->CommonCfg.BeaconPeriod, HW_BSSID_0, OPMODE_AP);
UpdateBeaconHandler(pAd, NULL,
BCN_UPDATE_AP_RENEW);
AsicSetSyncModeAndEnable(
pAd, pAd->CommonCfg.BeaconPeriod,
HW_BSSID_0, OPMODE_AP);
} else
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Carrier gone\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL,
DBG_LVL_TRACE, ("Carrier gone\n"));
}
pCarrierDetect->OneSecIntCount = 0;
@ -226,7 +231,6 @@ VOID APMlmePeriodicExec(
#ifdef WIFI_DIAG
DiagApMlmeOneSecProc(pAd);
#endif
}
#ifdef AP_SCAN_SUPPORT
@ -239,20 +243,21 @@ VOID APMlmePeriodicExec(
if ((pAd->Mlme.OneSecPeriodicRound % 2 == 1
#ifdef APCLI_AUTO_CONNECT_SUPPORT
&& (pAd->ApCfg.ApCliAutoConnectChannelSwitching == FALSE)
&& (pAd->ApCfg.ApCliAutoConnectChannelSwitching == FALSE)
#endif /* APCLI_AUTO_CONNECT_SUPPORT */
) ||
(pAd->Mlme.OneSecPeriodicRound % 2 == 1
) ||
(pAd->Mlme.OneSecPeriodicRound % 2 == 1
#ifdef CONFIG_MAP_SUPPORT
&& (IS_MAP_TURNKEY_ENABLE(pAd))
&& (IS_MAP_TURNKEY_ENABLE(pAd))
#endif /* APCLI_AUTO_CONNECT_SUPPORT */
)) {
)) {
ApCliIfUp(pAd);
}
{
INT loop;
ULONG Now32;
MAC_TABLE_ENTRY *pEntry;
#ifdef MAC_REPEATER_SUPPORT
@ -268,38 +273,49 @@ VOID APMlmePeriodicExec(
#ifdef APCLI_CERT_SUPPORT
if ((pApCliEntry->bBlockAssoc == TRUE) &&
RTMP_TIME_AFTER(Now32, pApCliEntry->LastMicErrorTime + (60*OS_HZ)))
RTMP_TIME_AFTER(Now32,
pApCliEntry->LastMicErrorTime +
(60 * OS_HZ)))
pAd->ApCfg.ApCliTab[loop].bBlockAssoc = FALSE;
#endif /* APCLI_CERT_SUPPORT */
if ((pApCliEntry->Valid == TRUE)
&& (VALID_UCAST_ENTRY_WCID(pAd, pApCliEntry->MacTabWCID))) {
if ((pApCliEntry->Valid == TRUE) &&
(VALID_UCAST_ENTRY_WCID(pAd,
pApCliEntry->MacTabWCID))) {
/* update channel quality for Roaming and UI LinkQuality display */
MlmeCalculateChannelQuality(pAd,
&pAd->MacTab.Content[pApCliEntry->MacTabWCID], Now32);
pEntry = &pAd->MacTab.Content
[pApCliEntry->MacTabWCID];
/* update channel quality for Roaming and UI LinkQuality display */
if (pEntry && (pApCliEntry->MacTabWCID > 0) &&
IS_ENTRY_AP(pEntry))
MlmeCalculateChannelQuality(pAd, pEntry,
Now32);
}
}
}
#endif /* APCLI_SUPPORT */
#ifdef DOT11_N_SUPPORT
{
INT IdBss = 0;
UCHAR ht_protect_en = 1;
BSS_STRUCT *pMbss = NULL;
{
INT IdBss = 0;
UCHAR ht_protect_en = 1;
BSS_STRUCT *pMbss = NULL;
for (IdBss = 0; IdBss < pAd->ApCfg.BssidNum; IdBss++) {
pMbss = &pAd->ApCfg.MBSSID[IdBss];
for (IdBss = 0; IdBss < pAd->ApCfg.BssidNum; IdBss++) {
pMbss = &pAd->ApCfg.MBSSID[IdBss];
if ((pMbss) && (&pMbss->wdev) && (pMbss->wdev.DevInfo.Active)) {
ht_protect_en = wlan_config_get_ht_protect_en(&pMbss->wdev);
if (ht_protect_en) {
ApUpdateCapabilityAndErpIe(pAd, pMbss);
APUpdateOperationMode(pAd, &pMbss->wdev);
}
if ((pMbss) && (&pMbss->wdev) &&
(pMbss->wdev.DevInfo.Active)) {
ht_protect_en = wlan_config_get_ht_protect_en(
&pMbss->wdev);
if (ht_protect_en) {
ApUpdateCapabilityAndErpIe(pAd, pMbss);
APUpdateOperationMode(pAd,
&pMbss->wdev);
}
}
}
}
#endif /* DOT11_N_SUPPORT */
#ifdef A_BAND_SUPPORT
@ -330,6 +346,16 @@ VOID APMlmePeriodicExec(
if (pDot11hTest == NULL)
continue;
#ifdef MT_DFS_SUPPORT
#ifdef CONFIG_MAP_SUPPORT
if (IS_MAP_TURNKEY_ENABLE(pAd)) {
if (wdev->map_indicate_channel_change &&
(wdev->map_radar_detect == 0)) {
wdev->map_indicate_channel_change = 0;
wapp_send_ch_change_rsp(pAd, wdev,
wdev->channel);
}
}
#endif
if (pDot11hTest->RDMode == RD_SILENCE_MODE) {
if (BandInCac[BandIdx] == TRUE)
continue;
@ -337,17 +363,35 @@ VOID APMlmePeriodicExec(
BandInCac[BandIdx] = TRUE;
#ifdef BACKGROUND_SCAN_SUPPORT
if (IS_SUPPORT_MT_ZEROWAIT_DFS(pAd) == TRUE)
ChannelMovingTime = pDot11hTest->DfsZeroWaitChMovingTime;
ChannelMovingTime =
pDot11hTest
->DfsZeroWaitChMovingTime;
else
#endif
{
ChannelMovingTime = pDot11hTest->ChMovingTime;
ChannelMovingTime =
pDot11hTest->ChMovingTime;
}
if (pDot11hTest->RDCount++ > ChannelMovingTime) {
if (pDot11hTest->RDCount++ >
ChannelMovingTime) {
pDot11hTest->RDCount = 0;
MlmeEnqueue(pAd, DFS_STATE_MACHINE, DFS_CAC_END, 0, NULL, HcGetBandByWdev(wdev));
AsicSetSyncModeAndEnable(pAd, pAd->CommonCfg.BeaconPeriod, HW_BSSID_0, OPMODE_AP);
#ifdef CONFIG_MAP_SUPPORT
if (IS_MAP_ENABLE(pAd)) {
wapp_send_cac_stop(
pAd,
RtmpOsGetNetIfIndex(
wdev->if_dev),
wdev->channel, TRUE);
}
#endif
MlmeEnqueue(pAd, DFS_STATE_MACHINE,
DFS_CAC_END, 0, NULL,
HcGetBandByWdev(wdev));
AsicSetSyncModeAndEnable(
pAd,
pAd->CommonCfg.BeaconPeriod,
HW_BSSID_0, OPMODE_AP);
pDot11hTest->RDMode = RD_NORMAL_MODE;
}
} else
@ -383,26 +427,43 @@ VOID APMlmePeriodicExec(
if (pAd->CommonCfg.dbdc_mode)
apcli2Gidx = 1;
#endif
if (APCLI_IF_UP_CHECK(pAd, apcli2Gidx) && (pAd->bApCliCertTest == TRUE)) {
if (APCLI_IF_UP_CHECK(pAd, apcli2Gidx) &&
(pAd->bApCliCertTest == TRUE)) {
if ((OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_SCAN_2040)) &&
(pAd->CommonCfg.Dot11BssWidthTriggerScanInt != 0) &&
((pAd->Mlme.OneSecPeriodicRound % pAd->CommonCfg.Dot11BssWidthTriggerScanInt) == (pAd->CommonCfg.Dot11BssWidthTriggerScanInt-1))) {
(pAd->CommonCfg.Dot11BssWidthTriggerScanInt != 0) &&
((pAd->Mlme.OneSecPeriodicRound %
pAd->CommonCfg.Dot11BssWidthTriggerScanInt) ==
(pAd->CommonCfg.Dot11BssWidthTriggerScanInt - 1))) {
#ifdef MT7615
if (IS_MT7615(pAd) || IS_MT7622(pAd)) {
PAPCLI_STRUCT pApCliEntry = &pAd->ApCfg.ApCliTab[BSS0];
PAPCLI_STRUCT pApCliEntry =
&pAd->ApCfg.ApCliTab[BSS0];
MAC_TABLE_ENTRY *pEntry = NULL;
STA_TR_ENTRY *tr_entry = NULL;
UINT tx_tp = 0;
UINT rx_tp = 0;
if (pApCliEntry->Valid == TRUE) {
pEntry = &pAd->MacTab.Content[pApCliEntry->MacTabWCID];
tr_entry = &pAd->MacTab.tr_entry[pApCliEntry->MacTabWCID];
pEntry =
&pAd->MacTab.Content
[pApCliEntry
->MacTabWCID];
tr_entry =
&pAd->MacTab.tr_entry
[pApCliEntry
->MacTabWCID];
}
if ((pEntry) && IS_ENTRY_APCLI(pEntry) && (tr_entry->PortSecured == WPA_802_1X_PORT_SECURED)) {
tx_tp = ((pApCliEntry->OneSecTxBytes) >> BYTES_PER_SEC_TO_MBPS);
rx_tp = ((pApCliEntry->OneSecRxBytes) >> BYTES_PER_SEC_TO_MBPS);
if ((pEntry) &&
IS_ENTRY_APCLI(pEntry) &&
(tr_entry->PortSecured ==
WPA_802_1X_PORT_SECURED)) {
tx_tp = ((pApCliEntry
->OneSecTxBytes) >>
BYTES_PER_SEC_TO_MBPS);
rx_tp = ((pApCliEntry
->OneSecRxBytes) >>
BYTES_PER_SEC_TO_MBPS);
}
/* Check last scan time at least 30 seconds from now. */
@ -413,42 +474,75 @@ VOID APMlmePeriodicExec(
if ((tx_tp < 1) && (rx_tp < 1)) {
MLME_SCAN_REQ_STRUCT ScanReq;
/* Fill out stuff for scan request and kick to scan*/
ScanParmFill(pAd, &ScanReq, ZeroSsid, 0, BSS_ANY, SCAN_2040_BSS_COEXIST);
ScanParmFill(
pAd, &ScanReq, ZeroSsid,
0, BSS_ANY,
SCAN_2040_BSS_COEXIST);
/* Before scan, reset trigger event table. */
TriEventInit(pAd);
MlmeEnqueue(pAd, AP_SYNC_STATE_MACHINE, APMT2_MLME_SCAN_REQ, sizeof(MLME_SCAN_REQ_STRUCT), &ScanReq, (ULONG)(&pApCliEntry->wdev));
MlmeEnqueue(
pAd,
AP_SYNC_STATE_MACHINE,
APMT2_MLME_SCAN_REQ,
sizeof(MLME_SCAN_REQ_STRUCT),
&ScanReq,
(ULONG)(&pApCliEntry
->wdev));
/* Set InfoReq = 1, So after scan , alwats sebd 20/40 Coexistence frame to AP*/
pAd->CommonCfg.BSSCoexist2040.field.InfoReq = 1;
pAd->CommonCfg.BSSCoexist2040
.field.InfoReq = 1;
RTMP_MLME_HANDLER(pAd);
}
} else
#endif /* MT7615 */
{
MTWF_LOG(DBG_CAT_MLME, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
MTWF_LOG(
DBG_CAT_MLME, DBG_SUBCAT_ALL,
DBG_LVL_TRACE,
("MMCHK - LastOneSecTotalTxCount/LastOneSecRxOkDataCnt = %d/%d\n",
pAd->RalinkCounters.LastOneSecTotalTxCount,
pAd->RalinkCounters.LastOneSecRxOkDataCnt));
pAd->RalinkCounters
.LastOneSecTotalTxCount,
pAd->RalinkCounters
.LastOneSecRxOkDataCnt));
/* Check last scan time at least 30 seconds from now. */
/* Check traffic is less than about 1.5~2Mbps.*/
/* it might cause data lost if we enqueue scanning.*/
/* This criteria needs to be considered*/
if ((pAd->RalinkCounters.LastOneSecTotalTxCount < 70) && (pAd->RalinkCounters.LastOneSecRxOkDataCnt < 70)) {
if ((pAd->RalinkCounters
.LastOneSecTotalTxCount <
70) &&
(pAd->RalinkCounters
.LastOneSecRxOkDataCnt <
70)) {
MLME_SCAN_REQ_STRUCT ScanReq;
/* Fill out stuff for scan request and kick to scan*/
ScanParmFill(pAd, &ScanReq, ZeroSsid, 0, BSS_ANY, SCAN_2040_BSS_COEXIST);
ScanParmFill(
pAd, &ScanReq, ZeroSsid,
0, BSS_ANY,
SCAN_2040_BSS_COEXIST);
/* Before scan, reset trigger event table. */
TriEventInit(pAd);
MlmeEnqueue(pAd, AP_SYNC_STATE_MACHINE, APMT2_MLME_SCAN_REQ, sizeof(MLME_SCAN_REQ_STRUCT), &ScanReq, 0);
MlmeEnqueue(
pAd,
AP_SYNC_STATE_MACHINE,
APMT2_MLME_SCAN_REQ,
sizeof(MLME_SCAN_REQ_STRUCT),
&ScanReq, 0);
/* Set InfoReq = 1, So after scan , alwats sebd 20/40 Coexistence frame to AP*/
pAd->CommonCfg.BSSCoexist2040.field.InfoReq = 1;
pAd->CommonCfg.BSSCoexist2040
.field.InfoReq = 1;
RTMP_MLME_HANDLER(pAd);
}
MTWF_LOG(DBG_CAT_MLME, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
MTWF_LOG(
DBG_CAT_MLME, DBG_SUBCAT_ALL,
DBG_LVL_TRACE,
("MMCHK - LastOneSecTotalTxCount/LastOneSecRxOkDataCnt = %d/%d\n",
pAd->RalinkCounters.LastOneSecTotalTxCount,
pAd->RalinkCounters.LastOneSecRxOkDataCnt));
pAd->RalinkCounters
.LastOneSecTotalTxCount,
pAd->RalinkCounters
.LastOneSecRxOkDataCnt));
}
}
}
@ -462,7 +556,6 @@ VOID APMlmePeriodicExec(
#endif
}
/*! \brief To substitute the message type if the message is coming from external
* \param *Fr The frame received
* \param *Machine The state machine
@ -471,18 +564,15 @@ VOID APMlmePeriodicExec(
* \pre
* \post
*/
BOOLEAN APMsgTypeSubst(
IN PRTMP_ADAPTER pAd,
IN PFRAME_802_11 pFrame,
OUT INT *Machine,
OUT INT *MsgType)
BOOLEAN APMsgTypeSubst(IN PRTMP_ADAPTER pAd, IN PFRAME_802_11 pFrame,
OUT INT *Machine, OUT INT *MsgType)
{
USHORT Seq;
#ifdef DOT11_SAE_SUPPORT
USHORT Alg;
#endif /* DOT11_SAE_SUPPORT */
UCHAR EAPType;
BOOLEAN Return = FALSE;
UCHAR EAPType;
BOOLEAN Return = FALSE;
#ifdef WSC_AP_SUPPORT
UCHAR EAPCode;
PMAC_TABLE_ENTRY pEntry;
@ -511,10 +601,10 @@ BOOLEAN APMsgTypeSubst(
if (pEntry) {
wdev = &pAd->ApCfg.MBSSID[pEntry->func_tb_idx].wdev;
if (pEntry->bWscCapable
|| IS_AKM_OPEN(wdev->SecConfig.AKMMap)
|| IS_AKM_SHARED(wdev->SecConfig.AKMMap)
|| IS_AKM_AUTOSWITCH(wdev->SecConfig.AKMMap)) {
if (pEntry->bWscCapable ||
IS_AKM_OPEN(wdev->SecConfig.AKMMap) ||
IS_AKM_SHARED(wdev->SecConfig.AKMMap) ||
IS_AKM_AUTOSWITCH(wdev->SecConfig.AKMMap)) {
/*
WSC AP only can service one WSC STA in one WPS session.
Forward this EAP packet to WSC SM if this EAP packets is from
@ -523,14 +613,19 @@ BOOLEAN APMsgTypeSubst(
*/
wsc_ctrl = &wdev->WscControl;
if ((MAC_ADDR_EQUAL(wsc_ctrl->EntryAddr, pEntry->Addr) ||
MAC_ADDR_EQUAL(wsc_ctrl->EntryAddr, ZERO_MAC_ADDR)) &&
IS_ENTRY_CLIENT(pEntry) &&
(wsc_ctrl->WscConfMode != WSC_DISABLE)) {
if ((MAC_ADDR_EQUAL(wsc_ctrl->EntryAddr,
pEntry->Addr) ||
MAC_ADDR_EQUAL(wsc_ctrl->EntryAddr,
ZERO_MAC_ADDR)) &&
IS_ENTRY_CLIENT(pEntry) &&
(wsc_ctrl->WscConfMode != WSC_DISABLE)) {
*Machine = WSC_STATE_MACHINE;
EAPType = *((UCHAR *)pFrame + hdr_len + LENGTH_802_1_H + 1);
EAPCode = *((UCHAR *)pFrame + hdr_len + LENGTH_802_1_H + 4);
Return = WscMsgTypeSubst(EAPType, EAPCode, MsgType);
EAPType = *((UCHAR *)pFrame + hdr_len +
LENGTH_802_1_H + 1);
EAPCode = *((UCHAR *)pFrame + hdr_len +
LENGTH_802_1_H + 4);
Return = WscMsgTypeSubst(
EAPType, EAPCode, MsgType);
}
}
}
@ -539,8 +634,9 @@ BOOLEAN APMsgTypeSubst(
if (!Return) {
*Machine = WPA_STATE_MACHINE;
EAPType = *((UCHAR *)pFrame + hdr_len + LENGTH_802_1_H + 1);
Return = WpaMsgTypeSubst(EAPType, (INT *) MsgType);
EAPType = *((UCHAR *)pFrame + hdr_len + LENGTH_802_1_H +
1);
Return = WpaMsgTypeSubst(EAPType, (INT *)MsgType);
}
return Return;
@ -609,17 +705,20 @@ BOOLEAN APMsgTypeSubst(
if (Seq == 1
#ifdef DOT11_SAE_SUPPORT
|| (Alg == AUTH_MODE_SAE && Seq == 2)
|| (Alg == AUTH_MODE_SAE && Seq == 2)
#endif /* DOT11_SAE_SUPPORT */
)
)
*MsgType = APMT2_PEER_AUTH_REQ;
else if (Seq == 3)
*MsgType = APMT2_PEER_AUTH_CONFIRM;
else {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("wrong AUTH seq=%d Octet=%02x %02x %02x %02x %02x %02x %02x %02x\n",
Seq,
pFrame->Octet[0], pFrame->Octet[1], pFrame->Octet[2], pFrame->Octet[3],
pFrame->Octet[4], pFrame->Octet[5], pFrame->Octet[6], pFrame->Octet[7]));
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("wrong AUTH seq=%d Octet=%02x %02x %02x %02x %02x %02x %02x %02x\n",
Seq, pFrame->Octet[0], pFrame->Octet[1],
pFrame->Octet[2], pFrame->Octet[3],
pFrame->Octet[4], pFrame->Octet[5],
pFrame->Octet[6], pFrame->Octet[7]));
return FALSE;
}
@ -634,10 +733,10 @@ BOOLEAN APMsgTypeSubst(
case SUBTYPE_ACTION_NO_ACK:
*Machine = ACTION_STATE_MACHINE;
/* Sometimes Sta will return with category bytes with MSB = 1, if they receive catogory out of their support */
if ((pFrame->Octet[0]&0x7F) > MAX_PEER_CATE_MSG)
*MsgType = MT2_ACT_INVALID;
else
*MsgType = (pFrame->Octet[0]&0x7F);
if ((pFrame->Octet[0] & 0x7F) > MAX_PEER_CATE_MSG)
*MsgType = MT2_ACT_INVALID;
else
*MsgType = (pFrame->Octet[0] & 0x7F);
break;
@ -648,7 +747,6 @@ BOOLEAN APMsgTypeSubst(
return TRUE;
}
/*
========================================================================
Routine Description:
@ -662,10 +760,9 @@ BOOLEAN APMsgTypeSubst(
========================================================================
*/
VOID APAsicEvaluateRxAnt(
IN PRTMP_ADAPTER pAd)
VOID APAsicEvaluateRxAnt(IN PRTMP_ADAPTER pAd)
{
ULONG TxTotalCnt;
ULONG TxTotalCnt;
#ifdef CONFIG_ATE
if (ATE_ON(pAd))
@ -680,8 +777,8 @@ VOID APAsicEvaluateRxAnt(
#endif /* CARRIER_DETECTION_SUPPORT */
bbp_set_rxpath(pAd, pAd->Antenna.field.RxPath);
TxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
pAd->RalinkCounters.OneSecTxRetryOkCount +
pAd->RalinkCounters.OneSecTxFailCount;
pAd->RalinkCounters.OneSecTxRetryOkCount +
pAd->RalinkCounters.OneSecTxFailCount;
if (TxTotalCnt > 50) {
RTMPSetTimer(&pAd->Mlme.RxAntEvalTimer, 20);
@ -726,7 +823,6 @@ VOID APAsicRxAntEvalTimeout(RTMP_ADAPTER *pAd)
bbp_set_rxpath(pAd, pAd->Mlme.RealRxPath);
}
/*
========================================================================
Routine Description:
@ -740,14 +836,12 @@ VOID APAsicRxAntEvalTimeout(RTMP_ADAPTER *pAd)
========================================================================
*/
VOID APAsicAntennaAvg(
IN PRTMP_ADAPTER pAd,
IN UCHAR AntSelect,
IN SHORT * RssiAvg)
VOID APAsicAntennaAvg(IN PRTMP_ADAPTER pAd, IN UCHAR AntSelect,
IN SHORT *RssiAvg)
{
SHORT realavgrssi;
LONG realavgrssi1;
ULONG recvPktNum = pAd->RxAnt.RcvPktNum[AntSelect];
SHORT realavgrssi;
LONG realavgrssi1;
ULONG recvPktNum = pAd->RxAnt.RcvPktNum[AntSelect];
realavgrssi1 = pAd->RxAnt.Pair1AvgRssiGroup1[AntSelect];
@ -756,7 +850,7 @@ VOID APAsicAntennaAvg(
return;
}
realavgrssi = (SHORT) (realavgrssi1 / recvPktNum);
realavgrssi = (SHORT)(realavgrssi1 / recvPktNum);
pAd->RxAnt.Pair1AvgRssiGroup1[0] = 0;
pAd->RxAnt.Pair1AvgRssiGroup1[1] = 0;
pAd->RxAnt.Pair1AvgRssiGroup2[0] = 0;
@ -765,4 +859,3 @@ VOID APAsicAntennaAvg(
pAd->RxAnt.RcvPktNum[1] = 0;
*RssiAvg = realavgrssi - 256;
}

View File

@ -28,7 +28,9 @@
#include "rt_config.h"
extern VOID write_tmac_info_tim(RTMP_ADAPTER *pAd, INT apidx, UCHAR *tmac_buf, HTTRANSMIT_SETTING *BeaconTransmit, ULONG frmLen);
extern VOID write_tmac_info_tim(RTMP_ADAPTER *pAd, INT apidx, UCHAR *tmac_buf,
HTTRANSMIT_SETTING *BeaconTransmit,
ULONG frmLen);
BOOLEAN TimTransmitRequired(RTMP_ADAPTER *pAd, INT apidx, BSS_STRUCT *pMbss)
{
@ -47,10 +49,7 @@ BOOLEAN TimTransmitRequired(RTMP_ADAPTER *pAd, INT apidx, BSS_STRUCT *pMbss)
}
#ifdef MT_MAC
VOID MtUpdateTimToAsic(
IN RTMP_ADAPTER *pAd,
IN INT apidx,
IN ULONG FrameLen)
VOID MtUpdateTimToAsic(IN RTMP_ADAPTER *pAd, IN INT apidx, IN ULONG FrameLen)
{
TIM_BUF_STRUC *tim_buf = NULL;
UCHAR *buf;
@ -60,12 +59,14 @@ VOID MtUpdateTimToAsic(
struct wifi_dev *wdev = &pAd->ApCfg.MBSSID[apidx].wdev;
struct _RTMP_CHIP_CAP *cap = hc_get_chip_cap(pAd->hdev_ctrl);
IF_DEV_CONFIG_OPMODE_ON_AP(pAd) {
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
tim_buf = &wdev->bcn_buf.tim_buf;
}
if (!tim_buf) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s(): bcn_buf is NULL!\n", __func__));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s(): bcn_buf is NULL!\n", __func__));
return;
}
@ -83,11 +84,13 @@ VOID MtUpdateTimToAsic(
send_mlme_pkt(pAd, pkt, wdev, qIdx, FALSE);
return;
} else
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s(): TimPkt is NULL!\n", __func__));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s(): TimPkt is NULL!\n", __func__));
}
#endif /* MT_MAC */
VOID write_tmac_info_tim(RTMP_ADAPTER *pAd, INT apidx, UCHAR *tmac_buf, HTTRANSMIT_SETTING *BeaconTransmit, ULONG frmLen)
VOID write_tmac_info_tim(RTMP_ADAPTER *pAd, INT apidx, UCHAR *tmac_buf,
HTTRANSMIT_SETTING *BeaconTransmit, ULONG frmLen)
{
MAC_TX_INFO mac_info;
struct wifi_dev *wdev;
@ -134,7 +137,8 @@ VOID write_tmac_info_tim(RTMP_ADAPTER *pAd, INT apidx, UCHAR *tmac_buf, HTTRANSM
mac_info.Preamble = LONG_PREAMBLE;
NdisZeroMemory(tmac_buf, sizeof(TMAC_TXD_L));
#endif
pAd->archOps.write_tmac_info_fixed_rate(pAd, tmac_buf, &mac_info, BeaconTransmit);
pAd->archOps.write_tmac_info_fixed_rate(pAd, tmac_buf, &mac_info,
BeaconTransmit);
}
VOID APMakeBssTimFrame(RTMP_ADAPTER *pAd, INT apidx)
@ -144,12 +148,14 @@ VOID APMakeBssTimFrame(RTMP_ADAPTER *pAd, INT apidx)
LARGE_INTEGER FakeTimestamp;
ULONG FrameLen = 0;
UCHAR *pTimFrame, *ptr, *tmac_info;
HTTRANSMIT_SETTING TimTransmit = {.word = 0}; /* MGMT frame PHY rate setting when operatin at HT rate. */
HTTRANSMIT_SETTING TimTransmit = {
.word = 0
}; /* MGMT frame PHY rate setting when operatin at HT rate. */
struct _RTMP_CHIP_CAP *cap = hc_get_chip_cap(pAd->hdev_ctrl);
UINT8 tx_hw_hdr_len = cap->tx_hw_hdr_len;
UCHAR Cat = 11;/* Tim Category field */
UCHAR Act = 0;/* Tim Action field */
UCHAR ChkBcn = 0;/* Check Beacon field init from 0. */
UCHAR Cat = 11; /* Tim Category field */
UCHAR Act = 0; /* Tim Action field */
UCHAR ChkBcn = 0; /* Check Beacon field init from 0. */
ULONG UpdatePos = 0;
struct wifi_dev *wdev = &pAd->ApCfg.MBSSID[apidx].wdev;
@ -157,25 +163,18 @@ VOID APMakeBssTimFrame(RTMP_ADAPTER *pAd, INT apidx)
return;
if (wdev->bcn_buf.tim_buf.TimPkt == NULL) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s():Invalid TimPkt for MBSS[%d]\n",
__func__, apidx));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s():Invalid TimPkt for MBSS[%d]\n", __func__,
apidx));
return;
}
tmac_info = (UCHAR *)GET_OS_PKT_DATAPTR(wdev->bcn_buf.tim_buf.TimPkt);
pTimFrame = (UCHAR *)(tmac_info + tx_hw_hdr_len);
ActHeaderInit(pAd,
&TimHdr,
BROADCAST_ADDR,
wdev->if_addr,
wdev->bssid);
MakeOutgoingFrame(pTimFrame, &FrameLen,
sizeof(HEADER_802_11), &TimHdr,
1, &Cat,
1, &Act,
1, &ChkBcn,
TIMESTAMP_LEN, &FakeTimestamp,
END_OF_ARGS);
ActHeaderInit(pAd, &TimHdr, BROADCAST_ADDR, wdev->if_addr, wdev->bssid);
MakeOutgoingFrame(pTimFrame, &FrameLen, sizeof(HEADER_802_11), &TimHdr,
1, &Cat, 1, &Act, 1, &ChkBcn, TIMESTAMP_LEN,
&FakeTimestamp, END_OF_ARGS);
TimTransmit.word = 0;
wdev->bcn_buf.TimIELocationInTim = (UCHAR)FrameLen;
UpdatePos = wdev->bcn_buf.TimIELocationInTim;
@ -186,7 +185,7 @@ VOID APMakeBssTimFrame(RTMP_ADAPTER *pAd, INT apidx)
*/
ptr = pTimFrame + (UCHAR)FrameLen;
*ptr = IE_TIM;
*(ptr+1) = 0x0e;
*(ptr + 1) = 0x0e;
*(ptr + 2) = pAd->ApCfg.DtimCount;
*(ptr + 3) = pAd->ApCfg.DtimPeriod;
*(ptr + 4) = 0xa0;
@ -202,7 +201,7 @@ VOID APMakeBssTimFrame(RTMP_ADAPTER *pAd, INT apidx)
*(ptr + 14) = 0xa0;
*(ptr + 15) = 0xa0;
/* adjust TIM length according to the new TIM */
FrameLen += 16;/* (2 + *(ptr+1)); */
FrameLen += 16; /* (2 + *(ptr+1)); */
/* When Beacon is use CCK to send, high rate TIM shall use OFDM to send. and it's mandatory. */
if (wdev->channel <= 14) {
@ -214,16 +213,17 @@ VOID APMakeBssTimFrame(RTMP_ADAPTER *pAd, INT apidx)
}
write_tmac_info_tim(pAd, apidx, tmac_info, &TimTransmit, FrameLen);
#ifdef BCN_V2_SUPPORT /* add bcn v2 support , 1.5k beacon support */
#ifdef BCN_V2_SUPPORT /* add bcn v2 support , 1.5k beacon support */
AsicUpdateBeacon(pAd, wdev, FrameLen, PKT_V2_TIM);
#else
AsicUpdateBeacon(pAd, wdev, FrameLen, PKT_TIM);
#endif
if (0) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s(): Dump the TimFrame of BSS%d!\n",
__func__, apidx));
hex_dump("Initial TimFrameBuf", tmac_info, FrameLen + tx_hw_hdr_len);
("%s(): Dump the TimFrame of BSS%d!\n", __func__,
apidx));
hex_dump("Initial TimFrameBuf", tmac_info,
FrameLen + tx_hw_hdr_len);
}
}
@ -261,16 +261,17 @@ INT wdev_tim_buf_init(RTMP_ADAPTER *pAd, TIM_BUF_STRUC *tim_info)
/* tim_info->TimBufIdx = HW_BEACON_MAX_NUM; */
if (!tim_info->TimPkt) {
ret = RTMPAllocateNdisPacket(pAd, &tim_info->TimPkt, NULL, 0, NULL, MAX_TIM_SIZE);
ret = RTMPAllocateNdisPacket(pAd, &tim_info->TimPkt, NULL, 0,
NULL, MAX_TIM_SIZE);
if (ret != NDIS_STATUS_SUCCESS)
return FALSE;
} else {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s():TimPkt is allocated!\n", __func__));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s():TimPkt is allocated!\n", __func__));
}
tim_info->bTimSntReq = TRUE;
return TRUE;
}
#endif /* MT_MAC */

View File

@ -30,7 +30,6 @@
#ifdef AP_QLOAD_SUPPORT
struct GNU_PACKED _ELM_QBSS_LOAD {
UINT8 ElementId;
UINT8 Length;
@ -51,11 +50,10 @@ struct GNU_PACKED _ELM_QBSS_LOAD {
likely to accept future admission control requests, but it does not
represent a guarantee that the HC will admit these requests. */
UINT16 AvalAdmCap;
};
#define ELM_QBSS_LOAD_ID 11
#define ELM_QBSS_LOAD_LEN 5
#define ELM_QBSS_LOAD_ID 11
#define ELM_QBSS_LOAD_LEN 5
/*
We will send a alarm when channel busy time (primary or secondary) >=
@ -66,28 +64,21 @@ struct GNU_PACKED _ELM_QBSS_LOAD {
If you want to enable it, use command
"iwpriv ra0 set qloadalarmtimethres=90"
*/
#define QBSS_LOAD_ALRAM_BUSY_TIME_THRESHOLD 0 /* unit: % */
#define QBSS_LOAD_ALRAM_BUSY_NUM_THRESHOLD 10 /* unit: 1 */
#define QBSS_LOAD_ALRAM_BUSY_TIME_THRESHOLD 0 /* unit: % */
#define QBSS_LOAD_ALRAM_BUSY_NUM_THRESHOLD 10 /* unit: 1 */
/* a alarm will not re-issued until QBSS_LOAD_ALARM_DURATION * TBTT */
#define QBSS_LOAD_ALARM_DURATION 100 /* unit: TBTT */
#define QBSS_LOAD_ALARM_DURATION 100 /* unit: TBTT */
static VOID QBSS_LoadAlarmSuspend(
IN RTMP_ADAPTER * pAd);
static VOID QBSS_LoadAlarmSuspend(IN RTMP_ADAPTER *pAd);
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
/* handle a alarm */
static VOID QBSS_LoadAlarm(
IN RTMP_ADAPTER * pAd);
static VOID QBSS_LoadAlarmBusyTimeThresholdReset(
IN RTMP_ADAPTER * pAd,
IN UINT32 TimePeriod);
static VOID QBSS_LoadAlarm(IN RTMP_ADAPTER *pAd);
static VOID QBSS_LoadAlarmBusyTimeThresholdReset(IN RTMP_ADAPTER *pAd,
IN UINT32 TimePeriod);
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
/* --------------------------------- Private -------------------------------- */
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
@ -110,8 +101,7 @@ Note:
2. Change channel to the clear channel.
========================================================================
*/
static VOID QBSS_LoadAlarm(
IN RTMP_ADAPTER * pAd)
static VOID QBSS_LoadAlarm(IN RTMP_ADAPTER *pAd)
{
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
#ifdef DOT11_N_SUPPORT
@ -134,19 +124,21 @@ static VOID QBSS_LoadAlarm(
op_ext_cha = wlan_operate_get_ext_cha(wdev);
op_ht_bw = wlan_operate_get_ht_bw(wdev);
if ((op_ext_cha != 0) &&
(op_ht_bw != HT_BW_20)) {
if ((op_ext_cha != 0) && (op_ht_bw != HT_BW_20)) {
MAC_TABLE *pMacTable;
UINT32 StaId;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("qbss> Alarm! Change to 20 bw...\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("qbss> Alarm! Change to 20 bw...\n"));
/* disassociate stations without D3 2040Coexistence function */
pMacTable = &pAd->MacTab;
/*TODO: Carter, check StaId why start from 1.*/
for (StaId = 1; VALID_UCAST_ENTRY_WCID(pAd, StaId); StaId++) {
MAC_TABLE_ENTRY *pEntry = &pMacTable->Content[StaId];
for (StaId = 1; VALID_UCAST_ENTRY_WCID(pAd, StaId);
StaId++) {
MAC_TABLE_ENTRY *pEntry =
&pMacTable->Content[StaId];
BOOLEAN bDisconnectSta = FALSE;
if (!IS_ENTRY_CLIENT(pEntry))
@ -160,7 +152,9 @@ static VOID QBSS_LoadAlarm(
if (bDisconnectSta) {
/* send wireless event - for ageout */
RTMPSendWirelessEvent(pAd, IW_AGEOUT_EVENT_FLAG, pEntry->Addr, 0, 0);
RTMPSendWirelessEvent(
pAd, IW_AGEOUT_EVENT_FLAG,
pEntry->Addr, 0, 0);
{
PUCHAR pOutBuffer = NULL;
NDIS_STATUS NStatus;
@ -168,28 +162,54 @@ static VOID QBSS_LoadAlarm(
HEADER_802_11 DeAuthHdr;
USHORT Reason;
/* send out a DISASSOC request frame */
NStatus = MlmeAllocateMemory(pAd, &pOutBuffer);
NStatus = MlmeAllocateMemory(
pAd, &pOutBuffer);
if (NStatus != NDIS_STATUS_SUCCESS) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, (" MlmeAllocateMemory fail ..\n"));
if (NStatus !=
NDIS_STATUS_SUCCESS) {
MTWF_LOG(
DBG_CAT_AP,
DBG_SUBCAT_ALL,
DBG_LVL_TRACE,
(" MlmeAllocateMemory fail ..\n"));
/*NdisReleaseSpinLock(&pAd->MacTabLock); */
continue;
}
Reason = REASON_DEAUTH_STA_LEAVING;
MgtMacHeaderInit(pAd, &DeAuthHdr, SUBTYPE_DEAUTH, 0,
pEntry->Addr,
pAd->ApCfg.MBSSID[pEntry->func_tb_idx].wdev.if_addr,
pAd->ApCfg.MBSSID[pEntry->func_tb_idx].wdev.bssid);
MakeOutgoingFrame(pOutBuffer, &FrameLen,
sizeof(HEADER_802_11), &DeAuthHdr,
2, &Reason,
END_OF_ARGS);
MiniportMMRequest(pAd, 0, pOutBuffer, FrameLen);
Reason =
REASON_DEAUTH_STA_LEAVING;
MgtMacHeaderInit(
pAd, &DeAuthHdr,
SUBTYPE_DEAUTH, 0,
pEntry->Addr,
pAd->ApCfg
.MBSSID[pEntry->func_tb_idx]
.wdev.if_addr,
pAd->ApCfg
.MBSSID[pEntry->func_tb_idx]
.wdev.bssid);
MakeOutgoingFrame(
pOutBuffer, &FrameLen,
sizeof(HEADER_802_11),
&DeAuthHdr, 2, &Reason,
END_OF_ARGS);
MiniportMMRequest(pAd, 0,
pOutBuffer,
FrameLen);
MlmeFreeMemory(pOutBuffer);
}
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("qbss> Alarm! Deauth the station %02x:%02x:%02x:%02x:%02x:%02x\n",
PRINT_MAC(pEntry->Addr)));
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL,
DBG_LVL_TRACE,
("qbss> Alarm! Deauth the station %02x:%02x:%02x:%02x:%02x:%02x\n",
PRINT_MAC(pEntry->Addr)));
#ifdef MAP_R2
if (IS_MAP_ENABLE(pAd) &&
IS_MAP_R2_ENABLE(pAd))
wapp_handle_sta_disassoc(
pAd, pEntry->wcid,
REASON_DEAUTH_STA_LEAVING);
#endif
mac_entry_delete(pAd, pEntry);
continue;
}
@ -205,14 +225,15 @@ static VOID QBSS_LoadAlarm(
#endif /* DOT11_N_SUPPORT */
{
/* we are in 20MHz bandwidth so try to switch channel */
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("qbss> Alarm! Switch channel...\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("qbss> Alarm! Switch channel...\n"));
/* send command to switch channel */
RTEnqueueInternalCmd(pAd, CMDTHREAD_CHAN_RESCAN, (VOID *)&i, sizeof(UCHAR));
RTEnqueueInternalCmd(pAd, CMDTHREAD_CHAN_RESCAN,
(VOID *)&i, sizeof(UCHAR));
}
}
}
/*
========================================================================
Routine Description:
@ -229,20 +250,20 @@ Note:
EX: TBTT=100ms, 90%, pAd->QloadBusyTimeThreshold = 90ms
========================================================================
*/
static VOID QBSS_LoadAlarmBusyTimeThresholdReset(
IN RTMP_ADAPTER * pAd,
IN UINT32 TimePeriod)
static VOID QBSS_LoadAlarmBusyTimeThresholdReset(IN RTMP_ADAPTER *pAd,
IN UINT32 TimePeriod)
{
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
pQloadCtrl->QloadBusyTimeThreshold = TimePeriod;
pQloadCtrl->QloadBusyTimeThreshold *= pQloadCtrl->QloadAlarmBusyTimeThreshold;
pQloadCtrl->QloadBusyTimeThreshold *=
pQloadCtrl->QloadAlarmBusyTimeThreshold;
pQloadCtrl->QloadBusyTimeThreshold /= 100;
pQloadCtrl->QloadBusyTimeThreshold <<= 10; /* translate mini-sec to micro-sec */
pQloadCtrl->QloadBusyTimeThreshold <<=
10; /* translate mini-sec to micro-sec */
}
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
/*
========================================================================
Routine Description:
@ -267,13 +288,14 @@ VOID QBSS_LoadInit(RTMP_ADAPTER *pAd)
for (IdBss = 0; IdBss < pAd->ApCfg.BssidNum; IdBss++) {
if ((pAd->ApCfg.MBSSID[IdBss].wdev.bWmmCapable)
#ifdef DOT11K_RRM_SUPPORT
|| (IS_RRM_ENABLE(&pAd->ApCfg.MBSSID[IdBss].wdev))
|| (IS_RRM_ENABLE(&pAd->ApCfg.MBSSID[IdBss].wdev))
#endif /* DOT11K_RRM_SUPPORT */
) {
) {
if (pAd->ApCfg.MBSSID[IdBss].wdev.channel > 14)
pQloadCtrl = HcGetQloadCtrlByRf(pAd, RFIC_5GHZ);
else
pQloadCtrl = HcGetQloadCtrlByRf(pAd, RFIC_24GHZ);
pQloadCtrl =
HcGetQloadCtrlByRf(pAd, RFIC_24GHZ);
if (!pQloadCtrl)
continue;
if (pQloadCtrl->FlgQloadEnable)
@ -287,28 +309,30 @@ VOID QBSS_LoadInit(RTMP_ADAPTER *pAd)
AsicSetChBusyStat(pAd, pQloadCtrl->FlgQloadEnable);
pQloadCtrl->QloadChanUtilTotal = 0;
pQloadCtrl->QloadChanUtilTotalCcaNavTx = 0;
pQloadCtrl->QloadUpTimeLast = 0;
#ifdef QLOAD_FUNC_BUSY_TIME_STATS
/* clear busy time statistics */
NdisZeroMemory(pQloadCtrl->QloadBusyCountPri, sizeof(pQloadCtrl->QloadBusyCountPri));
NdisZeroMemory(pQloadCtrl->QloadBusyCountSec, sizeof(pQloadCtrl->QloadBusyCountSec));
NdisZeroMemory(pQloadCtrl->QloadBusyCountPri,
sizeof(pQloadCtrl->QloadBusyCountPri));
NdisZeroMemory(pQloadCtrl->QloadBusyCountSec,
sizeof(pQloadCtrl->QloadBusyCountSec));
#endif /* QLOAD_FUNC_BUSY_TIME_STATS */
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
/* init threshold before QBSS_LoadAlarmReset */
pQloadCtrl->QloadAlarmBusyTimeThreshold = QBSS_LOAD_ALRAM_BUSY_TIME_THRESHOLD;
pQloadCtrl->QloadAlarmBusyNumThreshold = QBSS_LOAD_ALRAM_BUSY_NUM_THRESHOLD;
pQloadCtrl->QloadAlarmBusyTimeThreshold =
QBSS_LOAD_ALRAM_BUSY_TIME_THRESHOLD;
pQloadCtrl->QloadAlarmBusyNumThreshold =
QBSS_LOAD_ALRAM_BUSY_NUM_THRESHOLD;
QBSS_LoadAlarmReset(pAd);
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
}
}
}
/*
========================================================================
Routine Description:
@ -323,8 +347,7 @@ Return Value:
Note:
========================================================================
*/
VOID QBSS_LoadAlarmReset(
IN RTMP_ADAPTER *pAd)
VOID QBSS_LoadAlarmReset(IN RTMP_ADAPTER *pAd)
{
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
@ -337,7 +360,6 @@ VOID QBSS_LoadAlarmReset(
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
}
/*
========================================================================
Routine Description:
@ -352,8 +374,7 @@ Return Value:
Note:
========================================================================
*/
VOID QBSS_LoadAlarmResume(
IN RTMP_ADAPTER *pAd)
VOID QBSS_LoadAlarmResume(IN RTMP_ADAPTER *pAd)
{
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
@ -362,7 +383,6 @@ VOID QBSS_LoadAlarmResume(
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
}
/*
========================================================================
Routine Description:
@ -377,8 +397,7 @@ Return Value:
Note:
========================================================================
*/
static VOID QBSS_LoadAlarmSuspend(
IN RTMP_ADAPTER *pAd)
static VOID QBSS_LoadAlarmSuspend(IN RTMP_ADAPTER *pAd)
{
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
@ -387,7 +406,6 @@ static VOID QBSS_LoadAlarmSuspend(
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
}
/*
========================================================================
Routine Description:
@ -402,18 +420,17 @@ Return Value:
Note:
========================================================================
*/
UINT32 QBSS_LoadBusyTimeGet(
IN RTMP_ADAPTER *pAd)
UINT32 QBSS_LoadBusyTimeGet(IN RTMP_ADAPTER *pAd)
{
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
if (pQloadCtrl->QloadChanUtilBeaconCnt == 0)
return pQloadCtrl->QloadChanUtilTotal;
return (pQloadCtrl->QloadChanUtilTotal / pQloadCtrl->QloadChanUtilBeaconCnt);
return (pQloadCtrl->QloadChanUtilTotal /
pQloadCtrl->QloadChanUtilBeaconCnt);
}
/*
========================================================================
Routine Description:
@ -430,8 +447,7 @@ Note:
We will clear the alarm in the function.
========================================================================
*/
BOOLEAN QBSS_LoadIsAlarmIssued(
IN RTMP_ADAPTER *pAd)
BOOLEAN QBSS_LoadIsAlarmIssued(IN RTMP_ADAPTER *pAd)
{
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
@ -444,7 +460,6 @@ BOOLEAN QBSS_LoadIsAlarmIssued(
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
}
/*
========================================================================
Routine Description:
@ -460,9 +475,7 @@ Return Value:
Note:
========================================================================
*/
BOOLEAN QBSS_LoadIsBusyTimeAccepted(
IN RTMP_ADAPTER *pAd,
IN UINT32 BusyTime)
BOOLEAN QBSS_LoadIsBusyTimeAccepted(IN RTMP_ADAPTER *pAd, IN UINT32 BusyTime)
{
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
@ -478,10 +491,8 @@ BOOLEAN QBSS_LoadIsBusyTimeAccepted(
}
#ifdef CONFIG_HOTSPOT_R2
UINT32 QBSS_LoadElementAppend_HSTEST(
IN RTMP_ADAPTER *pAd,
OUT UINT8 *pBeaconBuf,
IN UCHAR apidx)
UINT32 QBSS_LoadElementAppend_HSTEST(IN RTMP_ADAPTER *pAd,
OUT UINT8 *pBeaconBuf, IN UCHAR apidx)
{
struct _ELM_QBSS_LOAD load, *pLoad = &load;
ULONG ElmLen;
@ -495,14 +506,14 @@ UINT32 QBSS_LoadElementAppend_HSTEST(
/* init */
pLoad->ElementId = ELM_QBSS_LOAD_ID;
pLoad->Length = ELM_QBSS_LOAD_LEN;
pLoad->StationCount = le2cpu16(pAd->ApCfg.MBSSID[apidx].HotSpotCtrl.QLoadStaCnt);
pLoad->StationCount =
le2cpu16(pAd->ApCfg.MBSSID[apidx].HotSpotCtrl.QLoadStaCnt);
pLoad->ChanUtil = pAd->ApCfg.MBSSID[apidx].HotSpotCtrl.QLoadCU;
/* because no ACM is supported, the available bandwidth is 1 sec */
pLoad->AvalAdmCap = le2cpu16(0xffff); /* 0x7a12 * 32us = 1 second */
/* copy the element to the frame */
MakeOutgoingFrame(pBeaconBuf, &ElmLen,
sizeof(struct _ELM_QBSS_LOAD), pLoad,
END_OF_ARGS);
MakeOutgoingFrame(pBeaconBuf, &ElmLen, sizeof(struct _ELM_QBSS_LOAD),
pLoad, END_OF_ARGS);
return ElmLen;
} /* End of QBSS_LoadElementAppend */
#endif
@ -524,7 +535,8 @@ Note:
function is using.
========================================================================
*/
UINT32 QBSS_LoadElementAppend(RTMP_ADAPTER *pAd, UINT8 *pBeaconBuf, QLOAD_CTRL *pQloadCtrl)
UINT32 QBSS_LoadElementAppend(RTMP_ADAPTER *pAd, UINT8 *pBeaconBuf,
QLOAD_CTRL *pQloadCtrl, UCHAR apidx)
{
struct _ELM_QBSS_LOAD load, *pLoad = &load;
ULONG ElmLen;
@ -536,18 +548,16 @@ UINT32 QBSS_LoadElementAppend(RTMP_ADAPTER *pAd, UINT8 *pBeaconBuf, QLOAD_CTRL *
/* init */
pLoad->ElementId = ELM_QBSS_LOAD_ID;
pLoad->Length = ELM_QBSS_LOAD_LEN;
pLoad->StationCount = le2cpu16(MacTableAssocStaNumGet(pAd));
pLoad->ChanUtil = pQloadCtrl->QloadChanUtil;
pLoad->StationCount = le2cpu16(pAd->ApCfg.MBSSID[apidx].StaCount);
pLoad->ChanUtil = pQloadCtrl->QloadChanUtilCcaNavTx;
/* because no ACM is supported, the available bandwidth is 1 sec */
pLoad->AvalAdmCap = le2cpu16(0x7a12); /* 0x7a12 * 32us = 1 second */
/* copy the element to the frame */
MakeOutgoingFrame(pBeaconBuf, &ElmLen,
sizeof(struct _ELM_QBSS_LOAD), pLoad,
END_OF_ARGS);
MakeOutgoingFrame(pBeaconBuf, &ElmLen, sizeof(struct _ELM_QBSS_LOAD),
pLoad, END_OF_ARGS);
return ElmLen;
}
/*
========================================================================
Routine Description:
@ -571,35 +581,38 @@ Note:
recalculate the time period.
========================================================================
*/
VOID QBSS_LoadUpdate(
IN RTMP_ADAPTER *pAd,
IN ULONG UpTime)
VOID QBSS_LoadUpdate(IN RTMP_ADAPTER *pAd, IN ULONG UpTime)
{
UINT32 ChanUtilNu, ChanUtilDe;
UINT32 ChanUtilNu, ChanUtilNuCcaNavTx, ChanUtilDe;
UINT32 BusyTime = 0;
UINT32 BusyTimeCcaNavTx = 0;
UINT32 BusyTimeId;
UINT32 TimePeriod = pAd->CommonCfg.BeaconPeriod;
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
BOOLEAN FlgIsBusyOverThreshold = FALSE;
BOOLEAN FlgIsAlarmNeeded = FALSE;
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
#ifdef OCE_SUPPORT
BOOLEAN SameChanUtil = TRUE;
#endif /* OCE_SUPPORT */
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
UINT8 UpdateBands = 1, i = 0;
#ifdef ACS_CTCC_SUPPORT
#if defined(ACS_CTCC_SUPPORT) || defined(OCE_SUPPORT)
struct wifi_dev *wdev = NULL;
UCHAR band_idx = 0;
AUTO_CH_CTRL *auto_ch_ctrl = NULL;
wdev = &pAd->ApCfg.MBSSID[MAIN_MBSSID].wdev;
band_idx = HcGetBandByWdev(wdev);
auto_ch_ctrl = HcGetAutoChCtrlbyBandIdx(pAd, band_idx);
#endif
#endif /* ACS_CTCC_SUPPORT OCE_SUPPORT*/
UpdateBands = (pAd->CommonCfg.dbdc_mode == 0)?1:2;
UpdateBands = (pAd->CommonCfg.dbdc_mode == 0) ? 1 : 2;
for (i = 0; i < UpdateBands; i++) {
if (pAd->CommonCfg.dbdc_mode != 0) {
UCHAR PhyMode = HcGetRadioPhyModeByBandIdx(pAd, i);
UINT32 RfIC = (WMODE_CAP_5G(PhyMode)) ? RFIC_5GHZ : RFIC_24GHZ;
UINT32 RfIC = (WMODE_CAP_5G(PhyMode)) ? RFIC_5GHZ :
RFIC_24GHZ;
pQloadCtrl = HcGetQloadCtrlByRf(pAd, RfIC);
if (!pQloadCtrl)
continue;
@ -607,22 +620,23 @@ VOID QBSS_LoadUpdate(
/* check whether channel busy time calculation is enabled */
if ((pQloadCtrl->FlgQloadEnable == 0) ||
(pQloadCtrl->FlgQloadAlarmIsSuspended == TRUE))
(pQloadCtrl->FlgQloadAlarmIsSuspended == TRUE))
continue;
/* calculate new time period if needed */
if ((UpTime > 0) &&
(pQloadCtrl->QloadUpTimeLast > 0) &&
(UpTime > pQloadCtrl->QloadUpTimeLast)) {
if ((UpTime > 0) && (pQloadCtrl->QloadUpTimeLast > 0) &&
(UpTime > pQloadCtrl->QloadUpTimeLast)) {
/* re-calculate time period */
TimePeriod = (UINT32)(UpTime - pQloadCtrl->QloadUpTimeLast);
TimePeriod =
(UINT32)(UpTime - pQloadCtrl->QloadUpTimeLast);
/* translate to mini-second */
TimePeriod = (TimePeriod*1000)/OS_HZ;
TimePeriod = (TimePeriod * 1000) / OS_HZ;
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
/* re-calculate QloadBusyTimeThreshold */
if (TimePeriod != pQloadCtrl->QloadTimePeriodLast)
QBSS_LoadAlarmBusyTimeThresholdReset(pAd, TimePeriod);
QBSS_LoadAlarmBusyTimeThresholdReset(
pAd, TimePeriod);
pQloadCtrl->QloadTimePeriodLast = TimePeriod;
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
@ -635,25 +649,33 @@ VOID QBSS_LoadUpdate(
{
struct freq_oper oper;
if (hc_radio_query_by_index(pAd, i, &oper) != HC_STATUS_OK)
if (hc_radio_query_by_index(pAd, i, &oper) !=
HC_STATUS_OK)
continue;
if ((oper.ext_cha != 0) &&
(oper.ht_bw != 0)
if ((oper.ext_cha != 0) && (oper.ht_bw != 0)
#ifdef OFFCHANNEL_SCAN_FEATURE
&& (!ApScanRunning(pAd, NULL)) && (pAd->ScanCtrl.state == OFFCHANNEL_SCAN_INVALID)
&& (!ApScanRunning(pAd, NULL)) &&
(pAd->ScanCtrl.state == OFFCHANNEL_SCAN_INVALID)
#endif
) {
) {
/* in 20MHz, no need to check busy time of secondary channel */
#ifdef ACS_CTCC_SUPPORT
if (auto_ch_ctrl->AutoChSelCtrl.AutoChScanStatMachine.CurrState == AUTO_CH_SEL_SCAN_IDLE)
if (auto_ch_ctrl->AutoChSelCtrl
.AutoChScanStatMachine.CurrState ==
AUTO_CH_SEL_SCAN_IDLE)
#endif
BusyTime = AsicGetChBusyCnt(pAd, 1);
pQloadCtrl->QloadLatestChannelBusyTimeSec = BusyTime;
BusyTimeCcaNavTx =
AsicGetChBusyCnt(pAd, 1);
pQloadCtrl->QloadLatestChannelBusyTimeSec =
BusyTime;
#ifdef QLOAD_FUNC_BUSY_TIME_STATS
BusyTimeId = BusyTime >> 10; /* translate us to ms */
BusyTimeId = BusyTimeCcaNavTx >>
10; /* translate us to ms */
/* ex:95ms, 95*20/100 = 19 */
BusyTimeId = (BusyTimeId*QLOAD_BUSY_INTERVALS)/TimePeriod;
BusyTimeId =
(BusyTimeId * QLOAD_BUSY_INTERVALS) /
TimePeriod;
if (BusyTimeId >= QLOAD_BUSY_INTERVALS)
BusyTimeId = QLOAD_BUSY_INTERVALS - 1;
@ -662,11 +684,15 @@ VOID QBSS_LoadUpdate(
#endif /* QLOAD_FUNC_BUSY_TIME_STATS */
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
if ((pQloadCtrl->FlgQloadAlarmIsSuspended == FALSE) &&
(pQloadCtrl->QloadAlarmBusyTimeThreshold > 0)) {
if ((pQloadCtrl->FlgQloadAlarmIsSuspended ==
FALSE) &&
(pQloadCtrl->QloadAlarmBusyTimeThreshold >
0)) {
/* Alarm is not suspended and is enabled */
if ((pQloadCtrl->QloadBusyTimeThreshold != 0) &&
(BusyTime >= pQloadCtrl->QloadBusyTimeThreshold))
if ((pQloadCtrl->QloadBusyTimeThreshold !=
0) &&
(BusyTimeCcaNavTx >=
pQloadCtrl->QloadBusyTimeThreshold))
FlgIsBusyOverThreshold = TRUE;
}
@ -679,11 +705,14 @@ VOID QBSS_LoadUpdate(
/* BusyTime = AsicGetChBusyCnt(pAd, 0); */
/* update BusyTime from OneSecMibBucket[i] */
BusyTime = pAd->OneSecMibBucket.ChannelBusyTime[i];
if (i < DBDC_BAND_NUM)
BusyTimeCcaNavTx =
pAd->OneSecMibBucket.ChannelBusyTimeCcaNavTx[i];
pQloadCtrl->QloadLatestChannelBusyTimePri = BusyTime;
#ifdef QLOAD_FUNC_BUSY_TIME_STATS
BusyTimeId = BusyTime >> 10; /* translate us to ms */
BusyTimeId = BusyTimeCcaNavTx >> 10; /* translate us to ms */
/* ex:95ms, 95*20/100 = 19 */
BusyTimeId = (BusyTimeId*QLOAD_BUSY_INTERVALS)/TimePeriod;
BusyTimeId = (BusyTimeId * QLOAD_BUSY_INTERVALS) / TimePeriod;
if (BusyTimeId >= QLOAD_BUSY_INTERVALS)
BusyTimeId = QLOAD_BUSY_INTERVALS - 1;
@ -693,38 +722,62 @@ VOID QBSS_LoadUpdate(
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
if ((pQloadCtrl->FlgQloadAlarmIsSuspended == FALSE) &&
(pQloadCtrl->QloadAlarmBusyTimeThreshold > 0)) {
(pQloadCtrl->QloadAlarmBusyTimeThreshold > 0)) {
/* Alarm is not suspended and is enabled */
if ((pQloadCtrl->QloadBusyTimeThreshold != 0) &&
(BusyTime >= pQloadCtrl->QloadBusyTimeThreshold))
(BusyTimeCcaNavTx >=
pQloadCtrl->QloadBusyTimeThreshold))
FlgIsBusyOverThreshold = TRUE;
}
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
/* accumulate channel busy time for primary channel */
pQloadCtrl->QloadChanUtilTotal += BusyTime;
pQloadCtrl->QloadChanUtilTotalCcaNavTx += BusyTimeCcaNavTx;
/* update new channel utilization for primary channel */
if (++pQloadCtrl->QloadChanUtilBeaconCnt >= pQloadCtrl->QloadChanUtilBeaconInt) {
if (++pQloadCtrl->QloadChanUtilBeaconCnt >=
pQloadCtrl->QloadChanUtilBeaconInt) {
ChanUtilNu = pQloadCtrl->QloadChanUtilTotal;
ChanUtilNu *= 255;
ChanUtilNuCcaNavTx =
pQloadCtrl->QloadChanUtilTotalCcaNavTx;
ChanUtilNuCcaNavTx *= 255;
ChanUtilDe = pQloadCtrl->QloadChanUtilBeaconInt;
ChanUtilDe *= 1000000; /* sec to us */
pQloadCtrl->QloadChanUtil = (UINT8)(ChanUtilNu/ChanUtilDe);
#ifdef OCE_SUPPORT
if (pQloadCtrl->QloadChanUtilCcaNavTx ==
(UINT8)(ChanUtilNuCcaNavTx / ChanUtilDe))
SameChanUtil = TRUE;
else
SameChanUtil = FALSE;
#endif /* OCE_SUPPORT */
pQloadCtrl->QloadChanUtil =
(UINT8)(ChanUtilNu / ChanUtilDe);
pQloadCtrl->QloadChanUtilCcaNavTx =
(UINT8)(ChanUtilNuCcaNavTx / ChanUtilDe);
if ((ChanUtilNu/ChanUtilDe) >= 255)
if ((ChanUtilNu / ChanUtilDe) >= 255)
pQloadCtrl->QloadChanUtil = 255;
if ((ChanUtilNuCcaNavTx / ChanUtilDe) >= 255)
pQloadCtrl->QloadChanUtilCcaNavTx = 255;
/* re-accumulate channel busy time */
pQloadCtrl->QloadChanUtilBeaconCnt = 0;
pQloadCtrl->QloadChanUtilTotal = 0;
pQloadCtrl->QloadChanUtilTotalCcaNavTx = 0;
#ifdef OCE_SUPPORT
if (!SameChanUtil)
UpdateBeaconHandler(pAd, wdev,
BCN_UPDATE_IE_CHG);
#endif /* OCE_SUPPORT */
}
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
/* check if alarm function is enabled */
if ((pQloadCtrl->FlgQloadAlarmIsSuspended == FALSE) &&
(pQloadCtrl->QloadAlarmBusyTimeThreshold > 0)) {
(pQloadCtrl->QloadAlarmBusyTimeThreshold > 0)) {
/* Alarm is not suspended and is enabled */
/* check if we need to issue a alarm */
@ -733,7 +786,9 @@ VOID QBSS_LoadUpdate(
/* last alarm ended so we can check new alarm */
pQloadCtrl->QloadAlarmBusyNum++;
if (pQloadCtrl->QloadAlarmBusyNum >= pQloadCtrl->QloadAlarmBusyNumThreshold) {
if (pQloadCtrl->QloadAlarmBusyNum >=
pQloadCtrl
->QloadAlarmBusyNumThreshold) {
/*
The continued number of busy time >= threshold is larger
than number threshold so issuing a alarm.
@ -750,7 +805,8 @@ VOID QBSS_LoadUpdate(
New alarm occurs so we can not re-issue new alarm during
QBSS_LOAD_ALARM_DURATION * TBTT.
*/
if (++pQloadCtrl->QloadAlarmDuration >= QBSS_LOAD_ALARM_DURATION) {
if (++pQloadCtrl->QloadAlarmDuration >=
QBSS_LOAD_ALARM_DURATION) {
/* can re-issue next alarm */
pQloadCtrl->QloadAlarmDuration = 0;
pQloadCtrl->QloadAlarmBusyNum = 0;
@ -770,7 +826,6 @@ VOID QBSS_LoadUpdate(
}
}
/*
========================================================================
Routine Description:
@ -785,33 +840,35 @@ Return Value:
Note:
========================================================================
*/
VOID QBSS_LoadStatusClear(
IN RTMP_ADAPTER *pAd,
IN UCHAR Channel)
VOID QBSS_LoadStatusClear(IN RTMP_ADAPTER *pAd, IN UCHAR Channel)
{
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
if (pAd->CommonCfg.dbdc_mode == 0)
pQloadCtrl = HcGetQloadCtrl(pAd);
else
pQloadCtrl = (Channel > 14) ? HcGetQloadCtrlByRf(pAd, RFIC_5GHZ) : HcGetQloadCtrlByRf(pAd, RFIC_24GHZ);
pQloadCtrl = (Channel > 14) ?
HcGetQloadCtrlByRf(pAd, RFIC_5GHZ) :
HcGetQloadCtrlByRf(pAd, RFIC_24GHZ);
if (pQloadCtrl) {
#ifdef QLOAD_FUNC_BUSY_TIME_STATS
/* clear busy time statistics */
NdisZeroMemory(pQloadCtrl->QloadBusyCountPri, sizeof(pQloadCtrl->QloadBusyCountPri));
NdisZeroMemory(pQloadCtrl->QloadBusyCountSec, sizeof(pQloadCtrl->QloadBusyCountSec));
/* clear busy time statistics */
NdisZeroMemory(pQloadCtrl->QloadBusyCountPri,
sizeof(pQloadCtrl->QloadBusyCountPri));
NdisZeroMemory(pQloadCtrl->QloadBusyCountSec,
sizeof(pQloadCtrl->QloadBusyCountSec));
#endif /* QLOAD_FUNC_BUSY_TIME_STATS */
#ifdef QLOAD_FUNC_BUSY_TIME_ALARM
/* clear alarm function variables */
pQloadCtrl->QloadChanUtilTotal = 0;
pQloadCtrl->QloadChanUtilTotalCcaNavTx = 0;
pQloadCtrl->FlgQloadAlarm = FALSE;
pQloadCtrl->QloadAlarmBusyNum = 0;
#endif /* QLOAD_FUNC_BUSY_TIME_ALARM */
}
}
/*
========================================================================
Routine Description:
@ -835,32 +892,34 @@ INT Show_QoSLoad_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
QLOAD_CTRL *pQloadCtrl = HcGetQloadCtrl(pAd);
Time = pAd->CommonCfg.BeaconPeriod / QLOAD_BUSY_INTERVALS;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("\n\tPrimary Busy Time\tTimes\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("\n\tPrimary Busy Time\tTimes\n"));
for (BusyTimeId = 0; BusyTimeId < QLOAD_BUSY_INTERVALS; BusyTimeId++) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("\t%dms ~ %dms\t\t%d\n",
BusyTimeId*Time,
(BusyTimeId+1)*Time,
pQloadCtrl->QloadBusyCountPri[BusyTimeId]));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("\t%dms ~ %dms\t\t%d\n", BusyTimeId * Time,
(BusyTimeId + 1) * Time,
pQloadCtrl->QloadBusyCountPri[BusyTimeId]));
}
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("\n\tSecondary Busy Time\tTimes\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("\n\tSecondary Busy Time\tTimes\n"));
for (BusyTimeId = 0; BusyTimeId < QLOAD_BUSY_INTERVALS; BusyTimeId++) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("\t%dms ~ %dms\t\t%d\n",
BusyTimeId*Time,
(BusyTimeId+1)*Time,
pQloadCtrl->QloadBusyCountSec[BusyTimeId]));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("\t%dms ~ %dms\t\t%d\n", BusyTimeId * Time,
(BusyTimeId + 1) * Time,
pQloadCtrl->QloadBusyCountSec[BusyTimeId]));
}
#else
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("\tBusy time statistics is not included into the driver!\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("\tBusy time statistics is not included into the driver!\n"));
#endif /* QLOAD_FUNC_BUSY_TIME_STATS */
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("\n"));
return TRUE;
}
/*
========================================================================
Routine Description:
@ -883,7 +942,6 @@ INT Set_QloadClr_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
return TRUE;
}
/*
========================================================================
Routine Description:
@ -911,7 +969,6 @@ INT Set_QloadAlarmTimeThreshold_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *Arg)
return TRUE;
}
/*
========================================================================
Routine Description:
@ -938,4 +995,3 @@ INT Set_QloadAlarmNumThreshold_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *Arg)
}
#endif /* AP_QLOAD_SUPPORT */

View File

@ -27,4 +27,3 @@
*/
#include "rt_config.h"

View File

@ -36,10 +36,8 @@
#include "rt_os_util.h"
#include "rt_os_net.h"
NET_DEV_STATS *RT28xx_get_wds_ether_stats(PNET_DEV net_dev);
/* Register WDS interface */
VOID RT28xx_WDS_Init(VOID *pAd, PNET_DEV net_dev)
{
@ -51,20 +49,21 @@ VOID RT28xx_WDS_Init(VOID *pAd, PNET_DEV net_dev)
netDevOpHook.xmit = rt28xx_send_packets;
netDevOpHook.ioctl = rt28xx_ioctl;
netDevOpHook.get_stats = RT28xx_get_wds_ether_stats;
NdisMoveMemory(&netDevOpHook.devAddr[0], RTMP_OS_NETDEV_GET_PHYADDR(net_dev), MAC_ADDR_LEN);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("The new WDS interface MAC = %02X:%02X:%02X:%02X:%02X:%02X\n",
PRINT_MAC(netDevOpHook.devAddr)));
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_WDS_INIT,
0, &netDevOpHook, 0);
NdisMoveMemory(&netDevOpHook.devAddr[0],
RTMP_OS_NETDEV_GET_PHYADDR(net_dev), MAC_ADDR_LEN);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("The new WDS interface MAC = %02X:%02X:%02X:%02X:%02X:%02X\n",
PRINT_MAC(netDevOpHook.devAddr)));
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_WDS_INIT, 0,
&netDevOpHook, 0);
}
INT wds_virtual_if_open(PNET_DEV pDev)
{
VOID *pAd;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s: ===> %s\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s: ===> %s\n", RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
pAd = RTMP_OS_NETDEV_GET_PRIV(pDev);
@ -81,13 +80,12 @@ INT wds_virtual_if_open(PNET_DEV pDev)
return 0;
}
INT wds_virtual_if_close(PNET_DEV pDev)
{
VOID *pAd;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s: ===> %s\n",
RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s: ===> %s\n", RTMP_OS_NETDEV_GET_DEVNAME(pDev), __func__));
pAd = RTMP_OS_NETDEV_GET_PRIV(pDev);
/* RTMP_OS_NETDEV_CARRIER_OFF(pDev); */
@ -102,7 +100,6 @@ INT wds_virtual_if_close(PNET_DEV pDev)
return 0;
}
VOID RT28xx_WDS_Remove(VOID *pAd)
{
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_WDS_REMOVE, 0, NULL, 0);

View File

@ -28,7 +28,7 @@
*/
#include "rt_config.h"
extern UCHAR EAPOL[];
extern UCHAR EAPOL[];
/*
==========================================================================
@ -48,7 +48,6 @@ MAC_TABLE_ENTRY *PACInquiry(RTMP_ADAPTER *pAd, UCHAR Wcid)
return pEntry;
}
/*
==========================================================================
Description:
@ -58,7 +57,6 @@ MAC_TABLE_ENTRY *PACInquiry(RTMP_ADAPTER *pAd, UCHAR Wcid)
*/
VOID HandleCounterMeasure(RTMP_ADAPTER *pAd, MAC_TABLE_ENTRY *pEntry)
{
#ifndef RT_CFG80211_SUPPORT
INT i;
#endif
@ -72,12 +70,14 @@ VOID HandleCounterMeasure(RTMP_ADAPTER *pAd, MAC_TABLE_ENTRY *pEntry)
return;
#ifndef RT_CFG80211_SUPPORT
/* if entry not set key done, ignore this RX MIC ERROR */
if ((pEntry->SecConfig.Handshake.WpaState < AS_PTKINITDONE) || (pEntry->SecConfig.Handshake.GTKState != REKEY_ESTABLISHED))
/* if entry not set key done, ignore this RX MIC ERROR */
if ((pEntry->SecConfig.Handshake.WpaState < AS_PTKINITDONE) ||
(pEntry->SecConfig.Handshake.GTKState != REKEY_ESTABLISHED))
return;
#endif
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("HandleCounterMeasure ===>\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("HandleCounterMeasure ===>\n"));
/* record which entry causes this MIC error, if this entry sends disauth/disassoc, AP doesn't need to log the CM */
pEntry->CMTimerRunning = TRUE;
pAd->ApCfg.MICFailureCounter++;
@ -85,23 +85,31 @@ VOID HandleCounterMeasure(RTMP_ADAPTER *pAd, MAC_TABLE_ENTRY *pEntry)
RTMPSendWirelessEvent(pAd, IW_MIC_ERROR_EVENT_FLAG, pEntry->Addr, 0, 0);
#ifdef RT_CFG80211_SUPPORT
{
const UCHAR tsc[6] = {0, 0, 0, 0, 0, 0};
PNET_DEV pNetDev = pAd->ApCfg.MBSSID[pEntry->func_tb_idx].wdev.if_dev;
const UCHAR tsc[6] = { 0, 0, 0, 0, 0, 0 };
PNET_DEV pNetDev =
pAd->ApCfg.MBSSID[pEntry->func_tb_idx].wdev.if_dev;
/* NL80211_KEYTYPE_PAIRWISE = 1, tsc = tsc of frame causing mic failure */
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s:calling cfg event to HandleCounterMeasure\n", __FUNCTION__));
cfg80211_michael_mic_failure(pNetDev, pEntry->Addr, 1, 0, tsc, GFP_KERNEL);
("%s:calling cfg event to HandleCounterMeasure\n",
__FUNCTION__));
cfg80211_michael_mic_failure(pNetDev, pEntry->Addr, 1, 0, tsc,
GFP_KERNEL);
}
#endif
if (pAd->ApCfg.CMTimerRunning == TRUE) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("Receive CM Attack Twice within 60 seconds ====>>>\n"));
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("Receive CM Attack Twice within 60 seconds ====>>>\n"));
/* send wireless event - for counter measures */
RTMPSendWirelessEvent(pAd, IW_COUNTER_MEASURES_EVENT_FLAG, pEntry->Addr, 0, 0);
RTMPSendWirelessEvent(pAd, IW_COUNTER_MEASURES_EVENT_FLAG,
pEntry->Addr, 0, 0);
ApLogEvent(pAd, pEntry->Addr, EVENT_COUNTER_M);
#ifndef RT_CFG80211_SUPPORT
/* renew GTK */
GenRandom(pAd, pAd->ApCfg.MBSSID[pEntry->func_tb_idx].wdev.bssid, pAd->ApCfg.MBSSID[pEntry->func_tb_idx].GNonce);
GenRandom(pAd,
pAd->ApCfg.MBSSID[pEntry->func_tb_idx].wdev.bssid,
pAd->ApCfg.MBSSID[pEntry->func_tb_idx].GNonce);
#endif
/* Cancel CounterMeasure Timer */
RTMPCancelTimer(&pAd->ApCfg.CounterMeasureTimer, &Cancelled);
@ -112,9 +120,17 @@ VOID HandleCounterMeasure(RTMP_ADAPTER *pAd, MAC_TABLE_ENTRY *pEntry)
for (i = 0; VALID_UCAST_ENTRY_WCID(pAd, i); i++) {
struct wifi_dev *wdev = pAd->MacTab.Content[i].wdev;
/* happened twice within 60 sec, AP SENDS disaccociate all associated STAs. All STA's transition to State 2 */
if ((IS_ENTRY_CLIENT(&pAd->MacTab.Content[i])) && wdev != NULL
&& wdev->channel == pEntry->wdev->channel)
MlmeDeAuthAction(pAd, &pAd->MacTab.Content[i], REASON_MIC_FAILURE, FALSE);
if ((IS_ENTRY_CLIENT(&pAd->MacTab.Content[i])) &&
wdev != NULL &&
wdev->channel == pEntry->wdev->channel) {
#ifdef MAP_R2
if (IS_MAP_ENABLE(pAd) && IS_MAP_R2_ENABLE(pAd))
wapp_handle_sta_disassoc(
pAd, i, REASON_MIC_FAILURE);
#endif
MlmeDeAuthAction(pAd, &pAd->MacTab.Content[i],
REASON_MIC_FAILURE, FALSE);
}
}
#endif
@ -128,13 +144,13 @@ VOID HandleCounterMeasure(RTMP_ADAPTER *pAd, MAC_TABLE_ENTRY *pEntry)
/*MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("GKeyDoneStations=%d\n", pAd->ApCfg.MBSSID[pEntry->func_tb_idx].GKeyDoneStations)); */
}
RTMPSetTimer(&pAd->ApCfg.CounterMeasureTimer, 60 * MLME_TASK_EXEC_INTV * MLME_TASK_EXEC_MULTIPLE);
RTMPSetTimer(&pAd->ApCfg.CounterMeasureTimer,
60 * MLME_TASK_EXEC_INTV * MLME_TASK_EXEC_MULTIPLE);
pAd->ApCfg.CMTimerRunning = TRUE;
pAd->ApCfg.PrevaMICFailTime = pAd->ApCfg.aMICFailTime;
RTMP_GetCurrentSystemTime(&pAd->ApCfg.aMICFailTime);
}
/*
==========================================================================
Description:
@ -142,75 +158,72 @@ VOID HandleCounterMeasure(RTMP_ADAPTER *pAd, MAC_TABLE_ENTRY *pEntry)
Return:
==========================================================================
*/
VOID CMTimerExec(
IN PVOID SystemSpecific1,
IN PVOID FunctionContext,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3)
VOID CMTimerExec(IN PVOID SystemSpecific1, IN PVOID FunctionContext,
IN PVOID SystemSpecific2, IN PVOID SystemSpecific3)
{
UINT i, j = 0;
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)FunctionContext;
UINT i, j = 0;
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)FunctionContext;
pAd->ApCfg.BANClass3Data = FALSE;
for (i = 0; VALID_UCAST_ENTRY_WCID(pAd, i); i++) {
if (IS_ENTRY_CLIENT(&pAd->MacTab.Content[i])
&& (pAd->MacTab.Content[i].CMTimerRunning == TRUE)) {
if (IS_ENTRY_CLIENT(&pAd->MacTab.Content[i]) &&
(pAd->MacTab.Content[i].CMTimerRunning == TRUE)) {
pAd->MacTab.Content[i].CMTimerRunning = FALSE;
j++;
}
}
if (j > 1)
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("Find more than one entry which generated MIC Fail ..\n"));
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("Find more than one entry which generated MIC Fail ..\n"));
pAd->ApCfg.CMTimerRunning = FALSE;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("Counter measure timer expired, resume connection access.\n"));
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("Counter measure timer expired, resume connection access.\n"));
}
#ifdef HOSTAPD_SUPPORT
/*for sending an event to notify hostapd about michael failure. */
VOID ieee80211_notify_michael_failure(
IN PRTMP_ADAPTER pAd,
IN PHEADER_802_11 pHeader,
IN UINT keyix,
IN INT report)
VOID ieee80211_notify_michael_failure(IN PRTMP_ADAPTER pAd,
IN PHEADER_802_11 pHeader, IN UINT keyix,
IN INT report)
{
static const char *tag = "MLME-MICHAELMICFAILURE.indication";
/* struct net_device *dev = pAd->net_dev; */
/* union iwreq_data wrqu; */
char buf[128]; /* XXX */
char buf[128]; /* XXX */
/* TODO: needed parameters: count, keyid, key type, src address, TSC */
if (report) { /*station reports a mic error to this ap. */
snprintf(buf, sizeof(buf), "%s(keyid=%d %scast addr=%s)", tag,
keyix, "uni",
ether_sprintf(pHeader->Addr2));
keyix, "uni", ether_sprintf(pHeader->Addr2));
} else { /*ap itself receives a mic error. */
snprintf(buf, sizeof(buf), "%s(keyid=%d %scast addr=%s)", tag,
keyix, IEEE80211_IS_MULTICAST(pHeader->Addr1) ? "broad" : "uni",
ether_sprintf(pHeader->Addr2));
keyix,
IEEE80211_IS_MULTICAST(pHeader->Addr1) ? "broad" :
"uni",
ether_sprintf(pHeader->Addr2));
}
RtmpOSWrielessEventSend(pAd->net_dev, RT_WLAN_EVENT_CUSTOM, -1, NULL, NULL, 0);
RtmpOSWrielessEventSend(pAd->net_dev, RT_WLAN_EVENT_CUSTOM, -1, NULL,
NULL, 0);
/* NdisZeroMemory(&wrqu, sizeof(wrqu)); */
/* wrqu.data.length = strlen(buf); */
/* wireless_send_event(dev, RT_WLAN_EVENT_CUSTOM, &wrqu, buf); */
}
const CHAR *ether_sprintf(const UINT8 *mac)
{
static char etherbuf[18];
snprintf(etherbuf, sizeof(etherbuf), "%02x:%02x:%02x:%02x:%02x:%02x", PRINT_MAC(mac));
snprintf(etherbuf, sizeof(etherbuf), "%02x:%02x:%02x:%02x:%02x:%02x",
PRINT_MAC(mac));
return etherbuf;
}
#endif /* HOSTAPD_SUPPORT */
#ifdef APCLI_SUPPORT
#endif/*APCLI_SUPPORT*/
#endif /*APCLI_SUPPORT*/

View File

@ -32,8 +32,7 @@
extern VOID *p5G_pAd;
extern VOID *p2G_pAd;
INT ApcliLinkMonitorThread(
IN ULONG Context)
INT ApcliLinkMonitorThread(IN ULONG Context)
{
RTMP_ADAPTER *pAd;
RTMP_ADAPTER *pAd_other_band;
@ -46,27 +45,28 @@ INT ApcliLinkMonitorThread(
if (p2G_pAd == NULL) {
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_TRACE,
("##### no 2G pAd!!!\n"));
("##### no 2G pAd!!!\n"));
/* RtmpOSTaskNotifyToExit(pTask); */
/* return 0; */
} else if (p5G_pAd == NULL) {
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_TRACE,
("##### no 5G pAd!!!\n"));
("##### no 5G pAd!!!\n"));
/* RtmpOSTaskNotifyToExit(pTask); */
/* return 0; */
}
if (p5G_pAd == pAd) {
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_TRACE,
("we are 5G interface, wait 2G link update\n"));
("we are 5G interface, wait 2G link update\n"));
pAd_other_band = p2G_pAd;
} else {
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_TRACE,
("we are 2G interface, wait 5G link update\n"));
("we are 2G interface, wait 5G link update\n"));
pAd_other_band = p5G_pAd;
}
while (pTask && !RTMP_OS_TASK_IS_KILLED(pTask) && (pAd_other_band != NULL)) {
while (pTask && !RTMP_OS_TASK_IS_KILLED(pTask) &&
(pAd_other_band != NULL)) {
if (RtmpOSTaskWait(pAd, pTask, &status) == FALSE) {
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS);
break;
@ -93,7 +93,7 @@ INT ApcliLinkMonitorThread(
* of execution immediately upon a complete().
*/
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_TRACE,
("<---ApcliLinkMonitorThread\n"));
("<---ApcliLinkMonitorThread\n"));
/* if (pTask) */
/* RtmpOSTaskNotifyToExit(pTask); */
return 0;
@ -111,15 +111,15 @@ NDIS_STATUS RtmpApcliLinkTaskInit(IN PRTMP_ADAPTER pAd)
if (status == NDIS_STATUS_FAILURE) {
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_TRACE,
("%s: Unable to start ApcliLinkMonitorThread!\n", get_dev_name_prefix(pAd, INT_APCLI)));
("%s: Unable to start ApcliLinkMonitorThread!\n",
get_dev_name_prefix(pAd, INT_APCLI)));
return NDIS_STATUS_FAILURE;
}
return NDIS_STATUS_SUCCESS;
}
VOID RtmpApcliLinkTaskExit(
IN RTMP_ADAPTER *pAd)
VOID RtmpApcliLinkTaskExit(IN RTMP_ADAPTER *pAd)
{
INT ret;
/* Terminate cmdQ thread */
@ -128,9 +128,9 @@ VOID RtmpApcliLinkTaskExit(
ret = RtmpOSTaskKill(&pAd->apcliLinkTask);
if (ret == NDIS_STATUS_FAILURE)
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_ERROR, ("Kill command task fail!\n"));
MTWF_LOG(DBG_CAT_CLIENT, CATCLIENT_APCLI, DBG_LVL_ERROR,
("Kill command task fail!\n"));
}
}
#endif /* APCLI_LINK_COVER_SUPPORT */
#endif /* APCLI_SUPPORT */

View File

@ -30,12 +30,8 @@
#ifdef A4_CONN
#include "rt_config.h"
BOOLEAN a4_interface_init(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN BOOLEAN is_ap,
IN UCHAR a4_type
)
BOOLEAN a4_interface_init(IN PRTMP_ADAPTER adapter, IN UCHAR if_index,
IN BOOLEAN is_ap, IN UCHAR a4_type)
{
BSS_STRUCT *mbss = NULL;
BOOLEAN add_inf = FALSE;
@ -74,18 +70,14 @@ BOOLEAN a4_interface_init(
MtCmdSetA4Enable(adapter, HOST2CR4, TRUE);
adapter->a4_interface_count++;
}
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN, ("a4_interface_init a4_interface_count: %d\n",
adapter->a4_interface_count));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("a4_interface_init a4_interface_count: %d\n",
adapter->a4_interface_count));
return TRUE;
}
BOOLEAN a4_interface_deinit(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN BOOLEAN is_ap,
IN UCHAR a4_type
)
BOOLEAN a4_interface_deinit(IN PRTMP_ADAPTER adapter, IN UCHAR if_index,
IN BOOLEAN is_ap, IN UCHAR a4_type)
{
BSS_STRUCT *mbss = NULL;
PA4_CONNECT_ENTRY a4_entry = NULL, pConnEntryTmp = NULL;
@ -100,17 +92,22 @@ BOOLEAN a4_interface_deinit(
mbss = &adapter->ApCfg.MBSSID[if_index];
if (mbss->a4_init) {
a4_entry_list = &mbss->a4_entry_list;
DlListForEachSafe(a4_entry, pConnEntryTmp, a4_entry_list, A4_CONNECT_ENTRY, List) {
DlListForEachSafe(a4_entry, pConnEntryTmp,
a4_entry_list, A4_CONNECT_ENTRY, List)
{
if (a4_entry) {
entry = &adapter->MacTab.Content[a4_entry->wcid];
a4_ap_peer_disable(adapter, entry, a4_type);
entry = &adapter->MacTab
.Content[a4_entry->wcid];
a4_ap_peer_disable(adapter, entry,
a4_type);
}
}
mbss->a4_init &= ~(1 << a4_type);
if (!mbss->a4_init) {
NdisFreeSpinLock(&mbss->a4_entry_lock);
RoutingTabDestory(adapter, if_index, ROUTING_ENTRY_A4);
RoutingTabDestory(adapter, if_index,
ROUTING_ENTRY_A4);
delete_inf = TRUE;
}
}
@ -137,19 +134,15 @@ BOOLEAN a4_interface_deinit(
adapter->a4_interface_count--;
if (adapter->a4_interface_count == 0)
MtCmdSetA4Enable(adapter, HOST2CR4, FALSE);
}
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN, ("a4_interface_init a4_interface_count: %d\n",
adapter->a4_interface_count));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("a4_interface_init a4_interface_count: %d\n",
adapter->a4_interface_count));
return TRUE;
}
INT a4_get_entry_count(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index
)
INT a4_get_entry_count(IN PRTMP_ADAPTER adapter, IN UCHAR if_index)
{
int count = 0;
BSS_STRUCT *mbss = NULL;
@ -166,12 +159,8 @@ INT a4_get_entry_count(
return count;
}
BOOLEAN a4_lookup_entry_by_wcid(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN UCHAR wcid
)
BOOLEAN a4_lookup_entry_by_wcid(IN PRTMP_ADAPTER adapter, IN UCHAR if_index,
IN UCHAR wcid)
{
BSS_STRUCT *mbss = NULL;
PDL_LIST a4_entry_list = NULL;
@ -183,10 +172,9 @@ BOOLEAN a4_lookup_entry_by_wcid(
mbss = &adapter->ApCfg.MBSSID[if_index];
a4_entry_list = &mbss->a4_entry_list;
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List) {
if (a4_entry &&
a4_entry->valid &&
(a4_entry->wcid == wcid)) {
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List)
{
if (a4_entry && a4_entry->valid && (a4_entry->wcid == wcid)) {
found = TRUE;
break;
}
@ -194,12 +182,8 @@ BOOLEAN a4_lookup_entry_by_wcid(
return found;
}
BOOLEAN a4_lookup_entry_by_addr(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN PUCHAR mac_addr
)
BOOLEAN a4_lookup_entry_by_addr(IN PRTMP_ADAPTER adapter, IN UCHAR if_index,
IN PUCHAR mac_addr)
{
BSS_STRUCT *mbss = NULL;
PDL_LIST a4_entry_list = NULL;
@ -207,13 +191,13 @@ BOOLEAN a4_lookup_entry_by_addr(
PMAC_TABLE_ENTRY entry = NULL;
BOOLEAN found = FALSE;
if ((a4_get_entry_count(adapter, if_index) == 0) ||
(mac_addr == NULL))
if ((a4_get_entry_count(adapter, if_index) == 0) || (mac_addr == NULL))
return FALSE;
mbss = &adapter->ApCfg.MBSSID[if_index];
a4_entry_list = &mbss->a4_entry_list;
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List) {
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List)
{
if (a4_entry && a4_entry->valid && VALID_WCID(a4_entry->wcid)) {
entry = &adapter->MacTab.Content[a4_entry->wcid];
@ -226,12 +210,7 @@ BOOLEAN a4_lookup_entry_by_addr(
return found;
}
VOID a4_add_entry(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN UCHAR wcid
)
VOID a4_add_entry(IN PRTMP_ADAPTER adapter, IN UCHAR if_index, IN UCHAR wcid)
{
BSS_STRUCT *mbss = NULL;
PA4_CONNECT_ENTRY a4_entry = NULL;
@ -251,15 +230,11 @@ VOID a4_add_entry(
RTMP_SEM_UNLOCK(&mbss->a4_entry_lock);
} else
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s: Fail to alloc memory for pNewConnEntry\n", __func__));
("%s: Fail to alloc memory for pNewConnEntry\n",
__func__));
}
VOID a4_delete_entry(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN UCHAR wcid
)
VOID a4_delete_entry(IN PRTMP_ADAPTER adapter, IN UCHAR if_index, IN UCHAR wcid)
{
BSS_STRUCT *mbss = NULL;
PA4_CONNECT_ENTRY a4_entry = NULL;
@ -271,10 +246,9 @@ VOID a4_delete_entry(
mbss = &adapter->ApCfg.MBSSID[if_index];
a4_entry_list = &mbss->a4_entry_list;
RTMP_SEM_LOCK(&mbss->a4_entry_lock);
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List) {
if (a4_entry &&
a4_entry->valid &&
(a4_entry->wcid == wcid)) {
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List)
{
if (a4_entry && a4_entry->valid && (a4_entry->wcid == wcid)) {
DlListDel(&a4_entry->List);
os_free_mem(a4_entry);
break;
@ -283,12 +257,8 @@ VOID a4_delete_entry(
RTMP_SEM_UNLOCK(&mbss->a4_entry_lock);
}
VOID a4_proxy_delete(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN PUCHAR mac_addr
)
VOID a4_proxy_delete(IN PRTMP_ADAPTER adapter, IN UCHAR if_index,
IN PUCHAR mac_addr)
{
if (a4_get_entry_count(adapter, if_index) == 0)
return;
@ -307,7 +277,8 @@ BOOLEAN a4_get_dst_ip(void *pkt, unsigned char *ip)
TypeLen = (pSrcBuf[type_len_idx] << 8) | pSrcBuf[type_len_idx + 1];
while (TypeLen == ETH_TYPE_VLAN) {
type_len_idx += 2;
TypeLen = (pSrcBuf[type_len_idx] << 8) | pSrcBuf[type_len_idx + 1];
TypeLen = (pSrcBuf[type_len_idx] << 8) |
pSrcBuf[type_len_idx + 1];
}
if (TypeLen == ETH_TYPE_IPv4) {
ip_header = &pSrcBuf[type_len_idx + 2];
@ -316,34 +287,24 @@ BOOLEAN a4_get_dst_ip(void *pkt, unsigned char *ip)
}
return FALSE;
}
BOOLEAN a4_proxy_lookup(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN PUCHAR mac_addr,
IN BOOLEAN update_alive_time,
IN BOOLEAN is_rx,
OUT UCHAR *wcid
)
BOOLEAN a4_proxy_lookup(IN PRTMP_ADAPTER adapter, IN UCHAR if_index,
IN PUCHAR mac_addr, IN BOOLEAN update_alive_time,
IN BOOLEAN is_rx, OUT UCHAR *wcid)
{
*wcid = 0;
if (a4_get_entry_count(adapter, if_index) == 0) {
return FALSE;
}
if (RoutingTabLookup(adapter, if_index, mac_addr, update_alive_time, wcid) != NULL)
if (RoutingTabLookup(adapter, if_index, mac_addr, update_alive_time,
wcid) != NULL)
return TRUE;
else {
return FALSE;
}
}
VOID a4_proxy_update(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN UCHAR wcid,
IN PUCHAR mac_addr,
IN UINT32 ip /* ARP Sender IP*/
VOID a4_proxy_update(IN PRTMP_ADAPTER adapter, IN UCHAR if_index, IN UCHAR wcid,
IN PUCHAR mac_addr, IN UINT32 ip /* ARP Sender IP*/
)
{
UCHAR proxy_wcid = 0;
@ -356,14 +317,17 @@ VOID a4_proxy_update(
if (!VALID_WCID(wcid) || !mac_addr)
return;
routing_entry = RoutingTabLookup(adapter, if_index, mac_addr, TRUE, &proxy_wcid);
routing_entry = RoutingTabLookup(adapter, if_index, mac_addr, TRUE,
&proxy_wcid);
found = (routing_entry != NULL) ? TRUE : FALSE;
if (found) {
if (ROUTING_ENTRY_TEST_FLAG(routing_entry, ROUTING_ENTRY_A4)) {
/* Mean the target change to other ProxyAP */
if (proxy_wcid != wcid) {
RoutingTabSetOneFree(adapter, if_index, mac_addr, ROUTING_ENTRY_A4);
RoutingTabSetOneFree(adapter, if_index,
mac_addr,
ROUTING_ENTRY_A4);
routing_entry = NULL;
found = FALSE;
}
@ -379,7 +343,8 @@ VOID a4_proxy_update(
if (routing_entry) {
SET_ROUTING_ENTRY(routing_entry, ROUTING_ENTRY_A4);
RoutingEntrySet(adapter, if_index, wcid, mac_addr, routing_entry);
RoutingEntrySet(adapter, if_index, wcid, mac_addr,
routing_entry);
}
}
@ -387,11 +352,7 @@ VOID a4_proxy_update(
RoutingTabARPLookupUpdate(adapter, if_index, routing_entry, ip);
}
VOID a4_proxy_maintain(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index
)
VOID a4_proxy_maintain(IN PRTMP_ADAPTER adapter, IN UCHAR if_index)
{
if (a4_get_entry_count(adapter, if_index) == 0)
return;
@ -399,12 +360,8 @@ VOID a4_proxy_maintain(
RoutingTabMaintain(adapter, if_index);
}
INT a4_hard_transmit(
IN PRTMP_ADAPTER adapter,
IN struct wifi_dev *wdev,
IN PNDIS_PACKET pkt
)
INT a4_hard_transmit(IN PRTMP_ADAPTER adapter, IN struct wifi_dev *wdev,
IN PNDIS_PACKET pkt)
{
UINT pkt_len;
INT ret = NDIS_STATUS_SUCCESS;
@ -413,7 +370,8 @@ INT a4_hard_transmit(
/* Precautionary measure */
if (RTMP_GET_PACKET_WCID(pkt) == 0) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN, ("invalid wcid=0 in a4_hard_transmit\n"));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("invalid wcid=0 in a4_hard_transmit\n"));
RELEASE_NDIS_PACKET(adapter, pkt, NDIS_STATUS_FAILURE);
return ret;
}
@ -423,9 +381,12 @@ INT a4_hard_transmit(
else {
wcid = RTMP_GET_PACKET_WCID(pkt);
pkt_len = GET_OS_PKT_LEN(pkt);
if ((pkt_len <= 14)
|| (!RTMPCheckEtherType(adapter, pkt, &adapter->MacTab.tr_entry[wcid], wdev))) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN, ("Pkt Len/Ethernet Check Fail\n"));
if ((pkt_len <= 14) ||
(!RTMPCheckEtherType(adapter, pkt,
&adapter->MacTab.tr_entry[wcid],
wdev))) {
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("Pkt Len/Ethernet Check Fail\n"));
RELEASE_NDIS_PACKET(adapter, pkt, NDIS_STATUS_FAILURE);
return ret;
}
@ -434,12 +395,8 @@ INT a4_hard_transmit(
return ret;
}
PNDIS_PACKET a4_clone_packet(
IN PRTMP_ADAPTER adapter,
IN PNET_DEV if_dev,
IN PNDIS_PACKET pkt
)
PNDIS_PACKET a4_clone_packet(IN PRTMP_ADAPTER adapter, IN PNET_DEV if_dev,
IN PNDIS_PACKET pkt)
{
struct sk_buff *skb = NULL;
PNDIS_PACKET pkt_clone = NULL;
@ -454,12 +411,8 @@ PNDIS_PACKET a4_clone_packet(
return pkt_clone;
}
void a4_send_clone_pkt(
IN PRTMP_ADAPTER adapter,
IN UCHAR if_index,
IN PNDIS_PACKET pkt,
IN PUCHAR exclude_mac_addr
)
void a4_send_clone_pkt(IN PRTMP_ADAPTER adapter, IN UCHAR if_index,
IN PNDIS_PACKET pkt, IN PUCHAR exclude_mac_addr)
{
struct wifi_dev *wdev = NULL;
PNDIS_PACKET pkt_clone = NULL;
@ -467,6 +420,9 @@ void a4_send_clone_pkt(
PA4_CONNECT_ENTRY a4_entry = NULL;
PROUTING_ENTRY routing_entry = NULL;
PMAC_TABLE_ENTRY entry = NULL;
#ifdef MAP_TS_TRAFFIC_SUPPORT
PMAC_TABLE_ENTRY peer_entry = NULL;
#endif
BOOLEAN found = FALSE;
UCHAR wcid = 0;
struct wifi_dev *ap_wdev = NULL;
@ -478,58 +434,87 @@ void a4_send_clone_pkt(
ap_wdev = &adapter->ApCfg.MBSSID[if_index].wdev;
#if (defined(IGMP_SNOOP_SUPPORT) && defined(IGMP_TX_QUERY_HOLD))
if (ap_wdev->IgmpSnoopEnable) { /* If snooping enabled*/
UCHAR *pDestAddr = NULL;
if (ap_wdev->IgmpSnoopEnable) { /* If snooping enabled*/
UCHAR *pDestAddr = NULL;
pDestAddr = GET_OS_PKT_DATAPTR(pPacket);
pDestAddr = GET_OS_PKT_DATAPTR(pPacket);
if (IS_MULTICAST_MAC_ADDR(pDestAddr)) {
PUCHAR pData = pDestAddr + 12;
UINT16 protoType = OS_NTOHS(*((UINT16 *)(pData)));
if (IS_MULTICAST_MAC_ADDR(pDestAddr)) {
PUCHAR pData = pDestAddr + 12;
UINT16 protoType =
OS_NTOHS(*((UINT16 *)(pData)));
/* Check whether membership query sent by some other device.*/
/* If detected, set internal query Hold duration to avoid flooding in network*/
/* Check whether membership query sent by some other device.*/
/* If detected, set internal query Hold duration to avoid flooding in network*/
if (protoType == ETH_P_IP) {
if (isIGMPquery(adapter, pDestAddr, pData)) {
adapter->ApCfg.MBSSID[if_index].IgmpQueryHoldTick = QUERY_HOLD_PERIOD;
}
} else if (protoType == ETH_P_IPV6) {
if (isMLDquery(adapter, pDestAddr, pData)) {
adapter->ApCfg.MBSSID[if_index].MldQueryHoldTick = QUERY_HOLD_PERIOD;
if (protoType == ETH_P_IP) {
if (isIGMPquery(adapter, pDestAddr,
pData)) {
adapter->ApCfg.MBSSID[if_index]
.IgmpQueryHoldTick =
QUERY_HOLD_PERIOD;
}
} else if (protoType == ETH_P_IPV6) {
if (isMLDquery(adapter, pDestAddr,
pData)) {
adapter->ApCfg.MBSSID[if_index]
.MldQueryHoldTick =
QUERY_HOLD_PERIOD;
}
}
}
}
}
#endif
if (exclude_mac_addr) {
routing_entry = RoutingTabLookup(adapter, if_index, exclude_mac_addr, FALSE, &wcid);
routing_entry = RoutingTabLookup(adapter, if_index,
exclude_mac_addr,
FALSE, &wcid);
if (routing_entry && ROUTING_ENTRY_TEST_FLAG(routing_entry, ROUTING_ENTRY_A4))
if (routing_entry &&
ROUTING_ENTRY_TEST_FLAG(routing_entry,
ROUTING_ENTRY_A4))
found = TRUE;
else
found = FALSE;
}
a4_entry_list = &adapter->ApCfg.MBSSID[if_index].a4_entry_list;
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List) {
if (a4_entry && a4_entry->valid && VALID_WCID(a4_entry->wcid)) {
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List)
{
if (a4_entry && a4_entry->valid &&
VALID_WCID(a4_entry->wcid)) {
if (found && (wcid == a4_entry->wcid))
continue;
entry = &adapter->MacTab.Content[a4_entry->wcid];
wdev = entry->wdev;
pkt_clone = a4_clone_packet(adapter, wdev->if_dev, pkt);
pkt_clone = a4_clone_packet(adapter,
wdev->if_dev, pkt);
if (pkt_clone == NULL) {
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s: Fail to alloc memory for pPacketClone\n", __func__));
MTWF_LOG(
DBG_CAT_ALL, DBG_SUBCAT_ALL,
DBG_LVL_ERROR,
("%s: Fail to alloc memory for pPacketClone\n",
__func__));
return;
}
#ifdef MAP_TS_TRAFFIC_SUPPORT
if (adapter->bTSEnable) {
peer_entry =
&adapter->MacTab
.Content[entry->wcid];
if (!map_ts_tx_process(adapter, wdev,
pkt_clone,
peer_entry)) {
RELEASE_NDIS_PACKET(
adapter, pkt_clone,
NDIS_STATUS_FAILURE);
continue;
}
}
#endif
RTMP_SET_PACKET_WCID(pkt_clone, entry->wcid);
RTMP_SET_PACKET_WDEV(pkt_clone, wdev->wdev_idx);
RTMP_SET_PACKET_MOREDATA(pkt_clone, FALSE);
@ -540,12 +525,8 @@ void a4_send_clone_pkt(
}
}
BOOLEAN a4_ap_peer_enable(
IN PRTMP_ADAPTER adapter,
IN PMAC_TABLE_ENTRY entry,
IN UCHAR type
)
BOOLEAN a4_ap_peer_enable(IN PRTMP_ADAPTER adapter, IN PMAC_TABLE_ENTRY entry,
IN UCHAR type)
{
BSS_STRUCT *mbss = NULL;
UCHAR if_index;
@ -560,9 +541,8 @@ BOOLEAN a4_ap_peer_enable(
mbss = &adapter->ApCfg.MBSSID[if_index];
#ifdef WSC_AP_SUPPORT
if (mbss &&
(mbss->WscControl.WscConfMode != WSC_DISABLE) &&
(mbss->WscControl.bWscTrigger == TRUE))
if (mbss && (mbss->WscControl.WscConfMode != WSC_DISABLE) &&
(mbss->WscControl.bWscTrigger == TRUE))
return FALSE;
#endif /* WSC_AP_SUPPORT */
@ -571,19 +551,19 @@ BOOLEAN a4_ap_peer_enable(
a4_proxy_delete(adapter, if_index, entry->Addr);
os_zero_mem(&wtbl_hdr_trans, sizeof(CMD_WTBL_HDR_TRANS_T));
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("Enabled A4 for entry:%02x-%02x-%02x-%02x-%02x-%02x\n",
PRINT_MAC(entry->Addr)));
MTWF_LOG(
DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("Enabled A4 for entry:%02x-%02x-%02x-%02x-%02x-%02x\n",
PRINT_MAC(entry->Addr)));
wtbl_hdr_trans.u2Tag = WTBL_HDR_TRANS;
wtbl_hdr_trans.u2Length = sizeof(CMD_WTBL_HDR_TRANS_T);
wtbl_hdr_trans.ucTd = 1;
wtbl_hdr_trans.ucFd = 1;
wtbl_hdr_trans.ucDisRhtr = 0;
if (NDIS_STATUS_SUCCESS != CmdExtWtblUpdate(adapter,
entry->wcid,
SET_WTBL,
&wtbl_hdr_trans,
sizeof(CMD_WTBL_HDR_TRANS_T)))
if (NDIS_STATUS_SUCCESS !=
CmdExtWtblUpdate(adapter, entry->wcid, SET_WTBL,
&wtbl_hdr_trans,
sizeof(CMD_WTBL_HDR_TRANS_T)))
return FALSE;
a4_add_entry(adapter, if_index, entry->wcid);
@ -591,18 +571,15 @@ BOOLEAN a4_ap_peer_enable(
if (type > GET_ENTRY_A4(entry)) {
SET_ENTRY_A4(entry, type);
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("SET_A4_ENTRY type:%d OK!\n", type));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("SET_A4_ENTRY type:%d OK!\n", type));
}
return TRUE;
}
BOOLEAN a4_ap_peer_disable(
IN PRTMP_ADAPTER adapter,
IN PMAC_TABLE_ENTRY entry,
IN UCHAR type
)
BOOLEAN a4_ap_peer_disable(IN PRTMP_ADAPTER adapter, IN PMAC_TABLE_ENTRY entry,
IN UCHAR type)
{
UCHAR if_index;
@ -616,25 +593,22 @@ BOOLEAN a4_ap_peer_disable(
if (type == GET_ENTRY_A4(entry)) {
SET_ENTRY_A4(entry, A4_TYPE_NONE);
a4_delete_entry(adapter, if_index, entry->wcid);
RoutingTabSetAllFree(adapter, if_index, entry->wcid, ROUTING_ENTRY_A4);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("a4_ap_peer_disable: Disable A4 for entry : %02x-%02x-%02x-%02x-%02x-%02x\n",
PRINT_MAC(entry->Addr)));
RoutingTabSetAllFree(adapter, if_index, entry->wcid,
ROUTING_ENTRY_A4);
MTWF_LOG(
DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("a4_ap_peer_disable: Disable A4 for entry : %02x-%02x-%02x-%02x-%02x-%02x\n",
PRINT_MAC(entry->Addr)));
}
return TRUE;
}
#ifdef APCLI_SUPPORT
BOOLEAN a4_apcli_peer_enable(
IN PRTMP_ADAPTER adapter,
IN PAPCLI_STRUCT apcli_entry,
IN PMAC_TABLE_ENTRY entry,
IN UCHAR type
)
BOOLEAN a4_apcli_peer_enable(IN PRTMP_ADAPTER adapter,
IN PAPCLI_STRUCT apcli_entry,
IN PMAC_TABLE_ENTRY entry, IN UCHAR type)
{
CMD_WTBL_HDR_TRANS_T wtbl_hdr_trans;
if (!apcli_entry || !entry || !IS_ENTRY_APCLI(entry))
@ -642,27 +616,27 @@ BOOLEAN a4_apcli_peer_enable(
#ifdef WSC_AP_SUPPORT
if (((apcli_entry->WscControl.WscConfMode != WSC_DISABLE) &&
(apcli_entry->WscControl.bWscTrigger == TRUE)))
(apcli_entry->WscControl.bWscTrigger == TRUE)))
return FALSE;
#endif /* WSC_AP_SUPPORT */
if (IS_ENTRY_A4(entry) == FALSE) {
os_zero_mem(&wtbl_hdr_trans, sizeof(CMD_WTBL_HDR_TRANS_T));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("a4_apcli_peer_enable enabled A4 for entry : %02x-%02x-%02x-%02x-%02x-%02x\n",
PRINT_MAC(entry->Addr)));
MTWF_LOG(
DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("a4_apcli_peer_enable enabled A4 for entry : %02x-%02x-%02x-%02x-%02x-%02x\n",
PRINT_MAC(entry->Addr)));
wtbl_hdr_trans.u2Tag = WTBL_HDR_TRANS;
wtbl_hdr_trans.u2Length = sizeof(CMD_WTBL_HDR_TRANS_T);
wtbl_hdr_trans.ucTd = 1;
wtbl_hdr_trans.ucFd = 1;
wtbl_hdr_trans.ucDisRhtr = 0;
if (CmdExtWtblUpdate(adapter,
entry->wcid,
SET_WTBL,
&wtbl_hdr_trans,
sizeof(CMD_WTBL_HDR_TRANS_T)) == NDIS_STATUS_SUCCESS)
MTWF_LOG(DBG_CAT_CLIENT, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("SET_A4_ENTRY OK!\n"));
if (CmdExtWtblUpdate(adapter, entry->wcid, SET_WTBL,
&wtbl_hdr_trans,
sizeof(CMD_WTBL_HDR_TRANS_T)) ==
NDIS_STATUS_SUCCESS)
MTWF_LOG(DBG_CAT_CLIENT, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("SET_A4_ENTRY OK!\n"));
else
return FALSE;
}
@ -674,22 +648,18 @@ BOOLEAN a4_apcli_peer_enable(
return TRUE;
}
BOOLEAN a4_apcli_peer_disable(
IN PRTMP_ADAPTER adapter,
IN PAPCLI_STRUCT apcli_entry,
IN PMAC_TABLE_ENTRY entry,
IN UCHAR type
)
BOOLEAN a4_apcli_peer_disable(IN PRTMP_ADAPTER adapter,
IN PAPCLI_STRUCT apcli_entry,
IN PMAC_TABLE_ENTRY entry, IN UCHAR type)
{
if (!apcli_entry || !entry)
return FALSE;
if (type == GET_ENTRY_A4(entry)) {
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("a4_apcli_peer_disable, Disable A4 for entry:%02x-%02x-%02x-%02x-%02x-%02x\n",
PRINT_MAC(entry->Addr)));
MTWF_LOG(
DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("a4_apcli_peer_disable, Disable A4 for entry:%02x-%02x-%02x-%02x-%02x-%02x\n",
PRINT_MAC(entry->Addr)));
SET_APCLI_A4(apcli_entry, A4_TYPE_NONE);
SET_ENTRY_A4(entry, A4_TYPE_NONE);
}
@ -698,10 +668,7 @@ BOOLEAN a4_apcli_peer_disable(
}
#endif /* APCLI_SUPPORT */
INT Set_APProxy_Status_Show_Proc(
IN PRTMP_ADAPTER adapter,
IN RTMP_STRING * arg)
INT Set_APProxy_Status_Show_Proc(IN PRTMP_ADAPTER adapter, IN RTMP_STRING *arg)
{
POS_COOKIE obj;
UCHAR if_index;
@ -710,13 +677,15 @@ INT Set_APProxy_Status_Show_Proc(
ULONG now = 0, AliveTime = 0;
PDL_LIST a4_entry_list = NULL;
PA4_CONNECT_ENTRY a4_entry = NULL;
PROUTING_ENTRY routing_entry = NULL, *routing_entry_list[ROUTING_POOL_SIZE];
PROUTING_ENTRY routing_entry = NULL,
*routing_entry_list[ROUTING_POOL_SIZE];
UCHAR *proxy_mac_addr = NULL, proxy_ip[64];
obj = (POS_COOKIE) adapter->OS_Cookie;
obj = (POS_COOKIE)adapter->OS_Cookie;
if_index = obj->ioctl_if;
if ((obj->ioctl_if_type != INT_MBSSID) && (obj->ioctl_if_type != INT_MAIN))
if ((obj->ioctl_if_type != INT_MBSSID) &&
(obj->ioctl_if_type != INT_MAIN))
return FALSE;
if (a4_get_entry_count(adapter, if_index) == 0)
@ -724,54 +693,73 @@ INT Set_APProxy_Status_Show_Proc(
a4_entry_list = &adapter->ApCfg.MBSSID[if_index].a4_entry_list;
NdisGetSystemUpTime(&now);
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List) {
DlListForEach(a4_entry, a4_entry_list, A4_CONNECT_ENTRY, List)
{
if (a4_entry && a4_entry->valid && VALID_WCID(a4_entry->wcid)) {
count = 0;
proxy_mac_addr = adapter->MacTab.Content[a4_entry->wcid].Addr;
proxy_mac_addr =
adapter->MacTab.Content[a4_entry->wcid].Addr;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("Proxy Mac: %02X:%02X:%02X:%02X:%02X:%02X\n",
PRINT_MAC(proxy_mac_addr)));
("Proxy Mac: %02X:%02X:%02X:%02X:%02X:%02X\n",
PRINT_MAC(proxy_mac_addr)));
if (GetRoutingEntryAll(adapter, if_index, a4_entry->wcid, ROUTING_ENTRY_A4,
ROUTING_POOL_SIZE, (ROUTING_ENTRY **)&routing_entry_list, &count)) {
if (GetRoutingEntryAll(
adapter, if_index, a4_entry->wcid,
ROUTING_ENTRY_A4, ROUTING_POOL_SIZE,
(ROUTING_ENTRY **)&routing_entry_list,
&count)) {
for (i = 0; i < count; i++) {
routing_entry = (PROUTING_ENTRY)routing_entry_list[i];
routing_entry = (PROUTING_ENTRY)
routing_entry_list[i];
if (!routing_entry)
continue;
if (routing_entry->KeepAliveTime >= now)
AliveTime = ((routing_entry->KeepAliveTime - now) / OS_HZ);
AliveTime =
((routing_entry
->KeepAliveTime -
now) /
OS_HZ);
else
AliveTime = 0;
if (routing_entry->IPAddr != 0) {
ip_addr = routing_entry->IPAddr;
sprintf(proxy_ip, "%d.%d.%d.%d",
(ip_addr & 0xff),
((ip_addr & (0xff << 8)) >> 8),
((ip_addr & (0xff << 16)) >> 16),
((ip_addr & (0xff << 24)) >> 24));
(ip_addr & 0xff),
((ip_addr &
(0xff << 8)) >>
8),
((ip_addr &
(0xff << 16)) >>
16),
((ip_addr &
(0xff << 24)) >>
24));
} else
strcpy(proxy_ip, "0.0.0.0");
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("MAC:%02X:%02X:%02X:%02X:%02X:%02X, IP:%s, AgeOut:%lus, Retry:(%d,%d)\n",
PRINT_MAC(routing_entry->Mac), proxy_ip, AliveTime,
routing_entry->Retry, ROUTING_ENTRY_MAX_RETRY));
MTWF_LOG(
DBG_CAT_ALL, DBG_SUBCAT_ALL,
DBG_LVL_OFF,
("MAC:%02X:%02X:%02X:%02X:%02X:%02X, IP:%s, AgeOut:%lus, Retry:(%d,%d)\n",
PRINT_MAC(routing_entry->Mac),
proxy_ip, AliveTime,
routing_entry->Retry,
ROUTING_ENTRY_MAX_RETRY));
}
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("Total Count = %d\n\n", count));
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL,
DBG_LVL_OFF,
("Total Count = %d\n\n", count));
}
}
}
return TRUE;
}
INT Set_APProxy_Refresh_Proc(
IN PRTMP_ADAPTER adapter,
IN RTMP_STRING * arg)
INT Set_APProxy_Refresh_Proc(IN PRTMP_ADAPTER adapter, IN RTMP_STRING *arg)
{
adapter->a4_need_refresh = TRUE;
return TRUE;

View File

@ -21,27 +21,33 @@
Abstract:
*/
#ifdef CLIENT_WDS
#include "rt_config.h"
VOID CliWds_ProxyTabInit(
IN PRTMP_ADAPTER pAd)
VOID CliWds_ProxyTabInit(IN PRTMP_ADAPTER pAd)
{
INT idx;
ULONG i;
NdisAllocateSpinLock(pAd, &pAd->ApCfg.CliWdsTabLock);
os_alloc_mem(pAd, (UCHAR **)&(pAd->ApCfg.pCliWdsEntryPool), sizeof(CLIWDS_PROXY_ENTRY) * CLIWDS_POOL_SIZE);
os_alloc_mem(pAd, (UCHAR **)&(pAd->ApCfg.pCliWdsEntryPool),
sizeof(CLIWDS_PROXY_ENTRY) * CLIWDS_POOL_SIZE);
if (pAd->ApCfg.pCliWdsEntryPool) {
NdisZeroMemory(pAd->ApCfg.pCliWdsEntryPool, sizeof(CLIWDS_PROXY_ENTRY) * CLIWDS_POOL_SIZE);
NdisZeroMemory(pAd->ApCfg.pCliWdsEntryPool,
sizeof(CLIWDS_PROXY_ENTRY) * CLIWDS_POOL_SIZE);
initList(&pAd->ApCfg.CliWdsEntryFreeList);
for (i = 0; i < CLIWDS_POOL_SIZE; i++)
insertTailList(&pAd->ApCfg.CliWdsEntryFreeList, (RT_LIST_ENTRY *)(pAd->ApCfg.pCliWdsEntryPool + (ULONG)i));
insertTailList(
&pAd->ApCfg.CliWdsEntryFreeList,
(RT_LIST_ENTRY *)(pAd->ApCfg.pCliWdsEntryPool +
(ULONG)i));
} else
MTWF_LOG(DBG_CAT_CLIENT, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s Fail to alloc memory for pAd->CommonCfg.pCliWdsEntryPool", __func__));
MTWF_LOG(
DBG_CAT_CLIENT, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s Fail to alloc memory for pAd->CommonCfg.pCliWdsEntryPool",
__func__));
for (idx = 0; idx < CLIWDS_HASH_TAB_SIZE; idx++)
initList(&pAd->ApCfg.CliWdsProxyTb[idx]);
@ -49,9 +55,7 @@ VOID CliWds_ProxyTabInit(
return;
}
VOID CliWds_ProxyTabDestory(
IN PRTMP_ADAPTER pAd)
VOID CliWds_ProxyTabDestory(IN PRTMP_ADAPTER pAd)
{
INT idx;
PCLIWDS_PROXY_ENTRY pCliWdsEntry;
@ -62,7 +66,8 @@ VOID CliWds_ProxyTabDestory(
(PCLIWDS_PROXY_ENTRY)pAd->ApCfg.CliWdsProxyTb[idx].pHead;
while (pCliWdsEntry) {
PCLIWDS_PROXY_ENTRY pCliWdsEntryNext = pCliWdsEntry->pNext;
PCLIWDS_PROXY_ENTRY pCliWdsEntryNext =
pCliWdsEntry->pNext;
CliWdsEntyFree(pAd, pCliWdsEntry);
pCliWdsEntry = pCliWdsEntryNext;
}
@ -75,33 +80,27 @@ VOID CliWds_ProxyTabDestory(
return;
}
PCLIWDS_PROXY_ENTRY CliWdsEntyAlloc(
IN PRTMP_ADAPTER pAd)
PCLIWDS_PROXY_ENTRY CliWdsEntyAlloc(IN PRTMP_ADAPTER pAd)
{
PCLIWDS_PROXY_ENTRY pCliWdsEntry;
RTMP_SEM_LOCK(&pAd->ApCfg.CliWdsTabLock);
pCliWdsEntry = (PCLIWDS_PROXY_ENTRY)removeHeadList(&pAd->ApCfg.CliWdsEntryFreeList);
pCliWdsEntry = (PCLIWDS_PROXY_ENTRY)removeHeadList(
&pAd->ApCfg.CliWdsEntryFreeList);
RTMP_SEM_UNLOCK(&pAd->ApCfg.CliWdsTabLock);
return pCliWdsEntry;
}
VOID CliWdsEntyFree(
IN PRTMP_ADAPTER pAd,
IN PCLIWDS_PROXY_ENTRY pCliWdsEntry)
VOID CliWdsEntyFree(IN PRTMP_ADAPTER pAd, IN PCLIWDS_PROXY_ENTRY pCliWdsEntry)
{
RTMP_SEM_LOCK(&pAd->ApCfg.CliWdsTabLock);
insertTailList(&pAd->ApCfg.CliWdsEntryFreeList, (RT_LIST_ENTRY *)pCliWdsEntry);
insertTailList(&pAd->ApCfg.CliWdsEntryFreeList,
(RT_LIST_ENTRY *)pCliWdsEntry);
RTMP_SEM_UNLOCK(&pAd->ApCfg.CliWdsTabLock);
return;
}
VOID CliWdsEnryFreeAid(
IN PRTMP_ADAPTER pAd,
IN SHORT Aid)
VOID CliWdsEnryFreeAid(IN PRTMP_ADAPTER pAd, IN SHORT Aid)
{
INT idx;
PCLIWDS_PROXY_ENTRY pCliWdsEntry;
@ -110,22 +109,22 @@ VOID CliWdsEnryFreeAid(
(PCLIWDS_PROXY_ENTRY)pAd->ApCfg.CliWdsProxyTb[idx].pHead;
while (pCliWdsEntry) {
if (pCliWdsEntry->Aid == Aid) {
delEntryList(&pAd->ApCfg.CliWdsProxyTb[idx], (RT_LIST_ENTRY *)pCliWdsEntry);
delEntryList(&pAd->ApCfg.CliWdsProxyTb[idx],
(RT_LIST_ENTRY *)pCliWdsEntry);
CliWdsEntyFree(pAd, pCliWdsEntry);
}
pCliWdsEntry = pCliWdsEntry->pNext;
}
}
return;
}
UCHAR *CliWds_ProxyLookup(RTMP_ADAPTER *pAd, UCHAR *pMac)
{
UINT8 HashId = (*(pMac + 5) & (CLIWDS_HASH_TAB_SIZE - 1));
PCLIWDS_PROXY_ENTRY pCliWdsEntry;
pCliWdsEntry = (PCLIWDS_PROXY_ENTRY)pAd->ApCfg.CliWdsProxyTb[HashId].pHead;
pCliWdsEntry =
(PCLIWDS_PROXY_ENTRY)pAd->ApCfg.CliWdsProxyTb[HashId].pHead;
while (pCliWdsEntry) {
if (MAC_ADDR_EQUAL(pMac, pCliWdsEntry->Addr)) {
@ -135,7 +134,8 @@ UCHAR *CliWds_ProxyLookup(RTMP_ADAPTER *pAd, UCHAR *pMac)
/*FIXME: take aid as wcid shall be refined, let aid is aid, wcid is wcid.*/
if (VALID_UCAST_ENTRY_WCID(pAd, pCliWdsEntry->Aid))
return pAd->MacTab.Content[pCliWdsEntry->Aid].Addr;
return pAd->MacTab.Content[pCliWdsEntry->Aid]
.Addr;
else
return NULL;
}
@ -146,11 +146,7 @@ UCHAR *CliWds_ProxyLookup(RTMP_ADAPTER *pAd, UCHAR *pMac)
return NULL;
}
VOID CliWds_ProxyTabUpdate(
IN PRTMP_ADAPTER pAd,
IN SHORT Aid,
IN PUCHAR pMac)
VOID CliWds_ProxyTabUpdate(IN PRTMP_ADAPTER pAd, IN SHORT Aid, IN PUCHAR pMac)
{
UINT8 HashId = (*(pMac + 5) & (CLIWDS_HASH_TAB_SIZE - 1));
PCLIWDS_PROXY_ENTRY pCliWdsEntry;
@ -167,15 +163,14 @@ VOID CliWds_ProxyTabUpdate(
COPY_MAC_ADDR(&pCliWdsEntry->Addr, pMac);
pCliWdsEntry->LastRefTime = Now;
pCliWdsEntry->pNext = NULL;
insertTailList(&pAd->ApCfg.CliWdsProxyTb[HashId], (RT_LIST_ENTRY *)pCliWdsEntry);
insertTailList(&pAd->ApCfg.CliWdsProxyTb[HashId],
(RT_LIST_ENTRY *)pCliWdsEntry);
}
return;
}
VOID CliWds_ProxyTabMaintain(
IN PRTMP_ADAPTER pAd)
VOID CliWds_ProxyTabMaintain(IN PRTMP_ADAPTER pAd)
{
ULONG idx;
PCLIWDS_PROXY_ENTRY pCliWdsEntry;
@ -183,13 +178,20 @@ VOID CliWds_ProxyTabMaintain(
NdisGetSystemUpTime(&Now);
for (idx = 0; idx < CLIWDS_HASH_TAB_SIZE; idx++) {
pCliWdsEntry = (PCLIWDS_PROXY_ENTRY)(pAd->ApCfg.CliWdsProxyTb[idx].pHead);
pCliWdsEntry =
(PCLIWDS_PROXY_ENTRY)(pAd->ApCfg.CliWdsProxyTb[idx]
.pHead);
while (pCliWdsEntry) {
PCLIWDS_PROXY_ENTRY pCliWdsEntryNext = pCliWdsEntry->pNext;
if (RTMP_TIME_AFTER(Now, pCliWdsEntry->LastRefTime + (ULONG)((ULONG)(CLI_WDS_ENTRY_AGEOUT) * OS_HZ / 1000))) {
delEntryList(&pAd->ApCfg.CliWdsProxyTb[idx], (RT_LIST_ENTRY *)pCliWdsEntry);
PCLIWDS_PROXY_ENTRY pCliWdsEntryNext =
pCliWdsEntry->pNext;
if (RTMP_TIME_AFTER(
Now,
pCliWdsEntry->LastRefTime +
(ULONG)((ULONG)(CLI_WDS_ENTRY_AGEOUT)*OS_HZ /
1000))) {
delEntryList(&pAd->ApCfg.CliWdsProxyTb[idx],
(RT_LIST_ENTRY *)pCliWdsEntry);
CliWdsEntyFree(pAd, pCliWdsEntry);
}
@ -201,14 +203,13 @@ VOID CliWds_ProxyTabMaintain(
}
#ifndef WDS_SUPPORT
MAC_TABLE_ENTRY *FindWdsEntry(
IN PRTMP_ADAPTER pAd,
IN RX_BLK * pRxBlk)
MAC_TABLE_ENTRY *FindWdsEntry(IN PRTMP_ADAPTER pAd, IN RX_BLK *pRxBlk)
{
MAC_TABLE_ENTRY *pEntry;
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s(): Wcid = %d, PhyMode = 0x%x\n", __func__,
pRxBlk->wcid, pRxBlk->rx_rate.field.MODE));
MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s(): Wcid = %d, PhyMode = 0x%x\n", __func__, pRxBlk->wcid,
pRxBlk->rx_rate.field.MODE));
/* lookup the match wds entry for the incoming packet. */
pEntry = WdsTableLookupByWcid(pAd, pRxBlk->wcid, pRxBlk->Addr2, TRUE);
if (pEntry == NULL)
@ -218,41 +219,38 @@ MAC_TABLE_ENTRY *FindWdsEntry(
if ((pEntry == NULL) && (pAd->WdsTab.Mode >= WDS_LAZY_MODE)) {
UCHAR *pTmpBuf = pRxBlk->pData - LENGTH_802_11;
RXD_BASE_STRUCT *rxd_base = (RXD_BASE_STRUCT *)pRxBlk->rmac_info;
RXD_BASE_STRUCT *rxd_base =
(RXD_BASE_STRUCT *)pRxBlk->rmac_info;
NdisMoveMemory(pTmpBuf, pRxBlk->FC, LENGTH_802_11);
REPORT_MGMT_FRAME_TO_MLME(pAd, pRxBlk->wcid,
pTmpBuf,
pRxBlk->DataSize + LENGTH_802_11,
pRxBlk->rx_signal.raw_rssi[0],
pRxBlk->rx_signal.raw_rssi[1],
pRxBlk->rx_signal.raw_rssi[2],
pRxBlk->rx_signal.raw_rssi[3],
REPORT_MGMT_FRAME_TO_MLME(
pAd, pRxBlk->wcid, pTmpBuf,
pRxBlk->DataSize + LENGTH_802_11,
pRxBlk->rx_signal.raw_rssi[0],
pRxBlk->rx_signal.raw_rssi[1],
pRxBlk->rx_signal.raw_rssi[2],
pRxBlk->rx_signal.raw_rssi[3],
#if defined(CUSTOMER_DCC_FEATURE) || defined(CONFIG_MAP_SUPPORT)
pRxBlk->rx_signal.raw_snr[0],
pRxBlk->rx_signal.raw_snr[1],
pRxBlk->rx_signal.raw_snr[2],
pRxBlk->rx_signal.raw_snr[3],
pRxBlk->rx_signal.raw_snr[0],
pRxBlk->rx_signal.raw_snr[1],
pRxBlk->rx_signal.raw_snr[2],
pRxBlk->rx_signal.raw_snr[3],
#endif
(rxd_base != NULL) ? rxd_base->RxD1.ChFreq : 0,
0,
OPMODE_AP,
&pAd->ApCfg.MBSSID[pRxBlk->bss_idx].wdev,
pRxBlk->rx_rate.field.MODE);
MTWF_LOG(DBG_CAT_RX, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("!!! report WDS UC DATA (from %02x-%02x-%02x-%02x-%02x-%02x) to MLME (len=%d) !!!\n",
PRINT_MAC(pRxBlk->Addr2), pRxBlk->DataSize));
(rxd_base != NULL) ? rxd_base->RxD1.ChFreq : 0, 0,
OPMODE_AP, &pAd->ApCfg.MBSSID[pRxBlk->bss_idx].wdev,
pRxBlk->rx_rate.field.MODE);
MTWF_LOG(
DBG_CAT_RX, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("!!! report WDS UC DATA (from %02x-%02x-%02x-%02x-%02x-%02x) to MLME (len=%d) !!!\n",
PRINT_MAC(pRxBlk->Addr2), pRxBlk->DataSize));
}
return pEntry;
}
MAC_TABLE_ENTRY *WdsTableLookupByWcid(
IN PRTMP_ADAPTER pAd,
IN UCHAR wcid,
IN PUCHAR pAddr,
IN BOOLEAN bResetIdelCount)
MAC_TABLE_ENTRY *WdsTableLookupByWcid(IN PRTMP_ADAPTER pAd, IN UCHAR wcid,
IN PUCHAR pAddr,
IN BOOLEAN bResetIdelCount)
{
ULONG WdsIndex;
MAC_TABLE_ENTRY *pCurEntry = NULL, *pEntry = NULL;
@ -280,7 +278,8 @@ MAC_TABLE_ENTRY *WdsTableLookupByWcid(
if (bResetIdelCount) {
pCurEntry->NoDataIdleCount = 0;
/* TODO: shiang-usw, remove upper setting because we need to migrate to tr_entry! */
pAd->MacTab.tr_entry[pCurEntry->tr_tb_idx].NoDataIdleCount = 0;
pAd->MacTab.tr_entry[pCurEntry->tr_tb_idx]
.NoDataIdleCount = 0;
}
pEntry = pCurEntry;
break;
@ -291,10 +290,9 @@ MAC_TABLE_ENTRY *WdsTableLookupByWcid(
return pEntry;
}
MAC_TABLE_ENTRY *WdsTableLookup(RTMP_ADAPTER *pAd, UCHAR *addr, BOOLEAN bResetIdelCount)
MAC_TABLE_ENTRY *WdsTableLookup(RTMP_ADAPTER *pAd, UCHAR *addr,
BOOLEAN bResetIdelCount)
{
USHORT HashIdx;
PMAC_TABLE_ENTRY pEntry = NULL;
@ -303,11 +301,13 @@ MAC_TABLE_ENTRY *WdsTableLookup(RTMP_ADAPTER *pAd, UCHAR *addr, BOOLEAN bResetId
HashIdx = MAC_ADDR_HASH_INDEX(addr);
pEntry = pAd->MacTab.Hash[HashIdx];
while (pEntry) {
if (IS_ENTRY_WDS(pEntry) && MAC_ADDR_EQUAL(pEntry->Addr, addr)) {
if (IS_ENTRY_WDS(pEntry) &&
MAC_ADDR_EQUAL(pEntry->Addr, addr)) {
if (bResetIdelCount) {
pEntry->NoDataIdleCount = 0;
/* TODO: shiang-usw, remove upper setting because we need to migrate to tr_entry! */
pAd->MacTab.tr_entry[pEntry->wcid].NoDataIdleCount = 0;
pAd->MacTab.tr_entry[pEntry->wcid]
.NoDataIdleCount = 0;
}
break;
}
@ -320,4 +320,3 @@ MAC_TABLE_ENTRY *WdsTableLookup(RTMP_ADAPTER *pAd, UCHAR *addr, BOOLEAN bResetId
#endif
#endif /* CLIENT_WDS */

View File

@ -30,15 +30,15 @@
#include "rt_config.h"
#ifdef DBG_STARVATION
static void cmdq_starv_timeout_handle(struct starv_dbg *starv, struct starv_log_entry *entry)
static void cmdq_starv_timeout_handle(struct starv_dbg *starv,
struct starv_log_entry *entry)
{
struct _CmdQElmt *cmd = container_of(starv, struct _CmdQElmt, starv);
struct _CmdQ *cmdq = starv->block->priv;
struct starv_log_basic *log = NULL;
os_alloc_mem(NULL, (UCHAR **) &log, sizeof(struct starv_log_basic));
os_alloc_mem(NULL, (UCHAR **)&log, sizeof(struct starv_log_basic));
if (!log)
return;
@ -61,7 +61,6 @@ static void cmdq_starv_block_init(struct starv_log *ctrl, struct _CmdQ *cmdq)
}
#endif /*DBG_STARVATION*/
/*
========================================================================
@ -77,8 +76,7 @@ static void cmdq_starv_block_init(struct starv_log *ctrl, struct _CmdQ *cmdq)
========================================================================
*/
VOID RTInitializeCmdQ(
IN PCmdQ cmdq)
VOID RTInitializeCmdQ(IN PCmdQ cmdq)
{
cmdq->head = NULL;
cmdq->tail = NULL;
@ -86,7 +84,6 @@ VOID RTInitializeCmdQ(
cmdq->CmdQState = RTMP_TASK_STAT_INITED;
}
/*
========================================================================
@ -102,9 +99,7 @@ VOID RTInitializeCmdQ(
========================================================================
*/
VOID RTThreadDequeueCmd(
IN PCmdQ cmdq,
OUT PCmdQElmt * pcmdqelmt)
VOID RTThreadDequeueCmd(IN PCmdQ cmdq, OUT PCmdQElmt *pcmdqelmt)
{
*pcmdqelmt = cmdq->head;
@ -117,7 +112,6 @@ VOID RTThreadDequeueCmd(
}
}
/*
========================================================================
@ -133,18 +127,17 @@ VOID RTThreadDequeueCmd(
========================================================================
*/
NDIS_STATUS RTEnqueueInternalCmd(
IN PRTMP_ADAPTER pAd,
IN NDIS_OID Oid,
IN PVOID pInformationBuffer,
IN UINT32 InformationBufferLength)
NDIS_STATUS RTEnqueueInternalCmd(IN PRTMP_ADAPTER pAd, IN NDIS_OID Oid,
IN PVOID pInformationBuffer,
IN UINT32 InformationBufferLength)
{
NDIS_STATUS status;
ULONG flag = 0;
PCmdQElmt cmdqelmt = NULL;
NDIS_STATUS status;
ULONG flag = 0;
PCmdQElmt cmdqelmt = NULL;
if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) {
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("--->RTEnqueueInternalCmd - NIC is not exist!!\n"));
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("--->RTEnqueueInternalCmd - NIC is not exist!!\n"));
return NDIS_STATUS_FAILURE;
}
@ -156,13 +149,16 @@ NDIS_STATUS RTEnqueueInternalCmd(
NdisZeroMemory(cmdqelmt, sizeof(CmdQElmt));
if (InformationBufferLength > 0) {
status = os_alloc_mem(pAd, (PUCHAR *)&cmdqelmt->buffer, InformationBufferLength);
status = os_alloc_mem(pAd, (PUCHAR *)&cmdqelmt->buffer,
InformationBufferLength);
if ((status != NDIS_STATUS_SUCCESS) || (cmdqelmt->buffer == NULL)) {
if ((status != NDIS_STATUS_SUCCESS) ||
(cmdqelmt->buffer == NULL)) {
os_free_mem(cmdqelmt);
return NDIS_STATUS_RESOURCES;
} else {
NdisMoveMemory(cmdqelmt->buffer, pInformationBuffer, InformationBufferLength);
NdisMoveMemory(cmdqelmt->buffer, pInformationBuffer,
InformationBufferLength);
cmdqelmt->bufferlength = InformationBufferLength;
}
} else {
@ -200,21 +196,14 @@ NDIS_STATUS RTEnqueueInternalCmd(
return NDIS_STATUS_SUCCESS;
}
/*Define common Cmd Thread*/
#ifdef CONFIG_AP_SUPPORT
static NTSTATUS _802_11_CounterMeasureHdlr(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
static NTSTATUS _802_11_CounterMeasureHdlr(IN PRTMP_ADAPTER pAd,
IN PCmdQElmt CMDQelmt)
{
IF_DEV_CONFIG_OPMODE_ON_AP(pAd) {
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
MAC_TABLE_ENTRY *pEntry;
pEntry = (MAC_TABLE_ENTRY *)CMDQelmt->buffer;
@ -232,7 +221,7 @@ static NTSTATUS ApSoftReStart(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
pMbss = &pAd->ApCfg.MBSSID[apidx];
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("cmd> ApSoftReStart: apidx = %d\n", apidx));
("cmd> ApSoftReStart: apidx = %d\n", apidx));
APStop(pAd, pMbss, AP_BSS_OPER_SINGLE);
APStartUp(pAd, pMbss, AP_BSS_OPER_SINGLE);
@ -246,7 +235,8 @@ static NTSTATUS ApCliSetChannel(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
UCHAR channel = 0;
channel = pApCliTab->MlmeAux.Channel;
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("cmd> channel=%d CMDTHREAD_APCLI_PBC_TIMEOUT!\n", channel));
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("cmd> channel=%d CMDTHREAD_APCLI_PBC_TIMEOUT!\n", channel));
rtmp_set_channel(pAd, &pApCliTab->wdev, channel);
return NDIS_STATUS_SUCCESS;
@ -259,15 +249,29 @@ static NTSTATUS CmdApCliIfDown(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
NdisMoveMemory(&apidx, CMDQelmt->buffer, sizeof(UCHAR));
apcliEn = pAd->ApCfg.ApCliTab[apidx].Enable;
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("cmd> CMDTHREAD_APCLI_IF_DOWN! apidx=%u, apcliEn=%d\n", apidx, apcliEn));
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("cmd> CMDTHREAD_APCLI_IF_DOWN! apidx=%u, apcliEn=%d\n",
apidx, apcliEn));
/* bring apcli interface down first */
if (apcliEn == TRUE) {
pAd->ApCfg.ApCliTab[apidx].Enable = FALSE;
ApCliIfDown(pAd);
pAd->ApCfg.ApCliTab[apidx].Enable = apcliEn;
}
pAd->ApCfg.ApCliTab[apidx].Enable = apcliEn;
#ifdef CONFIG_MAP_SUPPORT
else if ((pAd->ApCfg.ApCliTab[apidx].wdev.WscControl.WscConfMode !=
WSC_DISABLE) &&
(pAd->ApCfg.ApCliTab[apidx].wdev.WscControl.bWscTrigger) &&
IS_MAP_ENABLE(pAd)) {
MTWF_LOG(
DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("MAP WPS CASE FIRST LINKDOWN THEN CONNECTION apidx=%u, apcliEn=%d\n",
apidx, apcliEn));
ApCliIfDown(pAd);
pAd->ApCfg.ApCliTab[apidx].Enable = TRUE;
}
#endif
return NDIS_STATUS_SUCCESS;
}
@ -277,7 +281,8 @@ static NTSTATUS CmdWscApCliLinkDown(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
UCHAR apidx = 0;
NdisMoveMemory(&apidx, CMDQelmt->buffer, sizeof(UCHAR));
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("cmd> CMDTHREAD_WSC_APCLI_LINK_DOWN! apidx=%u\n", apidx));
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("cmd> CMDTHREAD_WSC_APCLI_LINK_DOWN! apidx=%u\n", apidx));
WscApCliLinkDownById(pAd, apidx);
return NDIS_STATUS_SUCCESS;
}
@ -287,9 +292,6 @@ static NTSTATUS CmdWscApCliLinkDown(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
#endif /* CONFIG_AP_SUPPORT */
#ifdef CONFIG_AP_SUPPORT
static NTSTATUS ChannelRescanHdlr(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
{
@ -303,16 +305,19 @@ static NTSTATUS ChannelRescanHdlr(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
NdisMoveMemory(&apidx, CMDQelmt->buffer, sizeof(UCHAR));
pMbss = &pAd->ApCfg.MBSSID[apidx];
Channel = APAutoSelectChannel(pAd, wdev, TRUE, pAutoChCtrl->pChannelInfo->IsABand);
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("cmd> Re-scan channel!\n"));
Channel = APAutoSelectChannel(pAd, wdev, TRUE,
pAutoChCtrl->pChannelInfo->IsABand);
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("cmd> Re-scan channel!\n"));
#ifdef ACS_CTCC_SUPPORT
if (!pAd->ApCfg.auto_ch_score_flag)
#endif
{
wdev->channel = Channel;
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("cmd> Switch to %d!\n", Channel));
APStop(pAd, pMbss, AP_BSS_OPER_BY_RF);
APStartUp(pAd, pMbss, AP_BSS_OPER_BY_RF);
wdev->channel = Channel;
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("cmd> Switch to %d!\n", Channel));
APStop(pAd, pMbss, AP_BSS_OPER_BY_RF);
APStartUp(pAd, pMbss, AP_BSS_OPER_BY_RF);
}
#ifdef AP_QLOAD_SUPPORT
QBSS_LoadAlarmResume(pAd);
@ -321,18 +326,19 @@ static NTSTATUS ChannelRescanHdlr(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
}
#endif /* CONFIG_AP_SUPPORT*/
#ifdef LINUX
#ifdef RT_CFG80211_SUPPORT
static NTSTATUS RegHintHdlr(RTMP_ADAPTER *pAd, IN PCmdQElmt CMDQelmt)
{
RT_CFG80211_CRDA_REG_HINT(pAd, CMDQelmt->buffer, CMDQelmt->bufferlength);
RT_CFG80211_CRDA_REG_HINT(pAd, CMDQelmt->buffer,
CMDQelmt->bufferlength);
return NDIS_STATUS_SUCCESS;
}
static NTSTATUS RegHint11DHdlr(RTMP_ADAPTER *pAd, IN PCmdQElmt CMDQelmt)
{
RT_CFG80211_CRDA_REG_HINT11D(pAd, CMDQelmt->buffer, CMDQelmt->bufferlength);
RT_CFG80211_CRDA_REG_HINT11D(pAd, CMDQelmt->buffer,
CMDQelmt->bufferlength);
return NDIS_STATUS_SUCCESS;
}
@ -342,15 +348,14 @@ static NTSTATUS RT_Mac80211_ScanEnd(RTMP_ADAPTER *pAd, IN PCmdQElmt CMDQelmt)
return NDIS_STATUS_SUCCESS;
}
static NTSTATUS RT_Mac80211_ConnResultInfom(RTMP_ADAPTER *pAd, IN PCmdQElmt CMDQelmt)
static NTSTATUS RT_Mac80211_ConnResultInfom(RTMP_ADAPTER *pAd,
IN PCmdQElmt CMDQelmt)
{
return NDIS_STATUS_SUCCESS;
}
#endif /* RT_CFG80211_SUPPORT */
#endif /* LINUX */
#ifdef STREAM_MODE_SUPPORT
static NTSTATUS UpdateTXChainAddress(RTMP_ADAPTER *pAd, IN PCmdQElmt CMDQelmt)
{
@ -359,15 +364,16 @@ static NTSTATUS UpdateTXChainAddress(RTMP_ADAPTER *pAd, IN PCmdQElmt CMDQelmt)
}
#endif /* STREAM_MODE_SUPPORT */
#ifdef CFG_TDLS_SUPPORT
static NTSTATUS CFGTdlsSendCHSWSetupHdlr(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
static NTSTATUS CFGTdlsSendCHSWSetupHdlr(IN PRTMP_ADAPTER pAd,
IN PCmdQElmt CMDQelmt)
{
return NDIS_STATUS_SUCCESS;
}
static NTSTATUS CFGTdlsAutoTeardownHdlr(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
static NTSTATUS CFGTdlsAutoTeardownHdlr(IN PRTMP_ADAPTER pAd,
IN PCmdQElmt CMDQelmt)
{
MAC_TABLE_ENTRY *pEntry = (MAC_TABLE_ENTRY *)(CMDQelmt->buffer);
@ -377,15 +383,16 @@ static NTSTATUS CFGTdlsAutoTeardownHdlr(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQe
#endif /* CFG_TDLS_SUPPORT */
static NTSTATUS mac_table_delete_handle(struct _RTMP_ADAPTER *ad, struct _CmdQElmt *elem)
static NTSTATUS mac_table_delete_handle(struct _RTMP_ADAPTER *ad,
struct _CmdQElmt *elem)
{
struct _MAC_TABLE_ENTRY *entry = (struct _MAC_TABLE_ENTRY *)(elem->buffer);
struct _MAC_TABLE_ENTRY *entry =
(struct _MAC_TABLE_ENTRY *)(elem->buffer);
MacTableDeleteEntry(ad, entry->wcid, entry->Addr);
return NDIS_STATUS_SUCCESS;
}
static NTSTATUS RXVWriteInFile(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
{
RTMP_OS_FD_EXT srcf;
@ -394,9 +401,10 @@ static NTSTATUS RXVWriteInFile(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
RTMP_STRING tmpSrc[256], chipname[100];
PRxVBQElmt prxvbqelmt = (PRxVBQElmt)CMDQelmt->buffer;
srcf = os_file_open(pAd->RxvFilePath, O_WRONLY|O_CREAT|O_APPEND, 0);
srcf = os_file_open(pAd->RxvFilePath, O_WRONLY | O_CREAT | O_APPEND, 0);
if (srcf.Status) {
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("Open file \"%s\" failed!\n", pAd->RxvFilePath));
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("Open file \"%s\" failed!\n", pAd->RxvFilePath));
return NDIS_STATUS_FAILURE;
}
@ -413,11 +421,14 @@ static NTSTATUS RXVWriteInFile(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
sprintf(tmpSrc, "======================================\n");
os_file_write(srcf, tmpSrc, strlen(tmpSrc));
os_file_write(srcf, chipname, strlen(chipname));
sprintf(tmpSrc, "WCID(STA Index) = %d, We will record all WCID if WCID = 0.\n", pAd->ucRxvWcid);
sprintf(tmpSrc,
"WCID(STA Index) = %d, We will record all WCID if WCID = 0.\n",
pAd->ucRxvWcid);
os_file_write(srcf, tmpSrc, strlen(tmpSrc));
sprintf(tmpSrc, "Band Index = %d\n", pAd->ucRxvBandIdx);
os_file_write(srcf, tmpSrc, strlen(tmpSrc));
sprintf(tmpSrc, "CSD-Debug Group1/Group2 = 0x%x/0x%x\n", pAd->ucRxvG1, pAd->ucRxvG2);
sprintf(tmpSrc, "CSD-Debug Group1/Group2 = 0x%x/0x%x\n",
pAd->ucRxvG1, pAd->ucRxvG2);
os_file_write(srcf, tmpSrc, strlen(tmpSrc));
sprintf(tmpSrc, "======================================\n");
os_file_write(srcf, tmpSrc, strlen(tmpSrc));
@ -425,15 +436,13 @@ static NTSTATUS RXVWriteInFile(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
}
sprintf(tmpSrc, "[TimeStamp %u][STA %d][Rxv_SN %u][AggCnt %u]\n",
prxvbqelmt->timestamp,
prxvbqelmt->wcid,
prxvbqelmt->rxv_sn,
prxvbqelmt->aggcnt
);
prxvbqelmt->timestamp, prxvbqelmt->wcid, prxvbqelmt->rxv_sn,
prxvbqelmt->aggcnt);
os_file_write(srcf, tmpSrc, strlen(tmpSrc));
sprintf(tmpSrc, "[FcsErrorBitmap[255-0] 0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x]\n",
sprintf(tmpSrc,
"[FcsErrorBitmap[255-0] 0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x]\n",
prxvbqelmt->arFCScheckBitmap[7],
prxvbqelmt->arFCScheckBitmap[6],
prxvbqelmt->arFCScheckBitmap[5],
@ -441,29 +450,28 @@ static NTSTATUS RXVWriteInFile(IN PRTMP_ADAPTER pAd, IN PCmdQElmt CMDQelmt)
prxvbqelmt->arFCScheckBitmap[3],
prxvbqelmt->arFCScheckBitmap[2],
prxvbqelmt->arFCScheckBitmap[1],
prxvbqelmt->arFCScheckBitmap[0]
);
prxvbqelmt->arFCScheckBitmap[0]);
os_file_write(srcf, tmpSrc, strlen(tmpSrc));
os_file_write(srcf, "[RXV DUMP START]\n", strlen("[RXV DUMP START]\n"));
for (i = 0; i < 9; i++) {
sprintf(tmpSrc, "[RXVD%d] %08x\n", (i+1), prxvbqelmt->RXV_CYCLE[i]);
sprintf(tmpSrc, "[RXVD%d] %08x\n", (i + 1),
prxvbqelmt->RXV_CYCLE[i]);
os_file_write(srcf, tmpSrc, strlen(tmpSrc));
}
os_file_write(srcf, "[RXV DUMP END]\n", strlen("[RXV DUMP END]\n"));
Ret = os_file_close(srcf);
if (Ret)
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("File Close Error ! Ret = %d\n", Ret));
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("File Close Error ! Ret = %d\n", Ret));
return NDIS_STATUS_SUCCESS;
}
typedef NTSTATUS (*CMDHdlr)(RTMP_ADAPTER *pAd, IN PCmdQElmt CMDQelmt);
typedef struct {
UINT32 CmdID;
CMDHdlr CmdHdlr;
@ -471,71 +479,77 @@ typedef struct {
static MT_CMD_TABL_T CMDHdlrTable[] = {
/*STA related*/
/*AP related*/
/*STA related*/
/*AP related*/
#ifdef CONFIG_AP_SUPPORT
{CMDTHREAD_CHAN_RESCAN, ChannelRescanHdlr},
{CMDTHREAD_802_11_COUNTER_MEASURE, _802_11_CounterMeasureHdlr},
{CMDTHREAD_AP_RESTART, ApSoftReStart},
{ CMDTHREAD_CHAN_RESCAN, ChannelRescanHdlr },
{ CMDTHREAD_802_11_COUNTER_MEASURE, _802_11_CounterMeasureHdlr },
{ CMDTHREAD_AP_RESTART, ApSoftReStart },
#ifdef APCLI_SUPPORT
{CMDTHREAD_APCLI_PBC_TIMEOUT, ApCliSetChannel},
{CMDTHREAD_APCLI_IF_DOWN, CmdApCliIfDown},
{ CMDTHREAD_APCLI_PBC_TIMEOUT, ApCliSetChannel },
{ CMDTHREAD_APCLI_IF_DOWN, CmdApCliIfDown },
#ifdef WSC_AP_SUPPORT
{CMDTHREAD_WSC_APCLI_LINK_DOWN, CmdWscApCliLinkDown},
{ CMDTHREAD_WSC_APCLI_LINK_DOWN, CmdWscApCliLinkDown },
#endif /* WSC_AP_SUPPORT */
#endif /* APCLI_SUPPORT */
#endif
/*CFG 802.11*/
#if defined(LINUX) && defined(RT_CFG80211_SUPPORT)
{CMDTHREAD_REG_HINT, RegHintHdlr},
{CMDTHREAD_REG_HINT_11D, RegHint11DHdlr},
{CMDTHREAD_SCAN_END, RT_Mac80211_ScanEnd},
{CMDTHREAD_CONNECT_RESULT_INFORM, RT_Mac80211_ConnResultInfom},
/*CFG 802.11*/
#if defined(LINUX) && defined(RT_CFG80211_SUPPORT)
{ CMDTHREAD_REG_HINT, RegHintHdlr },
{ CMDTHREAD_REG_HINT_11D, RegHint11DHdlr },
{ CMDTHREAD_SCAN_END, RT_Mac80211_ScanEnd },
{ CMDTHREAD_CONNECT_RESULT_INFORM, RT_Mac80211_ConnResultInfom },
#endif
/*P2P*/
/*RT3593*/
/*P2P*/
/*RT3593*/
#ifdef STREAM_MODE_SUPPORT
{CMDTHREAD_UPDATE_TX_CHAIN_ADDRESS, UpdateTXChainAddress},
{ CMDTHREAD_UPDATE_TX_CHAIN_ADDRESS, UpdateTXChainAddress },
#endif
/*TDLS*/
/*TDLS*/
#ifdef CFG_TDLS_SUPPORT
{CMDTHREAD_TDLS_SEND_CH_SW_SETUP, CFGTdlsSendCHSWSetupHdlr},
{CMDTHREAD_TDLS_AUTO_TEARDOWN, CFGTdlsAutoTeardownHdlr},
{ CMDTHREAD_TDLS_SEND_CH_SW_SETUP, CFGTdlsSendCHSWSetupHdlr },
{ CMDTHREAD_TDLS_AUTO_TEARDOWN, CFGTdlsAutoTeardownHdlr },
#endif
#ifdef WIFI_SPECTRUM_SUPPORT
{CMDTHRED_WIFISPECTRUM_DUMP_RAW_DATA, WifiSpectrumRawDataHandler},
{ CMDTHRED_WIFISPECTRUM_DUMP_RAW_DATA, WifiSpectrumRawDataHandler },
#endif /* WIFI_SPECTRUM_SUPPORT */
#ifdef INTERNAL_CAPTURE_SUPPORT
{CMDTHRED_ICAP_DUMP_RAW_DATA, ICapRawDataHandler},
#endif/* INTERNAL_CAPTURE_SUPPORT */
{ CMDTHRED_ICAP_DUMP_RAW_DATA, ICapRawDataHandler },
#endif /* INTERNAL_CAPTURE_SUPPORT */
#if defined(RLM_CAL_CACHE_SUPPORT) || defined(PRE_CAL_TRX_SET2_SUPPORT)
{CMDTHRED_PRECAL_TXLPF, PreCalTxLPFStoreProcHandler},
{CMDTHRED_PRECAL_TXIQ, PreCalTxIQStoreProcHandler},
{CMDTHRED_PRECAL_TXDC, PreCalTxDCStoreProcHandler},
{CMDTHRED_PRECAL_RXFI, PreCalRxFIStoreProcHandler},
{CMDTHRED_PRECAL_RXFD, PreCalRxFDStoreProcHandler},
#endif /* defined(RLM_CAL_CACHE_SUPPORT) || defined(PRE_CAL_TRX_SET2_SUPPORT) */
{ CMDTHRED_PRECAL_TXLPF, PreCalTxLPFStoreProcHandler },
{ CMDTHRED_PRECAL_TXIQ, PreCalTxIQStoreProcHandler },
{ CMDTHRED_PRECAL_TXDC, PreCalTxDCStoreProcHandler },
{ CMDTHRED_PRECAL_RXFI, PreCalRxFIStoreProcHandler },
{ CMDTHRED_PRECAL_RXFD, PreCalRxFDStoreProcHandler },
#endif /* defined(RLM_CAL_CACHE_SUPPORT) || defined(PRE_CAL_TRX_SET2_SUPPORT) */
#ifdef CONFIG_AP_SUPPORT
{CMDTHRED_DOT11H_SWITCH_CHANNEL, Dot11HCntDownTimeoutAction},
{ CMDTHRED_DOT11H_SWITCH_CHANNEL, Dot11HCntDownTimeoutAction },
#ifdef CUSTOMER_DCC_FEATURE
{ CMDTREAD_AP_SWITCH_CHANNEL, APChannelSwitch },
#endif
#endif /* CONFIG_AP_SUPPORT */
#ifdef MT_DFS_SUPPORT
{CMDTHRED_DFS_CAC_TIMEOUT, DfsChannelSwitchTimeoutAction},
{CMDTHRED_DFS_AP_RESTART, DfsAPRestart},
{ CMDTHRED_DFS_CAC_TIMEOUT, DfsChannelSwitchTimeoutAction },
{ CMDTHRED_DFS_AP_RESTART, DfsAPRestart },
{ CMDTHRED_DFS_RADAR_DETECTED_SW_CH, DfsSwitchChAfterRadarDetected },
#endif
{CMDTHRED_MAC_TABLE_DEL, mac_table_delete_handle},
{CMDTHRED_RXV_WRITE_IN_FILE, RXVWriteInFile},
{CMDTHREAD_END_CMD_ID, NULL}
{ CMDTHRED_MAC_TABLE_DEL, mac_table_delete_handle },
{ CMDTHRED_RXV_WRITE_IN_FILE, RXVWriteInFile },
{ CMDTHREAD_END_CMD_ID, NULL }
};
static inline CMDHdlr ValidCMD(IN PCmdQElmt CMDQelmt)
{
SHORT CMDIndex = CMDQelmt->command;
SHORT CurIndex = 0;
USHORT CMDHdlrTableLength = sizeof(CMDHdlrTable) / sizeof(MT_CMD_TABL_T);
USHORT CMDHdlrTableLength =
sizeof(CMDHdlrTable) / sizeof(MT_CMD_TABL_T);
CMDHdlr Handler = NULL;
if (CMDIndex > CMDTHREAD_END_CMD_ID) {
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("CMD(%x) is out of boundary\n", CMDQelmt->command));
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("CMD(%x) is out of boundary\n", CMDQelmt->command));
return NULL;
}
@ -547,21 +561,33 @@ static inline CMDHdlr ValidCMD(IN PCmdQElmt CMDQelmt)
}
if (Handler == NULL)
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("No corresponding CMDHdlr for this CMD(%x)\n", CMDQelmt->command));
MTWF_LOG(DBG_CAT_CFG, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("No corresponding CMDHdlr for this CMD(%x)\n",
CMDQelmt->command));
return Handler;
}
VOID CMDHandler(RTMP_ADAPTER *pAd)
{
PCmdQElmt cmdqelmt;
NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
NTSTATUS ntStatus;
CMDHdlr Handler = NULL;
PCmdQElmt cmdqelmt;
NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
NTSTATUS ntStatus;
CMDHdlr Handler = NULL;
UINT32 process_cnt = 0;
while (pAd && pAd->CmdQ.size > 0) {
NdisStatus = NDIS_STATUS_SUCCESS;
/* For worst case, avoid process CmdQ too long which cause RCU_sched stall */
process_cnt++;
/* process_cnt-16 */
if ((!in_interrupt()) &&
(process_cnt >= (MAX_LEN_OF_CMD_QUEUE >> 4))) {
process_cnt = 0;
OS_SCHEDULE();
}
NdisAcquireSpinLock(&pAd->CmdQLock);
RTThreadDequeueCmd(&pAd->CmdQ, &cmdqelmt);
NdisReleaseSpinLock(&pAd->CmdQLock);
@ -569,8 +595,8 @@ VOID CMDHandler(RTMP_ADAPTER *pAd)
if (cmdqelmt == NULL)
break;
if (!(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST) || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS))) {
if (!(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST) ||
RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS))) {
Handler = ValidCMD(cmdqelmt);
if (Handler)
@ -587,12 +613,13 @@ VOID CMDHandler(RTMP_ADAPTER *pAd)
os_free_mem(cmdqelmt);
} else {
if ((cmdqelmt->buffer != NULL) && (cmdqelmt->bufferlength != 0))
if ((cmdqelmt->buffer != NULL) &&
(cmdqelmt->bufferlength != 0))
os_free_mem(cmdqelmt->buffer);
os_free_mem(cmdqelmt);
}
} /* end of while */
} /* end of while */
}
void RtmpCmdQExit(RTMP_ADAPTER *pAd)
@ -618,4 +645,3 @@ void RtmpCmdQInit(RTMP_ADAPTER *pAd)
cmdq_starv_block_init(&pAd->starv_log_ctrl, &pAd->CmdQ);
#endif /*DBG_STARVATION*/
}

View File

@ -46,8 +46,7 @@ static inline VOID CarrierDetectionResetStatus(PRTMP_ADAPTER pAd)
RTMP_CARRIER_IO_WRITE8(pAd, 1, 1);
}
static inline VOID CarrierDetectionStatusGet(PRTMP_ADAPTER pAd,
PUINT8 pStatus)
static inline VOID CarrierDetectionStatusGet(PRTMP_ADAPTER pAd, PUINT8 pStatus)
{
struct _RTMP_CHIP_CAP *cap = hc_get_chip_cap(pAd->hdev_ctrl);
*pStatus = 0;
@ -55,13 +54,12 @@ static inline VOID CarrierDetectionStatusGet(PRTMP_ADAPTER pAd,
if (cap->carrier_func == TONE_RADAR_V3) {
UINT32 mac_value = 0;
RTMP_BBP_IO_READ32(pAd, TR_R1, &mac_value);
*pStatus = (UINT8) mac_value;
*pStatus = (UINT8)mac_value;
} else
RTMP_CARRIER_IO_READ8(pAd, 1, pStatus);
}
static inline VOID CarrierDetectionEnable(PRTMP_ADAPTER pAd,
BOOLEAN bEnable)
static inline VOID CarrierDetectionEnable(PRTMP_ADAPTER pAd, BOOLEAN bEnable)
{
struct _RTMP_CHIP_CAP *cap = hc_get_chip_cap(pAd->hdev_ctrl);
@ -71,7 +69,6 @@ static inline VOID CarrierDetectionEnable(PRTMP_ADAPTER pAd,
RTMP_CARRIER_IO_WRITE8(pAd, 0, bEnable);
}
/*
==========================================================================
Description:
@ -84,8 +81,7 @@ static inline VOID CarrierDetectionEnable(PRTMP_ADAPTER pAd,
Note:
==========================================================================
*/
INT isCarrierDetectExist(
IN PRTMP_ADAPTER pAd)
INT isCarrierDetectExist(IN PRTMP_ADAPTER pAd)
{
if (pAd->CommonCfg.CarrierDetect.CD_State == CD_SILENCE)
return TRUE;
@ -111,15 +107,16 @@ INT isCarrierDetectExist(
*/
INT Set_CarrierDetect_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
POS_COOKIE pObj = (POS_COOKIE)pAd->OS_Cookie;
UCHAR apidx = pObj->ioctl_if;
UINT Enable;
if (apidx != MAIN_MBSSID)
return FALSE;
Enable = (UINT) os_str_tol(arg, 0, 10);
pAd->CommonCfg.CarrierDetect.Enable = (BOOLEAN)(Enable == 0 ? FALSE : TRUE);
Enable = (UINT)os_str_tol(arg, 0, 10);
pAd->CommonCfg.CarrierDetect.Enable =
(BOOLEAN)(Enable == 0 ? FALSE : TRUE);
RTMP_CHIP_RADAR_GLRT_COMPENSATE(pAd);
RTMP_CHIP_CCK_MRC_STATUS_CTRL(pAd);
@ -128,13 +125,15 @@ INT Set_CarrierDetect_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
else
CarrierDetectionStop(pAd);
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s:: %s\n", __func__,
pAd->CommonCfg.CarrierDetect.Enable == TRUE ? "Enable Carrier Detection" : "Disable Carrier Detection"));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s:: %s\n", __func__,
pAd->CommonCfg.CarrierDetect.Enable == TRUE ?
"Enable Carrier Detection" :
"Disable Carrier Detection"));
return TRUE;
}
#endif /* CONFIG_AP_SUPPORT */
/*
==========================================================================
Description:
@ -150,10 +149,10 @@ INT Set_CarrierDetect_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
Note:
==========================================================================
*/
VOID CarrierDetectionPeriodicStateCtrl(
IN PRTMP_ADAPTER pAd)
VOID CarrierDetectionPeriodicStateCtrl(IN PRTMP_ADAPTER pAd)
{
PCARRIER_DETECTION_STRUCT pCarrierDetect = &pAd->CommonCfg.CarrierDetect;
PCARRIER_DETECTION_STRUCT pCarrierDetect =
&pAd->CommonCfg.CarrierDetect;
CD_STATE *pCD_State = &pCarrierDetect->CD_State;
ULONG *pOneSecIntCount = &pCarrierDetect->OneSecIntCount;
struct _RTMP_CHIP_CAP *cap = hc_get_chip_cap(pAd->hdev_ctrl);
@ -168,8 +167,9 @@ VOID CarrierDetectionPeriodicStateCtrl(
/* TODO: shiang-7603 */
if (IS_HIF_TYPE(pAd, HIF_MT)) {
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s(%d): Not support for HIF_MT yet!\n",
__func__, __LINE__));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("%s(%d): Not support for HIF_MT yet!\n", __func__,
__LINE__));
return;
}
@ -182,23 +182,24 @@ VOID CarrierDetectionPeriodicStateCtrl(
if (TrStatus) {
if (*pCD_State == CD_NORMAL) {
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("Carrier Detected ! (TrStatus = 0x%x)\n", TrStatus));
MTWF_LOG(
DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_OFF,
("Carrier Detected ! (TrStatus = 0x%x)\n",
TrStatus));
*pCD_State = CD_SILENCE;
/* stop all TX actions including Beacon sending.*/
AsicDisableSync(pAd, HW_BSSID_0);
}
*pOneSecIntCount = pCarrierDetect->CarrierGoneThreshold;
*pOneSecIntCount = pCarrierDetect->CarrierGoneThreshold;
CarrierDetectionResetStatus(pAd);
} else
*pOneSecIntCount = 0;
*pOneSecIntCount = 0;
/*CarrierDetectionResetStatus(pAd);*/
}
}
/*
==========================================================================
Description:
@ -214,17 +215,19 @@ VOID CarrierDetectionPeriodicStateCtrl(
Note:
==========================================================================
*/
VOID RTMPHandleRadarInterrupt(PRTMP_ADAPTER pAd)
VOID RTMPHandleRadarInterrupt(PRTMP_ADAPTER pAd)
{
UINT32 value, delta;
UCHAR bbp = 0;
PCARRIER_DETECTION_STRUCT pCarrierDetect = &pAd->CommonCfg.CarrierDetect;
PCARRIER_DETECTION_STRUCT pCarrierDetect =
&pAd->CommonCfg.CarrierDetect;
struct _RTMP_CHIP_CAP *cap = hc_get_chip_cap(pAd->hdev_ctrl);
if (cap->carrier_func > TONE_RADAR_V2)
return;
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("RTMPHandleRadarInterrupt()\n"));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("RTMPHandleRadarInterrupt()\n"));
RTMP_IO_READ32(pAd, PBF_LIFE_TIMER, &value);
RTMP_IO_READ32(pAd, CH_IDLE_STA, &pCarrierDetect->idle_time);
pCarrierDetect->busy_time = AsicGetChBusyCnt(pAd, 0);
@ -254,14 +257,16 @@ VOID RTMPHandleRadarInterrupt(PRTMP_ADAPTER pAd)
pCarrierDetect->Debug = 0;
for (i = 0; i < 20; i++)
printk("%3d %4ld %ld %ld\n", i, time[i], idle[i], busy[i]);
printk("%3d %4ld %ld %ld\n", i, time[i],
idle[i], busy[i]);
cd_idx = 0;
}
}
if (pCarrierDetect->CD_State == CD_NORMAL) {
if ((delta < pCarrierDetect->criteria) && (pCarrierDetect->recheck))
if ((delta < pCarrierDetect->criteria) &&
(pCarrierDetect->recheck))
pCarrierDetect->recheck--;
else
pCarrierDetect->recheck = pCarrierDetect->recheck1;
@ -271,7 +276,8 @@ VOID RTMPHandleRadarInterrupt(PRTMP_ADAPTER pAd)
pCarrierDetect->CD_State = CD_SILENCE;
if (pCarrierDetect->Debug != DBG_LVL_TRACE) {
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Carrier Detected\n"));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL,
DBG_LVL_TRACE, ("Carrier Detected\n"));
/* stop all TX actions including Beacon sending.*/
AsicDisableSync(pAd, HW_BSSID_0);
} else
@ -283,14 +289,14 @@ VOID RTMPHandleRadarInterrupt(PRTMP_ADAPTER pAd)
CarrierDetectionStatusGet(pAd, &bbp);
if (bbp & 0x1) {
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("CS bit not cleared!!!\n"));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("CS bit not cleared!!!\n"));
CarrierDetectionResetStatus(pAd);
}
/* re-enable carrier detection */
CarrierDetectionEnable(pAd, 1);
} else if (cap->carrier_func == TONE_RADAR_V1 &&
pCarrierDetect->Enable)
} else if (cap->carrier_func == TONE_RADAR_V1 && pCarrierDetect->Enable)
ToneRadarProgram(pAd);
}
@ -307,8 +313,7 @@ VOID RTMPHandleRadarInterrupt(PRTMP_ADAPTER pAd)
Note:
==========================================================================
*/
INT CarrierDetectReset(
IN PRTMP_ADAPTER pAd)
INT CarrierDetectReset(IN PRTMP_ADAPTER pAd)
{
pAd->CommonCfg.CarrierDetect.CD_State = CD_NORMAL;
return 0;
@ -357,7 +362,8 @@ INT Set_CarrierCriteria_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
INT Set_CarrierReCheck_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
pAd->CommonCfg.CarrierDetect.recheck1 = os_str_tol(arg, 0, 10);
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Set Recheck = %u\n", pAd->CommonCfg.CarrierDetect.recheck1));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("Set Recheck = %u\n", pAd->CommonCfg.CarrierDetect.recheck1));
return TRUE;
}
@ -380,8 +386,11 @@ INT Set_CarrierReCheck_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
*/
INT Set_CarrierGoneThreshold_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
pAd->CommonCfg.CarrierDetect.CarrierGoneThreshold = os_str_tol(arg, 0, 10);
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("Set CarrierGoneThreshold = %u\n", pAd->CommonCfg.CarrierDetect.CarrierGoneThreshold));
pAd->CommonCfg.CarrierDetect.CarrierGoneThreshold =
os_str_tol(arg, 0, 10);
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("Set CarrierGoneThreshold = %u\n",
pAd->CommonCfg.CarrierDetect.CarrierGoneThreshold));
return TRUE;
}
@ -400,10 +409,11 @@ INT Set_CarrierGoneThreshold_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
Note:
==========================================================================
*/
INT Set_CarrierDebug_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
INT Set_CarrierDebug_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
pAd->CommonCfg.CarrierDetect.Debug = os_str_tol(arg, 0, 10);
printk("pAd->CommonCfg.CarrierDetect.Debug = %ld\n", pAd->CommonCfg.CarrierDetect.Debug);
printk("pAd->CommonCfg.CarrierDetect.Debug = %ld\n",
pAd->CommonCfg.CarrierDetect.Debug);
return TRUE;
}
@ -423,7 +433,7 @@ INT Set_CarrierDebug_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
Note:
==========================================================================
*/
INT Set_CarrierDelta_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
INT Set_CarrierDelta_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
pAd->CommonCfg.CarrierDetect.delta = os_str_tol(arg, 0, 10);
printk("Delta = %d\n", pAd->CommonCfg.CarrierDetect.delta);
@ -446,7 +456,7 @@ INT Set_CarrierDelta_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
Note:
==========================================================================
*/
INT Set_CarrierDivFlag_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
INT Set_CarrierDivFlag_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
pAd->CommonCfg.CarrierDetect.div_flag = os_str_tol(arg, 0, 10);
printk("DivFlag = %d\n", pAd->CommonCfg.CarrierDetect.div_flag);
@ -470,10 +480,11 @@ INT Set_CarrierDivFlag_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
Note:
==========================================================================
*/
INT Set_CarrierThrd_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
INT Set_CarrierThrd_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
pAd->CommonCfg.CarrierDetect.threshold = os_str_tol(arg, 0, 10);
printk("CarrThrd = %d(0x%x)\n", pAd->CommonCfg.CarrierDetect.threshold, pAd->CommonCfg.CarrierDetect.threshold);
printk("CarrThrd = %d(0x%x)\n", pAd->CommonCfg.CarrierDetect.threshold,
pAd->CommonCfg.CarrierDetect.threshold);
CarrierDetectionStart(pAd);
return TRUE;
}
@ -494,7 +505,7 @@ INT Set_CarrierThrd_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
Note:
==========================================================================
*/
INT Set_CarrierSymRund_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
INT Set_CarrierSymRund_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
pAd->CommonCfg.CarrierDetect.SymRund = os_str_tol(arg, 0, 10);
printk("SymRund = %d\n", pAd->CommonCfg.CarrierDetect.SymRund);
@ -523,7 +534,8 @@ INT Set_CarrierMask_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
pAd->CommonCfg.CarrierDetect.VGA_Mask = os_str_tol(arg, 0, 10);
pAd->CommonCfg.CarrierDetect.Packet_End_Mask = os_str_tol(arg, 0, 10);
pAd->CommonCfg.CarrierDetect.Rx_PE_Mask = os_str_tol(arg, 0, 10);
printk("CarrMask = %u(%x)\n", pAd->CommonCfg.CarrierDetect.VGA_Mask, pAd->CommonCfg.CarrierDetect.VGA_Mask);
printk("CarrMask = %u(%x)\n", pAd->CommonCfg.CarrierDetect.VGA_Mask,
pAd->CommonCfg.CarrierDetect.VGA_Mask);
CarrierDetectionStart(pAd);
return TRUE;
}
@ -542,10 +554,10 @@ INT Set_CarrierMask_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
Note:
==========================================================================
*/
VOID CSInit(
IN PRTMP_ADAPTER pAd)
VOID CSInit(IN PRTMP_ADAPTER pAd)
{
PCARRIER_DETECTION_STRUCT pCarrierDetect = &pAd->CommonCfg.CarrierDetect;
PCARRIER_DETECTION_STRUCT pCarrierDetect =
&pAd->CommonCfg.CarrierDetect;
pCarrierDetect->TimeStamp = 0;
pCarrierDetect->recheck = pCarrierDetect->recheck1;
pCarrierDetect->OneSecIntCount = 0;
@ -570,7 +582,8 @@ VOID CarrierDetectionStart(PRTMP_ADAPTER pAd)
{
/*ULONG Value;*/
/* Enable Bandwidth usage monitor*/
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("CarrierDetectionStart\n"));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("CarrierDetectionStart\n"));
/*RTMP_IO_READ32(pAd, CH_TIME_CFG, &Value);*/
/*RTMP_IO_WRITE32(pAd, CH_TIME_CFG, Value | 0x1f); */
@ -581,7 +594,8 @@ VOID CarrierDetectionStart(PRTMP_ADAPTER pAd)
/* trun on interrupt polling for pcie device */
if (pAd->infType == RTMP_DEV_INF_PCIE)
AsicSendCommandToMcu(pAd, CD_INT_POLLING_CMD, 0xff, 0x01, 0x00, FALSE);
AsicSendCommandToMcu(pAd, CD_INT_POLLING_CMD, 0xff,
0x01, 0x00, FALSE);
pAd->CommonCfg.CarrierDetect.bCsInit = TRUE;
}
@ -601,7 +615,7 @@ VOID CarrierDetectionStart(PRTMP_ADAPTER pAd)
Note:
==========================================================================
*/
VOID CarrierDetectionStop(IN PRTMP_ADAPTER pAd)
VOID CarrierDetectionStop(IN PRTMP_ADAPTER pAd)
{
CarrierDetectReset(pAd);
CarrierDetectionEnable(pAd, 0);
@ -629,7 +643,7 @@ static VOID ToneRadarProgram(PRTMP_ADAPTER pAd)
CHAR bw = HcGetBw(pAd, wdev);
/* if wireless mode is 20Mhz mode, then the threshold should div by 2 */
if (bw == BW_20)
if (bw == BW_20)
threshold = pAd->CommonCfg.CarrierDetect.threshold >> 1;
else
threshold = pAd->CommonCfg.CarrierDetect.threshold;
@ -655,7 +669,8 @@ static VOID ToneRadarProgram(PRTMP_ADAPTER pAd)
VOID ToneRadarProgram_v1(PRTMP_ADAPTER pAd, ULONG threshold)
{
UCHAR bbp;
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("ToneRadarProgram v1\n"));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("ToneRadarProgram v1\n"));
/* programe delta delay & division bit*/
BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R184, 0xf0);
bbp = pAd->CommonCfg.CarrierDetect.delta << 4;
@ -692,15 +707,17 @@ VOID ToneRadarProgram_v2(PRTMP_ADAPTER pAd, ULONG threshold)
{
UCHAR bbp;
/* programe delta delay & division bit*/
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("ToneRadarProgram v2\n"));
bbp = pAd->CommonCfg.CarrierDetect.delta | \
((pAd->CommonCfg.CarrierDetect.SymRund & 0x3) << 4) | \
((pAd->CommonCfg.CarrierDetect.div_flag & 0x1) << 6) | \
0x80; /* Full 40MHz Detection Mode */
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("ToneRadarProgram v2\n"));
bbp = pAd->CommonCfg.CarrierDetect.delta |
((pAd->CommonCfg.CarrierDetect.SymRund & 0x3) << 4) |
((pAd->CommonCfg.CarrierDetect.div_flag & 0x1) << 6) |
0x80; /* Full 40MHz Detection Mode */
RTMP_CARRIER_IO_WRITE8(pAd, 5, bbp);
/* program *_mask*/
RTMP_CARRIER_IO_WRITE8(pAd, 2, pAd->CommonCfg.CarrierDetect.VGA_Mask);
RTMP_CARRIER_IO_WRITE8(pAd, 3, pAd->CommonCfg.CarrierDetect.Packet_End_Mask);
RTMP_CARRIER_IO_WRITE8(pAd, 3,
pAd->CommonCfg.CarrierDetect.Packet_End_Mask);
RTMP_CARRIER_IO_WRITE8(pAd, 4, pAd->CommonCfg.CarrierDetect.Rx_PE_Mask);
/* program threshold*/
RTMP_CARRIER_IO_WRITE8(pAd, 6, threshold & 0xff);
@ -731,7 +748,8 @@ VOID ToneRadarProgram_v3(PRTMP_ADAPTER pAd, ULONG threshold)
Carrier Sense (Tone Radar) BBP initialization
(MT7650 Carrier sense programming guide_v1_20120824.docx)
*/
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("ToneRadarProgram v3\n"));
MTWF_LOG(DBG_CAT_HW, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("ToneRadarProgram v3\n"));
CarrierDetectionEnable(pAd, 0);
RTMP_BBP_IO_WRITE32(pAd, TR_R2, 0x002d002d);
RTMP_BBP_IO_WRITE32(pAd, TR_R3, 0x0003002d);
@ -740,6 +758,4 @@ VOID ToneRadarProgram_v3(PRTMP_ADAPTER pAd, ULONG threshold)
CarrierDetectionEnable(pAd, 1);
}
#endif /* CARRIER_DETECTION_SUPPORT */

View File

@ -23,7 +23,8 @@
#include "rt_config.h"
static INT build_wsc_probe_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *buf)
static INT build_wsc_probe_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev,
UCHAR *buf)
{
INT len = 0;
#ifdef WSC_INCLUDED
@ -31,17 +32,17 @@ static INT build_wsc_probe_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHA
if (wdev->wdev_type == WDEV_TYPE_APCLI) {
#ifdef APCLI_SUPPORT
/*
/*
Append WSC information in probe request if WSC state is running
*/
if ((wdev->WscControl.WscConfMode != WSC_DISABLE) &&
(wdev->WscControl.bWscTrigger))
bHasWscIe = TRUE;
if ((wdev->WscControl.WscConfMode != WSC_DISABLE) &&
(wdev->WscControl.bWscTrigger))
bHasWscIe = TRUE;
#if defined(WSC_V2_SUPPORT) && !defined(CONFIG_MAP_SUPPORT) && !defined(CON_WPS)
/* need to check if !defined(CONFIG_MAP_SUPPORT) is necessary */
else if (wdev->WscControl.WscV2Info.bEnableWpsV2)
bHasWscIe = TRUE;
/* need to check if !defined(CONFIG_MAP_SUPPORT) is necessary */
else if (wdev->WscControl.WscV2Info.bEnableWpsV2)
bHasWscIe = TRUE;
#endif /* WSC_V2_SUPPORT */
#endif /* APCLI_SUPPORT */
#ifdef CON_WPS
@ -51,15 +52,17 @@ static INT build_wsc_probe_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHA
bHasWscIe = FALSE;
pWscControl = &wdev->WscControl;
if ((pWscControl->conWscStatus == CON_WPS_STATUS_DISABLED) ||
(pAd->ApCfg.ConWpsApCliMode != CON_WPS_APCLI_BAND_AUTO))
if ((pWscControl->conWscStatus ==
CON_WPS_STATUS_DISABLED) ||
(pAd->ApCfg.ConWpsApCliMode !=
CON_WPS_APCLI_BAND_AUTO))
bHasWscIe = TRUE;
MTWF_LOG(DBG_CAT_PROTO, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("[scan_active: %d] ConWpsApCliMode=%d conWscStatus=%d bHasWscIe=%d\n",
__LINE__, pAd->ApCfg.ConWpsApCliMode,
pWscControl->conWscStatus, bHasWscIe));
MTWF_LOG(
DBG_CAT_PROTO, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("[scan_active: %d] ConWpsApCliMode=%d conWscStatus=%d bHasWscIe=%d\n",
__LINE__, pAd->ApCfg.ConWpsApCliMode,
pWscControl->conWscStatus, bHasWscIe));
}
#endif /*CON_WPS*/
} else if (wdev->wdev_type == WDEV_TYPE_STA) {
@ -76,14 +79,16 @@ static INT build_wsc_probe_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHA
MAKE_IE_TO_BUF(buf, pWscBuf, WscIeLen, len);
os_free_mem(pWscBuf);
} else
MTWF_LOG(DBG_CAT_PROTO, DBG_SUBCAT_ALL, DBG_LVL_WARN, ("%s:: WscBuf Allocate failed!\n", __func__));
MTWF_LOG(DBG_CAT_PROTO, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("%s:: WscBuf Allocate failed!\n", __func__));
}
#endif /* WSC_INCLUDED */
return len;
}
static INT build_wsc_probe_rsp_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *buf)
static INT build_wsc_probe_rsp_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev,
UCHAR *buf)
{
INT len = 0;
@ -94,9 +99,9 @@ static INT build_wsc_probe_rsp_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHA
/* for windows 7 logo test */
if ((wdev->WscControl.WscConfMode != WSC_DISABLE) &&
#ifdef DOT1X_SUPPORT
(!IS_IEEE8021X_Entry(wdev)) &&
(!IS_IEEE8021X_Entry(wdev)) &&
#endif /* DOT1X_SUPPORT */
(IS_CIPHER_WEP(wdev->SecConfig.PairwiseCipher))) {
(IS_CIPHER_WEP(wdev->SecConfig.PairwiseCipher))) {
/*
Non-WPS Windows XP and Vista PCs are unable to determine if a WEP enalbed network is static key based
or 802.1X based. If the legacy station gets an EAP-Rquest/Identity from the AP, it assume the WEP
@ -107,14 +112,18 @@ static INT build_wsc_probe_rsp_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHA
The IE would be 7 bytes long with the Extended Capability field set to 0 (all bits zero)
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/randz/protocol/securing_public_wi-fi_hotspots.asp
*/
const UCHAR PROVISION_SERVICE_IE[7] = {0xDD, 0x05, 0x00, 0x50, 0xF2, 0x05, 0x00};
const UCHAR PROVISION_SERVICE_IE[7] = {
0xDD, 0x05, 0x00, 0x50, 0xF2, 0x05, 0x00
};
MAKE_IE_TO_BUF(buf, PROVISION_SERVICE_IE, 7, len);
}
/* add Simple Config Information Element */
if ((wdev->WscControl.WscConfMode > WSC_DISABLE) && (wdev->WscIEProbeResp.ValueLen))
MAKE_IE_TO_BUF(buf, wdev->WscIEProbeResp.Value, wdev->WscIEProbeResp.ValueLen, len);
if ((wdev->WscControl.WscConfMode > WSC_DISABLE) &&
(wdev->WscIEProbeResp.ValueLen))
MAKE_IE_TO_BUF(buf, wdev->WscIEProbeResp.Value,
wdev->WscIEProbeResp.ValueLen, len);
break;
}
@ -126,7 +135,8 @@ static INT build_wsc_probe_rsp_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHA
/* PSTA_ADMIN_CONFIG pStaCfg = GetStaCfgByWdev(pAd,wdev); */
/* add Simple Config Information Element */
if (wdev->WscIEProbeResp.ValueLen != 0)
MAKE_IE_TO_BUF(buf, wdev->WscIEProbeResp.Value, wdev->WscIEProbeResp.ValueLen, len);
MAKE_IE_TO_BUF(buf, wdev->WscIEProbeResp.Value,
wdev->WscIEProbeResp.ValueLen, len);
break;
}
@ -137,28 +147,29 @@ static INT build_wsc_probe_rsp_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHA
return len;
}
static INT build_wsc_assoc_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *buf)
static INT build_wsc_assoc_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev,
UCHAR *buf)
{
INT len = 0;
#ifdef WSC_STA_SUPPORT
/* Add WSC IE if we are connecting to WSC AP */
if ((wdev->WscControl.WscEnAssociateIE) &&
(wdev->WscControl.WscConfMode != WSC_DISABLE) &&
(wdev->WscControl.bWscTrigger)) {
(wdev->WscControl.WscConfMode != WSC_DISABLE) &&
(wdev->WscControl.bWscTrigger)) {
UCHAR *pWscBuf = NULL, WscIeLen = 0;
os_alloc_mem(pAd, (UCHAR **) &pWscBuf, 512);
os_alloc_mem(pAd, (UCHAR **)&pWscBuf, 512);
if (pWscBuf != NULL) {
NdisZeroMemory(pWscBuf, 512);
WscBuildAssocReqIE(&wdev->WscControl, pWscBuf, &WscIeLen);
WscBuildAssocReqIE(&wdev->WscControl, pWscBuf,
&WscIeLen);
MAKE_IE_TO_BUF(buf, pWscBuf, WscIeLen, len);
os_free_mem(pWscBuf);
} else
MTWF_LOG(DBG_CAT_CLIENT, DBG_SUBCAT_ALL, DBG_LVL_WARN,
("%s:: WscBuf Allocate failed!\n",
__func__));
("%s:: WscBuf Allocate failed!\n", __func__));
}
#endif /* WSC_STA_SUPPORT */
@ -170,38 +181,45 @@ INT build_wsc_ie(RTMP_ADAPTER *pAd, struct _build_ie_info *info)
INT len = 0;
if (info->frame_subtype == SUBTYPE_PROBE_REQ)
len += build_wsc_probe_req_ie(pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
len += build_wsc_probe_req_ie(pAd, info->wdev,
(UCHAR *)(info->frame_buf + len));
else if (info->frame_subtype == SUBTYPE_PROBE_RSP)
len += build_wsc_probe_rsp_ie(pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
len += build_wsc_probe_rsp_ie(pAd, info->wdev,
(UCHAR *)(info->frame_buf + len));
else if (info->frame_subtype == SUBTYPE_ASSOC_REQ)
len += build_wsc_assoc_req_ie(pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
len += build_wsc_assoc_req_ie(pAd, info->wdev,
(UCHAR *)(info->frame_buf + len));
return len;
}
INT build_extra_probe_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *buf)
INT build_extra_probe_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev,
UCHAR *buf)
{
INT len = 0;
SCAN_INFO *ScanInfo = &wdev->ScanInfo;
#ifdef RT_CFG80211_SUPPORT
#ifdef APCLI_CFG80211_SUPPORT
if ((pAd->ApCfg.ApCliTab[wdev->func_idx].wpa_supplicant_info.WpaSupplicantUP != WPA_SUPPLICANT_DISABLE) &&
(pAd->cfg80211_ctrl.ExtraIeLen > 0)) {
if ((pAd->ApCfg.ApCliTab[wdev->func_idx]
.wpa_supplicant_info.WpaSupplicantUP !=
WPA_SUPPLICANT_DISABLE) &&
(pAd->cfg80211_ctrl.ExtraIeLen > 0)) {
MAKE_IE_TO_BUF(buf, pAd->cfg80211_ctrl.pExtraIe,
pAd->cfg80211_ctrl.ExtraIeLen, len);
pAd->cfg80211_ctrl.ExtraIeLen, len);
}
#endif /* APCLI_CFG80211_SUPPORT */
#endif /* RT_CFG80211_SUPPORT */
if (ScanInfo->ExtraIeLen && ScanInfo->ExtraIe) {
MAKE_IE_TO_BUF(buf, ScanInfo->ExtraIe,
ScanInfo->ExtraIeLen, len);
MAKE_IE_TO_BUF(buf, ScanInfo->ExtraIe, ScanInfo->ExtraIeLen,
len);
}
return len;
}
INT build_extra_assoc_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *buf)
INT build_extra_assoc_req_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev,
UCHAR *buf)
{
INT len = 0;
return len;
@ -212,16 +230,19 @@ INT build_extra_ie(RTMP_ADAPTER *pAd, struct _build_ie_info *info)
INT len = 0;
if (info->frame_subtype == SUBTYPE_PROBE_REQ)
len += build_extra_probe_req_ie(pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
len += build_extra_probe_req_ie(
pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
else if (info->frame_subtype == SUBTYPE_ASSOC_REQ)
len += build_extra_assoc_req_ie(pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
len += build_extra_assoc_req_ie(
pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
return len;
}
#ifdef CONFIG_AP_SUPPORT
/* Extended Capabilities IE */
INT build_ap_extended_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *buf)
INT build_ap_extended_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev,
UCHAR *buf)
{
INT len = 0;
ULONG infoPos;
@ -238,8 +259,8 @@ INT build_ap_extended_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *bu
/* P802.11n_D1.10, HT Information Exchange Support */
if ((pAd->CommonCfg.bBssCoexEnable == TRUE) &&
WMODE_CAP_N(wdev->PhyMode) && (wdev->channel <= 14) &&
(wdev->DesiredHtPhyInfo.bHtEnable))
WMODE_CAP_N(wdev->PhyMode) && (wdev->channel <= 14) &&
(wdev->DesiredHtPhyInfo.bHtEnable))
extCapInfo.BssCoexistMgmtSupport = 1;
#endif /* DOT11N_DRAFT3 */
@ -268,12 +289,20 @@ INT build_ap_extended_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *bu
extCapInfo.interworking = 1;
#endif
#if defined(CONFIG_HOTSPOT) || defined(FTM_SUPPORT)
#if defined(CONFIG_HOTSPOT) || defined(FTM_SUPPORT) || \
defined(CONFIG_DOT11U_INTERWORKING)
if (mbss->GASCtrl.b11U_enable)
extCapInfo.interworking = 1;
#endif
#ifdef DOT11_VHT_AC
if (WMODE_CAP_AC(wdev->PhyMode) && (wdev->channel > 14))
extCapInfo.operating_mode_notification = 1;
#endif /* DOT11_VHT_AC */
#ifdef FTM_SUPPORT
/* add IE_EXT_CAPABILITY IE here */
@ -292,6 +321,28 @@ INT build_ap_extended_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *bu
*/
extCapInfo.ftm_resp = 1;
#endif /* FTM_SUPPORT */
#ifdef OCE_FILS_SUPPORT
if (IS_AKM_FILS(wdev->SecConfig.AKMMap))
extCapInfo.FILSCap = 1;
#endif /* OCE_FILS_SUPPORT */
#ifdef DOT11_SAE_PWD_ID_SUPPORT
{
struct _SECURITY_CONFIG *sec_cfg = &wdev->SecConfig;
if (IS_AKM_SAE(sec_cfg->AKMMap) && sec_cfg->pwd_id_cnt != 0)
extCapInfo.sae_pwd_id_in_use = 1;
else
extCapInfo.sae_pwd_id_in_use = 0;
if (IS_AKM_SAE(sec_cfg->AKMMap) && sec_cfg->sae_cap.pwd_id_only)
extCapInfo.sae_pwd_id_used_exclusively = 1;
else
extCapInfo.sae_pwd_id_used_exclusively = 0;
}
#endif
pInfo = (PUCHAR)(&extCapInfo);
for (infoPos = 0; infoPos < extInfoLen; infoPos++) {
@ -302,7 +353,8 @@ INT build_ap_extended_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *bu
}
if (bNeedAppendExtIE == TRUE) {
for (infoPos = (extInfoLen - 1); infoPos >= EXT_CAP_MIN_SAFE_LENGTH; infoPos--) {
for (infoPos = (extInfoLen - 1);
infoPos >= EXT_CAP_MIN_SAFE_LENGTH; infoPos--) {
if (pInfo[infoPos] == 0)
extInfoLen--;
else
@ -312,7 +364,7 @@ INT build_ap_extended_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *bu
RTMPEndianChange((UCHAR *)&extCapInfo, 8);
#endif
MAKE_IE_TO_BUF(buf, &ExtCapIe, 1, len);
MAKE_IE_TO_BUF(buf, &ExtCapIe, 1, len);
MAKE_IE_TO_BUF(buf, &extInfoLen, 1, len);
MAKE_IE_TO_BUF(buf, &extCapInfo, extInfoLen, len);
}
@ -329,7 +381,8 @@ INT build_extended_cap_ie(RTMP_ADAPTER *pAd, struct _build_ie_info *info)
switch (wdev->wdev_type) {
default:
#ifdef CONFIG_AP_SUPPORT
len += build_ap_extended_cap_ie(pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
len += build_ap_extended_cap_ie(
pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
#endif /* CONFIG_AP_SUPPORT */
break;
}
@ -338,11 +391,14 @@ INT build_extended_cap_ie(RTMP_ADAPTER *pAd, struct _build_ie_info *info)
}
#ifdef CONFIG_AP_SUPPORT
static INT build_ap_wmm_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *buf)
static INT build_ap_wmm_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev,
UCHAR *buf)
{
INT len = 0;
UCHAR i;
UCHAR WmeParmIe[26] = {IE_VENDOR_SPECIFIC, 24, 0x00, 0x50, 0xf2, 0x02, 0x01, 0x01, 0, 0};
UCHAR WmeParmIe[26] = {
IE_VENDOR_SPECIFIC, 24, 0x00, 0x50, 0xf2, 0x02, 0x01, 0x01, 0, 0
};
UINT8 AIFSN[4];
#ifdef UAPSD_SUPPORT
BSS_STRUCT *pMbss = wdev->func_dev;
@ -357,13 +413,20 @@ static INT build_ap_wmm_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *
NdisMoveMemory(AIFSN, pBssEdca->Aifsn, sizeof(AIFSN));
for (i = QID_AC_BK; i <= QID_AC_VO; i++) {
WmeParmIe[10 + (i * 4)] = (i << 5) + /* b5-6 is ACI */
((UCHAR)pBssEdca->bACM[i] << 4) + /* b4 is ACM */
(AIFSN[i] & 0x0f); /* b0-3 is AIFSN */
WmeParmIe[11 + (i * 4)] = (pBssEdca->Cwmax[i] << 4) + /* b5-8 is CWMAX */
(pBssEdca->Cwmin[i] & 0x0f); /* b0-3 is CWMIN */
WmeParmIe[12 + (i * 4)] = (UCHAR)(pBssEdca->Txop[i] & 0xff); /* low byte of TXOP */
WmeParmIe[13 + (i * 4)] = (UCHAR)(pBssEdca->Txop[i] >> 8); /* high byte of TXOP */
WmeParmIe[10 + (i * 4)] =
(i << 5) + /* b5-6 is ACI */
((UCHAR)pBssEdca->bACM[i]
<< 4) + /* b4 is ACM */
(AIFSN[i] & 0x0f); /* b0-3 is AIFSN */
WmeParmIe[11 + (i * 4)] =
(pBssEdca->Cwmax[i] << 4) + /* b5-8 is CWMAX */
(pBssEdca->Cwmin[i] & 0x0f); /* b0-3 is CWMIN */
WmeParmIe[12 + (i * 4)] =
(UCHAR)(pBssEdca->Txop[i] &
0xff); /* low byte of TXOP */
WmeParmIe[13 + (i * 4)] =
(UCHAR)(pBssEdca->Txop[i] >>
8); /* high byte of TXOP */
}
MAKE_IE_TO_BUF(buf, WmeParmIe, 26, len);
@ -373,7 +436,6 @@ static INT build_ap_wmm_cap_ie(RTMP_ADAPTER *pAd, struct wifi_dev *wdev, UCHAR *
}
#endif /* CONFIG_AP_SUPPORT */
INT build_wmm_cap_ie(RTMP_ADAPTER *pAd, struct _build_ie_info *info)
{
INT len = 0;
@ -383,10 +445,10 @@ INT build_wmm_cap_ie(RTMP_ADAPTER *pAd, struct _build_ie_info *info)
return len;
switch (wdev->wdev_type) {
default:
#ifdef CONFIG_AP_SUPPORT
len += build_ap_wmm_cap_ie(pAd, info->wdev, (UCHAR *)(info->frame_buf + len));
len += build_ap_wmm_cap_ie(pAd, info->wdev,
(UCHAR *)(info->frame_buf + len));
#endif /* CONFIG_AP_SUPPORT */
break;
}
@ -394,3 +456,130 @@ INT build_wmm_cap_ie(RTMP_ADAPTER *pAd, struct _build_ie_info *info)
return len;
}
ULONG build_support_rate_ie(struct wifi_dev *wdev, UCHAR *sup_rate,
UCHAR sup_rate_len, UCHAR *buf)
{
ULONG frame_len;
ULONG bss_mem_selector_len = 0;
UCHAR bss_mem_selector_code = BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_SAE_H2E_ONLY;
USHORT PhyMode = wdev->PhyMode;
UCHAR real_sup_rate_len = sup_rate_len;
UCHAR total_len;
if (PhyMode == WMODE_B)
real_sup_rate_len = 4;
#ifdef DOT11_SAE_SUPPORT
if (wdev->SecConfig.sae_cap.gen_pwe_method == PWE_HASH_ONLY &&
real_sup_rate_len < 8)
bss_mem_selector_len++;
#endif
total_len = real_sup_rate_len + bss_mem_selector_len;
MakeOutgoingFrame(buf, &frame_len, 1, &SupRateIe, 1, &total_len,
real_sup_rate_len, sup_rate, bss_mem_selector_len,
&bss_mem_selector_code, END_OF_ARGS);
return frame_len;
}
ULONG build_support_ext_rate_ie(struct wifi_dev *wdev, UCHAR sup_rate_len,
UCHAR *ext_sup_rate, UCHAR ext_sup_rate_len,
UCHAR *buf)
{
ULONG frame_len = 0;
ULONG bss_mem_selector_len = 0;
UCHAR bss_mem_selector_code = BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_SAE_H2E_ONLY;
USHORT PhyMode = wdev->PhyMode;
UCHAR total_len;
if (PhyMode == WMODE_B)
return frame_len;
#ifdef DOT11_SAE_SUPPORT
if (sup_rate_len >= 8 &&
wdev->SecConfig.sae_cap.gen_pwe_method == PWE_HASH_ONLY)
bss_mem_selector_len++;
#endif
if (ext_sup_rate_len == 0 && bss_mem_selector_len == 0)
return frame_len;
total_len = ext_sup_rate_len + bss_mem_selector_len;
MakeOutgoingFrame(buf, &frame_len, 1, &ExtRateIe, 1, &total_len,
ext_sup_rate_len, ext_sup_rate, bss_mem_selector_len,
&bss_mem_selector_code, END_OF_ARGS);
return frame_len;
}
VOID parse_support_rate_ie(struct dev_rate_info *rate, EID_STRUCT *eid_ptr)
{
UCHAR i = 0;
if ((eid_ptr->Len <= MAX_LEN_OF_SUPPORTED_RATES) &&
(eid_ptr->Len > 0)) {
rate->SupRateLen = 0;
for (i = 0; i < eid_ptr->Len; i++)
if (eid_ptr->Octet[i] !=
(BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_HT_PHY) &&
eid_ptr->Octet[i] !=
(BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_VHT_PHY) &&
eid_ptr->Octet[i] !=
(BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_SAE_H2E_ONLY) &&
eid_ptr->Octet[i] !=
(BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_HE_PHY))
rate->SupRate[rate->SupRateLen++] =
eid_ptr->Octet[i];
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_INFO,
("%s - IE_SUPP_RATES., Len=%d. Rates[0]=%x\n",
__func__, eid_ptr->Len, rate->SupRate[0]));
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_INFO,
("Rates[1]=%x %x %x %x %x %x %x\n", rate->SupRate[1],
rate->SupRate[2], rate->SupRate[3], rate->SupRate[4],
rate->SupRate[5], rate->SupRate[6],
rate->SupRate[7]));
} else {
UCHAR RateDefault[8] = { 0x82, 0x84, 0x8b, 0x96,
0x12, 0x24, 0x48, 0x6c };
/* HT rate not ready yet. return true temporarily. rt2860c */
/*MTWF_LOG(DBG_CAT_AP, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("PeerAssocReqSanity - wrong IE_SUPP_RATES\n")); */
NdisMoveMemory(rate->SupRate, RateDefault, 8);
rate->SupRateLen = 8;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE,
("%s - wrong IE_SUPP_RATES., Len=%d\n", __func__,
eid_ptr->Len));
}
}
VOID parse_support_ext_rate_ie(struct dev_rate_info *rate, EID_STRUCT *eid_ptr)
{
UINT16 i = 0;
if (eid_ptr->Len > MAX_LEN_OF_SUPPORTED_RATES) {
MTWF_LOG(
DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR,
("%s:ext support rate ie size(%d) is large than MAX_LEN_OF_SUPPORTED_RATE(%d))\n",
__func__, eid_ptr->Len, MAX_LEN_OF_SUPPORTED_RATES));
return;
}
rate->ExtRateLen = 0;
for (i = 0; i < eid_ptr->Len; i++)
if (eid_ptr->Octet[i] != (BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_HT_PHY) &&
eid_ptr->Octet[i] != (BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_VHT_PHY) &&
eid_ptr->Octet[i] !=
(BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_SAE_H2E_ONLY) &&
eid_ptr->Octet[i] != (BSS_MEMBERSHIP_SELECTOR_VALID |
BSS_MEMBERSHIP_SELECTOR_HE_PHY))
rate->ExtRate[rate->ExtRateLen++] = eid_ptr->Octet[i];
}

View File

@ -35,7 +35,6 @@
#include "rt_config.h"
extern MATProtoOps MATProtoIPHandle;
extern MATProtoOps MATProtoARPHandle;
extern MATProtoOps MATProtoPPPoEDisHandle;
@ -45,34 +44,34 @@ extern MATProtoOps MATProtoIPv6Handle;
extern UCHAR SNAP_802_1H[];
extern UCHAR SNAP_BRIDGE_TUNNEL[];
#define MAX_MAT_NODE_ENTRY_NUM 128 /* We support maximum 128 node entry for our system */
#define MAT_NODE_ENTRY_SIZE 40 /*28 // bytes //change to 40 for IPv6Mac Table */
#define MAX_MAT_NODE_ENTRY_NUM \
128 /* We support maximum 128 node entry for our system */
#define MAT_NODE_ENTRY_SIZE \
40 /*28 // bytes //change to 40 for IPv6Mac Table */
typedef struct _MATNodeEntry {
UCHAR data[MAT_NODE_ENTRY_SIZE];
struct _MATNodeEntry *next;
} MATNodeEntry, *PMATNodeEntry;
#ifdef KMALLOC_BATCH
/*static MATNodeEntry *MATNodeEntryPoll = NULL; */
#endif
static MATProtoTable MATProtoTb[] = {
{ETH_P_IP, &MATProtoIPHandle}, /* IP handler */
{ETH_P_ARP, &MATProtoARPHandle}, /* ARP handler */
{ETH_P_PPP_DISC, &MATProtoPPPoEDisHandle}, /* PPPoE discovery stage handler */
{ETH_P_PPP_SES, &MATProtoPPPoESesHandle}, /* PPPoE session stage handler */
{ETH_P_IPV6, &MATProtoIPv6Handle}, /* IPv6 handler */
{ ETH_P_IP, &MATProtoIPHandle }, /* IP handler */
{ ETH_P_ARP, &MATProtoARPHandle }, /* ARP handler */
{ ETH_P_PPP_DISC,
&MATProtoPPPoEDisHandle }, /* PPPoE discovery stage handler */
{ ETH_P_PPP_SES,
&MATProtoPPPoESesHandle }, /* PPPoE session stage handler */
{ ETH_P_IPV6, &MATProtoIPv6Handle }, /* IPv6 handler */
};
#define MAX_MAT_SUPPORT_PROTO_NUM (sizeof(MATProtoTb)/sizeof(MATProtoTable))
#define MAX_MAT_SUPPORT_PROTO_NUM (sizeof(MATProtoTb) / sizeof(MATProtoTable))
/* --------------------------------- Public Function-------------------------------- */
NDIS_STATUS MATDBEntryFree(
IN MAT_STRUCT * pMatStruct,
IN PUCHAR NodeEntry)
NDIS_STATUS MATDBEntryFree(IN MAT_STRUCT *pMatStruct, IN PUCHAR NodeEntry)
{
#ifdef KMALLOC_BATCH
MATNodeEntry *pPtr, *pMATNodeEntryPoll;
@ -92,7 +91,7 @@ NDIS_STATUS MATDBEntryFree(
return TRUE;
}
PUCHAR MATDBEntryAlloc(IN MAT_STRUCT * pMatStruct, IN UINT32 size)
PUCHAR MATDBEntryAlloc(IN MAT_STRUCT *pMatStruct, IN UINT32 size)
{
#ifdef KMALLOC_BATCH
MATNodeEntry *pPtr = NULL, *pMATNodeEntryPoll;
@ -110,7 +109,6 @@ PUCHAR MATDBEntryAlloc(IN MAT_STRUCT * pMatStruct, IN UINT32 size)
return (PUCHAR)pPtr;
}
VOID dumpPkt(PUCHAR pHeader, int len)
{
int i;
@ -120,16 +118,17 @@ VOID dumpPkt(PUCHAR pHeader, int len)
for (i = 0; i < len; i++) {
if ((i % 16 == 0) && (i != 0))
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF, ("\n"));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF,
("\n"));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF, ("%02x ", tmp[i] & 0xff));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF,
("%02x ", tmp[i] & 0xff));
}
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF, ("\n--EndDump\n"));
return;
}
/*
========================================================================
Routine Description:
@ -157,17 +156,14 @@ VOID dumpPkt(PUCHAR pHeader, int len)
handle DHCP packet.
========================================================================
*/
PUCHAR MATEngineTxHandle(
IN PRTMP_ADAPTER pAd,
IN PNDIS_PACKET pPkt,
IN UINT ifIdx,
IN UCHAR OpMode)
PUCHAR MATEngineTxHandle(IN PRTMP_ADAPTER pAd, IN PNDIS_PACKET pPkt,
IN UINT ifIdx, IN UCHAR OpMode)
{
PUCHAR pLayerHdr = NULL, pPktHdr = NULL, pMacAddr = NULL;
UINT16 protoType, protoType_ori;
INT i;
struct _MATProtoOps *pHandle = NULL;
PUCHAR retSkb = NULL;
PUCHAR pLayerHdr = NULL, pPktHdr = NULL, pMacAddr = NULL;
UINT16 protoType, protoType_ori;
INT i;
struct _MATProtoOps *pHandle = NULL;
PUCHAR retSkb = NULL;
BOOLEAN bVLANPkt = FALSE;
if (pAd->MatCfg.status != MAT_ENGINE_STAT_INITED)
@ -189,31 +185,41 @@ PUCHAR MATEngineTxHandle(
bVLANPkt = TRUE;
}
/* For differnet protocol, dispatch to specific handler */
for (i = 0; i < MAX_MAT_SUPPORT_PROTO_NUM; i++) {
if (protoType == MATProtoTb[i].protocol) {
pHandle = MATProtoTb[i].pHandle; /* the pHandle must not be null! */
pLayerHdr = bVLANPkt ? (pPktHdr + MAT_VLAN_ETH_HDR_LEN) : (pPktHdr + MAT_ETHER_HDR_LEN);
pHandle =
MATProtoTb[i]
.pHandle; /* the pHandle must not be null! */
pLayerHdr = bVLANPkt ?
(pPktHdr + MAT_VLAN_ETH_HDR_LEN) :
(pPktHdr + MAT_ETHER_HDR_LEN);
#ifdef CONFIG_AP_SUPPORT
#ifdef APCLI_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_AP(pAd) {
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
#ifdef MAC_REPEATER_SUPPORT
UCHAR tempIdx = ifIdx;
UCHAR CliIdx = 0xFF;
if (tempIdx >= REPT_MLME_START_IDX) {
CliIdx = tempIdx - REPT_MLME_START_IDX;
pMacAddr = &pAd->ApCfg.pRepeaterCliPool[CliIdx].CurrentAddress[0];
pMacAddr =
&pAd->ApCfg
.pRepeaterCliPool[CliIdx]
.CurrentAddress[0];
} else
#endif /* MAC_REPEATER_SUPPORT */
pMacAddr = &pAd->ApCfg.ApCliTab[ifIdx].wdev.if_addr[0];
pMacAddr = &pAd->ApCfg.ApCliTab[ifIdx]
.wdev.if_addr[0];
}
#endif /* APCLI_SUPPORT */
#endif /* CONFIG_AP_SUPPORT */
if (pHandle->tx != NULL)
retSkb = pHandle->tx((PVOID)&pAd->MatCfg, RTPKT_TO_OSPKT(pPkt), pLayerHdr, pMacAddr);
retSkb = pHandle->tx((PVOID)&pAd->MatCfg,
RTPKT_TO_OSPKT(pPkt),
pLayerHdr, pMacAddr);
return retSkb;
}
@ -222,7 +228,6 @@ PUCHAR MATEngineTxHandle(
return retSkb;
}
/*
========================================================================
Routine Description:
@ -245,16 +250,14 @@ PUCHAR MATEngineTxHandle(
Note:
========================================================================
*/
PUCHAR MATEngineRxHandle(
IN PRTMP_ADAPTER pAd,
IN PNDIS_PACKET pPkt,
IN UINT infIdx)
PUCHAR MATEngineRxHandle(IN PRTMP_ADAPTER pAd, IN PNDIS_PACKET pPkt,
IN UINT infIdx)
{
PUCHAR pMacAddr = NULL;
PUCHAR pLayerHdr = NULL, pPktHdr = NULL;
UINT16 protoType;
INT i = 0;
struct _MATProtoOps *pHandle = NULL;
PUCHAR pMacAddr = NULL;
PUCHAR pLayerHdr = NULL, pPktHdr = NULL;
UINT16 protoType;
INT i = 0;
struct _MATProtoOps *pHandle = NULL;
if (pAd->MatCfg.status != MAT_ENGINE_STAT_INITED)
return NULL;
@ -273,18 +276,23 @@ PUCHAR MATEngineRxHandle(
pLayerHdr = (pPktHdr + MAT_ETHER_HDR_LEN);
if (protoType == ETH_P_VLAN) {
protoType = OS_NTOHS(get_unaligned((PUINT16)(pPktHdr + 12 + LENGTH_802_1Q))); /* Shift VLAN Tag Length (4 byte) */
protoType = OS_NTOHS(get_unaligned((
PUINT16)(pPktHdr + 12 +
LENGTH_802_1Q))); /* Shift VLAN Tag Length (4 byte) */
pLayerHdr = (pPktHdr + MAT_VLAN_ETH_HDR_LEN);
}
for (i = 0; i < MAX_MAT_SUPPORT_PROTO_NUM; i++) {
if (protoType == MATProtoTb[i].protocol) {
pHandle = MATProtoTb[i].pHandle; /* the pHandle must not be null! */
pHandle =
MATProtoTb[i]
.pHandle; /* the pHandle must not be null! */
/* RTMP_SEM_LOCK(&MATDBLock); */
if (pHandle->rx != NULL)
pMacAddr = pHandle->rx((PVOID)&pAd->MatCfg, RTPKT_TO_OSPKT(pPkt), pLayerHdr, NULL);
pMacAddr = pHandle->rx((PVOID)&pAd->MatCfg,
RTPKT_TO_OSPKT(pPkt),
pLayerHdr, NULL);
/* RTMP_SEM_UNLOCK(&MATDBLock); */
break;
@ -297,25 +305,23 @@ PUCHAR MATEngineRxHandle(
return NULL;
}
BOOLEAN MATPktRxNeedConvert(
IN PRTMP_ADAPTER pAd,
IN PNET_DEV net_dev)
BOOLEAN MATPktRxNeedConvert(IN PRTMP_ADAPTER pAd, IN PNET_DEV net_dev)
{
#ifdef CONFIG_AP_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_AP(pAd) {
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
#ifdef APCLI_SUPPORT
int i = 0;
/* Check if the packet will be send to apcli interface. */
while (i < MAX_APCLI_NUM) {
/*BSSID match the ApCliBssid ?(from a valid AP) */
if ((pAd->ApCfg.ApCliTab[i].Valid == TRUE)
&& (net_dev == pAd->ApCfg.ApCliTab[i].wdev.if_dev)
if ((pAd->ApCfg.ApCliTab[i].Valid == TRUE) &&
(net_dev == pAd->ApCfg.ApCliTab[i].wdev.if_dev)
#ifdef A4_CONN
&& (IS_APCLI_A4(&pAd->ApCfg.ApCliTab[i]) == FALSE)
&& (IS_APCLI_A4(&pAd->ApCfg.ApCliTab[i]) == FALSE)
#endif /* A4_CONN */
){
) {
//MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_WARN,("MATPktRxNeedConvert TRUE for ApCliTab[%d]\n",i));
return TRUE;
}
@ -329,9 +335,7 @@ BOOLEAN MATPktRxNeedConvert(
return FALSE;
}
NDIS_STATUS MATEngineExit(
IN RTMP_ADAPTER * pAd)
NDIS_STATUS MATEngineExit(IN RTMP_ADAPTER *pAd)
{
struct _MATProtoOps *pHandle = NULL;
int i;
@ -360,11 +364,9 @@ NDIS_STATUS MATEngineExit(
return TRUE;
}
NDIS_STATUS MATEngineInit(
IN RTMP_ADAPTER * pAd)
NDIS_STATUS MATEngineInit(IN RTMP_ADAPTER *pAd)
{
MATProtoOps *pHandle = NULL;
MATProtoOps *pHandle = NULL;
int i, status;
if (pAd->MatCfg.status == MAT_ENGINE_STAT_INITED)
@ -372,11 +374,13 @@ NDIS_STATUS MATEngineInit(
#ifdef KMALLOC_BATCH
/* Allocate memory for node entry, we totally allocate 128 entries and link them together. */
os_alloc_mem_suspend(NULL, (UCHAR **)&(pAd->MatCfg.pMATNodeEntryPoll), sizeof(MATNodeEntry) * MAX_MAT_NODE_ENTRY_NUM);
os_alloc_mem_suspend(NULL, (UCHAR **)&(pAd->MatCfg.pMATNodeEntryPoll),
sizeof(MATNodeEntry) * MAX_MAT_NODE_ENTRY_NUM);
if (pAd->MatCfg.pMATNodeEntryPoll != NULL) {
MATNodeEntry *pPtr = NULL;
NdisZeroMemory(pAd->MatCfg.pMATNodeEntryPoll, sizeof(MATNodeEntry) * MAX_MAT_NODE_ENTRY_NUM);
NdisZeroMemory(pAd->MatCfg.pMATNodeEntryPoll,
sizeof(MATNodeEntry) * MAX_MAT_NODE_ENTRY_NUM);
pPtr = pAd->MatCfg.pMATNodeEntryPoll;
for (i = 0; i < (MAX_MAT_NODE_ENTRY_NUM - 1); i++) {
@ -399,11 +403,17 @@ NDIS_STATUS MATEngineInit(
status = pHandle->init(&pAd->MatCfg);
if (status == FALSE) {
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_ERROR, ("MATEngine Init Protocol (0x%x) failed, Stop the MAT Funciton initialization failed!\n", MATProtoTb[i].protocol));
MTWF_LOG(
DBG_CAT_PROTO, CATPROTO_MAT,
DBG_LVL_ERROR,
("MATEngine Init Protocol (0x%x) failed, Stop the MAT Funciton initialization failed!\n",
MATProtoTb[i].protocol));
goto init_failed;
}
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE, ("MATEngine Init Protocol (0x%04x) success!\n", MATProtoTb[i].protocol));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE,
("MATEngine Init Protocol (0x%04x) success!\n",
MATProtoTb[i].protocol));
}
}
@ -440,4 +450,3 @@ init_failed:
}
#endif /* MAT_SUPPORT */

View File

@ -33,34 +33,38 @@
static NDIS_STATUS MATProto_IP_Init(MAT_STRUCT *pMatCfg);
static NDIS_STATUS MATProto_IP_Exit(MAT_STRUCT *pMatCfg);
static PUCHAR MATProto_IP_Rx(MAT_STRUCT *pMatCfg, PNDIS_PACKET pSkb, PUCHAR pLayerHdr, PUCHAR pMacAddr);
static PUCHAR MATProto_IP_Tx(MAT_STRUCT *pMatCfg, PNDIS_PACKET pSkb, PUCHAR pLayerHdr, PUCHAR pMacAddr);
static PUCHAR MATProto_IP_Rx(MAT_STRUCT *pMatCfg, PNDIS_PACKET pSkb,
PUCHAR pLayerHdr, PUCHAR pMacAddr);
static PUCHAR MATProto_IP_Tx(MAT_STRUCT *pMatCfg, PNDIS_PACKET pSkb,
PUCHAR pLayerHdr, PUCHAR pMacAddr);
static NDIS_STATUS MATProto_ARP_Init(MAT_STRUCT *pMatCfg);
static NDIS_STATUS MATProto_ARP_Exit(MAT_STRUCT *pMatCfg);
static PUCHAR MATProto_ARP_Rx(MAT_STRUCT *pMatCfg, PNDIS_PACKET pSkb, PUCHAR pLayerHdr, PUCHAR pMacAddr);
static PUCHAR MATProto_ARP_Tx(MAT_STRUCT *pMatCfg, PNDIS_PACKET pSkb, PUCHAR pLayerHdr, PUCHAR pMacAddr);
static PUCHAR MATProto_ARP_Rx(MAT_STRUCT *pMatCfg, PNDIS_PACKET pSkb,
PUCHAR pLayerHdr, PUCHAR pMacAddr);
static PUCHAR MATProto_ARP_Tx(MAT_STRUCT *pMatCfg, PNDIS_PACKET pSkb,
PUCHAR pLayerHdr, PUCHAR pMacAddr);
#define IPV4_ADDR_LEN 4
#define NEED_UPDATE_IPMAC_TB(Mac, IP) (IS_UCAST_MAC(Mac) && IS_GOOD_IP(IP))
typedef struct _IPMacMappingEntry {
UINT ipAddr; /* In network order */
UCHAR macAddr[MAC_ADDR_LEN];
ULONG lastTime;
UINT ipAddr; /* In network order */
UCHAR macAddr[MAC_ADDR_LEN];
ULONG lastTime;
struct _IPMacMappingEntry *pNext;
} IPMacMappingEntry, *PIPMacMappingEntry;
typedef struct _IPMacMappingTable {
BOOLEAN valid;
IPMacMappingEntry * hash[MAT_MAX_HASH_ENTRY_SUPPORT + 1]; /*0~63 for specific station, 64 for broadcast MacAddress */
UCHAR curMcastAddr[MAC_ADDR_LEN]; /* The multicast mac addr for currecnt received packet destined to ipv4 multicast addr */
BOOLEAN valid;
IPMacMappingEntry *hash
[MAT_MAX_HASH_ENTRY_SUPPORT +
1]; /*0~63 for specific station, 64 for broadcast MacAddress */
UCHAR curMcastAddr
[MAC_ADDR_LEN]; /* The multicast mac addr for currecnt received packet destined to ipv4 multicast addr */
} IPMacMappingTable;
struct _MATProtoOps MATProtoIPHandle = {
.init = MATProto_IP_Init,
.tx = MATProto_IP_Tx,
@ -72,13 +76,10 @@ struct _MATProtoOps MATProtoARPHandle = {
.init = MATProto_ARP_Init,
.tx = MATProto_ARP_Tx,
.rx = MATProto_ARP_Rx,
.exit = MATProto_ARP_Exit,
.exit = MATProto_ARP_Exit,
};
VOID dumpIPMacTb(
IN MAT_STRUCT *pMatCfg,
IN int index)
VOID dumpIPMacTb(IN MAT_STRUCT *pMatCfg, IN int index)
{
IPMacMappingTable *pIPMacTable;
IPMacMappingEntry *pHead;
@ -89,7 +90,9 @@ VOID dumpIPMacTb(
return;
if (!pIPMacTable->valid) {
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF, ("%s():IPMacTable not init yet, so cannot do dump!\n", __func__));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF,
("%s():IPMacTable not init yet, so cannot do dump!\n",
__func__));
return;
}
@ -102,58 +105,61 @@ VOID dumpIPMacTb(
startIdx = endIdx = index;
}
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF, ("%s():\n", __func__));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF,
("%s():\n", __func__));
for (; startIdx <= endIdx; startIdx++) {
for (; startIdx <= endIdx; startIdx++) {
pHead = pIPMacTable->hash[startIdx];
while (pHead) {
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF, ("IPMac[%d]:\n", startIdx));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF, ("\t:IP=0x%x,Mac=%02x:%02x:%02x:%02x:%02x:%02x, lastTime=0x%lx, next=%p\n",
pHead->ipAddr, pHead->macAddr[0], pHead->macAddr[1], pHead->macAddr[2],
pHead->macAddr[3], pHead->macAddr[4], pHead->macAddr[5], pHead->lastTime,
pHead->pNext));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF,
("IPMac[%d]:\n", startIdx));
MTWF_LOG(
DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF,
("\t:IP=0x%x,Mac=%02x:%02x:%02x:%02x:%02x:%02x, lastTime=0x%lx, next=%p\n",
pHead->ipAddr, pHead->macAddr[0],
pHead->macAddr[1], pHead->macAddr[2],
pHead->macAddr[3], pHead->macAddr[4],
pHead->macAddr[5], pHead->lastTime,
pHead->pNext));
pHead = pHead->pNext;
}
}
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF, ("\t----EndOfDump!\n"));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF,
("\t----EndOfDump!\n"));
}
static inline NDIS_STATUS getDstIPFromIpPkt(
IN PUCHAR pIpHdr,
IN UINT *dstIP)
static inline NDIS_STATUS getDstIPFromIpPkt(IN PUCHAR pIpHdr, IN UINT *dstIP)
{
if (!pIpHdr)
return FALSE;
NdisMoveMemory(dstIP, (pIpHdr + 16), 4); /*shift 16 for IP header len before DstIP. */
NdisMoveMemory(dstIP, (pIpHdr + 16),
4); /*shift 16 for IP header len before DstIP. */
/* MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE, ("%s(): Get the dstIP=0x%x\n", __func__, *dstIP)); */
return TRUE;
}
static inline NDIS_STATUS getSrcIPFromIpPkt(
IN PUCHAR pIpHdr,
IN UINT *pSrcIP)
static inline NDIS_STATUS getSrcIPFromIpPkt(IN PUCHAR pIpHdr, IN UINT *pSrcIP)
{
if (!pIpHdr)
return FALSE;
NdisMoveMemory(pSrcIP, (pIpHdr + 12), 4); /*shift 12 for IP header len before DstIP. */
NdisMoveMemory(pSrcIP, (pIpHdr + 12),
4); /*shift 12 for IP header len before DstIP. */
/* MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE, ("%s(): Get the srcIP=0x%x\n", __func__, *pSrcIP)); */
return TRUE;
}
static NDIS_STATUS IPMacTableUpdate(
IN MAT_STRUCT *pMatCfg,
IN PUCHAR pMacAddr,
IN UINT ipAddr)
static NDIS_STATUS IPMacTableUpdate(IN MAT_STRUCT *pMatCfg, IN PUCHAR pMacAddr,
IN UINT ipAddr)
{
UINT hashIdx;
UINT hashIdx;
IPMacMappingTable *pIPMacTable;
IPMacMappingEntry *pEntry = NULL, *pPrev = NULL, *pNewEntry = NULL;
ULONG now;
IPMacMappingEntry *pEntry = NULL, *pPrev = NULL, *pNewEntry = NULL,
*pTempEntry = NULL;
ULONG now;
pIPMacTable = (IPMacMappingTable *)pMatCfg->MatTableSet.IPMacTable;
if (!pIPMacTable)
@ -181,16 +187,20 @@ static NDIS_STATUS IPMacTableUpdate(
} else {
/* handle the age-out situation */
/*if ((Now - pEntry->lastTime) > MAT_TB_ENTRY_AGEOUT_TIME) */
if (RTMP_TIME_AFTER(now, pEntry->lastTime + MAT_TB_ENTRY_AGEOUT_TIME)) {
if (RTMP_TIME_AFTER(now,
pEntry->lastTime +
MAT_TB_ENTRY_AGEOUT_TIME)) {
/* Remove the aged entry */
if (pEntry == pIPMacTable->hash[hashIdx]) {
pIPMacTable->hash[hashIdx] = pEntry->pNext;
pIPMacTable->hash[hashIdx] =
pEntry->pNext;
pPrev = pIPMacTable->hash[hashIdx];
} else
pPrev->pNext = pEntry->pNext;
MATDBEntryFree(pMatCfg, (PUCHAR)pEntry);
pEntry = (pPrev == NULL ? NULL : pPrev->pNext);
pTempEntry = pEntry;
pEntry = (pPrev == NULL ? NULL : pPrev->pNext);
MATDBEntryFree(pMatCfg, (PUCHAR)pTempEntry);
pMatCfg->nodeCount--;
} else {
pPrev = pEntry;
@ -200,7 +210,8 @@ static NDIS_STATUS IPMacTableUpdate(
}
/* Allocate a new IPMacMapping entry and insert into the hash */
pNewEntry = (IPMacMappingEntry *)MATDBEntryAlloc(pMatCfg, sizeof(IPMacMappingEntry));
pNewEntry = (IPMacMappingEntry *)MATDBEntryAlloc(
pMatCfg, sizeof(IPMacMappingEntry));
if (pNewEntry != NULL) {
pNewEntry->ipAddr = ipAddr;
@ -225,15 +236,12 @@ static NDIS_STATUS IPMacTableUpdate(
return FALSE;
}
static PUCHAR IPMacTableLookUp(
IN MAT_STRUCT *pMatCfg,
IN UINT ipAddr)
static PUCHAR IPMacTableLookUp(IN MAT_STRUCT *pMatCfg, IN UINT ipAddr)
{
IPMacMappingTable *pIPMacTable;
UINT hashIdx, ip;
IPMacMappingEntry *pEntry = NULL;
PUCHAR pGroupMacAddr;
UINT hashIdx, ip;
IPMacMappingEntry *pEntry = NULL;
PUCHAR pGroupMacAddr;
pIPMacTable = (IPMacMappingTable *)pMatCfg->MatTableSet.IPMacTable;
if (!pIPMacTable)
@ -247,7 +255,8 @@ static PUCHAR IPMacTableLookUp(
if (IS_MULTICAST_IP(ip)) {
pGroupMacAddr = (PUCHAR)(&pIPMacTable->curMcastAddr);
ConvertMulticastIP2MAC((PUCHAR) &ipAddr, (UCHAR **)(&pGroupMacAddr), ETH_P_IP);
ConvertMulticastIP2MAC((PUCHAR)&ipAddr,
(UCHAR **)(&pGroupMacAddr), ETH_P_IP);
return pIPMacTable->curMcastAddr;
}
@ -277,13 +286,11 @@ static PUCHAR IPMacTableLookUp(
return pIPMacTable->hash[IPMAC_TB_HASH_INDEX_OF_BCAST]->macAddr;
}
static NDIS_STATUS IPMacTable_RemoveAll(
IN MAT_STRUCT *pMatCfg)
static NDIS_STATUS IPMacTable_RemoveAll(IN MAT_STRUCT *pMatCfg)
{
IPMacMappingEntry *pEntry;
IPMacMappingTable *pIPMacTable;
INT i;
INT i;
pIPMacTable = (IPMacMappingTable *)pMatCfg->MatTableSet.IPMacTable;
if (!pIPMacTable)
@ -305,33 +312,40 @@ static NDIS_STATUS IPMacTable_RemoveAll(
return TRUE;
}
static NDIS_STATUS IPMacTable_init(
IN MAT_STRUCT *pMatCfg)
static NDIS_STATUS IPMacTable_init(IN MAT_STRUCT *pMatCfg)
{
IPMacMappingTable *pIPMacTable;
IPMacMappingEntry *pEntry = NULL;
if (pMatCfg->MatTableSet.IPMacTable != NULL)
pIPMacTable = (IPMacMappingTable *)pMatCfg->MatTableSet.IPMacTable;
pIPMacTable =
(IPMacMappingTable *)pMatCfg->MatTableSet.IPMacTable;
else {
os_alloc_mem_suspend(NULL, (UCHAR **)&(pMatCfg->MatTableSet.IPMacTable), sizeof(IPMacMappingTable));
os_alloc_mem_suspend(
NULL, (UCHAR **)&(pMatCfg->MatTableSet.IPMacTable),
sizeof(IPMacMappingTable));
if (pMatCfg->MatTableSet.IPMacTable) {
pIPMacTable = (IPMacMappingTable *)pMatCfg->MatTableSet.IPMacTable;
pIPMacTable = (IPMacMappingTable *)
pMatCfg->MatTableSet.IPMacTable;
NdisZeroMemory(pIPMacTable, sizeof(IPMacMappingTable));
} else {
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_ERROR, ("IPMacTable_init(): Allocate memory for IPMacTable failed!\n"));
MTWF_LOG(
DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_ERROR,
("IPMacTable_init(): Allocate memory for IPMacTable failed!\n"));
return FALSE;
}
}
if (pIPMacTable->valid == FALSE) {
/*Set the last hash entry (hash[64]) as our default broadcast Mac address */
pEntry = (IPMacMappingEntry *)MATDBEntryAlloc(pMatCfg, sizeof(IPMacMappingEntry));
pEntry = (IPMacMappingEntry *)MATDBEntryAlloc(
pMatCfg, sizeof(IPMacMappingEntry));
if (!pEntry) {
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_ERROR, ("IPMacTable_init(): Allocate memory for IPMacTable broadcast entry failed!\n"));
MTWF_LOG(
DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_ERROR,
("IPMacTable_init(): Allocate memory for IPMacTable broadcast entry failed!\n"));
return FALSE;
}
@ -341,28 +355,24 @@ static NDIS_STATUS IPMacTable_init(
pIPMacTable->hash[IPMAC_TB_HASH_INDEX_OF_BCAST] = pEntry;
pIPMacTable->valid = TRUE;
} else
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE, ("%s(): IPMacTable already inited!\n", __func__));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE,
("%s(): IPMacTable already inited!\n", __func__));
return TRUE;
}
static NDIS_STATUS MATProto_ARP_Exit(
IN MAT_STRUCT *pMatCfg)
static NDIS_STATUS MATProto_ARP_Exit(IN MAT_STRUCT *pMatCfg)
{
INT status;
status = IPMacTable_RemoveAll(pMatCfg);
return status;
}
static PUCHAR MATProto_ARP_Rx(
IN MAT_STRUCT *pMatCfg,
IN PNDIS_PACKET pSkb,
IN PUCHAR pLayerHdr,
IN PUCHAR pMacAddr)
static PUCHAR MATProto_ARP_Rx(IN MAT_STRUCT *pMatCfg, IN PNDIS_PACKET pSkb,
IN PUCHAR pLayerHdr, IN PUCHAR pMacAddr)
{
PUCHAR pArpHdr = NULL, pRealMac = NULL;
PUCHAR tgtMac, tgtIP;
PUCHAR tgtMac, tgtIP;
BOOLEAN isUcastMac, isGoodIP;
pArpHdr = pLayerHdr;
/*dumpPkt(RTPKT_TO_OSPKT(pSkb)->data, RTPKT_TO_OSPKT(pSkb)->len); */
@ -370,7 +380,8 @@ static PUCHAR MATProto_ARP_Rx(
tgtMac = pArpHdr + 18;
tgtIP = tgtMac + 6;
/* isUcastMac = !(00:00:00:00:00:00|| mcastMac); */
isUcastMac = ((tgtMac[0] | tgtMac[1] | tgtMac[2] | tgtMac[3] | tgtMac[4] | tgtMac[5]) != 0);
isUcastMac = ((tgtMac[0] | tgtMac[1] | tgtMac[2] | tgtMac[3] |
tgtMac[4] | tgtMac[5]) != 0);
isUcastMac &= ((tgtMac[0] & 0x1) == 0);
/* isGoodIP = ip address is not 0.0.0.0 */
isGoodIP = (*(UINT *)tgtIP != 0);
@ -392,13 +403,10 @@ static PUCHAR MATProto_ARP_Rx(
return pRealMac;
}
static PUCHAR MATProto_ARP_Tx(
IN MAT_STRUCT *pMatCfg,
IN PNDIS_PACKET pSkb,
IN PUCHAR pLayerHdr,
IN PUCHAR pMacAddr)
static PUCHAR MATProto_ARP_Tx(IN MAT_STRUCT *pMatCfg, IN PNDIS_PACKET pSkb,
IN PUCHAR pLayerHdr, IN PUCHAR pMacAddr)
{
PUCHAR pSMac, pSIP;
PUCHAR pSMac, pSIP;
BOOLEAN isUcastMac, isGoodIP;
NET_PRO_ARP_HDR *arpHdr;
PUCHAR pPktHdr;
@ -411,15 +419,17 @@ static PUCHAR MATProto_ARP_Tx(
We just handle ether type hardware address and IPv4 internet
address type and opcode is ARP reuqest/response.
*/
if ((arpHdr->ar_hrd != OS_HTONS(ARPHRD_ETHER)) || (arpHdr->ar_pro != OS_HTONS(ETH_P_IP)) ||
(arpHdr->ar_op != OS_HTONS(ARPOP_REPLY) && arpHdr->ar_op != OS_HTONS(ARPOP_REQUEST)))
if ((arpHdr->ar_hrd != OS_HTONS(ARPHRD_ETHER)) ||
(arpHdr->ar_pro != OS_HTONS(ETH_P_IP)) ||
(arpHdr->ar_op != OS_HTONS(ARPOP_REPLY) &&
arpHdr->ar_op != OS_HTONS(ARPOP_REQUEST)))
return NULL;
/* We just take care about the sender(Mac/IP address) fields. */
pSMac = (PUCHAR)(pLayerHdr + 8);
pSMac = (PUCHAR)(pLayerHdr + 8);
pSIP = (PUCHAR)(pSMac + MAC_ADDR_LEN);
isUcastMac = IS_UCAST_MAC(pSMac);
isGoodIP = IS_GOOD_IP(get_unaligned32((PUINT) pSIP));
isGoodIP = IS_GOOD_IP(get_unaligned32((PUINT)pSIP));
/*
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE,("%s(): ARP Pkt=>senderIP=%d.%d.%d.%d, senderMac=%02x:%02x:%02x:%02x:%02x:%02x\n",
@ -427,7 +437,7 @@ static PUCHAR MATProto_ARP_Tx(
pSMac[0],pSMac[1],pSMac[2],pSMac[3],pSMac[4],pSMac[5]));
*/
if (isUcastMac && isGoodIP)
IPMacTableUpdate(pMatCfg, pSMac, get_unaligned32((PUINT) pSIP));
IPMacTableUpdate(pMatCfg, pSMac, get_unaligned32((PUINT)pSIP));
/*
For outgoing unicast mac, we need to replace the senderMAC as ourself to make
@ -439,9 +449,14 @@ static PUCHAR MATProto_ARP_Tx(
if (newSkb) {
if (IS_VLAN_PACKET(GET_OS_PKT_DATAPTR(newSkb)))
pSMac = (PUCHAR)(GET_OS_PKT_DATAPTR(newSkb) + MAT_VLAN_ETH_HDR_LEN + 8);
pSMac = (PUCHAR)(GET_OS_PKT_DATAPTR(
newSkb) +
MAT_VLAN_ETH_HDR_LEN +
8);
else
pSMac = (PUCHAR)(GET_OS_PKT_DATAPTR(newSkb) + MAT_ETHER_HDR_LEN + 8);
pSMac = (PUCHAR)(GET_OS_PKT_DATAPTR(
newSkb) +
MAT_ETHER_HDR_LEN + 8);
}
}
@ -452,46 +467,39 @@ static PUCHAR MATProto_ARP_Tx(
return (PUCHAR)newSkb;
}
static NDIS_STATUS MATProto_ARP_Init(
IN MAT_STRUCT *pMatCfg)
static NDIS_STATUS MATProto_ARP_Init(IN MAT_STRUCT *pMatCfg)
{
BOOLEAN status = FALSE;
status = IPMacTable_init(pMatCfg);
return status;
}
static NDIS_STATUS MATProto_IP_Exit(
IN MAT_STRUCT *pMatCfg)
static NDIS_STATUS MATProto_IP_Exit(IN MAT_STRUCT *pMatCfg)
{
INT status;
status = IPMacTable_RemoveAll(pMatCfg);
return status;
}
static PUCHAR MATProto_IP_Rx(
IN MAT_STRUCT *pMatCfg,
IN PNDIS_PACKET pSkb,
IN PUCHAR pLayerHdr,
IN PUCHAR pDevMacAdr)
static PUCHAR MATProto_IP_Rx(IN MAT_STRUCT *pMatCfg, IN PNDIS_PACKET pSkb,
IN PUCHAR pLayerHdr, IN PUCHAR pDevMacAdr)
{
#ifdef MAC_REPEATER_SUPPORT
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER) pMatCfg->pPriv;
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)pMatCfg->pPriv;
USHORT wcid = 0xFF;
PMAC_TABLE_ENTRY pEntry = NULL;
PREPEATER_CLIENT_ENTRY pReptEntry = NULL;
#endif /* MAC_REPEATER_SUPPORT */
PUCHAR pMacAddr;
UINT dstIP = 0;
PUCHAR pMacAddr;
UINT dstIP = 0;
/* Fetch the IP addres from the packet header. */
getDstIPFromIpPkt(pLayerHdr, &dstIP);
pMacAddr = IPMacTableLookUp(pMatCfg, dstIP);
#ifdef MAC_REPEATER_SUPPORT
if (pAd == NULL) {
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_ERROR, ("%s():ERROR! pAd is null!\n", __func__));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_ERROR,
("%s():ERROR! pAd is null!\n", __func__));
return pMacAddr;
}
@ -501,7 +509,7 @@ static PUCHAR MATProto_IP_Rx(
if (pAd->ApCfg.bMACRepeaterEn) {
if (pEntry->bReptCli) {
UINT ip;
UINT ip;
struct wifi_dev *wdev;
ip = ntohl(dstIP);
@ -522,28 +530,44 @@ static PUCHAR MATProto_IP_Rx(
bHdrChanged = FALSE;
pUdpHdr = pLayerHdr + 20;
srcPort = OS_NTOHS(get_unaligned((PUINT16)(pUdpHdr)));
dstPort = OS_NTOHS(get_unaligned((PUINT16)(pUdpHdr + 2)));
srcPort = OS_NTOHS(get_unaligned(
(PUINT16)(pUdpHdr)));
dstPort = OS_NTOHS(get_unaligned(
(PUINT16)(pUdpHdr + 2)));
if (srcPort == 67 && dstPort == 68) { /*It's a DHCP packet */
PUCHAR bootpHdr, dhcpHdr, pCliHwAddr;
if (srcPort == 67 &&
dstPort ==
68) { /*It's a DHCP packet */
PUCHAR bootpHdr, dhcpHdr,
pCliHwAddr;
bootpHdr = pUdpHdr + 8;
dhcpHdr = bootpHdr + 236;
pCliHwAddr = (bootpHdr + 28);
if (pReptEntry)
NdisMoveMemory(pCliHwAddr, pReptEntry->OriginalAddress, MAC_ADDR_LEN);
NdisMoveMemory(
pCliHwAddr,
pReptEntry
->OriginalAddress,
MAC_ADDR_LEN);
else
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_OFF,
("%s() MatchAPCLITabIdx = %u\n",
__func__, pEntry->func_tb_idx));
MTWF_LOG(
DBG_CAT_PROTO,
CATPROTO_MAT,
DBG_LVL_OFF,
("%s() MatchAPCLITabIdx = %u\n",
__func__,
pEntry->func_tb_idx));
bHdrChanged = TRUE;
}
if (bHdrChanged == TRUE) {
NdisZeroMemory((pUdpHdr + 6), 2); /*modify the UDP chksum as zero */
NdisZeroMemory(
(pUdpHdr + 6),
2); /*modify the UDP chksum as zero */
#ifdef DHCP_UC_SUPPORT
*(UINT16 *)(pUdpHdr + 6) = RTMP_UDP_Checksum(pSkb);
*(UINT16 *)(pUdpHdr + 6) =
RTMP_UDP_Checksum(pSkb);
#endif /* DHCP_UC_SUPPORT */
}
}
@ -555,15 +579,12 @@ static PUCHAR MATProto_IP_Rx(
return pMacAddr;
}
static UCHAR DHCP_MAGIC[] = {0x63, 0x82, 0x53, 0x63};
static PUCHAR MATProto_IP_Tx(
IN MAT_STRUCT *pMatCfg,
IN PNDIS_PACKET pSkb,
IN PUCHAR pLayerHdr,
IN PUCHAR pDevMacAdr)
static UCHAR DHCP_MAGIC[] = { 0x63, 0x82, 0x53, 0x63 };
static PUCHAR MATProto_IP_Tx(IN MAT_STRUCT *pMatCfg, IN PNDIS_PACKET pSkb,
IN PUCHAR pLayerHdr, IN PUCHAR pDevMacAdr)
{
#if defined(DHCP_UC_SUPPORT) && defined(MAC_REPEATER_SUPPORT)
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER) pMatCfg->pPriv;
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)pMatCfg->pPriv;
BOOLEAN use_dhcpbroadcast = TRUE;
#endif /* DHCP_UC_SUPPORT && MAC_REPEATER_SUPPORT */
PUCHAR pSrcMac;
@ -574,10 +595,12 @@ static PUCHAR MATProto_IP_Tx(
pPktHdr = GET_OS_PKT_DATAPTR(pSkb);
pSrcMac = pPktHdr + 6;
pSrcIP = pLayerHdr + 12;
needUpdate = NEED_UPDATE_IPMAC_TB(pSrcMac, get_unaligned32((PUINT)(pSrcIP)));
needUpdate =
NEED_UPDATE_IPMAC_TB(pSrcMac, get_unaligned32((PUINT)(pSrcIP)));
if (needUpdate)
IPMacTableUpdate(pMatCfg, pSrcMac, get_unaligned32((PUINT)(pSrcIP)));
IPMacTableUpdate(pMatCfg, pSrcMac,
get_unaligned32((PUINT)(pSrcIP)));
/*For UDP packet, we need to check about the DHCP packet, to modify the flag of DHCP discovey/request as broadcast. */
if (*(pLayerHdr + 9) == 0x11) {
@ -598,28 +621,40 @@ static PUCHAR MATProto_IP_Tx(
if (newSkb) {
/* reassign packet header pointer for new skb*/
if (IS_VLAN_PACKET(GET_OS_PKT_DATAPTR(newSkb))) {
pPktHdr = GET_OS_PKT_DATAPTR(newSkb);
pLayerHdr = (pPktHdr + MAT_VLAN_ETH_HDR_LEN);
if (IS_VLAN_PACKET(GET_OS_PKT_DATAPTR(
newSkb))) {
pPktHdr = GET_OS_PKT_DATAPTR(
newSkb);
pLayerHdr =
(pPktHdr +
MAT_VLAN_ETH_HDR_LEN);
udpHdr = pLayerHdr + 20;
} else {
pPktHdr = GET_OS_PKT_DATAPTR(newSkb);
pLayerHdr = (pPktHdr + MAT_ETHER_HDR_LEN);
pPktHdr = GET_OS_PKT_DATAPTR(
newSkb);
pLayerHdr = (pPktHdr +
MAT_ETHER_HDR_LEN);
udpHdr = pLayerHdr + 20;
}
}
}
bootpHdr = udpHdr + 8;
bootpFlag = OS_NTOHS(get_unaligned((PUINT16)(bootpHdr + 10)));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE, ("is bootp packet! bootpFlag=0x%x\n", bootpFlag));
bootpFlag = OS_NTOHS(
get_unaligned((PUINT16)(bootpHdr + 10)));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE,
("is bootp packet! bootpFlag=0x%x\n",
bootpFlag));
dhcpHdr = bootpHdr + 236;
#if defined(DHCP_UC_SUPPORT) && defined(MAC_REPEATER_SUPPORT)
if (pAd->DhcpUcEnable == TRUE) {
if (pMatCfg->bMACRepeaterEn) { /* check repeater case*/
REPEATER_CLIENT_ENTRY *pReptEntry = NULL;
pReptEntry = RTMPLookupRepeaterCliEntry(pMatCfg->pPriv, FALSE, pDevMacAdr, TRUE);
REPEATER_CLIENT_ENTRY *pReptEntry =
NULL;
pReptEntry = RTMPLookupRepeaterCliEntry(
pMatCfg->pPriv, FALSE,
pDevMacAdr, TRUE);
if (pReptEntry != NULL)
use_dhcpbroadcast = FALSE;
@ -629,18 +664,29 @@ static PUCHAR MATProto_IP_Tx(
#endif /* DHCP_UC_SUPPORT && MAC_REPEATER_SUPPORT */
#if defined(DHCP_UC_SUPPORT) && defined(MAC_REPEATER_SUPPORT)
if ((bootpFlag != 0x8000) && (use_dhcpbroadcast == TRUE)) /*check if it's a broadcast request. */
if ((bootpFlag != 0x8000) &&
(use_dhcpbroadcast ==
TRUE)) /*check if it's a broadcast request. */
#else
if (bootpFlag != 0x8000) /*check if it's a broadcast request. */
if (bootpFlag !=
0x8000) /*check if it's a broadcast request. */
#endif
{
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE, ("the DHCP flag is a unicast, dhcp_magic=%02x:%02x:%02x:%02x\n",
dhcpHdr[0], dhcpHdr[1], dhcpHdr[2], dhcpHdr[3]));
MTWF_LOG(
DBG_CAT_PROTO, CATPROTO_MAT,
DBG_LVL_TRACE,
("the DHCP flag is a unicast, dhcp_magic=%02x:%02x:%02x:%02x\n",
dhcpHdr[0], dhcpHdr[1], dhcpHdr[2],
dhcpHdr[3]));
if (NdisEqualMemory(dhcpHdr, DHCP_MAGIC, 4)) {
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE, ("dhcp magic macthed!\n"));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT,
DBG_LVL_TRACE,
("dhcp magic macthed!\n"));
bootpFlag = OS_HTONS(0x8000);
NdisMoveMemory((bootpHdr + 10), &bootpFlag, 2); /*Set the bootp flag as broadcast */
NdisMoveMemory(
(bootpHdr + 10), &bootpFlag,
2); /*Set the bootp flag as broadcast */
bHdrChanged = TRUE;
}
}
@ -649,34 +695,61 @@ static PUCHAR MATProto_IP_Tx(
if (pMatCfg->bMACRepeaterEn) {
REPEATER_CLIENT_ENTRY *pReptEntry = NULL;
pReptEntry = RTMPLookupRepeaterCliEntry(pMatCfg->pPriv, FALSE, pDevMacAdr, TRUE);
pReptEntry = RTMPLookupRepeaterCliEntry(
pMatCfg->pPriv, FALSE, pDevMacAdr,
TRUE);
if (pReptEntry != NULL) {
ASSERT(pReptEntry->CliValid == TRUE);
NdisMoveMemory((bootpHdr + 28), pDevMacAdr, MAC_ADDR_LEN);
NdisMoveMemory((bootpHdr + 28),
pDevMacAdr,
MAC_ADDR_LEN);
if (NdisEqualMemory(dhcpHdr, DHCP_MAGIC, 4)) {
if (NdisEqualMemory(dhcpHdr, DHCP_MAGIC,
4)) {
PUCHAR pOptCode, pOptLen;
UINT16 udpLen;
udpLen = OS_NTOHS(get_unaligned((PUINT16)(udpHdr + 4)));
udpLen = OS_NTOHS(get_unaligned(
(PUINT16)(udpHdr + 4)));
pOptCode = (dhcpHdr + 4);
do {
pOptLen = pOptCode + 1;
if (*pOptCode == 61) { /* Client Identifier */
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE,
("Client Identifier found, change Hardware Address to "
"%02x:%02x:%02x:%02x:%02x:%02x\n",
pDevMacAdr[0], pDevMacAdr[1], pDevMacAdr[2],
pDevMacAdr[3], pDevMacAdr[4], pDevMacAdr[5]));
if (*pOptCode ==
61) { /* Client Identifier */
MTWF_LOG(
DBG_CAT_PROTO,
CATPROTO_MAT,
DBG_LVL_TRACE,
("Client Identifier found, change Hardware Address to "
"%02x:%02x:%02x:%02x:%02x:%02x\n",
pDevMacAdr
[0],
pDevMacAdr
[1],
pDevMacAdr
[2],
pDevMacAdr
[3],
pDevMacAdr
[4],
pDevMacAdr
[5]));
/* Change Hardware Address */
NdisMoveMemory((pOptCode + 3), pDevMacAdr, MAC_ADDR_LEN);
NdisMoveMemory(
(pOptCode +
3),
pDevMacAdr,
MAC_ADDR_LEN);
break;
}
pOptCode += (2 + *pOptLen);
} while ((*pOptCode != 0xFF) && ((pOptCode - udpHdr) <= udpLen));
pOptCode +=
(2 + *pOptLen);
} while ((*pOptCode != 0xFF) &&
((pOptCode - udpHdr) <=
udpLen));
}
bHdrChanged = TRUE;
@ -687,9 +760,11 @@ static PUCHAR MATProto_IP_Tx(
}
if (bHdrChanged == TRUE) {
NdisZeroMemory((udpHdr + 6), 2); /* Modify the UDP chksum as zero */
NdisZeroMemory((udpHdr + 6),
2); /* Modify the UDP chksum as zero */
#ifdef DHCP_UC_SUPPORT
*(UINT16 *)(udpHdr + 6) = RTMP_UDP_Checksum((newSkb == NULL) ? pSkb : newSkb);
*(UINT16 *)(udpHdr + 6) = RTMP_UDP_Checksum(
(newSkb == NULL) ? pSkb : newSkb);
#endif /* DHCP_UC_SUPPORT */
}
}
@ -697,16 +772,13 @@ static PUCHAR MATProto_IP_Tx(
return (PUCHAR)newSkb;
}
static NDIS_STATUS MATProto_IP_Init(
IN MAT_STRUCT *pMatCfg)
static NDIS_STATUS MATProto_IP_Init(IN MAT_STRUCT *pMatCfg)
{
BOOLEAN status;
status = IPMacTable_init(pMatCfg);
return status;
}
static inline void IPintToIPstr(int ipint, char Ipstr[20], ULONG BufLen)
{
int temp = 0;
@ -720,20 +792,17 @@ static inline void IPintToIPstr(int ipint, char Ipstr[20], ULONG BufLen)
snprintf(Ipstr, BufLen, "%s%d", Ipstr, temp);
}
VOID getIPMacTbInfo(
IN MAT_STRUCT *pMatCfg,
IN char *pOutBuf,
IN ULONG BufLen)
VOID getIPMacTbInfo(IN MAT_STRUCT *pMatCfg, IN char *pOutBuf, IN ULONG BufLen)
{
IPMacMappingTable *pIPMacTable;
IPMacMappingEntry *pHead;
int startIdx, endIdx;
char Ipstr[20] = {0};
char Ipstr[20] = { 0 };
pIPMacTable = (IPMacMappingTable *)pMatCfg->MatTableSet.IPMacTable;
if ((!pIPMacTable) || (!pIPMacTable->valid)) {
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE, ("%s():IPMacTable not init yet!\n", __func__));
MTWF_LOG(DBG_CAT_PROTO, CATPROTO_MAT, DBG_LVL_TRACE,
("%s():IPMacTable not init yet!\n", __func__));
return;
}
@ -743,23 +812,25 @@ VOID getIPMacTbInfo(
sprintf(pOutBuf, "\n");
sprintf(pOutBuf + strlen(pOutBuf), "%-18s%-20s\n", "IP", "MAC");
for (; startIdx < endIdx; startIdx++) {
for (; startIdx < endIdx; startIdx++) {
pHead = pIPMacTable->hash[startIdx];
while (pHead) {
/* if (strlen(pOutBuf) > (IW_PRIV_SIZE_MASK - 30)) */
if (RtmpOsCmdDisplayLenCheck(strlen(pOutBuf), 30) == FALSE)
if (RtmpOsCmdDisplayLenCheck(strlen(pOutBuf), 30) ==
FALSE)
break;
NdisZeroMemory(Ipstr, 20);
IPintToIPstr(pHead->ipAddr, Ipstr, sizeof(Ipstr));
sprintf(pOutBuf + strlen(pOutBuf), "%-18s%02x:%02x:%02x:%02x:%02x:%02x\n",
Ipstr, pHead->macAddr[0], pHead->macAddr[1], pHead->macAddr[2],
pHead->macAddr[3], pHead->macAddr[4], pHead->macAddr[5]);
sprintf(pOutBuf + strlen(pOutBuf),
"%-18s%02x:%02x:%02x:%02x:%02x:%02x\n", Ipstr,
pHead->macAddr[0], pHead->macAddr[1],
pHead->macAddr[2], pHead->macAddr[3],
pHead->macAddr[4], pHead->macAddr[5]);
pHead = pHead->pNext;
}
}
}
#endif /* MAT_SUPPORT */

Some files were not shown because too many files have changed in this diff Show More