Changeset 36939 for trunk


Ignore:
Timestamp:
2013-06-15T22:14:06+02:00 (3 years ago)
Author:
nbd
Message:

mac80211: update to wireless-testing 2013-06-13 + latest backport infrastructure

Signed-off-by: Felix Fietkau <nbd@…>

Location:
trunk/package/mac80211
Files:
8 added
12 deleted
52 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/mac80211/Makefile

    r36640 r36939  
    1111PKG_NAME:=mac80211 
    1212 
    13 PKG_VERSION:=2013-04-16 
    14 PKG_RELEASE:=2 
     13PKG_VERSION:=2013-06-13 
     14PKG_RELEASE:=1 
    1515PKG_SOURCE_URL:=http://mirror2.openwrt.org/sources 
    16 PKG_MD5SUM:=ec4cd40f0a8838aeea2ccff3ec5deb1a 
     16PKG_MD5SUM:=986749f5fbc5ec9b963e49c7171be300 
    1717 
    1818PKG_SOURCE:=compat-wireless-$(PKG_VERSION).tar.bz2 
     
    196196  AUTOLOAD:=$(call AutoLoad,31,p54spi) 
    197197endef 
    198  
    199 NEED_RT2X00_LIB_CRYPTO:=y 
    200 NEED_RT2X00_LIB_FIRMWARE:=y 
    201 NEED_RT2X00_LIB_EEPROM:=y 
    202 NEED_RT2X00_LIB_HT:=y 
    203 NEED_RT2X00_LIB_LEDS:=y 
    204198 
    205199define KernelPackage/rt2x00/Default 
     
    11731167endef 
    11741168 
    1175 BUILDFLAGS:= \ 
    1176         -I$(PKG_BUILD_DIR)/include \ 
    1177         -DCONFIG_CFG80211_INTERNAL_REGDB=y \ 
    1178         $(foreach opt,$(CONFOPTS),-DCONFIG_$(opt)) \ 
    1179         $(if $(CONFIG_PCI),-DCONFIG_B43_PCI_AUTOSELECT -DCONFIG_B43_PCICORE_AUTOSELECT) \ 
    1180         $(if $(CONFIG_LEDS_TRIGGERS), -DCONFIG_MAC80211_LEDS -DCONFIG_LEDS_TRIGGERS -DCONFIG_B43_LEDS -DCONFIG_B43LEGACY_LEDS) \ 
    1181         -DCONFIG_B43_HWRNG -DCONFIG_B43LEGACY_HWRNG \ 
    1182         $(if $(CONFIG_PCI),-DCONFIG_ATH9K_PCI) \ 
    1183         $(if $(CONFIG_TARGET_ar71xx),-DCONFIG_ATH9K_AHB) \ 
    1184         $(if $(CONFIG_PACKAGE_MAC80211_DEBUGFS), -DCONFIG_CFG80211_DEBUGFS -DCONFIG_MAC80211_DEBUGFS -DCONFIG_ATH9K_DEBUGFS -DCONFIG_CARL9170_DEBUGFS -DCONFIG_ATH9K_HTC_DEBUGFS -DCONFIG_ATH5K_DEBUG) \ 
    1185         $(if $(CONFIG_PACKAGE_MAC80211_MESH),-DCONFIG_MAC80211_MESH) \ 
    1186         $(if $(CONFIG_PACKAGE_ATH_DEBUG),-DCONFIG_ATH_DEBUG -DCONFIG_ATH9K_PKTLOG) \ 
    1187         -D__CONFIG_MAC80211_RC_DEFAULT=minstrel \ 
    1188         -DCONFIG_MAC80211_RC_MINSTREL_HT \ 
    1189         $(if $(CONFIG_ATH_USER_REGD),-DATH_USER_REGD=1) \ 
    1190         $(if $(CONFIG_PACKAGE_B43_DEBUG),-DCONFIG_B43_DEBUG) \ 
    1191         $(if $(CONFIG_PACKAGE_B43_PIO),-DCONFIG_B43_PIO) \ 
    1192         $(if $(CONFIG_PACKAGE_B43_PIO),-DCONFIG_B43_BCMA_PIO) \ 
    1193         $(if $(CONFIG_PACKAGE_B43_PHY_N),-DCONFIG_B43_PHY_N) \ 
    1194         $(if $(CONFIG_PACKAGE_B43_PHY_HT),-DCONFIG_B43_PHY_HT) \ 
    1195         $(if $(CONFIG_PACKAGE_B43_PHY_LCN),-DCONFIG_B43_PHY_LCN) \ 
    1196         -DCONFIG_B43_BCMA -DCONFIG_B43_BCMA_EXTRA \ 
    1197         -DCONFIG_B43_SSB \ 
    1198         $(if $(CONFIG_PACKAGE_RT2X00_LIB_DEBUGFS),-DCONFIG_RT2X00_LIB_DEBUGFS) \ 
    1199         $(if $(CONFIG_PACKAGE_RT2X00_DEBUG),-DCONFIG_RT2X00_DEBUG) \ 
    1200         $(if $(NEED_RT2X00_LIB_HT),-DCONFIG_RT2X00_LIB_HT) \ 
    1201         $(if $(NEED_RT2X00_LIB_CRYPTO),-DCONFIG_RT2X00_LIB_CRYPTO) \ 
    1202         $(if $(NEED_RT2X00_LIB_FIRMWARE),-DCONFIG_RT2X00_LIB_FIRMWARE) \ 
    1203         $(if $(NEED_RT2X00_LIB_EEPROM),-DCONFIG_RT2X00_LIB_EEPROM) \ 
    1204         $(if $(NEED_RT2X00_LIB_LEDS),-DCONFIG_RT2X00_LIB_LEDS) \ 
    1205         $(if $(CONFIG_PACKAGE_kmod-rt2x00-pci),-DCONFIG_RT2X00_LIB_PCI) \ 
    1206         $(if $(CONFIG_PACKAGE_kmod-rt2x00-usb),-DCONFIG_RT2X00_LIB_USB) \ 
    1207         $(if $(CONFIG_PACKAGE_kmod-rt2x00-usb),-DCONFIG_RT2800USB_RT53XX) \ 
    1208         $(if $(CONFIG_PACKAGE_kmod-rt2x00-soc),-DCONFIG_RT2X00_LIB_SOC) \ 
    1209         $(if $(CONFIG_TARGET_atheros),-DCONFIG_ATH5K_AHB,-DCONFIG_ATH5K_PCI) \ 
    1210         $(if $(CONFIG_PACKAGE_kmod-iwl3945),-DCONFIG_IWL3945) \ 
    1211         $(if $(CONFIG_PACKAGE_kmod-iwl4965),-DCONFIG_COMPAT_IWL4965) \ 
    1212         $(if $(CONFIG_PACKAGE_kmod-wl12xx),-DCONFIG_WL12XX -DCONFIG_COMPAT_WL12XX_SDIO) \ 
    1213         $(if $(CONFIG_PACKAGE_BRCM80211_DEBUG),-DCONFIG_BRCMDBG) \ 
    1214         $(if $(CONFIG_PACKAGE_kmod-brcmfmac),-DCONFIG_BRCMFMAC_USB) 
    1215  
    1216 MAKE_OPTS:= \ 
     1169config_package=$(if $(CONFIG_PACKAGE_kmod-$(1)),m) 
     1170 
     1171config-y:= \ 
     1172        WLAN \ 
     1173        NL80211_TESTMODE \ 
     1174        CFG80211_WEXT \ 
     1175        CFG80211_INTERNAL_REGDB \ 
     1176        MAC80211_RC_MINSTREL \ 
     1177        MAC80211_RC_MINSTREL_HT \ 
     1178        MAC80211_RC_DEFAULT_MINSTREL \ 
     1179 
     1180config-$(call config_package,cfg80211) += CFG80211 
     1181 
     1182config-$(call config_package,mac80211) += MAC80211 
     1183config-$(CONFIG_PACKAGE_MAC80211_MESH) += MAC80211_MESH 
     1184ifdef CONFIG_PACKAGE_MAC80211_DEBUGFS 
     1185  config-y += \ 
     1186        CFG80211_DEBUGFS \ 
     1187        MAC80211_DEBUGFS \ 
     1188        ATH9K_DEBUGFS \ 
     1189        ATH9K_HTC_DEBUGFS \ 
     1190        CARL9170_DEBUGFS \ 
     1191        ATH5K_DEBUG 
     1192endif 
     1193 
     1194config-$(call config_package,lib80211) += LIB80211 LIB80211_CRYPT_WEP LIB80211_CRYPT_CCMP LIB80211_CRYPT_TKIP 
     1195 
     1196config-$(call config_package,ath) += ATH_CARDS ATH_COMMON 
     1197config-$(CONFIG_PACKAGE_ATH_DEBUG) += ATH_DEBUG 
     1198 
     1199config-$(call config_package,ath9k) += ATH9K 
     1200config-$(call config_package,ath9k-common) += ATH9K_COMMON 
     1201config-$(CONFIG_TARGET_ar71xx) += ATH9K_AHB 
     1202config-$(CONFIG_PCI) += ATH9K_PCI 
     1203config-$(CONFIG_ATH_USER_REGD) += ATH_USER_REGD 
     1204 
     1205config-$(call config_package,ath9k-htc) += ATH9K_HTC 
     1206 
     1207config-$(call config_package,ath5k) += ATH5K 
     1208ifdef CONFIG_TARGET_atheros 
     1209  config-y += ATH5K_AHB 
     1210else 
     1211  config-y += ATH5K_PCI 
     1212endif 
     1213 
     1214config-$(call config_package,carl9170) += CARL9170 
     1215 
     1216config-$(call config_package,b43) += B43 
     1217config-y += B43_SSB B43_BCMA B43_BCMA_EXTRA 
     1218config-$(CONFIG_PACKAGE_B43_PHY_N) += B43_PHY_N 
     1219config-$(CONFIG_PACKAGE_B43_PHY_LP) += B43_PHY_LP 
     1220config-$(CONFIG_PACKAGE_B43_PHY_HT) += B43_PHY_HT 
     1221config-$(CONFIG_PACKAGE_B43_PIO) += B43_PIO 
     1222config-$(CONFIG_PACKAGE_B43_DEBUG) += B43_DEBUG 
     1223 
     1224config-$(call config_package,b43legacy) += B43LEGACY 
     1225config-y += B43LEGACY_DMA_MODE 
     1226 
     1227config-$(call config_package,brcmutil) += BRCMUTIL 
     1228config-$(call config_package,brcmsmac) += BRCMSMAC 
     1229config-$(call config_package,brcmfmac) += BRCMFMAC BRCMFMAC_USB 
     1230config-$(CONFIG_PACKAGE_BRCM80211_DEBUG) += BRCMDBG 
     1231 
     1232config-$(call config_package,mac80211-hwsim) += MAC80211_HWSIM 
     1233 
     1234config-$(call config_package,rt2x00-lib) += RT2X00 RT2X00_LIB 
     1235config-$(call config_package,rt2x00-pci) += RT2X00_LIB_PCI RT2X00_LIB_MMIO 
     1236config-$(call config_package,rt2x00-usb) += RT2X00_LIB_USB 
     1237config-$(call config_package,rt2x00-soc) += RT2X00_LIB_SOC 
     1238config-$(CONFIG_PACKAGE_RT2X00_LIB_DEBUGFS) += RT2X00_LIB_DEBUGFS 
     1239config-$(CONFIG_PACKAGE_RT2X00_DEBUG) += RT2X00_DEBUG 
     1240 
     1241config-$(call config_package,rt2400-pci) += RT2400PCI 
     1242config-$(call config_package,rt2500-pci) += RT2500PCI 
     1243config-$(call config_package,rt2500-usb) += RT2500USB 
     1244config-$(call config_package,rt61-pci) += RT61PCI 
     1245config-$(call config_package,rt73-usb) += RT73USB 
     1246 
     1247config-$(call config_package,rt2800-lib) += RT2800_LIB 
     1248config-y += RT2800PCI_RT33XX RT2800PCI_RT35XX RT2800PCI_RT53XX RT2800PCI_RT3290 
     1249 
     1250config-$(call config_package,rt2800-pci) += RT2800PCI 
     1251config-$(call config_package,rt2800-usb) += RT2800USB 
     1252 
     1253config-$(call config_package,iwl-legacy) += IWLEGACY 
     1254config-$(call config_package,iwl3945) += IWL3945 
     1255config-$(call config_package,iwl4965) += IWL4965 
     1256config-$(call config_package,iwlagn) += IWLWIFI 
     1257 
     1258config-$(call config_package,net-libipw) += LIBIPW 
     1259config-$(call config_package,net-ipw2100) += IPW2100 
     1260config-$(call config_package,net-ipw2200) += IPW2200 
     1261 
     1262config-$(call config_package,p54-common) += P54_COMMON 
     1263config-$(call config_package,p54-pci) += P54_PCI 
     1264config-$(call config_package,p54-usb) += P54_USB 
     1265config-$(call config_package,p54-spi) += P54_SPI 
     1266 
     1267config-$(call config_package,net-hermes) += HERMES 
     1268config-$(call config_package,net-hermes-pci) += PCI_HERMES 
     1269config-$(call config_package,net-hermes-plx) += PLX_HERMES 
     1270config-$(call config_package,net-hermes-pcmcia) += PCMCIA_HERMES 
     1271config-y += HERMES_PRISM 
     1272 
     1273config-$(call config_package,adm8211) += ADM8211 
     1274config-$(call config_package,libertas-sd) += LIBERTAS LIBERTAS_SDIO 
     1275config-$(call config_package,libertas-usb) += LIBERTAS LIBERTAS_USB 
     1276config-$(call config_package,mwl8k) += MWL8K 
     1277config-$(call config_package,rtl8180) += RTL8180 
     1278config-$(call config_package,rtl8187) += RTL8187 
     1279config-$(call config_package,wl12xx) += WL_TI WLCORE WLCORE_SDIO WL12XX 
     1280config-$(call config_package,zd1211rw) += ZD1211RW 
     1281 
     1282config-$(CONFIG_LEDS_TRIGGERS) += MAC80211_LEDS B43_LEDS B43LEGACY_LEDS 
     1283 
     1284MAKE_OPTS:= -C "$(PKG_BUILD_DIR)" \ 
    12171285        CROSS_COMPILE="$(KERNEL_CROSS)" \ 
    12181286        ARCH="$(LINUX_KARCH)" \ 
    1219         EXTRA_CFLAGS="$(BUILDFLAGS)" \ 
    1220         $(foreach opt,$(CONFOPTS),CONFIG_$(opt)=m) \ 
    1221         CONFIG_CFG80211_INTERNAL_REGDB=y \ 
    1222         CONFIG_CFG80211=$(if $(CONFIG_PACKAGE_kmod-cfg80211),m) \ 
    1223         CONFIG_MAC80211=$(if $(CONFIG_PACKAGE_kmod-mac80211),m) \ 
    1224         CONFIG_MAC80211_RC_MINSTREL=y \ 
    1225         CONFIG_MAC80211_MESH=$(CONFIG_PACKAGE_MAC80211_MESH) \ 
    1226         CONFIG_MAC80211_LEDS=$(CONFIG_LEDS_TRIGGERS) \ 
    1227         CONFIG_CFG80211_DEBUGFS=$(if $(CONFIG_PACKAGE_MAC80211_DEBUGFS),y) \ 
    1228         CONFIG_MAC80211_DEBUGFS=$(if $(CONFIG_PACKAGE_MAC80211_DEBUGFS),y) \ 
    1229         CONFIG_B43_PCMCIA=n CONFIG_B43_PIO=n \ 
    1230         CONFIG_B43_PCI_AUTOSELECT=$(if $(CONFIG_PCI),y) \ 
    1231         CONFIG_B43_PCICORE_AUTOSELECT=$(if $(CONFIG_PCI),y) \ 
    1232         CONFIG_B43LEGACY_LEDS=$(CONFIG_LEDS_TRIGGERS) \ 
    1233         CONFIG_B43_LEDS=$(CONFIG_LEDS_TRIGGERS) \ 
    1234         CONFIG_B43_HWRNG=$(if $(CONFIG_HW_RANDOM),y) \ 
    1235         CONFIG_B43LEGACY_HWRNG=$(if $(CONFIG_HW_RANDOM),y) \ 
    1236         CONFIG_B43=$(if $(CONFIG_PACKAGE_kmod-b43),m) \ 
    1237         CONFIG_B43LEGACY=$(if $(CONFIG_PACKAGE_kmod-b43legacy),m) \ 
    1238         CONFIG_B43_DEBUG=$(if $(CONFIG_PACKAGE_B43_DEBUG),y) \ 
    1239         CONFIG_B43_PIO=$(if $(CONFIG_PACKAGE_B43_PIO),y) \ 
    1240         CONFIG_B43_BCMA_PIO=$(if $(CONFIG_PACKAGE_B43_PIO),y) \ 
    1241         CONFIG_B43_PHY_N=$(if $(CONFIG_PACKAGE_B43_PHY_N),y) \ 
    1242         CONFIG_B43_PHY_HT=$(if $(CONFIG_PACKAGE_B43_PHY_HT),y) \ 
    1243         CONFIG_B43_PHY_LCN=$(if $(CONFIG_PACKAGE_B43_PHY_LCN),y) \ 
    1244         CONFIG_B43_BCMA=y \ 
    1245         CONFIG_B43_SSB=y \ 
    1246         CONFIG_ATH_CARDS=$(if $(CONFIG_PACKAGE_kmod-ath),m) \ 
    1247         CONFIG_ATH_COMMON=$(if $(CONFIG_PACKAGE_kmod-ath),m) \ 
    1248         CONFIG_ATH_DEBUG=$(if $(CONFIG_PACKAGE_ATH_DEBUG),y) \ 
    1249         CONFIG_ATH9K_PKTLOG=$(if $(CONFIG_PACKAGE_ATH_DEBUG),y) \ 
    1250         CONFIG_ATH5K=$(if $(CONFIG_PACKAGE_kmod-ath5k),m) \ 
    1251         CONFIG_ATH5K_PCI=$(if $(CONFIG_TARGET_atheros),,y) \ 
    1252         CONFIG_ATH5K_AHB=$(if $(CONFIG_TARGET_atheros),y) \ 
    1253         CONFIG_ATH5K_DEBUG=$(if $(CONFIG_PACKAGE_MAC80211_DEBUGFS),y) \ 
    1254         CONFIG_ATH9K=$(if $(CONFIG_PACKAGE_kmod-ath9k),m) \ 
    1255         CONFIG_ATH9K_PCI=$(CONFIG_PCI) \ 
    1256         CONFIG_ATH9K_AHB=$(if $(CONFIG_TARGET_ar71xx),y) \ 
    1257         CONFIG_ATH9K_HTC=$(if $(CONFIG_PACKAGE_kmod-ath9k-htc),m) \ 
    1258         CONFIG_ATH9K_HTC_DEBUGFS=$(if $(CONFIG_PACKAGE_MAC80211_DEBUGFS),y) \ 
    1259         CONFIG_ATH9K_HW=$(if $(CONFIG_PACKAGE_kmod-ath9k-common),m) \ 
    1260         CONFIG_ATH9K_COMMON=$(if $(CONFIG_PACKAGE_kmod-ath9k-common),m) \ 
    1261         CONFIG_ATH9K_DEBUGFS=$(if $(CONFIG_PACKAGE_MAC80211_DEBUGFS),y) \ 
    1262         CONFIG_AR5523= \ 
    1263         CONFIG_WIL6210= \ 
    1264         CONFIG_CARL9170=$(if $(CONFIG_PACKAGE_kmod-carl9170),m) \ 
    1265         CONFIG_CARL9170_DEBUGFS=$(if $(CONFIG_PACKAGE_MAC80211_DEBUGFS),y) \ 
    1266         CONFIG_COMPAT_ZD1211RW=$(if $(CONFIG_PACKAGE_kmod-zd1211rw),m) \ 
    1267         CONFIG_P54_COMMON=$(if $(CONFIG_PACKAGE_kmod-p54-common),m) \ 
    1268         CONFIG_P54_PCI=$(if $(CONFIG_PACKAGE_kmod-p54-pci),m) \ 
    1269         CONFIG_P54_USB=$(if $(CONFIG_PACKAGE_kmod-p54-usb),m) \ 
    1270         CONFIG_P54_SPI=$(if $(CONFIG_PACKAGE_kmod-p54-spi),m) \ 
    1271         CONFIG_P54_SPI_DEFAULT_EEPROM=n \ 
    1272         CONFIG_RT2X00=$(if $(CONFIG_PACKAGE_kmod-rt2x00-lib),m) \ 
    1273         CONFIG_RT2X00_LIB=$(if $(CONFIG_PACKAGE_kmod-rt2x00-lib),m) \ 
    1274         CONFIG_RT2X00_LIB_MMIO=$(if $(CONFIG_PACKAGE_kmod-rt2x00-pci),m) \ 
    1275         CONFIG_RT2X00_LIB_PCI=$(if $(CONFIG_PACKAGE_kmod-rt2x00-pci),m) \ 
    1276         CONFIG_RT2X00_LIB_USB=$(if $(CONFIG_PACKAGE_kmod-rt2x00-usb),m) \ 
    1277         CONFIG_RT2X00_LIB_SOC=$(if $(CONFIG_PACKAGE_kmod-rt2x00-soc),m) \ 
    1278         CONFIG_RT2X00_LIB_DEBUGFS=$(CONFIG_PACKAGE_RT2X00_LIB_DEBUGFS) \ 
    1279         CONFIG_RT2X00_LIB_CRYPTO=$(NEED_RT2X00_LIB_CRYPTO) \ 
    1280         CONFIG_RT2X00_LIB_FIRMWARE=$(NEED_RT2X00_LIB_FIRMWARE) \ 
    1281         CONFIG_RT2X00_LIB_EEPROM=$(NEED_RT2X00_LIB_EEPROM) \ 
    1282         CONFIG_RT2X00_LIB_HT=$(NEED_RT2X00_LIB_HT) \ 
    1283         CONFIG_RT2X00_LIB_LEDS=$(NEED_RT2X00_LIB_LEDS) \ 
    1284         CONFIG_RT2400PCI=$(if $(CONFIG_PACKAGE_kmod-rt2400-pci),m) \ 
    1285         CONFIG_RT2500PCI=$(if $(CONFIG_PACKAGE_kmod-rt2500-pci),m) \ 
    1286         CONFIG_RT2500USB=$(if $(CONFIG_PACKAGE_kmod-rt2500-usb),m) \ 
    1287         CONFIG_RT61PCI=$(if $(CONFIG_PACKAGE_kmod-rt61-pci),m) \ 
    1288         CONFIG_RT73USB=$(if $(CONFIG_PACKAGE_kmod-rt73-usb),m) \ 
    1289         CONFIG_RT2800_LIB=$(if $(CONFIG_PACKAGE_kmod-rt2800-lib),m) \ 
    1290         CONFIG_RT2800PCI=$(if $(CONFIG_PACKAGE_kmod-rt2800-pci),m) \ 
    1291         CONFIG_RT2800USB=$(if $(CONFIG_PACKAGE_kmod-rt2800-usb),m) \ 
    1292         CONFIG_RTL8180=$(if $(CONFIG_PACKAGE_kmod-rtl8180),m) \ 
    1293         CONFIG_RTL8187=$(if $(CONFIG_PACKAGE_kmod-rtl8187),m) \ 
    1294         CONFIG_RTL8192CE= \ 
    1295         CONFIG_RTLWIFI= \ 
    1296         CONFIG_COMPAT_MAC80211_HWSIM=$(if $(CONFIG_PACKAGE_kmod-mac80211-hwsim),m) \ 
    1297         CONFIG_PCMCIA= \ 
    1298         CONFIG_LIBIPW=$(if $(CONFIG_PACKAGE_kmod-net-libipw),m) \ 
    1299         CONFIG_LIBERTAS=$(if $(CONFIG_PACKAGE_kmod-libertas-sd)$(CONFIG_PACKAGE_kmod-libertas-usb),m) \ 
    1300         CONFIG_LIBERTAS_CS= \ 
    1301         CONFIG_LIBERTAS_SPI= \ 
    1302         CONFIG_COMPAT_LIBERTAS_SDIO=$(if $(CONFIG_PACKAGE_kmod-libertas-sd),m) \ 
    1303         CONFIG_LIBERTAS_THINFIRM= \ 
    1304         CONFIG_LIBERTAS_USB=$(if $(CONFIG_PACKAGE_kmod-libertas-usb),m) \ 
    1305         CONFIG_IPW2100=$(if $(CONFIG_PACKAGE_kmod-net-ipw2100),m) \ 
    1306         CONFIG_IPW2200=$(if $(CONFIG_PACKAGE_kmod-net-ipw2200),m) \ 
    1307         CONFIG_NL80211=y \ 
    1308         CONFIG_LIB80211=$(if $(CONFIG_PACKAGE_kmod-lib80211),m) \ 
    1309         CONFIG_LIB80211_CRYPT_WEP=$(if $(CONFIG_PACKAGE_kmod-lib80211),m) \ 
    1310         CONFIG_LIB80211_CRYPT_CCMP=$(if $(CONFIG_PACKAGE_kmod-lib80211),m) \ 
    1311         CONFIG_LIB80211_CRYPT_TKIP=$(if $(CONFIG_PACKAGE_kmod-lib80211),m) \ 
    1312         CONFIG_IWLWIFI=$(if $(CONFIG_PACKAGE_kmod-iwlagn),m) \ 
    1313         CONFIG_IWLEGACY=$(if $(CONFIG_PACKAGE_kmod-iwl-legacy),m) \ 
    1314         CONFIG_COMPAT_IWL4965=$(if $(CONFIG_PACKAGE_kmod-iwl4965),m) \ 
    1315         CONFIG_IWL3945=$(if $(CONFIG_PACKAGE_kmod-iwl3945),m) \ 
    1316         CONFIG_MWL8K=$(if $(CONFIG_PACKAGE_kmod-mwl8k),m) \ 
    1317         CONFIG_ATMEL= \ 
    1318         CONFIG_PCMCIA_ATMEL= \ 
    1319         CONFIG_ADM8211=$(if $(CONFIG_PACKAGE_kmod-adm8211),m) \ 
    1320         CONFIG_USB_NET_RNDIS_HOST= \ 
    1321         CONFIG_USB_NET_RNDIS_WLAN= \ 
    1322         CONFIG_USB_NET_CDCETHER= \ 
    1323         CONFIG_USB_USBNET= \ 
    1324         CONFIG_AT76C50X_USB= \ 
    1325         CONFIG_WL_TI=$(if $(CONFIG_PACKAGE_kmod-wl12xx),m) \ 
    1326         CONFIG_WLCORE=$(if $(CONFIG_PACKAGE_kmod-wl12xx),m) \ 
    1327         CONFIG_WL12XX=$(if $(CONFIG_PACKAGE_kmod-wl12xx),m) \ 
    1328         CONFIG_WLCORE_SDIO=$(if $(CONFIG_PACKAGE_kmod-wl12xx),m) \ 
    1329         CONFIG_EEPROM_93CX6= \ 
    1330         CONFIG_HERMES=$(if $(CONFIG_PACKAGE_kmod-net-hermes),m) \ 
    1331         CONFIG_HERMES_CACHE_FW_ON_INIT= \ 
    1332         CONFIG_PCI_HERMES=$(if $(CONFIG_PACKAGE_kmod-net-hermes-pci),m) \ 
    1333         CONFIG_PLX_HERMES=$(if $(CONFIG_PACKAGE_kmod-net-hermes-plx),m) \ 
    1334         CONFIG_PCMCIA_HERMES=$(if $(CONFIG_PACKAGE_kmod-net-hermes-pcmcia),m) \ 
    1335         CONFIG_HERMES_PRISM= \ 
    1336         CONFIG_APPLE_AIRPORT= \ 
    1337         CONFIG_TMD_HERMES= \ 
    1338         CONFIG_NORTEL_HERMES= \ 
    1339         CONFIG_PCMCIA_SPECTRUM= \ 
    1340         CONFIG_ORINOCO_USB= \ 
    1341         CONFIG_IWM= \ 
    1342         CONFIG_MWIFIEX= \ 
    1343         CONFIG_ATH6KL= \ 
    1344         CONFIG_MAC80211_RC_MINSTREL_HT=y \ 
    1345         MADWIFI= \ 
    1346         CONFIG_BRCMUTIL=$(if $(CONFIG_PACKAGE_kmod-brcmutil),m) \ 
    1347         CONFIG_BRCMSMAC=$(if $(CONFIG_PACKAGE_kmod-brcmsmac),m) \ 
    1348         CONFIG_BRCMFMAC=$(if $(CONFIG_PACKAGE_kmod-brcmfmac),m) \ 
    1349         CONFIG_BRCMFMAC_USB=$(if $(CONFIG_PACKAGE_kmod-brcmfmac),y) \ 
    1350         CONFIG_BRCMDBG=$(if $(CONFIG_PACKAGE_BRCM80211_DEBUG),y) \ 
     1287        EXTRA_CFLAGS="-I$(PKG_BUILD_DIR)/include" \ 
    13511288        KLIB_BUILD="$(LINUX_DIR)" \ 
    13521289        MODPROBE=true \ 
     
    13551292        KBUILD_LDFLAGS_MODULE_PREREQ= 
    13561293 
    1357 ifeq ($(CONFIG_PACKAGE_kmod-libertas-sd)$(CONFIG_PACKAGE_kmod-libertas-usb)$(CONFIG_PACKAGE_kmod-rt2x00-lib),) 
    1358   MAKE_OPTS += CONFIG_COMPAT_KFIFO= 
    1359 endif 
    1360  
    1361 DISABLE_CONFIG = \ 
    1362         COMPAT_BLUETOOTH.* \ 
    1363         COMPAT_CORDIC \ 
    1364         COMPAT_CRC8 \ 
    1365         COMPAT_MDIO \ 
    1366         COMPAT_NETWORK_MODULES \ 
    1367         COMPAT_NET_USB_MODULES \ 
    1368         COMPAT_VAR_MODULES \ 
    1369         COMPAT_RFKILL \ 
    1370         COMPAT_RFKILL_.* \ 
    1371         COMPAT_STAGING \ 
    1372         \ 
    1373         B43_PCMCIA \ 
    1374         B43_SDIO \ 
    1375         BCMA.* \ 
    1376         COMPAT_ATH9K_RATE_CONTROL \ 
    1377         HID_GENERIC \ 
    1378         MAC80211_RC_PID \ 
    1379         PCMCIA \ 
    1380         RFKILL_BACKPORT.* \ 
    1381         SSB \ 
    1382         SSB_SDIOHOST \ 
    1383         \ 
    1384         ATH5K_PCI \ 
    1385         ATH9K_BTCOEX_SUPPORT \ 
    1386         B43_PHY_N \ 
    1387         B43_PHY_HT \ 
    1388         B43_BCMA.* \ 
    1389         MAC80211_MESH \ 
    1390         RT2X00_LIB_PCI \ 
    1391         RT2X00_LIB_USB \ 
    1392         COMPAT_MWIFIEX 
    1393  
     1294define ConfigVars 
     1295$(subst $(space),,$(foreach opt,$(config-$(1)),CPTCFG_$(opt)=$(1) 
     1296)) 
     1297endef 
     1298 
     1299define mac80211_config 
     1300$(call ConfigVars,m)$(call ConfigVars,y) 
     1301endef 
     1302$(eval $(call shexport,mac80211_config)) 
    13941303 
    13951304define Build/Prepare 
     
    14171326        echo 'compat-wireless-$(PKG_VERSION)-$(PKG_RELEASE)-$(REVISION)' > $(PKG_BUILD_DIR)/compat_version 
    14181327        $(CP) ./files/regdb.txt $(PKG_BUILD_DIR)/net/wireless/db.txt 
    1419  
    1420         sed -i $(foreach config,$(DISABLE_CONFIG),-e 's,^\([    ]*export *CONFIG_$(config)=\),# \1,') $(PKG_BUILD_DIR)/config.mk 
    14211328endef 
    14221329 
     
    14241331 define Build/Compile/kmod 
    14251332        rm -rf $(PKG_BUILD_DIR)/modules 
    1426         +$(MAKE) $(PKG_JOBS) -C "$(PKG_BUILD_DIR)" $(MAKE_OPTS) modules 
     1333        +$(MAKE) $(PKG_JOBS) $(MAKE_OPTS) modules 
    14271334 endef 
    14281335endif 
     
    14321339        cmp $(PKG_BUILD_DIR)/include/linux/ath5k_platform.h $(LINUX_DIR)/include/linux/ath5k_platform.h 
    14331340        cmp $(PKG_BUILD_DIR)/include/linux/rt2x00_platform.h $(LINUX_DIR)/include/linux/rt2x00_platform.h 
     1341        $(SH_FUNC) var2file "$(call shvar,mac80211_config)" $(PKG_BUILD_DIR)/.config 
     1342        $(MAKE) $(MAKE_OPTS) allnoconfig 
    14341343endef 
    14351344 
  • trunk/package/mac80211/patches/020-disable_tty_set_termios.patch

    r34531 r36939  
    11--- a/compat/compat-2.6.39.c 
    22+++ b/compat/compat-2.6.39.c 
    3 @@ -12,6 +12,7 @@ 
    4  #include <linux/tty.h> 
     3@@ -13,6 +13,7 @@ 
    54 #include <linux/sched.h> 
     5 #include <linux/module.h> 
    66  
    77+#ifdef CONFIG_COMPAT_BLUETOOTH 
     
    99 /* 
    1010  *             Termios Helper Methods 
    11 @@ -111,4 +112,4 @@ int tty_set_termios(struct tty_struct *t 
     11@@ -112,4 +113,4 @@ int tty_set_termios(struct tty_struct *t 
    1212 } 
    1313 EXPORT_SYMBOL_GPL(tty_set_termios); 
  • trunk/package/mac80211/patches/201-ath5k-WAR-for-AR71xx-PCI-bug.patch

    r32002 r36939  
    11--- a/drivers/net/wireless/ath/ath5k/initvals.c 
    22+++ b/drivers/net/wireless/ath/ath5k/initvals.c 
    3 @@ -65,8 +65,14 @@ static const struct ath5k_ini ar5210_ini 
     3@@ -62,8 +62,14 @@ static const struct ath5k_ini ar5210_ini 
    44        { AR5K_IMR,             0 }, 
    55        { AR5K_IER,             AR5K_IER_DISABLE }, 
     
    1818--- a/drivers/net/wireless/ath/ath5k/dma.c 
    1919+++ b/drivers/net/wireless/ath/ath5k/dma.c 
    20 @@ -863,10 +863,18 @@ ath5k_hw_dma_init(struct ath5k_hw *ah) 
     20@@ -860,10 +860,18 @@ ath5k_hw_dma_init(struct ath5k_hw *ah) 
    2121         * guess we can tweak it and see how it goes ;-) 
    2222         */ 
  • trunk/package/mac80211/patches/300-pending_work.patch

    r36881 r36939  
    1 --- a/drivers/net/wireless/ath/ath9k/ath9k.h 
    2 +++ b/drivers/net/wireless/ath/ath9k/ath9k.h 
    3 @@ -234,6 +234,7 @@ struct ath_buf { 
    4         dma_addr_t bf_daddr;            /* physical addr of desc */ 
    5         dma_addr_t bf_buf_addr; /* physical addr of data buffer, for DMA */ 
    6         bool bf_stale; 
    7 +       struct ieee80211_tx_rate rates[4]; 
    8         struct ath_buf_state bf_state; 
    9  }; 
    10   
    11 @@ -250,9 +251,9 @@ struct ath_atx_tid { 
    12         int tidno; 
    13         int baw_head;   /* first un-acked tx buffer */ 
    14         int baw_tail;   /* next unused tx buffer slot */ 
    15 -       int sched; 
    16 -       int paused; 
    17 -       u8 state; 
    18 +       bool sched; 
    19 +       bool paused; 
    20 +       bool active; 
    21  }; 
    22   
    23  struct ath_node { 
    24 @@ -273,10 +274,6 @@ struct ath_node { 
    25  #endif 
    26  }; 
    27   
    28 -#define AGGR_CLEANUP         BIT(1) 
    29 -#define AGGR_ADDBA_COMPLETE  BIT(2) 
    30 -#define AGGR_ADDBA_PROGRESS  BIT(3) 
    31 - 
    32  struct ath_tx_control { 
    33         struct ath_txq *txq; 
    34         struct ath_node *an; 
    35 @@ -299,6 +296,7 @@ struct ath_tx { 
    36         struct ath_txq txq[ATH9K_NUM_TX_QUEUES]; 
    37         struct ath_descdma txdma; 
    38         struct ath_txq *txq_map[IEEE80211_NUM_ACS]; 
    39 +       struct ath_txq *uapsdq; 
    40         u32 txq_max_pending[IEEE80211_NUM_ACS]; 
    41         u16 max_aggr_framelen[IEEE80211_NUM_ACS][4][32]; 
    42  }; 
    43 @@ -346,6 +344,8 @@ int ath_txq_update(struct ath_softc *sc, 
    44  void ath_update_max_aggr_framelen(struct ath_softc *sc, int queue, int txop); 
    45  int ath_tx_start(struct ieee80211_hw *hw, struct sk_buff *skb, 
    46                  struct ath_tx_control *txctl); 
    47 +void ath_tx_cabq(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 
    48 +                struct sk_buff *skb); 
    49  void ath_tx_tasklet(struct ath_softc *sc); 
    50  void ath_tx_edma_tasklet(struct ath_softc *sc); 
    51  int ath_tx_aggr_start(struct ath_softc *sc, struct ieee80211_sta *sta, 
    52 @@ -356,6 +356,11 @@ void ath_tx_aggr_resume(struct ath_softc 
    53  void ath_tx_aggr_wakeup(struct ath_softc *sc, struct ath_node *an); 
    54  void ath_tx_aggr_sleep(struct ieee80211_sta *sta, struct ath_softc *sc, 
    55                        struct ath_node *an); 
    56 +void ath9k_release_buffered_frames(struct ieee80211_hw *hw, 
    57 +                                  struct ieee80211_sta *sta, 
    58 +                                  u16 tids, int nframes, 
    59 +                                  enum ieee80211_frame_release_type reason, 
    60 +                                  bool more_data); 
    61   
    62  /********/ 
    63  /* VIFs */ 
    64 @@ -658,11 +663,10 @@ enum sc_op_flags { 
    65  struct ath_rate_table; 
    66   
    67  struct ath9k_vif_iter_data { 
    68 -       const u8 *hw_macaddr; /* phy's hardware address, set 
    69 -                              * before starting iteration for 
    70 -                              * valid bssid mask. 
    71 -                              */ 
    72 +       u8 hw_macaddr[ETH_ALEN]; /* address of the first vif */ 
    73         u8 mask[ETH_ALEN]; /* bssid mask */ 
    74 +       bool has_hw_macaddr; 
    75 + 
    76         int naps;      /* number of AP vifs */ 
    77         int nmeshes;   /* number of mesh vifs */ 
    78         int nstations; /* number of station vifs */ 
    79 --- a/drivers/net/wireless/ath/ath9k/hw.c 
    80 +++ b/drivers/net/wireless/ath/ath9k/hw.c 
    81 @@ -1171,6 +1171,7 @@ u32 ath9k_regd_get_ctl(struct ath_regula 
    82  static inline void ath9k_hw_set_dma(struct ath_hw *ah) 
    83  { 
    84         struct ath_common *common = ath9k_hw_common(ah); 
    85 +       int txbuf_size; 
    86   
    87         ENABLE_REGWRITE_BUFFER(ah); 
    88   
    89 @@ -1224,13 +1225,17 @@ static inline void ath9k_hw_set_dma(stru 
    90                  * So set the usable tx buf size also to half to 
    91                  * avoid data/delimiter underruns 
    92                  */ 
    93 -               REG_WRITE(ah, AR_PCU_TXBUF_CTRL, 
    94 -                         AR_9285_PCU_TXBUF_CTRL_USABLE_SIZE); 
    95 -       } else if (!AR_SREV_9271(ah)) { 
    96 -               REG_WRITE(ah, AR_PCU_TXBUF_CTRL, 
    97 -                         AR_PCU_TXBUF_CTRL_USABLE_SIZE); 
    98 +               txbuf_size = AR_9285_PCU_TXBUF_CTRL_USABLE_SIZE; 
    99 +       } else if (AR_SREV_9340_13_OR_LATER(ah)) { 
    100 +               /* Uses fewer entries for AR934x v1.3+ to prevent rx overruns */ 
    101 +               txbuf_size = AR_9340_PCU_TXBUF_CTRL_USABLE_SIZE; 
    102 +       } else { 
    103 +               txbuf_size = AR_PCU_TXBUF_CTRL_USABLE_SIZE; 
    104         } 
    105   
    106 +       if (!AR_SREV_9271(ah)) 
    107 +               REG_WRITE(ah, AR_PCU_TXBUF_CTRL, txbuf_size); 
    108 + 
    109         REGWRITE_BUFFER_FLUSH(ah); 
    110   
    111         if (AR_SREV_9300_20_OR_LATER(ah)) 
    112 @@ -1305,9 +1310,13 @@ static bool ath9k_hw_set_reset(struct at 
    113                         AR_RTC_RC_COLD_RESET | AR_RTC_RC_WARM_RESET; 
    114         } else { 
    115                 tmpReg = REG_READ(ah, AR_INTR_SYNC_CAUSE); 
    116 -               if (tmpReg & 
    117 -                   (AR_INTR_SYNC_LOCAL_TIMEOUT | 
    118 -                    AR_INTR_SYNC_RADM_CPL_TIMEOUT)) { 
    119 +               if (AR_SREV_9340(ah)) 
    120 +                       tmpReg &= AR9340_INTR_SYNC_LOCAL_TIMEOUT; 
    121 +               else 
    122 +                       tmpReg &= AR_INTR_SYNC_LOCAL_TIMEOUT | 
    123 +                                 AR_INTR_SYNC_RADM_CPL_TIMEOUT; 
    124 + 
    125 +               if (tmpReg) { 
    126                         u32 val; 
    127                         REG_WRITE(ah, AR_INTR_SYNC_ENABLE, 0); 
    128   
    129 @@ -1366,7 +1375,10 @@ static bool ath9k_hw_set_reset(struct at 
    130   
    131         REGWRITE_BUFFER_FLUSH(ah); 
    132   
    133 -       udelay(50); 
    134 +       if (AR_SREV_9100(ah)) 
    135 +               mdelay(10); 
    136 +       else 
    137 +               udelay(50); 
    138   
    139         REG_WRITE(ah, AR_RTC_RC, 0); 
    140         if (!ath9k_hw_wait(ah, AR_RTC_RC, AR_RTC_RC_M, 0, AH_WAIT_TIMEOUT)) { 
    141 @@ -1377,8 +1389,12 @@ static bool ath9k_hw_set_reset(struct at 
    142         if (!AR_SREV_9100(ah)) 
    143                 REG_WRITE(ah, AR_RC, 0); 
    144   
    145 -       if (AR_SREV_9100(ah)) 
    146 +       if (AR_SREV_9100(ah) && type != ATH9K_RESET_WARM) { 
    147 +               if (ah->external_reset) 
    148 +                       ah->external_reset(); 
    149 + 
    150                 udelay(50); 
    151 +       } 
    152   
    153         return true; 
    154  } 
    155 @@ -1464,7 +1480,8 @@ static bool ath9k_hw_chip_reset(struct a 
    156                         reset_type = ATH9K_RESET_POWER_ON; 
    157                 else 
    158                         reset_type = ATH9K_RESET_COLD; 
    159 -       } else if (ah->chip_fullsleep || REG_READ(ah, AR_Q_TXE) || 
    160 +       } else if (ah->chip_fullsleep || 
    161 +                  REG_READ(ah, AR_Q_TXE) || 
    162                    (REG_READ(ah, AR_CR) & AR_CR_RXE)) 
    163                 reset_type = ATH9K_RESET_COLD; 
    164   
    165 @@ -1698,12 +1715,11 @@ static void ath9k_hw_reset_opmode(struct 
    166   
    167         ENABLE_REGWRITE_BUFFER(ah); 
    168   
    169 -       REG_WRITE(ah, AR_STA_ID0, get_unaligned_le32(common->macaddr)); 
    170 -       REG_WRITE(ah, AR_STA_ID1, get_unaligned_le16(common->macaddr + 4) 
    171 -                 | macStaId1 
    172 +       REG_RMW(ah, AR_STA_ID1, macStaId1 
    173                   | AR_STA_ID1_RTS_USE_DEF 
    174                   | (ah->config.ack_6mb ? AR_STA_ID1_ACKCTS_6MB : 0) 
    175 -                 | ah->sta_id1_defaults); 
    176 +                 | ah->sta_id1_defaults, 
    177 +                 ~AR_STA_ID1_SADH_MASK); 
    178         ath_hw_setbssidmask(common); 
    179         REG_WRITE(ah, AR_DEF_ANTENNA, saveDefAntenna); 
    180         ath9k_hw_write_associd(ah); 
    181 --- a/drivers/net/wireless/ath/ath9k/main.c 
    182 +++ b/drivers/net/wireless/ath/ath9k/main.c 
    183 @@ -839,10 +839,14 @@ static void ath9k_vif_iter(void *data, u 
    184         struct ath9k_vif_iter_data *iter_data = data; 
    185         int i; 
    186   
    187 -       if (iter_data->hw_macaddr) 
    188 +       if (iter_data->has_hw_macaddr) { 
    189                 for (i = 0; i < ETH_ALEN; i++) 
    190                         iter_data->mask[i] &= 
    191                                 ~(iter_data->hw_macaddr[i] ^ mac[i]); 
    192 +       } else { 
    193 +               memcpy(iter_data->hw_macaddr, mac, ETH_ALEN); 
    194 +               iter_data->has_hw_macaddr = true; 
    195 +       } 
    196   
    197         switch (vif->type) { 
    198         case NL80211_IFTYPE_AP: 
    199 @@ -891,7 +895,6 @@ void ath9k_calculate_iter_data(struct ie 
    200          * together with the BSSID mask when matching addresses. 
    201          */ 
    202         memset(iter_data, 0, sizeof(*iter_data)); 
    203 -       iter_data->hw_macaddr = common->macaddr; 
    204         memset(&iter_data->mask, 0xff, ETH_ALEN); 
    205   
    206         if (vif) 
    207 @@ -901,6 +904,8 @@ void ath9k_calculate_iter_data(struct ie 
    208         ieee80211_iterate_active_interfaces_atomic( 
    209                 sc->hw, IEEE80211_IFACE_ITER_RESUME_ALL, 
    210                 ath9k_vif_iter, iter_data); 
    211 + 
    212 +       memcpy(common->macaddr, iter_data->hw_macaddr, ETH_ALEN); 
    213  } 
    214   
    215  /* Called with sc->mutex held. */ 
    216 @@ -1327,6 +1332,7 @@ static int ath9k_sta_add(struct ieee8021 
    217         struct ath_common *common = ath9k_hw_common(sc->sc_ah); 
    218         struct ath_node *an = (struct ath_node *) sta->drv_priv; 
    219         struct ieee80211_key_conf ps_key = { }; 
    220 +       int key; 
    221   
    222         ath_node_attach(sc, sta, vif); 
    223   
    224 @@ -1334,7 +1340,9 @@ static int ath9k_sta_add(struct ieee8021 
    225             vif->type != NL80211_IFTYPE_AP_VLAN) 
    226                 return 0; 
    227   
    228 -       an->ps_key = ath_key_config(common, vif, sta, &ps_key); 
    229 +       key = ath_key_config(common, vif, sta, &ps_key); 
    230 +       if (key > 0) 
    231 +               an->ps_key = key; 
    232   
    233         return 0; 
    234  } 
    235 @@ -1351,6 +1359,7 @@ static void ath9k_del_ps_key(struct ath_ 
    236             return; 
    237   
    238         ath_key_delete(common, &ps_key); 
    239 +       an->ps_key = 0; 
    240  } 
    241   
    242  static int ath9k_sta_remove(struct ieee80211_hw *hw, 
    243 @@ -1678,6 +1687,7 @@ static int ath9k_ampdu_action(struct iee 
    244                               u16 tid, u16 *ssn, u8 buf_size) 
    245  { 
    246         struct ath_softc *sc = hw->priv; 
    247 +       bool flush = false; 
    248         int ret = 0; 
    249   
    250         local_bh_disable(); 
    251 @@ -1694,12 +1704,14 @@ static int ath9k_ampdu_action(struct iee 
    252                         ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 
    253                 ath9k_ps_restore(sc); 
    254                 break; 
    255 -       case IEEE80211_AMPDU_TX_STOP_CONT: 
    256         case IEEE80211_AMPDU_TX_STOP_FLUSH: 
    257         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 
    258 +               flush = true; 
    259 +       case IEEE80211_AMPDU_TX_STOP_CONT: 
    260                 ath9k_ps_wakeup(sc); 
    261                 ath_tx_aggr_stop(sc, sta, tid); 
    262 -               ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 
    263 +               if (!flush) 
    264 +                       ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 
    265                 ath9k_ps_restore(sc); 
    266                 break; 
    267         case IEEE80211_AMPDU_TX_OPERATIONAL: 
    268 @@ -2366,6 +2378,7 @@ struct ieee80211_ops ath9k_ops = { 
    269         .flush              = ath9k_flush, 
    270         .tx_frames_pending  = ath9k_tx_frames_pending, 
    271         .tx_last_beacon     = ath9k_tx_last_beacon, 
    272 +       .release_buffered_frames = ath9k_release_buffered_frames, 
    273         .get_stats          = ath9k_get_stats, 
    274         .set_antenna        = ath9k_set_antenna, 
    275         .get_antenna        = ath9k_get_antenna, 
    276 --- a/drivers/net/wireless/ath/ath9k/reg.h 
    277 +++ b/drivers/net/wireless/ath/ath9k/reg.h 
    278 @@ -798,6 +798,10 @@ 
    279  #define AR_SREV_REVISION_9485_10       0 
    280  #define AR_SREV_REVISION_9485_11        1 
    281  #define AR_SREV_VERSION_9340           0x300 
    282 +#define AR_SREV_REVISION_9340_10       0 
    283 +#define AR_SREV_REVISION_9340_11       1 
    284 +#define AR_SREV_REVISION_9340_12       2 
    285 +#define AR_SREV_REVISION_9340_13       3 
    286  #define AR_SREV_VERSION_9580           0x1C0 
    287  #define AR_SREV_REVISION_9580_10       4 /* AR9580 1.0 */ 
    288  #define AR_SREV_VERSION_9462           0x280 
    289 @@ -897,6 +901,10 @@ 
    290  #define AR_SREV_9340(_ah) \ 
    291         (((_ah)->hw_version.macVersion == AR_SREV_VERSION_9340)) 
    292   
    293 +#define AR_SREV_9340_13_OR_LATER(_ah) \ 
    294 +       (AR_SREV_9340((_ah)) && \ 
    295 +        ((_ah)->hw_version.macRev >= AR_SREV_REVISION_9340_13)) 
    296 + 
    297  #define AR_SREV_9285E_20(_ah) \ 
    298      (AR_SREV_9285_12_OR_LATER(_ah) && \ 
    299       ((REG_READ(_ah, AR_AN_SYNTH9) & 0x7) == 0x1)) 
    300 @@ -1007,6 +1015,8 @@ enum { 
    301                                 AR_INTR_SYNC_LOCAL_TIMEOUT | 
    302                                 AR_INTR_SYNC_MAC_SLEEP_ACCESS), 
    303   
    304 +       AR9340_INTR_SYNC_LOCAL_TIMEOUT = 0x00000010, 
    305 + 
    306         AR_INTR_SYNC_SPURIOUS = 0xFFFFFFFF, 
    307   
    308  }; 
    309 @@ -1493,9 +1503,6 @@ enum { 
    310  #define AR9271_RADIO_RF_RST                    0x20 
    311  #define AR9271_GATE_MAC_CTL                    0x4000 
    312   
    313 -#define AR_STA_ID0                 0x8000 
    314 -#define AR_STA_ID1                 0x8004 
    315 -#define AR_STA_ID1_SADH_MASK       0x0000FFFF 
    316  #define AR_STA_ID1_STA_AP          0x00010000 
    317  #define AR_STA_ID1_ADHOC           0x00020000 
    318  #define AR_STA_ID1_PWR_SAV         0x00040000 
    319 @@ -1884,6 +1891,7 @@ enum { 
    320  #define AR_PCU_TXBUF_CTRL_SIZE_MASK     0x7FF 
    321  #define AR_PCU_TXBUF_CTRL_USABLE_SIZE   0x700 
    322  #define AR_9285_PCU_TXBUF_CTRL_USABLE_SIZE   0x380 
    323 +#define AR_9340_PCU_TXBUF_CTRL_USABLE_SIZE   0x500 
    324   
    325  #define AR_PCU_MISC_MODE2               0x8344 
    326  #define AR_PCU_MISC_MODE2_MGMT_CRYPTO_ENABLE           0x00000002 
    327 --- a/drivers/net/wireless/ath/hw.c 
    328 +++ b/drivers/net/wireless/ath/hw.c 
    329 @@ -118,6 +118,12 @@ 
    330  void ath_hw_setbssidmask(struct ath_common *common) 
    331  { 
    332         void *ah = common->ah; 
    333 +       u32 id1; 
    334 + 
    335 +       REG_WRITE(ah, AR_STA_ID0, get_unaligned_le32(common->macaddr)); 
    336 +       id1 = REG_READ(ah, AR_STA_ID1) & ~AR_STA_ID1_SADH_MASK; 
    337 +       id1 |= get_unaligned_le16(common->macaddr + 4); 
    338 +       REG_WRITE(ah, AR_STA_ID1, id1); 
    339   
    340         REG_WRITE(ah, AR_BSSMSKL, get_unaligned_le32(common->bssidmask)); 
    341         REG_WRITE(ah, AR_BSSMSKU, get_unaligned_le16(common->bssidmask + 4)); 
    342 --- a/drivers/net/wireless/ath/reg.h 
    343 +++ b/drivers/net/wireless/ath/reg.h 
    344 @@ -23,6 +23,10 @@ 
    345  #define AR_MIBC_CMC            0x00000004 
    346  #define AR_MIBC_MCS            0x00000008 
    347   
    348 +#define AR_STA_ID0             0x8000 
    349 +#define AR_STA_ID1             0x8004 
    350 +#define AR_STA_ID1_SADH_MASK   0x0000ffff 
    351 + 
    352  /* 
    353   * BSSID mask registers. See ath_hw_set_bssid_mask() 
    354   * for detailed documentation about these registers. 
    355 --- a/drivers/net/wireless/iwlegacy/4965-mac.c 
    356 +++ b/drivers/net/wireless/iwlegacy/4965-mac.c 
    357 @@ -6059,7 +6059,7 @@ il4965_mac_channel_switch(struct ieee802 
    358         struct il_priv *il = hw->priv; 
    359         const struct il_channel_info *ch_info; 
    360         struct ieee80211_conf *conf = &hw->conf; 
    361 -       struct ieee80211_channel *channel = ch_switch->channel; 
    362 +       struct ieee80211_channel *channel = ch_switch->chandef.chan; 
    363         struct il_ht_config *ht_conf = &il->current_ht_config; 
    364         u16 ch; 
    365   
    366 @@ -6096,23 +6096,21 @@ il4965_mac_channel_switch(struct ieee802 
    367         il->current_ht_config.smps = conf->smps_mode; 
    368   
    369         /* Configure HT40 channels */ 
    370 -       il->ht.enabled = conf_is_ht(conf); 
    371 -       if (il->ht.enabled) { 
    372 -               if (conf_is_ht40_minus(conf)) { 
    373 -                       il->ht.extension_chan_offset = 
    374 -                           IEEE80211_HT_PARAM_CHA_SEC_BELOW; 
    375 -                       il->ht.is_40mhz = true; 
    376 -               } else if (conf_is_ht40_plus(conf)) { 
    377 -                       il->ht.extension_chan_offset = 
    378 -                           IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 
    379 -                       il->ht.is_40mhz = true; 
    380 -               } else { 
    381 -                       il->ht.extension_chan_offset = 
    382 -                           IEEE80211_HT_PARAM_CHA_SEC_NONE; 
    383 -                       il->ht.is_40mhz = false; 
    384 -               } 
    385 -       } else 
    386 +       switch (cfg80211_get_chandef_type(&ch_switch->chandef)) { 
    387 +       case NL80211_CHAN_NO_HT: 
    388 +       case NL80211_CHAN_HT20: 
    389                 il->ht.is_40mhz = false; 
    390 +               il->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE; 
    391 +               break; 
    392 +       case NL80211_CHAN_HT40MINUS: 
    393 +               il->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW; 
    394 +               il->ht.is_40mhz = true; 
    395 +               break; 
    396 +       case NL80211_CHAN_HT40PLUS: 
    397 +               il->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 
    398 +               il->ht.is_40mhz = true; 
    399 +               break; 
    400 +       } 
    401   
    402         if ((le16_to_cpu(il->staging.channel) != ch)) 
    403                 il->staging.flags = 0; 
    404 --- a/drivers/net/wireless/iwlegacy/4965.c 
    405 +++ b/drivers/net/wireless/iwlegacy/4965.c 
    406 @@ -1493,7 +1493,7 @@ il4965_hw_channel_switch(struct il_priv  
    407   
    408         cmd.band = band; 
    409         cmd.expect_beacon = 0; 
    410 -       ch = ch_switch->channel->hw_value; 
    411 +       ch = ch_switch->chandef.chan->hw_value; 
    412         cmd.channel = cpu_to_le16(ch); 
    413         cmd.rxon_flags = il->staging.flags; 
    414         cmd.rxon_filter_flags = il->staging.filter_flags; 
    415 --- a/drivers/net/wireless/iwlwifi/dvm/devices.c 
    416 +++ b/drivers/net/wireless/iwlwifi/dvm/devices.c 
    417 @@ -379,7 +379,7 @@ static int iwl5000_hw_channel_switch(str 
    418         }; 
    419   
    420         cmd.band = priv->band == IEEE80211_BAND_2GHZ; 
    421 -       ch = ch_switch->channel->hw_value; 
    422 +       ch = ch_switch->chandef.chan->hw_value; 
    423         IWL_DEBUG_11H(priv, "channel switch from %d to %d\n", 
    424                       ctx->active.channel, ch); 
    425         cmd.channel = cpu_to_le16(ch); 
    426 @@ -414,7 +414,8 @@ static int iwl5000_hw_channel_switch(str 
    427         } 
    428         IWL_DEBUG_11H(priv, "uCode time for the switch is 0x%x\n", 
    429                       cmd.switch_time); 
    430 -       cmd.expect_beacon = ch_switch->channel->flags & IEEE80211_CHAN_RADAR; 
    431 +       cmd.expect_beacon = 
    432 +               ch_switch->chandef.chan->flags & IEEE80211_CHAN_RADAR; 
    433   
    434         return iwl_dvm_send_cmd(priv, &hcmd); 
    435  } 
    436 @@ -540,7 +541,7 @@ static int iwl6000_hw_channel_switch(str 
    437         hcmd.data[0] = cmd; 
    438   
    439         cmd->band = priv->band == IEEE80211_BAND_2GHZ; 
    440 -       ch = ch_switch->channel->hw_value; 
    441 +       ch = ch_switch->chandef.chan->hw_value; 
    442         IWL_DEBUG_11H(priv, "channel switch from %u to %u\n", 
    443                       ctx->active.channel, ch); 
    444         cmd->channel = cpu_to_le16(ch); 
    445 @@ -575,7 +576,8 @@ static int iwl6000_hw_channel_switch(str 
    446         } 
    447         IWL_DEBUG_11H(priv, "uCode time for the switch is 0x%x\n", 
    448                       cmd->switch_time); 
    449 -       cmd->expect_beacon = ch_switch->channel->flags & IEEE80211_CHAN_RADAR; 
    450 +       cmd->expect_beacon = 
    451 +               ch_switch->chandef.chan->flags & IEEE80211_CHAN_RADAR; 
    452   
    453         err = iwl_dvm_send_cmd(priv, &hcmd); 
    454         kfree(cmd); 
    455 --- a/drivers/net/wireless/iwlwifi/dvm/mac80211.c 
    456 +++ b/drivers/net/wireless/iwlwifi/dvm/mac80211.c 
    457 @@ -970,7 +970,7 @@ static void iwlagn_mac_channel_switch(st 
    458  { 
    459         struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 
    460         struct ieee80211_conf *conf = &hw->conf; 
    461 -       struct ieee80211_channel *channel = ch_switch->channel; 
    462 +       struct ieee80211_channel *channel = ch_switch->chandef.chan; 
    463         struct iwl_ht_config *ht_conf = &priv->current_ht_config; 
    464         /* 
    465          * MULTI-FIXME 
    466 @@ -1008,11 +1008,21 @@ static void iwlagn_mac_channel_switch(st 
    467         priv->current_ht_config.smps = conf->smps_mode; 
    468   
    469         /* Configure HT40 channels */ 
    470 -       ctx->ht.enabled = conf_is_ht(conf); 
    471 -       if (ctx->ht.enabled) 
    472 -               iwlagn_config_ht40(conf, ctx); 
    473 -       else 
    474 +       switch (cfg80211_get_chandef_type(&ch_switch->chandef)) { 
    475 +       case NL80211_CHAN_NO_HT: 
    476 +       case NL80211_CHAN_HT20: 
    477                 ctx->ht.is_40mhz = false; 
    478 +               ctx->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE; 
    479 +               break; 
    480 +       case NL80211_CHAN_HT40MINUS: 
    481 +               ctx->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW; 
    482 +               ctx->ht.is_40mhz = true; 
    483 +               break; 
    484 +       case NL80211_CHAN_HT40PLUS: 
    485 +               ctx->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 
    486 +               ctx->ht.is_40mhz = true; 
    487 +               break; 
    488 +       } 
    489   
    490         if ((le16_to_cpu(ctx->staging.channel) != ch)) 
    491                 ctx->staging.flags = 0; 
    492 --- a/drivers/net/wireless/iwlwifi/dvm/rxon.c 
    493 +++ b/drivers/net/wireless/iwlwifi/dvm/rxon.c 
    494 @@ -1160,7 +1160,7 @@ int iwlagn_commit_rxon(struct iwl_priv * 
    495  } 
    496   
    497  void iwlagn_config_ht40(struct ieee80211_conf *conf, 
    498 -       struct iwl_rxon_context *ctx) 
    499 +                       struct iwl_rxon_context *ctx) 
    500  { 
    501         if (conf_is_ht40_minus(conf)) { 
    502                 ctx->ht.extension_chan_offset = 
    503 --- a/drivers/net/wireless/mac80211_hwsim.c 
    504 +++ b/drivers/net/wireless/mac80211_hwsim.c 
    505 @@ -25,6 +25,7 @@ 
    506  #include <linux/if_arp.h> 
    507  #include <linux/rtnetlink.h> 
    508  #include <linux/etherdevice.h> 
    509 +#include <linux/platform_device.h> 
    510  #include <linux/debugfs.h> 
    511  #include <linux/module.h> 
    512  #include <linux/ktime.h> 
    513 @@ -717,9 +718,17 @@ static bool mac80211_hwsim_tx_frame_no_n 
    514         rx_status.flag |= RX_FLAG_MACTIME_START; 
    515         rx_status.freq = chan->center_freq; 
    516         rx_status.band = chan->band; 
    517 -       rx_status.rate_idx = info->control.rates[0].idx; 
    518 -       if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS) 
    519 -               rx_status.flag |= RX_FLAG_HT; 
    520 +       if (info->control.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) { 
    521 +               rx_status.rate_idx = 
    522 +                       ieee80211_rate_get_vht_mcs(&info->control.rates[0]); 
    523 +               rx_status.vht_nss = 
    524 +                       ieee80211_rate_get_vht_nss(&info->control.rates[0]); 
    525 +               rx_status.flag |= RX_FLAG_VHT; 
    526 +       } else { 
    527 +               rx_status.rate_idx = info->control.rates[0].idx; 
    528 +               if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS) 
    529 +                       rx_status.flag |= RX_FLAG_HT; 
    530 +       } 
    531         if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH) 
    532                 rx_status.flag |= RX_FLAG_40MHZ; 
    533         if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI) 
    534 @@ -1687,6 +1696,7 @@ static void mac80211_hwsim_free(void) 
    535                 debugfs_remove(data->debugfs_ps); 
    536                 debugfs_remove(data->debugfs); 
    537                 ieee80211_unregister_hw(data->hw); 
    538 +               device_release_driver(data->dev); 
    539                 device_unregister(data->dev); 
    540                 ieee80211_free_hw(data->hw); 
    541         } 
    542 @@ -1695,7 +1705,9 @@ static void mac80211_hwsim_free(void) 
    543   
    544   
    545  static struct device_driver mac80211_hwsim_driver = { 
    546 -       .name = "mac80211_hwsim" 
    547 +       .name = "mac80211_hwsim", 
    548 +       .bus = &platform_bus_type, 
    549 +       .owner = THIS_MODULE, 
    550  }; 
    551   
    552  static const struct net_device_ops hwsim_netdev_ops = { 
    553 @@ -2187,9 +2199,15 @@ static int __init init_mac80211_hwsim(vo 
    554         spin_lock_init(&hwsim_radio_lock); 
    555         INIT_LIST_HEAD(&hwsim_radios); 
    556   
    557 +       err = driver_register(&mac80211_hwsim_driver); 
    558 +       if (err) 
    559 +               return err; 
    560 + 
    561         hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim"); 
    562 -       if (IS_ERR(hwsim_class)) 
    563 -               return PTR_ERR(hwsim_class); 
    564 +       if (IS_ERR(hwsim_class)) { 
    565 +               err = PTR_ERR(hwsim_class); 
    566 +               goto failed_unregister_driver; 
    567 +       } 
    568   
    569         memset(addr, 0, ETH_ALEN); 
    570         addr[0] = 0x02; 
    571 @@ -2211,12 +2229,20 @@ static int __init init_mac80211_hwsim(vo 
    572                                           "hwsim%d", i); 
    573                 if (IS_ERR(data->dev)) { 
    574                         printk(KERN_DEBUG 
    575 -                              "mac80211_hwsim: device_create " 
    576 -                              "failed (%ld)\n", PTR_ERR(data->dev)); 
    577 +                              "mac80211_hwsim: device_create failed (%ld)\n", 
    578 +                              PTR_ERR(data->dev)); 
    579                         err = -ENOMEM; 
    580                         goto failed_drvdata; 
    581                 } 
    582                 data->dev->driver = &mac80211_hwsim_driver; 
    583 +               err = device_bind_driver(data->dev); 
    584 +               if (err != 0) { 
    585 +                       printk(KERN_DEBUG 
    586 +                              "mac80211_hwsim: device_bind_driver failed (%d)\n", 
    587 +                              err); 
    588 +                       goto failed_hw; 
    589 +               } 
    590 + 
    591                 skb_queue_head_init(&data->pending); 
    592   
    593                 SET_IEEE80211_DEV(hw, data->dev); 
    594 @@ -2515,6 +2541,8 @@ failed_drvdata: 
    595         ieee80211_free_hw(hw); 
    596  failed: 
    597         mac80211_hwsim_free(); 
    598 +failed_unregister_driver: 
    599 +       driver_unregister(&mac80211_hwsim_driver); 
    600         return err; 
    601  } 
    602  module_init(init_mac80211_hwsim); 
    603 @@ -2527,5 +2555,6 @@ static void __exit exit_mac80211_hwsim(v 
    604   
    605         mac80211_hwsim_free(); 
    606         unregister_netdev(hwsim_mon); 
    607 +       driver_unregister(&mac80211_hwsim_driver); 
    608  } 
    609  module_exit(exit_mac80211_hwsim); 
    610 --- a/drivers/net/wireless/ti/wl12xx/cmd.c 
    611 +++ b/drivers/net/wireless/ti/wl12xx/cmd.c 
    612 @@ -301,7 +301,7 @@ int wl12xx_cmd_channel_switch(struct wl1 
    613         } 
    614   
    615         cmd->role_id = wlvif->role_id; 
    616 -       cmd->channel = ch_switch->channel->hw_value; 
    617 +       cmd->channel = ch_switch->chandef.chan->hw_value; 
    618         cmd->switch_time = ch_switch->count; 
    619         cmd->stop_tx = ch_switch->block_tx; 
    620   
    621 --- a/drivers/net/wireless/ti/wl18xx/cmd.c 
    622 +++ b/drivers/net/wireless/ti/wl18xx/cmd.c 
    623 @@ -42,11 +42,11 @@ int wl18xx_cmd_channel_switch(struct wl1 
    624         } 
    625   
    626         cmd->role_id = wlvif->role_id; 
    627 -       cmd->channel = ch_switch->channel->hw_value; 
    628 +       cmd->channel = ch_switch->chandef.chan->hw_value; 
    629         cmd->switch_time = ch_switch->count; 
    630         cmd->stop_tx = ch_switch->block_tx; 
    631   
    632 -       switch (ch_switch->channel->band) { 
    633 +       switch (ch_switch->chandef.chan->band) { 
    634         case IEEE80211_BAND_2GHZ: 
    635                 cmd->band = WLCORE_BAND_2_4GHZ; 
    636                 break; 
    637 @@ -55,7 +55,7 @@ int wl18xx_cmd_channel_switch(struct wl1 
    638                 break; 
    639         default: 
    640                 wl1271_error("invalid channel switch band: %d", 
    641 -                            ch_switch->channel->band); 
    642 +                            ch_switch->chandef.chan->band); 
    643                 ret = -EINVAL; 
    644                 goto out_free; 
    645         } 
    646 --- a/include/linux/ieee80211.h 
    647 +++ b/include/linux/ieee80211.h 
    648 @@ -673,6 +673,36 @@ struct ieee80211_channel_sw_ie { 
    649  } __packed; 
    650   
    651  /** 
    652 + * struct ieee80211_ext_chansw_ie 
    653 + * 
    654 + * This structure represents the "Extended Channel Switch Announcement element" 
    655 + */ 
    656 +struct ieee80211_ext_chansw_ie { 
    657 +       u8 mode; 
    658 +       u8 new_operating_class; 
    659 +       u8 new_ch_num; 
    660 +       u8 count; 
    661 +} __packed; 
    662 + 
    663 +/** 
    664 + * struct ieee80211_sec_chan_offs_ie - secondary channel offset IE 
    665 + * @sec_chan_offs: secondary channel offset, uses IEEE80211_HT_PARAM_CHA_SEC_* 
    666 + *     values here 
    667 + * This structure represents the "Secondary Channel Offset element" 
    668 + */ 
    669 +struct ieee80211_sec_chan_offs_ie { 
    670 +       u8 sec_chan_offs; 
    671 +} __packed; 
    672 + 
    673 +/** 
    674 + * struct ieee80211_wide_bw_chansw_ie - wide bandwidth channel switch IE 
    675 + */ 
    676 +struct ieee80211_wide_bw_chansw_ie { 
    677 +       u8 new_channel_width; 
    678 +       u8 new_center_freq_seg0, new_center_freq_seg1; 
    679 +} __packed; 
    680 + 
    681 +/** 
    682   * struct ieee80211_tim 
    683   * 
    684   * This structure refers to "Traffic Indication Map information element" 
    685 @@ -840,12 +870,15 @@ struct ieee80211_mgmt { 
    686                                 } __packed wme_action; 
    687                                 struct{ 
    688                                         u8 action_code; 
    689 -                                       u8 element_id; 
    690 -                                       u8 length; 
    691 -                                       struct ieee80211_channel_sw_ie sw_elem; 
    692 +                                       u8 variable[0]; 
    693                                 } __packed chan_switch; 
    694                                 struct{ 
    695                                         u8 action_code; 
    696 +                                       struct ieee80211_ext_chansw_ie data; 
    697 +                                       u8 variable[0]; 
    698 +                               } __packed ext_chan_switch; 
    699 +                               struct{ 
    700 +                                       u8 action_code; 
    701                                         u8 dialog_token; 
    702                                         u8 element_id; 
    703                                         u8 length; 
    704 @@ -1638,6 +1671,7 @@ enum ieee80211_eid { 
    705   
    706         WLAN_EID_HT_CAPABILITY = 45, 
    707         WLAN_EID_HT_OPERATION = 61, 
    708 +       WLAN_EID_SECONDARY_CHANNEL_OFFSET = 62, 
    709   
    710         WLAN_EID_RSN = 48, 
    711         WLAN_EID_MMIE = 76, 
    712 @@ -1672,6 +1706,8 @@ enum ieee80211_eid { 
    713         WLAN_EID_VHT_CAPABILITY = 191, 
    714         WLAN_EID_VHT_OPERATION = 192, 
    715         WLAN_EID_OPMODE_NOTIF = 199, 
    716 +       WLAN_EID_WIDE_BW_CHANNEL_SWITCH = 194, 
    717 +       WLAN_EID_CHANNEL_SWITCH_WRAPPER = 196, 
    718   
    719         /* 802.11ad */ 
    720         WLAN_EID_NON_TX_BSSID_CAP =  83, 
    721 @@ -1795,6 +1831,7 @@ enum ieee80211_key_len { 
    722   
    723  /* Public action codes */ 
    724  enum ieee80211_pub_actioncode { 
    725 +       WLAN_PUB_ACTION_EXT_CHANSW_ANN = 4, 
    726         WLAN_PUB_ACTION_TDLS_DISCOVER_RES = 14, 
    727  }; 
    728   
    729 --- a/include/net/cfg80211.h 
    730 +++ b/include/net/cfg80211.h 
    731 @@ -753,6 +753,8 @@ int cfg80211_check_station_change(struct 
    732   * @STATION_INFO_LOCAL_PM: @local_pm filled 
    733   * @STATION_INFO_PEER_PM: @peer_pm filled 
    734   * @STATION_INFO_NONPEER_PM: @nonpeer_pm filled 
    735 + * @STATION_INFO_CHAIN_SIGNAL: @chain_signal filled 
    736 + * @STATION_INFO_CHAIN_SIGNAL_AVG: @chain_signal_avg filled 
    737   */ 
    738  enum station_info_flags { 
    739         STATION_INFO_INACTIVE_TIME      = 1<<0, 
    740 @@ -781,6 +783,8 @@ enum station_info_flags { 
    741         STATION_INFO_NONPEER_PM         = 1<<23, 
    742         STATION_INFO_RX_BYTES64         = 1<<24, 
    743         STATION_INFO_TX_BYTES64         = 1<<25, 
    744 +       STATION_INFO_CHAIN_SIGNAL       = 1<<26, 
    745 +       STATION_INFO_CHAIN_SIGNAL_AVG   = 1<<27, 
    746  }; 
    747   
    748  /** 
    749 @@ -857,6 +861,8 @@ struct sta_bss_parameters { 
    750         u16 beacon_interval; 
    751  }; 
    752   
    753 +#define IEEE80211_MAX_CHAINS   4 
    754 + 
    755  /** 
    756   * struct station_info - station information 
    757   * 
    758 @@ -874,6 +880,9 @@ struct sta_bss_parameters { 
    759   *     For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_. 
    760   * @signal_avg: Average signal strength, type depends on the wiphy's signal_type. 
    761   *     For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_. 
    762 + * @chains: bitmask for filled values in @chain_signal, @chain_signal_avg 
    763 + * @chain_signal: per-chain signal strength of last received packet in dBm 
    764 + * @chain_signal_avg: per-chain signal strength average in dBm 
    765   * @txrate: current unicast bitrate from this station 
    766   * @rxrate: current unicast bitrate to this station 
    767   * @rx_packets: packets received from this station 
    768 @@ -909,6 +918,11 @@ struct station_info { 
    769         u8 plink_state; 
    770         s8 signal; 
    771         s8 signal_avg; 
    772 + 
    773 +       u8 chains; 
    774 +       s8 chain_signal[IEEE80211_MAX_CHAINS]; 
    775 +       s8 chain_signal_avg[IEEE80211_MAX_CHAINS]; 
    776 + 
    777         struct rate_info txrate; 
    778         struct rate_info rxrate; 
    779         u32 rx_packets; 
    780 @@ -954,6 +968,7 @@ enum monitor_flags { 
    781         MONITOR_FLAG_CONTROL            = 1<<NL80211_MNTR_FLAG_CONTROL, 
    782         MONITOR_FLAG_OTHER_BSS          = 1<<NL80211_MNTR_FLAG_OTHER_BSS, 
    783         MONITOR_FLAG_COOK_FRAMES        = 1<<NL80211_MNTR_FLAG_COOK_FRAMES, 
    784 +       MONITOR_FLAG_ACTIVE             = 1<<NL80211_MNTR_FLAG_ACTIVE, 
    785  }; 
    786   
    787  /** 
    788 @@ -4027,6 +4042,17 @@ bool cfg80211_reg_can_beacon(struct wiph 
    789  void cfg80211_ch_switch_notify(struct net_device *dev, 
    790                                struct cfg80211_chan_def *chandef); 
    791   
    792 +/** 
    793 + * ieee80211_operating_class_to_band - convert operating class to band 
    794 + * 
    795 + * @operating_class: the operating class to convert 
    796 + * @band: band pointer to fill 
    797 + * 
    798 + * Returns %true if the conversion was successful, %false otherwise. 
    799 + */ 
    800 +bool ieee80211_operating_class_to_band(u8 operating_class, 
    801 +                                      enum ieee80211_band *band); 
    802 + 
    803  /* 
    804   * cfg80211_tdls_oper_request - request userspace to perform TDLS operation 
    805   * @dev: the device on which the operation is requested 
    806 --- a/include/net/mac80211.h 
    807 +++ b/include/net/mac80211.h 
    808 @@ -210,7 +210,7 @@ struct ieee80211_chanctx_conf { 
    809   * @BSS_CHANGED_QOS: QoS for this association was enabled/disabled. Note 
    810   *     that it is only ever disabled for station mode. 
    811   * @BSS_CHANGED_IDLE: Idle changed for this BSS/interface. 
    812 - * @BSS_CHANGED_SSID: SSID changed for this BSS (AP mode) 
    813 + * @BSS_CHANGED_SSID: SSID changed for this BSS (AP and IBSS mode) 
    814   * @BSS_CHANGED_AP_PROBE_RESP: Probe Response changed for this BSS (AP mode) 
    815   * @BSS_CHANGED_PS: PS changed for this BSS (STA mode) 
    816   * @BSS_CHANGED_TXPOWER: TX power setting changed for this interface 
    817 @@ -327,7 +327,7 @@ enum ieee80211_rssi_event { 
    818   *     your driver/device needs to do. 
    819   * @ps: power-save mode (STA only). This flag is NOT affected by 
    820   *     offchannel/dynamic_ps operations. 
    821 - * @ssid: The SSID of the current vif. Only valid in AP-mode. 
    822 + * @ssid: The SSID of the current vif. Valid in AP and IBSS mode. 
    823   * @ssid_len: Length of SSID given in @ssid. 
    824   * @hidden_ssid: The SSID of the current vif is hidden. Only valid in AP-mode. 
    825   * @txpower: TX power in dBm 
    826 @@ -459,6 +459,8 @@ struct ieee80211_bss_conf { 
    827   * @IEEE80211_TX_CTL_DONTFRAG: Don't fragment this packet even if it 
    828   *     would be fragmented by size (this is optional, only used for 
    829   *     monitor injection). 
    830 + * @IEEE80211_TX_CTL_PS_RESPONSE: This frame is a response to a poll 
    831 + *     frame (PS-Poll or uAPSD). 
    832   * 
    833   * Note: If you have to add new flags to the enumeration, then don't 
    834   *      forget to update %IEEE80211_TX_TEMPORARY_FLAGS when necessary. 
    835 @@ -494,6 +496,7 @@ enum mac80211_tx_control_flags { 
    836         IEEE80211_TX_STATUS_EOSP                = BIT(28), 
    837         IEEE80211_TX_CTL_USE_MINRATE            = BIT(29), 
    838         IEEE80211_TX_CTL_DONTFRAG               = BIT(30), 
    839 +       IEEE80211_TX_CTL_PS_RESPONSE            = BIT(31), 
    840  }; 
    841   
    842  #define IEEE80211_TX_CTL_STBC_SHIFT            23 
    843 @@ -562,6 +565,9 @@ enum mac80211_rate_control_flags { 
    844  /* maximum number of rate stages */ 
    845  #define IEEE80211_TX_MAX_RATES 4 
    846   
    847 +/* maximum number of rate table entries */ 
    848 +#define IEEE80211_TX_RATE_TABLE_SIZE   4 
    849 + 
    850  /** 
    851   * struct ieee80211_tx_rate - rate selection/status 
    852   * 
    853 @@ -602,8 +608,8 @@ static inline void ieee80211_rate_set_vh 
    854                                           u8 mcs, u8 nss) 
    855  { 
    856         WARN_ON(mcs & ~0xF); 
    857 -       WARN_ON(nss & ~0x7); 
    858 -       rate->idx = (nss << 4) | mcs; 
    859 +       WARN_ON((nss - 1) & ~0x7); 
    860 +       rate->idx = ((nss - 1) << 4) | mcs; 
    861  } 
    862   
    863  static inline u8 
    864 @@ -615,7 +621,7 @@ ieee80211_rate_get_vht_mcs(const struct  
    865  static inline u8 
    866  ieee80211_rate_get_vht_nss(const struct ieee80211_tx_rate *rate) 
    867  { 
    868 -       return rate->idx >> 4; 
    869 +       return (rate->idx >> 4) + 1; 
    870  } 
    871   
    872  /** 
    873 @@ -656,7 +662,11 @@ struct ieee80211_tx_info { 
    874                                         struct ieee80211_tx_rate rates[ 
    875                                                 IEEE80211_TX_MAX_RATES]; 
    876                                         s8 rts_cts_rate_idx; 
    877 -                                       /* 3 bytes free */ 
    878 +                                       u8 use_rts:1; 
    879 +                                       u8 use_cts_prot:1; 
    880 +                                       u8 short_preamble:1; 
    881 +                                       u8 skip_table:1; 
    882 +                                       /* 2 bytes free */ 
    883                                 }; 
    884                                 /* only needed before rate control */ 
    885                                 unsigned long jiffies; 
    886 @@ -677,6 +687,8 @@ struct ieee80211_tx_info { 
    887                 struct { 
    888                         struct ieee80211_tx_rate driver_rates[ 
    889                                 IEEE80211_TX_MAX_RATES]; 
    890 +                       u8 pad[4]; 
    891 + 
    892                         void *rate_driver_data[ 
    893                                 IEEE80211_TX_INFO_RATE_DRIVER_DATA_SIZE / sizeof(void *)]; 
    894                 }; 
    895 @@ -840,6 +852,9 @@ enum mac80211_rx_flags { 
    896   * @signal: signal strength when receiving this frame, either in dBm, in dB or 
    897   *     unspecified depending on the hardware capabilities flags 
    898   *     @IEEE80211_HW_SIGNAL_* 
    899 + * @chains: bitmask of receive chains for which separate signal strength 
    900 + *     values were filled. 
    901 + * @chain_signal: per-chain signal strength, same format as @signal 
    902   * @antenna: antenna used 
    903   * @rate_idx: index of data rate into band's supported rates or MCS index if 
    904   *     HT or VHT is used (%RX_FLAG_HT/%RX_FLAG_VHT) 
    905 @@ -871,6 +886,8 @@ struct ieee80211_rx_status { 
    906         u8 band; 
    907         u8 antenna; 
    908         s8 signal; 
    909 +       u8 chains; 
    910 +       s8 chain_signal[IEEE80211_MAX_CHAINS]; 
    911         u8 ampdu_delimiter_crc; 
    912         u8 vendor_radiotap_align; 
    913         u8 vendor_radiotap_oui[3]; 
    914 @@ -1018,13 +1035,13 @@ struct ieee80211_conf { 
    915   *     the driver passed into mac80211. 
    916   * @block_tx: Indicates whether transmission must be blocked before the 
    917   *     scheduled channel switch, as indicated by the AP. 
    918 - * @channel: the new channel to switch to 
    919 + * @chandef: the new channel to switch to 
    920   * @count: the number of TBTT's until the channel switch event 
    921   */ 
    922  struct ieee80211_channel_switch { 
    923         u64 timestamp; 
    924         bool block_tx; 
    925 -       struct ieee80211_channel *channel; 
    926 +       struct cfg80211_chan_def chandef; 
    927         u8 count; 
    928  }; 
    929   
    930 @@ -1222,6 +1239,24 @@ enum ieee80211_sta_rx_bandwidth { 
    931  }; 
    932   
    933  /** 
    934 + * struct ieee80211_sta_rates - station rate selection table 
    935 + * 
    936 + * @rcu_head: RCU head used for freeing the table on update 
    937 + * @rates: transmit rates/flags to be used by default. 
    938 + *     Overriding entries per-packet is possible by using cb tx control. 
    939 + */ 
    940 +struct ieee80211_sta_rates { 
    941 +       struct rcu_head rcu_head; 
    942 +       struct { 
    943 +               s8 idx; 
    944 +               u8 count; 
    945 +               u8 count_cts; 
    946 +               u8 count_rts; 
    947 +               u16 flags; 
    948 +       } rate[IEEE80211_TX_RATE_TABLE_SIZE]; 
    949 +}; 
    950 + 
    951 +/** 
    952   * struct ieee80211_sta - station table entry 
    953   * 
    954   * A station table entry represents a station we are possibly 
    955 @@ -1248,6 +1283,7 @@ enum ieee80211_sta_rx_bandwidth { 
    956   *     notifications and capabilities. The value is only valid after 
    957   *     the station moves to associated state. 
    958   * @smps_mode: current SMPS mode (off, static or dynamic) 
    959 + * @tx_rates: rate control selection table 
    960   */ 
    961  struct ieee80211_sta { 
    962         u32 supp_rates[IEEE80211_NUM_BANDS]; 
    963 @@ -1261,6 +1297,7 @@ struct ieee80211_sta { 
    964         u8 rx_nss; 
    965         enum ieee80211_sta_rx_bandwidth bandwidth; 
    966         enum ieee80211_smps_mode smps_mode; 
    967 +       struct ieee80211_sta_rates __rcu *rates; 
    968   
    969         /* must be last */ 
    970         u8 drv_priv[0] __aligned(sizeof(void *)); 
    971 @@ -1416,6 +1453,9 @@ struct ieee80211_tx_control { 
    972   *     for different virtual interfaces. See the doc section on HW queue 
    973   *     control for more details. 
    974   * 
    975 + * @IEEE80211_HW_SUPPORTS_RC_TABLE: The driver supports using a rate 
    976 + *     selection table provided by the rate control algorithm. 
    977 + * 
    978   * @IEEE80211_HW_P2P_DEV_ADDR_FOR_INTF: Use the P2P Device address for any 
    979   *     P2P Interface. This will be honoured even if more than one interface 
    980   *     is supported. 
    981 @@ -1448,6 +1488,7 @@ enum ieee80211_hw_flags { 
    982         IEEE80211_HW_SUPPORTS_PER_STA_GTK               = 1<<21, 
    983         IEEE80211_HW_AP_LINK_PS                         = 1<<22, 
    984         IEEE80211_HW_TX_AMPDU_SETUP_IN_HW               = 1<<23, 
    985 +       IEEE80211_HW_SUPPORTS_RC_TABLE                  = 1<<24, 
    986         IEEE80211_HW_P2P_DEV_ADDR_FOR_INTF              = 1<<25, 
    987         IEEE80211_HW_TIMING_BEACON_ONLY                 = 1<<26, 
    988  }; 
    989 @@ -3144,6 +3185,25 @@ void ieee80211_sta_set_buffered(struct i 
    990                                 u8 tid, bool buffered); 
    991   
    992  /** 
    993 + * ieee80211_get_tx_rates - get the selected transmit rates for a packet 
    994 + * 
    995 + * Call this function in a driver with per-packet rate selection support 
    996 + * to combine the rate info in the packet tx info with the most recent 
    997 + * rate selection table for the station entry. 
    998 + * 
    999 + * @vif: &struct ieee80211_vif pointer from the add_interface callback. 
    1000 + * @sta: the receiver station to which this packet is sent. 
    1001 + * @skb: the frame to be transmitted. 
    1002 + * @dest: buffer for extracted rate/retry information 
    1003 + * @max_rates: maximum number of rates to fetch 
    1004 + */ 
    1005 +void ieee80211_get_tx_rates(struct ieee80211_vif *vif, 
    1006 +                           struct ieee80211_sta *sta, 
    1007 +                           struct sk_buff *skb, 
    1008 +                           struct ieee80211_tx_rate *dest, 
    1009 +                           int max_rates); 
    1010 + 
    1011 +/** 
    1012   * ieee80211_tx_status - transmit status callback 
    1013   * 
    1014   * Call this function for all transmitted frames after they have been 
    1015 @@ -4118,7 +4178,7 @@ void ieee80211_send_bar(struct ieee80211 
    1016   *     (deprecated; this will be removed once drivers get updated to use 
    1017   *     rate_idx_mask) 
    1018   * @rate_idx_mask: user-requested (legacy) rate mask 
    1019 - * @rate_idx_mcs_mask: user-requested MCS rate mask 
    1020 + * @rate_idx_mcs_mask: user-requested MCS rate mask (NULL if not in use) 
    1021   * @bss: whether this frame is sent out in AP or IBSS mode 
    1022   */ 
    1023  struct ieee80211_tx_rate_control { 
    1024 @@ -4130,7 +4190,7 @@ struct ieee80211_tx_rate_control { 
    1025         bool rts, short_preamble; 
    1026         u8 max_rate_idx; 
    1027         u32 rate_idx_mask; 
    1028 -       u8 rate_idx_mcs_mask[IEEE80211_HT_MCS_MASK_LEN]; 
    1029 +       u8 *rate_idx_mcs_mask; 
    1030         bool bss; 
    1031  }; 
    1032   
    1033 @@ -4219,6 +4279,22 @@ bool rate_usable_index_exists(struct iee 
    1034         return false; 
    1035  } 
    1036   
    1037 +/** 
    1038 + * rate_control_set_rates - pass the sta rate selection to mac80211/driver 
    1039 + * 
    1040 + * When not doing a rate control probe to test rates, rate control should pass 
    1041 + * its rate selection to mac80211. If the driver supports receiving a station 
    1042 + * rate table, it will use it to ensure that frames are always sent based on 
    1043 + * the most recent rate control module decision. 
    1044 + * 
    1045 + * @hw: pointer as obtained from ieee80211_alloc_hw() 
    1046 + * @pubsta: &struct ieee80211_sta pointer to the target destination. 
    1047 + * @rates: new tx rate set to be used for this station. 
    1048 + */ 
    1049 +int rate_control_set_rates(struct ieee80211_hw *hw, 
    1050 +                          struct ieee80211_sta *pubsta, 
    1051 +                          struct ieee80211_sta_rates *rates); 
    1052 + 
    1053  int ieee80211_rate_control_register(struct rate_control_ops *ops); 
    1054  void ieee80211_rate_control_unregister(struct rate_control_ops *ops); 
    1055   
    10561--- a/net/mac80211/agg-rx.c 
    10572+++ b/net/mac80211/agg-rx.c 
     
    108530                return -EINVAL; 
    108631  
    1087 --- a/net/mac80211/cfg.c 
    1088 +++ b/net/mac80211/cfg.c 
    1089 @@ -73,16 +73,19 @@ static int ieee80211_change_iface(struct 
    1090                 struct ieee80211_local *local = sdata->local; 
    1091   
    1092                 if (ieee80211_sdata_running(sdata)) { 
    1093 +                       u32 mask = MONITOR_FLAG_COOK_FRAMES | 
    1094 +                                  MONITOR_FLAG_ACTIVE; 
    1095 + 
    1096                         /* 
    1097 -                        * Prohibit MONITOR_FLAG_COOK_FRAMES to be 
    1098 -                        * changed while the interface is up. 
    1099 +                        * Prohibit MONITOR_FLAG_COOK_FRAMES and 
    1100 +                        * MONITOR_FLAG_ACTIVE to be changed while the 
    1101 +                        * interface is up. 
    1102                          * Else we would need to add a lot of cruft 
    1103                          * to update everything: 
    1104                          *      cooked_mntrs, monitor and all fif_* counters 
    1105                          *      reconfigure hardware 
    1106                          */ 
    1107 -                       if ((*flags & MONITOR_FLAG_COOK_FRAMES) != 
    1108 -                           (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES)) 
    1109 +                       if ((*flags & mask) != (sdata->u.mntr_flags & mask)) 
    1110                                 return -EBUSY; 
    1111   
    1112                         ieee80211_adjust_monitor_flags(sdata, -1); 
    1113 @@ -444,7 +447,7 @@ static void sta_set_sinfo(struct sta_inf 
    1114         struct ieee80211_local *local = sdata->local; 
    1115         struct timespec uptime; 
    1116         u64 packets = 0; 
    1117 -       int ac; 
    1118 +       int i, ac; 
    1119   
    1120         sinfo->generation = sdata->local->sta_generation; 
    1121   
    1122 @@ -488,6 +491,17 @@ static void sta_set_sinfo(struct sta_inf 
    1123                         sinfo->signal = (s8)sta->last_signal; 
    1124                 sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal); 
    1125         } 
    1126 +       if (sta->chains) { 
    1127 +               sinfo->filled |= STATION_INFO_CHAIN_SIGNAL | 
    1128 +                                STATION_INFO_CHAIN_SIGNAL_AVG; 
    1129 + 
    1130 +               sinfo->chains = sta->chains; 
    1131 +               for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) { 
    1132 +                       sinfo->chain_signal[i] = sta->chain_signal_last[i]; 
    1133 +                       sinfo->chain_signal_avg[i] = 
    1134 +                               (s8) -ewma_read(&sta->chain_signal_avg[i]); 
    1135 +               } 
    1136 +       } 
    1137   
    1138         sta_set_rate_info_tx(sta, &sta->last_tx_rate, &sinfo->txrate); 
    1139         sta_set_rate_info_rx(sta, &sinfo->rxrate); 
    1140 @@ -1052,6 +1066,7 @@ static int ieee80211_stop_ap(struct wiph 
    1141         ieee80211_free_keys(sdata); 
    1142   
    1143         sdata->vif.bss_conf.enable_beacon = false; 
    1144 +       sdata->vif.bss_conf.ssid_len = 0; 
    1145         clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state); 
    1146         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED); 
    1147   
    1148 @@ -2416,9 +2431,22 @@ static int ieee80211_set_bitrate_mask(st 
    1149         } 
    1150   
    1151         for (i = 0; i < IEEE80211_NUM_BANDS; i++) { 
    1152 +               struct ieee80211_supported_band *sband = wiphy->bands[i]; 
    1153 +               int j; 
    1154 + 
    1155                 sdata->rc_rateidx_mask[i] = mask->control[i].legacy; 
    1156                 memcpy(sdata->rc_rateidx_mcs_mask[i], mask->control[i].mcs, 
    1157                        sizeof(mask->control[i].mcs)); 
    1158 + 
    1159 +               sdata->rc_has_mcs_mask[i] = false; 
    1160 +               if (!sband) 
    1161 +                       continue; 
    1162 + 
    1163 +               for (j = 0; j < IEEE80211_HT_MCS_MASK_LEN; j++) 
    1164 +                       if (~sdata->rc_rateidx_mcs_mask[i][j]) { 
    1165 +                               sdata->rc_has_mcs_mask[i] = true; 
    1166 +                               break; 
    1167 +                       } 
    1168         } 
    1169   
    1170         return 0; 
    1171 --- a/net/mac80211/chan.c 
    1172 +++ b/net/mac80211/chan.c 
    1173 @@ -57,6 +57,22 @@ ieee80211_find_chanctx(struct ieee80211_ 
    1174         return NULL; 
    1175  } 
    1176   
    1177 +static bool ieee80211_is_radar_required(struct ieee80211_local *local) 
    1178 +{ 
    1179 +       struct ieee80211_sub_if_data *sdata; 
    1180 + 
    1181 +       rcu_read_lock(); 
    1182 +       list_for_each_entry_rcu(sdata, &local->interfaces, list) { 
    1183 +               if (sdata->radar_required) { 
    1184 +                       rcu_read_unlock(); 
    1185 +                       return true; 
    1186 +               } 
    1187 +       } 
    1188 +       rcu_read_unlock(); 
    1189 + 
    1190 +       return false; 
    1191 +} 
    1192 + 
    1193  static struct ieee80211_chanctx * 
    1194  ieee80211_new_chanctx(struct ieee80211_local *local, 
    1195                       const struct cfg80211_chan_def *chandef, 
    1196 @@ -76,6 +92,9 @@ ieee80211_new_chanctx(struct ieee80211_l 
    1197         ctx->conf.rx_chains_static = 1; 
    1198         ctx->conf.rx_chains_dynamic = 1; 
    1199         ctx->mode = mode; 
    1200 +       ctx->conf.radar_enabled = ieee80211_is_radar_required(local); 
    1201 +       if (!local->use_chanctx) 
    1202 +               local->hw.conf.radar_enabled = ctx->conf.radar_enabled; 
    1203   
    1204         /* acquire mutex to prevent idle from changing */ 
    1205         mutex_lock(&local->mtx); 
    1206 @@ -110,6 +129,7 @@ ieee80211_new_chanctx(struct ieee80211_l 
    1207  static void ieee80211_free_chanctx(struct ieee80211_local *local, 
    1208                                    struct ieee80211_chanctx *ctx) 
    1209  { 
    1210 +       bool check_single_channel = false; 
    1211         lockdep_assert_held(&local->chanctx_mtx); 
    1212   
    1213         WARN_ON_ONCE(ctx->refcount != 0); 
    1214 @@ -119,6 +139,14 @@ static void ieee80211_free_chanctx(struc 
    1215                 chandef->width = NL80211_CHAN_WIDTH_20_NOHT; 
    1216                 chandef->center_freq1 = chandef->chan->center_freq; 
    1217                 chandef->center_freq2 = 0; 
    1218 + 
    1219 +               /* NOTE: Disabling radar is only valid here for 
    1220 +                * single channel context. To be sure, check it ... 
    1221 +                */ 
    1222 +               if (local->hw.conf.radar_enabled) 
    1223 +                       check_single_channel = true; 
    1224 +               local->hw.conf.radar_enabled = false; 
    1225 + 
    1226                 ieee80211_hw_config(local, 0); 
    1227         } else { 
    1228                 drv_remove_chanctx(local, ctx); 
    1229 @@ -127,6 +155,9 @@ static void ieee80211_free_chanctx(struc 
    1230         list_del_rcu(&ctx->list); 
    1231         kfree_rcu(ctx, rcu_head); 
    1232   
    1233 +       /* throw a warning if this wasn't the only channel context. */ 
    1234 +       WARN_ON(check_single_channel && !list_empty(&local->chanctx_list)); 
    1235 + 
    1236         mutex_lock(&local->mtx); 
    1237         ieee80211_recalc_idle(local); 
    1238         mutex_unlock(&local->mtx); 
    1239 @@ -238,19 +269,11 @@ static void __ieee80211_vif_release_chan 
    1240  void ieee80211_recalc_radar_chanctx(struct ieee80211_local *local, 
    1241                                     struct ieee80211_chanctx *chanctx) 
    1242  { 
    1243 -       struct ieee80211_sub_if_data *sdata; 
    1244 -       bool radar_enabled = false; 
    1245 +       bool radar_enabled; 
    1246   
    1247         lockdep_assert_held(&local->chanctx_mtx); 
    1248   
    1249 -       rcu_read_lock(); 
    1250 -       list_for_each_entry_rcu(sdata, &local->interfaces, list) { 
    1251 -               if (sdata->radar_required) { 
    1252 -                       radar_enabled = true; 
    1253 -                       break; 
    1254 -               } 
    1255 -       } 
    1256 -       rcu_read_unlock(); 
    1257 +       radar_enabled = ieee80211_is_radar_required(local); 
    1258   
    1259         if (radar_enabled == chanctx->conf.radar_enabled) 
    1260                 return; 
    126132--- a/net/mac80211/debugfs_sta.c 
    126233+++ b/net/mac80211/debugfs_sta.c 
     
    127546                            TEST(UAPSD), TEST(SP), TEST(TDLS_PEER), 
    127647                            TEST(TDLS_PEER_AUTH), TEST(4ADDR_EVENT), 
    1277 --- a/net/mac80211/ibss.c 
    1278 +++ b/net/mac80211/ibss.c 
    1279 @@ -209,6 +209,8 @@ static void __ieee80211_sta_join_ibss(st 
    1280         sdata->vif.bss_conf.enable_beacon = true; 
    1281         sdata->vif.bss_conf.beacon_int = beacon_int; 
    1282         sdata->vif.bss_conf.basic_rates = basic_rates; 
    1283 +       sdata->vif.bss_conf.ssid_len = ifibss->ssid_len; 
    1284 +       memcpy(sdata->vif.bss_conf.ssid, ifibss->ssid, ifibss->ssid_len); 
    1285         bss_change = BSS_CHANGED_BEACON_INT; 
    1286         bss_change |= ieee80211_reset_erp_info(sdata); 
    1287         bss_change |= BSS_CHANGED_BSSID; 
    1288 @@ -217,6 +219,7 @@ static void __ieee80211_sta_join_ibss(st 
    1289         bss_change |= BSS_CHANGED_BASIC_RATES; 
    1290         bss_change |= BSS_CHANGED_HT; 
    1291         bss_change |= BSS_CHANGED_IBSS; 
    1292 +       bss_change |= BSS_CHANGED_SSID; 
    1293   
    1294         /* 
    1295          * In 5 GHz/802.11a, we can always use short slot time. 
    1296 @@ -911,7 +914,7 @@ void ieee80211_rx_mgmt_probe_beacon(stru 
    1297                 return; 
    1298   
    1299         ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 
    1300 -                               &elems); 
    1301 +                              false, &elems); 
    1302   
    1303         ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems); 
    1304  } 
    1305 @@ -1159,6 +1162,7 @@ int ieee80211_ibss_leave(struct ieee8021 
    1306         sdata->vif.bss_conf.ibss_joined = false; 
    1307         sdata->vif.bss_conf.ibss_creator = false; 
    1308         sdata->vif.bss_conf.enable_beacon = false; 
    1309 +       sdata->vif.bss_conf.ssid_len = 0; 
    1310         clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state); 
    1311         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED | 
    1312                                                 BSS_CHANGED_IBSS); 
    1313 --- a/net/mac80211/ieee80211_i.h 
    1314 +++ b/net/mac80211/ieee80211_i.h 
    1315 @@ -156,6 +156,7 @@ struct ieee80211_tx_data { 
    1316         struct ieee80211_sub_if_data *sdata; 
    1317         struct sta_info *sta; 
    1318         struct ieee80211_key *key; 
    1319 +       struct ieee80211_tx_rate rate; 
    1320   
    1321         unsigned int flags; 
    1322  }; 
    1323 @@ -740,6 +741,8 @@ struct ieee80211_sub_if_data { 
    1324   
    1325         /* bitmap of allowed (non-MCS) rate indexes for rate control */ 
    1326         u32 rc_rateidx_mask[IEEE80211_NUM_BANDS]; 
    1327 + 
    1328 +       bool rc_has_mcs_mask[IEEE80211_NUM_BANDS]; 
    1329         u8  rc_rateidx_mcs_mask[IEEE80211_NUM_BANDS][IEEE80211_HT_MCS_MASK_LEN]; 
    1330   
    1331         union { 
    1332 @@ -1025,7 +1028,7 @@ struct ieee80211_local { 
    1333         enum mac80211_scan_state next_scan_state; 
    1334         struct delayed_work scan_work; 
    1335         struct ieee80211_sub_if_data __rcu *scan_sdata; 
    1336 -       struct ieee80211_channel *csa_channel; 
    1337 +       struct cfg80211_chan_def csa_chandef; 
    1338         /* For backward compatibility only -- do not use */ 
    1339         struct cfg80211_chan_def _oper_chandef; 
    1340   
    1341 @@ -1184,10 +1187,13 @@ struct ieee802_11_elems { 
    1342         const u8 *perr; 
    1343         const struct ieee80211_rann_ie *rann; 
    1344         const struct ieee80211_channel_sw_ie *ch_switch_ie; 
    1345 +       const struct ieee80211_ext_chansw_ie *ext_chansw_ie; 
    1346 +       const struct ieee80211_wide_bw_chansw_ie *wide_bw_chansw_ie; 
    1347         const u8 *country_elem; 
    1348         const u8 *pwr_constr_elem; 
    1349         const struct ieee80211_timeout_interval_ie *timeout_int; 
    1350         const u8 *opmode_notif; 
    1351 +       const struct ieee80211_sec_chan_offs_ie *sec_chan_offs; 
    1352   
    1353         /* length of them, respectively */ 
    1354         u8 ssid_len; 
    1355 @@ -1258,10 +1264,6 @@ void ieee80211_recalc_ps_vif(struct ieee 
    1356  int ieee80211_max_network_latency(struct notifier_block *nb, 
    1357                                   unsigned long data, void *dummy); 
    1358  int ieee80211_set_arp_filter(struct ieee80211_sub_if_data *sdata); 
    1359 -void 
    1360 -ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata, 
    1361 -                                const struct ieee80211_channel_sw_ie *sw_elem, 
    1362 -                                struct ieee80211_bss *bss, u64 timestamp); 
    1363  void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata); 
    1364  void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 
    1365                                   struct sk_buff *skb); 
    1366 @@ -1499,13 +1501,13 @@ static inline void ieee80211_tx_skb(stru 
    1367         ieee80211_tx_skb_tid(sdata, skb, 7); 
    1368  } 
    1369   
    1370 -u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, 
    1371 +u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, bool action, 
    1372                                struct ieee802_11_elems *elems, 
    1373                                u64 filter, u32 crc); 
    1374 -static inline void ieee802_11_parse_elems(u8 *start, size_t len, 
    1375 +static inline void ieee802_11_parse_elems(u8 *start, size_t len, bool action, 
    1376                                           struct ieee802_11_elems *elems) 
    1377  { 
    1378 -       ieee802_11_parse_elems_crc(start, len, elems, 0, 0); 
    1379 +       ieee802_11_parse_elems_crc(start, len, action, elems, 0, 0); 
    1380  } 
    1381   
    1382  u32 ieee80211_mandatory_rates(struct ieee80211_local *local, 
     48--- a/net/mac80211/ht.c 
     49+++ b/net/mac80211/ht.c 
     50@@ -281,13 +281,14 @@ void ieee80211_ba_session_work(struct wo 
     51                                sta, tid, WLAN_BACK_RECIPIENT, 
     52                                WLAN_REASON_UNSPECIFIED, true); 
     53  
     54+               spin_lock_bh(&sta->lock); 
     55+ 
     56                tid_tx = sta->ampdu_mlme.tid_start_tx[tid]; 
     57                if (tid_tx) { 
     58                        /* 
     59                         * Assign it over to the normal tid_tx array 
     60                         * where it "goes live". 
     61                         */ 
     62-                       spin_lock_bh(&sta->lock); 
     63  
     64                        sta->ampdu_mlme.tid_start_tx[tid] = NULL; 
     65                        /* could there be a race? */ 
     66@@ -300,6 +301,7 @@ void ieee80211_ba_session_work(struct wo 
     67                        ieee80211_tx_ba_session_handle_start(sta, tid); 
     68                        continue; 
     69                } 
     70+               spin_unlock_bh(&sta->lock); 
     71  
     72                tid_tx = rcu_dereference_protected_tid_tx(sta, tid); 
     73                if (tid_tx && test_and_clear_bit(HT_AGG_STATE_WANT_STOP, 
    138374--- a/net/mac80211/iface.c 
    138475+++ b/net/mac80211/iface.c 
    1385 @@ -159,7 +159,8 @@ static int ieee80211_change_mtu(struct n 
    1386         return 0; 
    1387  } 
    1388   
    1389 -static int ieee80211_verify_mac(struct ieee80211_local *local, u8 *addr) 
    1390 +static int ieee80211_verify_mac(struct ieee80211_local *local, u8 *addr, 
    1391 +                               bool check_dup) 
    1392  { 
    1393         struct ieee80211_sub_if_data *sdata; 
    1394         u64 new, mask, tmp; 
    1395 @@ -179,10 +180,13 @@ static int ieee80211_verify_mac(struct i 
    1396                 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) | 
    1397                 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8); 
    1398   
    1399 +       if (!check_dup) 
    1400 +               return ret; 
    1401   
    1402         mutex_lock(&local->iflist_mtx); 
    1403         list_for_each_entry(sdata, &local->interfaces, list) { 
    1404 -               if (sdata->vif.type == NL80211_IFTYPE_MONITOR) 
    1405 +               if (sdata->vif.type == NL80211_IFTYPE_MONITOR && 
    1406 +                   !(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE)) 
    1407                         continue; 
    1408   
    1409                 m = sdata->vif.addr; 
    1410 @@ -204,12 +208,17 @@ static int ieee80211_change_mac(struct n 
    1411  { 
    1412         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 
    1413         struct sockaddr *sa = addr; 
    1414 +       bool check_dup = true; 
    1415         int ret; 
    1416   
    1417         if (ieee80211_sdata_running(sdata)) 
    1418                 return -EBUSY; 
    1419   
    1420 -       ret = ieee80211_verify_mac(sdata->local, sa->sa_data); 
    1421 +       if (sdata->vif.type == NL80211_IFTYPE_MONITOR && 
    1422 +           !(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE)) 
    1423 +               check_dup = false; 
    1424 + 
    1425 +       ret = ieee80211_verify_mac(sdata->local, sa->sa_data, check_dup); 
    1426         if (ret) 
    1427                 return ret; 
    1428   
    1429 @@ -450,7 +459,6 @@ int ieee80211_do_open(struct wireless_de 
     76@@ -463,7 +463,6 @@ int ieee80211_do_open(struct wireless_de 
    143077        struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev); 
    143178        struct net_device *dev = wdev->netdev; 
     
    143582        int res; 
    143683        u32 hw_reconf_flags = 0; 
    1437 @@ -474,6 +482,9 @@ int ieee80211_do_open(struct wireless_de 
    1438                         master->control_port_protocol; 
    1439                 sdata->control_port_no_encrypt = 
    1440                         master->control_port_no_encrypt; 
    1441 +               sdata->vif.cab_queue = master->vif.cab_queue; 
    1442 +               memcpy(sdata->vif.hw_queue, master->vif.hw_queue, 
    1443 +                      sizeof(sdata->vif.hw_queue)); 
    1444                 break; 
    1445                 } 
    1446         case NL80211_IFTYPE_AP: 
    1447 @@ -538,7 +549,11 @@ int ieee80211_do_open(struct wireless_de 
    1448                         break; 
    1449                 } 
    1450   
    1451 -               if (local->monitors == 0 && local->open_count == 0) { 
    1452 +               if (sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE) { 
    1453 +                       res = drv_add_interface(local, sdata); 
    1454 +                       if (res) 
    1455 +                               goto err_stop; 
    1456 +               } else if (local->monitors == 0 && local->open_count == 0) { 
    1457                         res = ieee80211_add_virtual_monitor(local); 
    1458                         if (res) 
    1459                                 goto err_stop; 
    1460 @@ -609,30 +624,8 @@ int ieee80211_do_open(struct wireless_de 
     84@@ -629,30 +628,8 @@ int ieee80211_do_open(struct wireless_de 
    146185  
    146286        set_bit(SDATA_STATE_RUNNING, &sdata->state); 
     
    1490114        /* 
    1491115         * set_multicast_list will be invoked by the networking core 
    1492 @@ -653,7 +646,11 @@ int ieee80211_do_open(struct wireless_de 
    1493   
    1494         ieee80211_recalc_ps(local, -1); 
    1495   
    1496 -       if (dev) { 
    1497 +       if (sdata->vif.type == NL80211_IFTYPE_MONITOR || 
    1498 +           sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 
    1499 +               /* XXX: for AP_VLAN, actually track AP queues */ 
    1500 +               netif_tx_start_all_queues(dev); 
    1501 +       } else if (dev) { 
    1502                 unsigned long flags; 
    1503                 int n_acs = IEEE80211_NUM_ACS; 
    1504                 int ac; 
    1505 @@ -916,7 +913,11 @@ static void ieee80211_do_stop(struct iee 
    1506                 mutex_lock(&local->mtx); 
    1507                 ieee80211_recalc_idle(local); 
    1508                 mutex_unlock(&local->mtx); 
    1509 -               break; 
    1510 + 
    1511 +               if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE)) 
    1512 +                       break; 
    1513 + 
    1514 +               /* fall through */ 
    1515         default: 
    1516                 if (going_down) 
    1517                         drv_remove_interface(local, sdata); 
    1518 @@ -1075,7 +1076,7 @@ static const struct net_device_ops ieee8 
    1519         .ndo_start_xmit         = ieee80211_monitor_start_xmit, 
    1520         .ndo_set_rx_mode        = ieee80211_set_multicast_list, 
    1521         .ndo_change_mtu         = ieee80211_change_mtu, 
    1522 -       .ndo_set_mac_address    = eth_mac_addr, 
    1523 +       .ndo_set_mac_address    = ieee80211_change_mac, 
    1524         .ndo_select_queue       = ieee80211_monitor_select_queue, 
    1525  }; 
    1526   
    1527 @@ -1092,6 +1093,74 @@ static void ieee80211_if_setup(struct ne 
     116@@ -1116,6 +1093,74 @@ static void ieee80211_if_setup(struct ne 
    1528117        dev->destructor = free_netdev; 
    1529118 } 
     
    1600189 { 
    1601190        struct ieee80211_sub_if_data *sdata = 
    1602 @@ -1196,6 +1265,9 @@ static void ieee80211_iface_work(struct  
     191@@ -1220,6 +1265,9 @@ static void ieee80211_iface_work(struct  
    1603192                                break; 
    1604193                        ieee80211_mesh_rx_queued_mgmt(sdata, skb); 
     
    1610199                        WARN(1, "frame for unexpected interface type"); 
    1611200                        break; 
    1612 @@ -1718,6 +1790,15 @@ void ieee80211_remove_interfaces(struct  
    1613   
    1614         ASSERT_RTNL(); 
    1615   
    1616 +       /* 
    1617 +        * Close all AP_VLAN interfaces first, as otherwise they 
    1618 +        * might be closed while the AP interface they belong to 
    1619 +        * is closed, causing unregister_netdevice_many() to crash. 
    1620 +        */ 
    1621 +       list_for_each_entry(sdata, &local->interfaces, list) 
    1622 +               if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 
    1623 +                       dev_close(sdata->dev); 
    1624 + 
    1625         mutex_lock(&local->iflist_mtx); 
    1626         list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) { 
    1627                 list_del(&sdata->list); 
    1628 --- a/net/mac80211/main.c 
    1629 +++ b/net/mac80211/main.c 
    1630 @@ -674,6 +674,7 @@ int ieee80211_register_hw(struct ieee802 
    1631         int channels, max_bitrates; 
    1632         bool supp_ht, supp_vht; 
    1633         netdev_features_t feature_whitelist; 
    1634 +       struct cfg80211_chan_def dflt_chandef = {}; 
    1635         static const u32 cipher_suites[] = { 
    1636                 /* keep WEP first, it may be removed below */ 
    1637                 WLAN_CIPHER_SUITE_WEP40, 
    1638 @@ -751,19 +752,19 @@ int ieee80211_register_hw(struct ieee802 
    1639                 sband = local->hw.wiphy->bands[band]; 
    1640                 if (!sband) 
    1641                         continue; 
    1642 -               if (!local->use_chanctx && !local->_oper_chandef.chan) { 
    1643 + 
    1644 +               if (!dflt_chandef.chan) { 
    1645 +                       cfg80211_chandef_create(&dflt_chandef, 
    1646 +                                               &sband->channels[0], 
    1647 +                                               NL80211_CHAN_NO_HT); 
    1648                         /* init channel we're on */ 
    1649 -                       struct cfg80211_chan_def chandef = { 
    1650 -                               .chan = &sband->channels[0], 
    1651 -                               .width = NL80211_CHAN_NO_HT, 
    1652 -                               .center_freq1 = sband->channels[0].center_freq, 
    1653 -                               .center_freq2 = 0 
    1654 -                       }; 
    1655 -                       local->hw.conf.chandef = local->_oper_chandef = chandef; 
    1656 +                       if (!local->use_chanctx && !local->_oper_chandef.chan) { 
    1657 +                               local->hw.conf.chandef = dflt_chandef; 
    1658 +                               local->_oper_chandef = dflt_chandef; 
    1659 +                       } 
    1660 +                       local->monitor_chandef = dflt_chandef; 
    1661                 } 
    1662 -               cfg80211_chandef_create(&local->monitor_chandef, 
    1663 -                                       &sband->channels[0], 
    1664 -                                       NL80211_CHAN_NO_HT); 
    1665 + 
    1666                 channels += sband->n_channels; 
    1667   
    1668                 if (max_bitrates < sband->n_bitrates) 
    1669 --- a/net/mac80211/mesh.c 
    1670 +++ b/net/mac80211/mesh.c 
    1671 @@ -838,7 +838,7 @@ ieee80211_mesh_rx_probe_req(struct ieee8 
    1672         if (baselen > len) 
    1673                 return; 
    1674   
    1675 -       ieee802_11_parse_elems(pos, len - baselen, &elems); 
    1676 +       ieee802_11_parse_elems(pos, len - baselen, false, &elems); 
    1677   
    1678         /* 802.11-2012 10.1.4.3.2 */ 
    1679         if ((!ether_addr_equal(mgmt->da, sdata->vif.addr) && 
    1680 @@ -899,7 +899,7 @@ static void ieee80211_mesh_rx_bcn_presp( 
    1681                 return; 
    1682   
    1683         ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 
    1684 -                              &elems); 
    1685 +                              false, &elems); 
    1686   
    1687         /* ignore non-mesh or secure / unsecure mismatch */ 
    1688         if ((!elems.mesh_id || !elems.mesh_config) || 
    1689 --- a/net/mac80211/mesh_hwmp.c 
    1690 +++ b/net/mac80211/mesh_hwmp.c 
    1691 @@ -880,7 +880,7 @@ void mesh_rx_path_sel_frame(struct ieee8 
    1692   
    1693         baselen = (u8 *) mgmt->u.action.u.mesh_action.variable - (u8 *) mgmt; 
    1694         ieee802_11_parse_elems(mgmt->u.action.u.mesh_action.variable, 
    1695 -                       len - baselen, &elems); 
    1696 +                              len - baselen, false, &elems); 
    1697   
    1698         if (elems.preq) { 
    1699                 if (elems.preq_len != 37) 
    1700 --- a/net/mac80211/mesh_plink.c 
    1701 +++ b/net/mac80211/mesh_plink.c 
    1702 @@ -544,8 +544,8 @@ static void mesh_plink_timer(unsigned lo 
    1703                 return; 
    1704         } 
    1705         mpl_dbg(sta->sdata, 
    1706 -               "Mesh plink timer for %pM fired on state %d\n", 
    1707 -               sta->sta.addr, sta->plink_state); 
    1708 +               "Mesh plink timer for %pM fired on state %s\n", 
    1709 +               sta->sta.addr, mplstates[sta->plink_state]); 
    1710         reason = 0; 
    1711         llid = sta->llid; 
    1712         plid = sta->plid; 
    1713 @@ -687,7 +687,7 @@ void mesh_rx_plink_frame(struct ieee8021 
    1714                 baseaddr += 4; 
    1715                 baselen += 4; 
    1716         } 
    1717 -       ieee802_11_parse_elems(baseaddr, len - baselen, &elems); 
    1718 +       ieee802_11_parse_elems(baseaddr, len - baselen, true, &elems); 
    1719   
    1720         if (!elems.peering) { 
    1721                 mpl_dbg(sdata, 
    1722 --- a/net/mac80211/mlme.c 
    1723 +++ b/net/mac80211/mlme.c 
    1724 @@ -289,6 +289,8 @@ ieee80211_determine_chantype(struct ieee 
    1725         } else { 
    1726                 /* 40 MHz (and 80 MHz) must be supported for VHT */ 
    1727                 ret = IEEE80211_STA_DISABLE_VHT; 
    1728 +               /* also mark 40 MHz disabled */ 
    1729 +               ret |= IEEE80211_STA_DISABLE_40MHZ; 
    1730                 goto out; 
    1731         } 
    1732   
    1733 @@ -303,12 +305,6 @@ ieee80211_determine_chantype(struct ieee 
    1734                                                channel->band); 
    1735         vht_chandef.center_freq2 = 0; 
    1736   
    1737 -       if (vht_oper->center_freq_seg2_idx) 
    1738 -               vht_chandef.center_freq2 = 
    1739 -                       ieee80211_channel_to_frequency( 
    1740 -                               vht_oper->center_freq_seg2_idx, 
    1741 -                               channel->band); 
    1742 - 
    1743         switch (vht_oper->chan_width) { 
    1744         case IEEE80211_VHT_CHANWIDTH_USE_HT: 
    1745                 vht_chandef.width = chandef->width; 
    1746 @@ -321,6 +317,10 @@ ieee80211_determine_chantype(struct ieee 
    1747                 break; 
    1748         case IEEE80211_VHT_CHANWIDTH_80P80MHZ: 
    1749                 vht_chandef.width = NL80211_CHAN_WIDTH_80P80; 
    1750 +               vht_chandef.center_freq2 = 
    1751 +                       ieee80211_channel_to_frequency( 
    1752 +                               vht_oper->center_freq_seg2_idx, 
    1753 +                               channel->band); 
    1754                 break; 
    1755         default: 
    1756                 if (verbose) 
    1757 @@ -604,7 +604,6 @@ static void ieee80211_add_vht_ie(struct  
    1758         u8 *pos; 
    1759         u32 cap; 
    1760         struct ieee80211_sta_vht_cap vht_cap; 
    1761 -       int i; 
    1762   
    1763         BUILD_BUG_ON(sizeof(vht_cap) != sizeof(sband->vht_cap)); 
    1764   
    1765 @@ -632,37 +631,6 @@ static void ieee80211_add_vht_ie(struct  
    1766                         cpu_to_le32(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE))) 
    1767                 cap &= ~IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE; 
    1768   
    1769 -       if (!(ap_vht_cap->vht_cap_info & 
    1770 -                       cpu_to_le32(IEEE80211_VHT_CAP_TXSTBC))) 
    1771 -               cap &= ~(IEEE80211_VHT_CAP_RXSTBC_1 | 
    1772 -                        IEEE80211_VHT_CAP_RXSTBC_3 | 
    1773 -                        IEEE80211_VHT_CAP_RXSTBC_4); 
    1774 - 
    1775 -       for (i = 0; i < 8; i++) { 
    1776 -               int shift = i * 2; 
    1777 -               u16 mask = IEEE80211_VHT_MCS_NOT_SUPPORTED << shift; 
    1778 -               u16 ap_mcs, our_mcs; 
    1779 - 
    1780 -               ap_mcs = (le16_to_cpu(ap_vht_cap->supp_mcs.tx_mcs_map) & 
    1781 -                                                               mask) >> shift; 
    1782 -               our_mcs = (le16_to_cpu(vht_cap.vht_mcs.rx_mcs_map) & 
    1783 -                                                               mask) >> shift; 
    1784 - 
    1785 -               if (our_mcs == IEEE80211_VHT_MCS_NOT_SUPPORTED) 
    1786 -                       continue; 
    1787 - 
    1788 -               switch (ap_mcs) { 
    1789 -               default: 
    1790 -                       if (our_mcs <= ap_mcs) 
    1791 -                               break; 
    1792 -                       /* fall through */ 
    1793 -               case IEEE80211_VHT_MCS_NOT_SUPPORTED: 
    1794 -                       vht_cap.vht_mcs.rx_mcs_map &= cpu_to_le16(~mask); 
    1795 -                       vht_cap.vht_mcs.rx_mcs_map |= 
    1796 -                               cpu_to_le16(ap_mcs << shift); 
    1797 -               } 
    1798 -       } 
    1799 - 
    1800         /* reserve and fill IE */ 
    1801         pos = skb_put(skb, sizeof(struct ieee80211_vht_cap) + 2); 
    1802         ieee80211_ie_build_vht_cap(pos, &vht_cap, cap); 
    1803 @@ -998,16 +966,7 @@ static void ieee80211_chswitch_work(stru 
    1804         if (!ifmgd->associated) 
    1805                 goto out; 
    1806   
    1807 -       /* 
    1808 -        * FIXME: Here we are downgrading to NL80211_CHAN_WIDTH_20_NOHT 
    1809 -        * and don't adjust our ht/vht settings 
    1810 -        * This is wrong - we should behave according to the CSA params 
    1811 -        */ 
    1812 -       local->_oper_chandef.chan = local->csa_channel; 
    1813 -       local->_oper_chandef.width = NL80211_CHAN_WIDTH_20_NOHT; 
    1814 -       local->_oper_chandef.center_freq1 = 
    1815 -               local->_oper_chandef.chan->center_freq; 
    1816 -       local->_oper_chandef.center_freq2 = 0; 
    1817 +       local->_oper_chandef = local->csa_chandef; 
    1818   
    1819         if (!local->ops->channel_switch) { 
    1820                 /* call "hw_config" only if doing sw channel switch */ 
    1821 @@ -1054,56 +1013,208 @@ static void ieee80211_chswitch_timer(uns 
    1822         ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.chswitch_work); 
    1823  } 
    1824   
    1825 -void 
    1826 +static void 
    1827  ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata, 
    1828 -                                const struct ieee80211_channel_sw_ie *sw_elem, 
    1829 -                                struct ieee80211_bss *bss, u64 timestamp) 
    1830 +                                u64 timestamp, struct ieee802_11_elems *elems, 
    1831 +                                bool beacon) 
    1832  { 
    1833 -       struct cfg80211_bss *cbss = 
    1834 -               container_of((void *)bss, struct cfg80211_bss, priv); 
    1835 -       struct ieee80211_channel *new_ch; 
    1836 +       struct ieee80211_local *local = sdata->local; 
    1837         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 
    1838 -       int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num, 
    1839 -                                                     cbss->channel->band); 
    1840 +       struct cfg80211_bss *cbss = ifmgd->associated; 
    1841 +       struct ieee80211_bss *bss; 
    1842         struct ieee80211_chanctx *chanctx; 
    1843 +       enum ieee80211_band new_band; 
    1844 +       int new_freq; 
    1845 +       u8 new_chan_no; 
    1846 +       u8 count; 
    1847 +       u8 mode; 
    1848 +       struct ieee80211_channel *new_chan; 
    1849 +       struct cfg80211_chan_def new_chandef = {}; 
    1850 +       struct cfg80211_chan_def new_vht_chandef = {}; 
    1851 +       const struct ieee80211_sec_chan_offs_ie *sec_chan_offs; 
    1852 +       const struct ieee80211_wide_bw_chansw_ie *wide_bw_chansw_ie; 
    1853 +       const struct ieee80211_ht_operation *ht_oper; 
    1854 +       int secondary_channel_offset = -1; 
    1855   
    1856         ASSERT_MGD_MTX(ifmgd); 
    1857   
    1858 -       if (!ifmgd->associated) 
    1859 +       if (!cbss) 
    1860 +               return; 
    1861 + 
    1862 +       if (local->scanning) 
    1863                 return; 
    1864   
    1865 -       if (sdata->local->scanning) 
    1866 +       /* disregard subsequent announcements if we are already processing */ 
    1867 +       if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED) 
    1868                 return; 
    1869   
    1870 -       /* Disregard subsequent beacons if we are already running a timer 
    1871 -          processing a CSA */ 
    1872 +       sec_chan_offs = elems->sec_chan_offs; 
    1873 +       wide_bw_chansw_ie = elems->wide_bw_chansw_ie; 
    1874 +       ht_oper = elems->ht_operation; 
    1875 + 
    1876 +       if (ifmgd->flags & (IEEE80211_STA_DISABLE_HT | 
    1877 +                           IEEE80211_STA_DISABLE_40MHZ)) { 
    1878 +               sec_chan_offs = NULL; 
    1879 +               wide_bw_chansw_ie = NULL; 
    1880 +               /* only used for bandwidth here */ 
    1881 +               ht_oper = NULL; 
    1882 +       } 
    1883   
    1884 -       if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED) 
    1885 +       if (ifmgd->flags & IEEE80211_STA_DISABLE_VHT) 
    1886 +               wide_bw_chansw_ie = NULL; 
    1887 + 
    1888 +       if (elems->ext_chansw_ie) { 
    1889 +               if (!ieee80211_operating_class_to_band( 
    1890 +                               elems->ext_chansw_ie->new_operating_class, 
    1891 +                               &new_band)) { 
    1892 +                       sdata_info(sdata, 
    1893 +                                  "cannot understand ECSA IE operating class %d, disconnecting\n", 
    1894 +                                  elems->ext_chansw_ie->new_operating_class); 
    1895 +                       ieee80211_queue_work(&local->hw, 
    1896 +                                            &ifmgd->csa_connection_drop_work); 
    1897 +               } 
    1898 +               new_chan_no = elems->ext_chansw_ie->new_ch_num; 
    1899 +               count = elems->ext_chansw_ie->count; 
    1900 +               mode = elems->ext_chansw_ie->mode; 
    1901 +       } else if (elems->ch_switch_ie) { 
    1902 +               new_band = cbss->channel->band; 
    1903 +               new_chan_no = elems->ch_switch_ie->new_ch_num; 
    1904 +               count = elems->ch_switch_ie->count; 
    1905 +               mode = elems->ch_switch_ie->mode; 
    1906 +       } else { 
    1907 +               /* nothing here we understand */ 
    1908                 return; 
    1909 +       } 
    1910 + 
    1911 +       bss = (void *)cbss->priv; 
    1912   
    1913 -       new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq); 
    1914 -       if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED) { 
    1915 +       new_freq = ieee80211_channel_to_frequency(new_chan_no, new_band); 
    1916 +       new_chan = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq); 
    1917 +       if (!new_chan || new_chan->flags & IEEE80211_CHAN_DISABLED) { 
    1918                 sdata_info(sdata, 
    1919                            "AP %pM switches to unsupported channel (%d MHz), disconnecting\n", 
    1920                            ifmgd->associated->bssid, new_freq); 
    1921 -               ieee80211_queue_work(&sdata->local->hw, 
    1922 +               ieee80211_queue_work(&local->hw, 
    1923 +                                    &ifmgd->csa_connection_drop_work); 
    1924 +               return; 
    1925 +       } 
    1926 + 
    1927 +       if (!beacon && sec_chan_offs) { 
    1928 +               secondary_channel_offset = sec_chan_offs->sec_chan_offs; 
    1929 +       } else if (beacon && ht_oper) { 
    1930 +               secondary_channel_offset = 
    1931 +                       ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET; 
    1932 +       } else if (!(ifmgd->flags & IEEE80211_STA_DISABLE_HT)) { 
    1933 +               /* 
    1934 +                * If it's not a beacon, HT is enabled and the IE not present, 
    1935 +                * it's 20 MHz, 802.11-2012 8.5.2.6: 
    1936 +                *      This element [the Secondary Channel Offset Element] is 
    1937 +                *      present when switching to a 40 MHz channel. It may be 
    1938 +                *      present when switching to a 20 MHz channel (in which 
    1939 +                *      case the secondary channel offset is set to SCN). 
    1940 +                */ 
    1941 +               secondary_channel_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE; 
    1942 +       } 
    1943 + 
    1944 +       switch (secondary_channel_offset) { 
    1945 +       default: 
    1946 +               /* secondary_channel_offset was present but is invalid */ 
    1947 +       case IEEE80211_HT_PARAM_CHA_SEC_NONE: 
    1948 +               cfg80211_chandef_create(&new_chandef, new_chan, 
    1949 +                                       NL80211_CHAN_HT20); 
    1950 +               break; 
    1951 +       case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: 
    1952 +               cfg80211_chandef_create(&new_chandef, new_chan, 
    1953 +                                       NL80211_CHAN_HT40PLUS); 
    1954 +               break; 
    1955 +       case IEEE80211_HT_PARAM_CHA_SEC_BELOW: 
    1956 +               cfg80211_chandef_create(&new_chandef, new_chan, 
    1957 +                                       NL80211_CHAN_HT40MINUS); 
    1958 +               break; 
    1959 +       case -1: 
    1960 +               cfg80211_chandef_create(&new_chandef, new_chan, 
    1961 +                                       NL80211_CHAN_NO_HT); 
    1962 +               break; 
    1963 +       } 
    1964 + 
    1965 +       if (wide_bw_chansw_ie) { 
    1966 +               new_vht_chandef.chan = new_chan; 
    1967 +               new_vht_chandef.center_freq1 = 
    1968 +                       ieee80211_channel_to_frequency( 
    1969 +                               wide_bw_chansw_ie->new_center_freq_seg0, 
    1970 +                               new_band); 
    1971 + 
    1972 +               switch (wide_bw_chansw_ie->new_channel_width) { 
    1973 +               default: 
    1974 +                       /* hmmm, ignore VHT and use HT if present */ 
    1975 +               case IEEE80211_VHT_CHANWIDTH_USE_HT: 
    1976 +                       new_vht_chandef.chan = NULL; 
    1977 +                       break; 
    1978 +               case IEEE80211_VHT_CHANWIDTH_80MHZ: 
    1979 +                       new_vht_chandef.width = NL80211_CHAN_WIDTH_80; 
    1980 +                       break; 
    1981 +               case IEEE80211_VHT_CHANWIDTH_160MHZ: 
    1982 +                       new_vht_chandef.width = NL80211_CHAN_WIDTH_160; 
    1983 +                       break; 
    1984 +               case IEEE80211_VHT_CHANWIDTH_80P80MHZ: 
    1985 +                       /* field is otherwise reserved */ 
    1986 +                       new_vht_chandef.center_freq2 = 
    1987 +                               ieee80211_channel_to_frequency( 
    1988 +                                       wide_bw_chansw_ie->new_center_freq_seg1, 
    1989 +                                       new_band); 
    1990 +                       new_vht_chandef.width = NL80211_CHAN_WIDTH_80P80; 
    1991 +                       break; 
    1992 +               } 
    1993 +               if (ifmgd->flags & IEEE80211_STA_DISABLE_80P80MHZ && 
    1994 +                   new_vht_chandef.width == NL80211_CHAN_WIDTH_80P80) 
    1995 +                       chandef_downgrade(&new_vht_chandef); 
    1996 +               if (ifmgd->flags & IEEE80211_STA_DISABLE_160MHZ && 
    1997 +                   new_vht_chandef.width == NL80211_CHAN_WIDTH_160) 
    1998 +                       chandef_downgrade(&new_vht_chandef); 
    1999 +               if (ifmgd->flags & IEEE80211_STA_DISABLE_40MHZ && 
    2000 +                   new_vht_chandef.width > NL80211_CHAN_WIDTH_20) 
    2001 +                       chandef_downgrade(&new_vht_chandef); 
    2002 +       } 
    2003 + 
    2004 +       /* if VHT data is there validate & use it */ 
    2005 +       if (new_vht_chandef.chan) { 
    2006 +               if (!cfg80211_chandef_compatible(&new_vht_chandef, 
    2007 +                                                &new_chandef)) { 
    2008 +                       sdata_info(sdata, 
    2009 +                                  "AP %pM CSA has inconsistent channel data, disconnecting\n", 
    2010 +                                  ifmgd->associated->bssid); 
    2011 +                       ieee80211_queue_work(&local->hw, 
    2012 +                                            &ifmgd->csa_connection_drop_work); 
    2013 +                       return; 
    2014 +               } 
    2015 +               new_chandef = new_vht_chandef; 
    2016 +       } 
    2017 + 
    2018 +       if (!cfg80211_chandef_usable(local->hw.wiphy, &new_chandef, 
    2019 +                                    IEEE80211_CHAN_DISABLED)) { 
    2020 +               sdata_info(sdata, 
    2021 +                          "AP %pM switches to unsupported channel (%d MHz, width:%d, CF1/2: %d/%d MHz), disconnecting\n", 
    2022 +                          ifmgd->associated->bssid, new_freq, 
    2023 +                          new_chandef.width, new_chandef.center_freq1, 
    2024 +                          new_chandef.center_freq2); 
    2025 +               ieee80211_queue_work(&local->hw, 
    2026                                      &ifmgd->csa_connection_drop_work); 
    2027                 return; 
    2028         } 
    2029   
    2030         ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED; 
    2031   
    2032 -       if (sdata->local->use_chanctx) { 
    2033 +       if (local->use_chanctx) { 
    2034                 sdata_info(sdata, 
    2035                            "not handling channel switch with channel contexts\n"); 
    2036 -               ieee80211_queue_work(&sdata->local->hw, 
    2037 +               ieee80211_queue_work(&local->hw, 
    2038                                      &ifmgd->csa_connection_drop_work); 
    2039                 return; 
    2040         } 
    2041   
    2042 -       mutex_lock(&sdata->local->chanctx_mtx); 
    2043 +       mutex_lock(&local->chanctx_mtx); 
    2044         if (WARN_ON(!rcu_access_pointer(sdata->vif.chanctx_conf))) { 
    2045 -               mutex_unlock(&sdata->local->chanctx_mtx); 
    2046 +               mutex_unlock(&local->chanctx_mtx); 
    2047                 return; 
    2048         } 
    2049         chanctx = container_of(rcu_access_pointer(sdata->vif.chanctx_conf), 
    2050 @@ -1111,40 +1222,39 @@ ieee80211_sta_process_chanswitch(struct  
    2051         if (chanctx->refcount > 1) { 
    2052                 sdata_info(sdata, 
    2053                            "channel switch with multiple interfaces on the same channel, disconnecting\n"); 
    2054 -               ieee80211_queue_work(&sdata->local->hw, 
    2055 +               ieee80211_queue_work(&local->hw, 
    2056                                      &ifmgd->csa_connection_drop_work); 
    2057 -               mutex_unlock(&sdata->local->chanctx_mtx); 
    2058 +               mutex_unlock(&local->chanctx_mtx); 
    2059                 return; 
    2060         } 
    2061 -       mutex_unlock(&sdata->local->chanctx_mtx); 
    2062 +       mutex_unlock(&local->chanctx_mtx); 
    2063   
    2064 -       sdata->local->csa_channel = new_ch; 
    2065 +       local->csa_chandef = new_chandef; 
    2066   
    2067 -       if (sw_elem->mode) 
    2068 -               ieee80211_stop_queues_by_reason(&sdata->local->hw, 
    2069 +       if (mode) 
    2070 +               ieee80211_stop_queues_by_reason(&local->hw, 
    2071                                 IEEE80211_MAX_QUEUE_MAP, 
    2072                                 IEEE80211_QUEUE_STOP_REASON_CSA); 
    2073   
    2074 -       if (sdata->local->ops->channel_switch) { 
    2075 +       if (local->ops->channel_switch) { 
    2076                 /* use driver's channel switch callback */ 
    2077                 struct ieee80211_channel_switch ch_switch = { 
    2078                         .timestamp = timestamp, 
    2079 -                       .block_tx = sw_elem->mode, 
    2080 -                       .channel = new_ch, 
    2081 -                       .count = sw_elem->count, 
    2082 +                       .block_tx = mode, 
    2083 +                       .chandef = new_chandef, 
    2084 +                       .count = count, 
    2085                 }; 
    2086   
    2087 -               drv_channel_switch(sdata->local, &ch_switch); 
    2088 +               drv_channel_switch(local, &ch_switch); 
    2089                 return; 
    2090         } 
    2091   
    2092         /* channel switch handled in software */ 
    2093 -       if (sw_elem->count <= 1) 
    2094 -               ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work); 
    2095 +       if (count <= 1) 
    2096 +               ieee80211_queue_work(&local->hw, &ifmgd->chswitch_work); 
    2097         else 
    2098                 mod_timer(&ifmgd->chswitch_timer, 
    2099 -                         TU_TO_EXP_TIME(sw_elem->count * 
    2100 -                                        cbss->beacon_interval)); 
    2101 +                         TU_TO_EXP_TIME(count * cbss->beacon_interval)); 
    2102  } 
    2103   
    2104  static u32 ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata, 
    2105 @@ -2120,7 +2230,6 @@ void ieee80211_beacon_loss(struct ieee80 
    2106   
    2107         trace_api_beacon_loss(sdata); 
    2108   
    2109 -       WARN_ON(hw->flags & IEEE80211_HW_CONNECTION_MONITOR); 
    2110         sdata->u.mgd.connection_loss = false; 
    2111         ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work); 
    2112  } 
    2113 @@ -2170,7 +2279,7 @@ static void ieee80211_auth_challenge(str 
    2114         u32 tx_flags = 0; 
    2115   
    2116         pos = mgmt->u.auth.variable; 
    2117 -       ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems); 
    2118 +       ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), false, &elems); 
    2119         if (!elems.challenge) 
    2120                 return; 
    2121         auth_data->expected_transaction = 4; 
    2122 @@ -2435,7 +2544,7 @@ static bool ieee80211_assoc_success(stru 
    2123         } 
    2124   
    2125         pos = mgmt->u.assoc_resp.variable; 
    2126 -       ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems); 
    2127 +       ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), false, &elems); 
    2128   
    2129         if (!elems.supp_rates) { 
    2130                 sdata_info(sdata, "no SuppRates element in AssocResp\n"); 
    2131 @@ -2604,7 +2713,7 @@ ieee80211_rx_mgmt_assoc_resp(struct ieee 
    2132                    capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14)))); 
    2133   
    2134         pos = mgmt->u.assoc_resp.variable; 
    2135 -       ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems); 
    2136 +       ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), false, &elems); 
    2137   
    2138         if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY && 
    2139             elems.timeout_int && 
    2140 @@ -2659,6 +2768,8 @@ static void ieee80211_rx_bss_info(struct 
    2141         struct ieee80211_channel *channel; 
    2142         bool need_ps = false; 
    2143   
    2144 +       lockdep_assert_held(&sdata->u.mgd.mtx); 
    2145 + 
    2146         if ((sdata->u.mgd.associated && 
    2147              ether_addr_equal(mgmt->bssid, sdata->u.mgd.associated->bssid)) || 
    2148             (sdata->u.mgd.assoc_data && 
    2149 @@ -2689,7 +2800,8 @@ static void ieee80211_rx_bss_info(struct 
    2150         if (bss) 
    2151                 ieee80211_rx_bss_put(local, bss); 
    2152   
    2153 -       if (!sdata->u.mgd.associated) 
    2154 +       if (!sdata->u.mgd.associated || 
    2155 +           !ether_addr_equal(mgmt->bssid, sdata->u.mgd.associated->bssid)) 
    2156                 return; 
    2157   
    2158         if (need_ps) { 
    2159 @@ -2698,10 +2810,9 @@ static void ieee80211_rx_bss_info(struct 
    2160                 mutex_unlock(&local->iflist_mtx); 
    2161         } 
    2162   
    2163 -       if (elems->ch_switch_ie && 
    2164 -           memcmp(mgmt->bssid, sdata->u.mgd.associated->bssid, ETH_ALEN) == 0) 
    2165 -               ieee80211_sta_process_chanswitch(sdata, elems->ch_switch_ie, 
    2166 -                                                bss, rx_status->mactime); 
    2167 +       ieee80211_sta_process_chanswitch(sdata, rx_status->mactime, 
    2168 +                                        elems, true); 
    2169 + 
    2170  } 
    2171   
    2172   
    2173 @@ -2726,7 +2837,7 @@ static void ieee80211_rx_mgmt_probe_resp 
    2174                 return; 
    2175   
    2176         ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 
    2177 -                               &elems); 
    2178 +                              false, &elems); 
    2179   
    2180         ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems); 
    2181   
    2182 @@ -2809,7 +2920,7 @@ ieee80211_rx_mgmt_beacon(struct ieee8021 
    2183         if (ifmgd->assoc_data && ifmgd->assoc_data->need_beacon && 
    2184             ether_addr_equal(mgmt->bssid, ifmgd->assoc_data->bss->bssid)) { 
    2185                 ieee802_11_parse_elems(mgmt->u.beacon.variable, 
    2186 -                                      len - baselen, &elems); 
    2187 +                                      len - baselen, false, &elems); 
    2188   
    2189                 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems); 
    2190                 ifmgd->assoc_data->have_beacon = true; 
    2191 @@ -2919,7 +3030,7 @@ ieee80211_rx_mgmt_beacon(struct ieee8021 
    2192   
    2193         ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4); 
    2194         ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable, 
    2195 -                                         len - baselen, &elems, 
    2196 +                                         len - baselen, false, &elems, 
    2197                                           care_about_ies, ncrc); 
    2198   
    2199         if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) { 
    2200 @@ -3066,6 +3177,8 @@ void ieee80211_sta_rx_queued_mgmt(struct 
    2201         enum rx_mgmt_action rma = RX_MGMT_NONE; 
    2202         u8 deauth_buf[IEEE80211_DEAUTH_FRAME_LEN]; 
    2203         u16 fc; 
    2204 +       struct ieee802_11_elems elems; 
    2205 +       int ies_len; 
    2206   
    2207         rx_status = (struct ieee80211_rx_status *) skb->cb; 
    2208         mgmt = (struct ieee80211_mgmt *) skb->data; 
    2209 @@ -3095,14 +3208,48 @@ void ieee80211_sta_rx_queued_mgmt(struct 
    2210                 rma = ieee80211_rx_mgmt_assoc_resp(sdata, mgmt, skb->len, &bss); 
    2211                 break; 
    2212         case IEEE80211_STYPE_ACTION: 
    2213 -               switch (mgmt->u.action.category) { 
    2214 -               case WLAN_CATEGORY_SPECTRUM_MGMT: 
    2215 +               if (mgmt->u.action.category == WLAN_CATEGORY_SPECTRUM_MGMT) { 
    2216 +                       ies_len = skb->len - 
    2217 +                                 offsetof(struct ieee80211_mgmt, 
    2218 +                                          u.action.u.chan_switch.variable); 
    2219 + 
    2220 +                       if (ies_len < 0) 
    2221 +                               break; 
    2222 + 
    2223 +                       ieee802_11_parse_elems( 
    2224 +                               mgmt->u.action.u.chan_switch.variable, 
    2225 +                               ies_len, true, &elems); 
    2226 + 
    2227 +                       if (elems.parse_error) 
    2228 +                               break; 
    2229 + 
    2230                         ieee80211_sta_process_chanswitch(sdata, 
    2231 -                                       &mgmt->u.action.u.chan_switch.sw_elem, 
    2232 -                                       (void *)ifmgd->associated->priv, 
    2233 -                                       rx_status->mactime); 
    2234 -                       break; 
    2235 +                                                        rx_status->mactime, 
    2236 +                                                        &elems, false); 
    2237 +               } else if (mgmt->u.action.category == WLAN_CATEGORY_PUBLIC) { 
    2238 +                       ies_len = skb->len - 
    2239 +                                 offsetof(struct ieee80211_mgmt, 
    2240 +                                          u.action.u.ext_chan_switch.variable); 
    2241 + 
    2242 +                       if (ies_len < 0) 
    2243 +                               break; 
    2244 + 
    2245 +                       ieee802_11_parse_elems( 
    2246 +                               mgmt->u.action.u.ext_chan_switch.variable, 
    2247 +                               ies_len, true, &elems); 
    2248 + 
    2249 +                       if (elems.parse_error) 
    2250 +                               break; 
    2251 + 
    2252 +                       /* for the handling code pretend this was also an IE */ 
    2253 +                       elems.ext_chansw_ie = 
    2254 +                               &mgmt->u.action.u.ext_chan_switch.data; 
    2255 + 
    2256 +                       ieee80211_sta_process_chanswitch(sdata, 
    2257 +                                                        rx_status->mactime, 
    2258 +                                                        &elems, false); 
    2259                 } 
    2260 +               break; 
    2261         } 
    2262         mutex_unlock(&ifmgd->mtx); 
    2263   
    2264 @@ -4197,7 +4344,7 @@ int ieee80211_mgd_deauth(struct ieee8021 
    2265         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 
    2266         u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN]; 
    2267         bool tx = !req->local_state_change; 
    2268 -       bool sent_frame = false; 
    2269 +       bool report_frame = false; 
    2270   
    2271         mutex_lock(&ifmgd->mtx); 
    2272   
    2273 @@ -4214,7 +4361,7 @@ int ieee80211_mgd_deauth(struct ieee8021 
    2274                 ieee80211_destroy_auth_data(sdata, false); 
    2275                 mutex_unlock(&ifmgd->mtx); 
    2276   
    2277 -               sent_frame = tx; 
    2278 +               report_frame = true; 
    2279                 goto out; 
    2280         } 
    2281   
    2282 @@ -4222,12 +4369,12 @@ int ieee80211_mgd_deauth(struct ieee8021 
    2283             ether_addr_equal(ifmgd->associated->bssid, req->bssid)) { 
    2284                 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH, 
    2285                                        req->reason_code, tx, frame_buf); 
    2286 -               sent_frame = tx; 
    2287 +               report_frame = true; 
    2288         } 
    2289         mutex_unlock(&ifmgd->mtx); 
    2290   
    2291   out: 
    2292 -       if (sent_frame) 
    2293 +       if (report_frame) 
    2294                 __cfg80211_send_deauth(sdata->dev, frame_buf, 
    2295                                        IEEE80211_DEAUTH_FRAME_LEN); 
    2296   
    2297 --- a/net/mac80211/pm.c 
    2298 +++ b/net/mac80211/pm.c 
    2299 @@ -38,8 +38,8 @@ int __ieee80211_suspend(struct ieee80211 
    2300                                         IEEE80211_MAX_QUEUE_MAP, 
    2301                                         IEEE80211_QUEUE_STOP_REASON_SUSPEND); 
    2302   
    2303 -       /* flush out all packets */ 
    2304 -       synchronize_net(); 
    2305 +       /* flush out all packets and station cleanup call_rcu()s */ 
    2306 +       rcu_barrier(); 
    2307   
    2308         ieee80211_flush_queues(local, NULL); 
    2309   
    2310 --- a/net/mac80211/rate.c 
    2311 +++ b/net/mac80211/rate.c 
    2312 @@ -252,6 +252,25 @@ rate_lowest_non_cck_index(struct ieee802 
    2313         return 0; 
    2314  } 
    2315   
    2316 +static void __rate_control_send_low(struct ieee80211_hw *hw, 
    2317 +                                   struct ieee80211_supported_band *sband, 
    2318 +                                   struct ieee80211_sta *sta, 
    2319 +                                   struct ieee80211_tx_info *info) 
    2320 +{ 
    2321 +       if ((sband->band != IEEE80211_BAND_2GHZ) || 
    2322 +           !(info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)) 
    2323 +               info->control.rates[0].idx = rate_lowest_index(sband, sta); 
    2324 +       else 
    2325 +               info->control.rates[0].idx = 
    2326 +                       rate_lowest_non_cck_index(sband, sta); 
    2327 + 
    2328 +       info->control.rates[0].count = 
    2329 +               (info->flags & IEEE80211_TX_CTL_NO_ACK) ? 
    2330 +               1 : hw->max_rate_tries; 
    2331 + 
    2332 +       info->control.skip_table = 1; 
    2333 +} 
    2334 + 
    2335   
    2336  bool rate_control_send_low(struct ieee80211_sta *sta, 
    2337                            void *priv_sta, 
    2338 @@ -262,16 +281,8 @@ bool rate_control_send_low(struct ieee80 
    2339         int mcast_rate; 
    2340   
    2341         if (!sta || !priv_sta || rc_no_data_or_no_ack_use_min(txrc)) { 
    2342 -               if ((sband->band != IEEE80211_BAND_2GHZ) || 
    2343 -                   !(info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)) 
    2344 -                       info->control.rates[0].idx = 
    2345 -                               rate_lowest_index(txrc->sband, sta); 
    2346 -               else 
    2347 -                       info->control.rates[0].idx = 
    2348 -                               rate_lowest_non_cck_index(txrc->sband, sta); 
    2349 -               info->control.rates[0].count = 
    2350 -                       (info->flags & IEEE80211_TX_CTL_NO_ACK) ? 
    2351 -                       1 : txrc->hw->max_rate_tries; 
    2352 +               __rate_control_send_low(txrc->hw, sband, sta, info); 
    2353 + 
    2354                 if (!sta && txrc->bss) { 
    2355                         mcast_rate = txrc->bss_conf->mcast_rate[sband->band]; 
    2356                         if (mcast_rate > 0) { 
    2357 @@ -355,7 +366,8 @@ static bool rate_idx_match_mcs_mask(stru 
    2358   
    2359   
    2360  static void rate_idx_match_mask(struct ieee80211_tx_rate *rate, 
    2361 -                               struct ieee80211_tx_rate_control *txrc, 
    2362 +                               struct ieee80211_supported_band *sband, 
    2363 +                               enum nl80211_chan_width chan_width, 
    2364                                 u32 mask, 
    2365                                 u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN]) 
    2366  { 
    2367 @@ -375,27 +387,17 @@ static void rate_idx_match_mask(struct i 
    2368                                   IEEE80211_TX_RC_USE_SHORT_PREAMBLE); 
    2369                 alt_rate.count = rate->count; 
    2370                 if (rate_idx_match_legacy_mask(&alt_rate, 
    2371 -                                              txrc->sband->n_bitrates, 
    2372 -                                              mask)) { 
    2373 +                                              sband->n_bitrates, mask)) { 
    2374                         *rate = alt_rate; 
    2375                         return; 
    2376                 } 
    2377         } else { 
    2378 -               struct sk_buff *skb = txrc->skb; 
    2379 -               struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 
    2380 -               __le16 fc; 
    2381 - 
    2382                 /* handle legacy rates */ 
    2383 -               if (rate_idx_match_legacy_mask(rate, txrc->sband->n_bitrates, 
    2384 -                                              mask)) 
    2385 +               if (rate_idx_match_legacy_mask(rate, sband->n_bitrates, mask)) 
    2386                         return; 
    2387   
    2388                 /* if HT BSS, and we handle a data frame, also try HT rates */ 
    2389 -               if (txrc->bss_conf->chandef.width == NL80211_CHAN_WIDTH_20_NOHT) 
    2390 -                       return; 
    2391 - 
    2392 -               fc = hdr->frame_control; 
    2393 -               if (!ieee80211_is_data(fc)) 
    2394 +               if (chan_width == NL80211_CHAN_WIDTH_20_NOHT) 
    2395                         return; 
    2396   
    2397                 alt_rate.idx = 0; 
    2398 @@ -408,7 +410,7 @@ static void rate_idx_match_mask(struct i 
    2399   
    2400                 alt_rate.flags |= IEEE80211_TX_RC_MCS; 
    2401   
    2402 -               if (txrc->bss_conf->chandef.width == NL80211_CHAN_WIDTH_40) 
    2403 +               if (chan_width == NL80211_CHAN_WIDTH_40) 
    2404                         alt_rate.flags |= IEEE80211_TX_RC_40_MHZ_WIDTH; 
    2405   
    2406                 if (rate_idx_match_mcs_mask(&alt_rate, mcs_mask)) { 
    2407 @@ -426,6 +428,228 @@ static void rate_idx_match_mask(struct i 
    2408          */ 
    2409  } 
    2410   
    2411 +static void rate_fixup_ratelist(struct ieee80211_vif *vif, 
    2412 +                               struct ieee80211_supported_band *sband, 
    2413 +                               struct ieee80211_tx_info *info, 
    2414 +                               struct ieee80211_tx_rate *rates, 
    2415 +                               int max_rates) 
    2416 +{ 
    2417 +       struct ieee80211_rate *rate; 
    2418 +       bool inval = false; 
    2419 +       int i; 
    2420 + 
    2421 +       /* 
    2422 +        * Set up the RTS/CTS rate as the fastest basic rate 
    2423 +        * that is not faster than the data rate unless there 
    2424 +        * is no basic rate slower than the data rate, in which 
    2425 +        * case we pick the slowest basic rate 
    2426 +        * 
    2427 +        * XXX: Should this check all retry rates? 
    2428 +        */ 
    2429 +       if (!(rates[0].flags & IEEE80211_TX_RC_MCS)) { 
    2430 +               u32 basic_rates = vif->bss_conf.basic_rates; 
    2431 +               s8 baserate = basic_rates ? ffs(basic_rates - 1) : 0; 
    2432 + 
    2433 +               rate = &sband->bitrates[rates[0].idx]; 
    2434 + 
    2435 +               for (i = 0; i < sband->n_bitrates; i++) { 
    2436 +                       /* must be a basic rate */ 
    2437 +                       if (!(basic_rates & BIT(i))) 
    2438 +                               continue; 
    2439 +                       /* must not be faster than the data rate */ 
    2440 +                       if (sband->bitrates[i].bitrate > rate->bitrate) 
    2441 +                               continue; 
    2442 +                       /* maximum */ 
    2443 +                       if (sband->bitrates[baserate].bitrate < 
    2444 +                            sband->bitrates[i].bitrate) 
    2445 +                               baserate = i; 
    2446 +               } 
    2447 + 
    2448 +               info->control.rts_cts_rate_idx = baserate; 
    2449 +       } 
    2450 + 
    2451 +       for (i = 0; i < max_rates; i++) { 
    2452 +               /* 
    2453 +                * make sure there's no valid rate following 
    2454 +                * an invalid one, just in case drivers don't 
    2455 +                * take the API seriously to stop at -1. 
    2456 +                */ 
    2457 +               if (inval) { 
    2458 +                       rates[i].idx = -1; 
    2459 +                       continue; 
    2460 +               } 
    2461 +               if (rates[i].idx < 0) { 
    2462 +                       inval = true; 
    2463 +                       continue; 
    2464 +               } 
    2465 + 
    2466 +               /* 
    2467 +                * For now assume MCS is already set up correctly, this 
    2468 +                * needs to be fixed. 
    2469 +                */ 
    2470 +               if (rates[i].flags & IEEE80211_TX_RC_MCS) { 
    2471 +                       WARN_ON(rates[i].idx > 76); 
    2472 + 
    2473 +                       if (!(rates[i].flags & IEEE80211_TX_RC_USE_RTS_CTS) && 
    2474 +                           info->control.use_cts_prot) 
    2475 +                               rates[i].flags |= 
    2476 +                                       IEEE80211_TX_RC_USE_CTS_PROTECT; 
    2477 +                       continue; 
    2478 +               } 
    2479 + 
    2480 +               if (rates[i].flags & IEEE80211_TX_RC_VHT_MCS) { 
    2481 +                       WARN_ON(ieee80211_rate_get_vht_mcs(&rates[i]) > 9); 
    2482 +                       continue; 
    2483 +               } 
    2484 + 
    2485 +               /* set up RTS protection if desired */ 
    2486 +               if (info->control.use_rts) { 
    2487 +                       rates[i].flags |= IEEE80211_TX_RC_USE_RTS_CTS; 
    2488 +                       info->control.use_cts_prot = false; 
    2489 +               } 
    2490 + 
    2491 +               /* RC is busted */ 
    2492 +               if (WARN_ON_ONCE(rates[i].idx >= sband->n_bitrates)) { 
    2493 +                       rates[i].idx = -1; 
    2494 +                       continue; 
    2495 +               } 
    2496 + 
    2497 +               rate = &sband->bitrates[rates[i].idx]; 
    2498 + 
    2499 +               /* set up short preamble */ 
    2500 +               if (info->control.short_preamble && 
    2501 +                   rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) 
    2502 +                       rates[i].flags |= IEEE80211_TX_RC_USE_SHORT_PREAMBLE; 
    2503 + 
    2504 +               /* set up G protection */ 
    2505 +               if (!(rates[i].flags & IEEE80211_TX_RC_USE_RTS_CTS) && 
    2506 +                   info->control.use_cts_prot && 
    2507 +                   rate->flags & IEEE80211_RATE_ERP_G) 
    2508 +                       rates[i].flags |= IEEE80211_TX_RC_USE_CTS_PROTECT; 
    2509 +       } 
    2510 +} 
    2511 + 
    2512 + 
    2513 +static void rate_control_fill_sta_table(struct ieee80211_sta *sta, 
    2514 +                                       struct ieee80211_tx_info *info, 
    2515 +                                       struct ieee80211_tx_rate *rates, 
    2516 +                                       int max_rates) 
    2517 +{ 
    2518 +       struct ieee80211_sta_rates *ratetbl = NULL; 
    2519 +       int i; 
    2520 + 
    2521 +       if (sta && !info->control.skip_table) 
    2522 +               ratetbl = rcu_dereference(sta->rates); 
    2523 + 
    2524 +       /* Fill remaining rate slots with data from the sta rate table. */ 
    2525 +       max_rates = min_t(int, max_rates, IEEE80211_TX_RATE_TABLE_SIZE); 
    2526 +       for (i = 0; i < max_rates; i++) { 
    2527 +               if (i < ARRAY_SIZE(info->control.rates) && 
    2528 +                   info->control.rates[i].idx >= 0 && 
    2529 +                   info->control.rates[i].count) { 
    2530 +                       if (rates != info->control.rates) 
    2531 +                               rates[i] = info->control.rates[i]; 
    2532 +               } else if (ratetbl) { 
    2533 +                       rates[i].idx = ratetbl->rate[i].idx; 
    2534 +                       rates[i].flags = ratetbl->rate[i].flags; 
    2535 +                       if (info->control.use_rts) 
    2536 +                               rates[i].count = ratetbl->rate[i].count_rts; 
    2537 +                       else if (info->control.use_cts_prot) 
    2538 +                               rates[i].count = ratetbl->rate[i].count_cts; 
    2539 +                       else 
    2540 +                               rates[i].count = ratetbl->rate[i].count; 
    2541 +               } else { 
    2542 +                       rates[i].idx = -1; 
    2543 +                       rates[i].count = 0; 
    2544 +               } 
    2545 + 
    2546 +               if (rates[i].idx < 0 || !rates[i].count) 
    2547 +                       break; 
    2548 +       } 
    2549 +} 
    2550 + 
    2551 +static void rate_control_apply_mask(struct ieee80211_sub_if_data *sdata, 
    2552 +                                   struct ieee80211_sta *sta, 
    2553 +                                   struct ieee80211_supported_band *sband, 
    2554 +                                   struct ieee80211_tx_info *info, 
    2555 +                                   struct ieee80211_tx_rate *rates, 
    2556 +                                   int max_rates) 
    2557 +{ 
    2558 +       enum nl80211_chan_width chan_width; 
    2559 +       u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN]; 
    2560 +       bool has_mcs_mask; 
    2561 +       u32 mask; 
    2562 +       int i; 
    2563 + 
    2564 +       /* 
    2565 +        * Try to enforce the rateidx mask the user wanted. skip this if the 
    2566 +        * default mask (allow all rates) is used to save some processing for 
    2567 +        * the common case. 
    2568 +        */ 
    2569 +       mask = sdata->rc_rateidx_mask[info->band]; 
    2570 +       has_mcs_mask = sdata->rc_has_mcs_mask[info->band]; 
    2571 +       if (mask == (1 << sband->n_bitrates) - 1 && !has_mcs_mask) 
    2572 +               return; 
    2573 + 
    2574 +       if (has_mcs_mask) 
    2575 +               memcpy(mcs_mask, sdata->rc_rateidx_mcs_mask[info->band], 
    2576 +                      sizeof(mcs_mask)); 
    2577 +       else 
    2578 +               memset(mcs_mask, 0xff, sizeof(mcs_mask)); 
    2579 + 
    2580 +       if (sta) { 
    2581 +               /* Filter out rates that the STA does not support */ 
    2582 +               mask &= sta->supp_rates[info->band]; 
    2583 +               for (i = 0; i < sizeof(mcs_mask); i++) 
    2584 +                       mcs_mask[i] &= sta->ht_cap.mcs.rx_mask[i]; 
    2585 +       } 
    2586 + 
    2587 +       /* 
    2588 +        * Make sure the rate index selected for each TX rate is 
    2589 +        * included in the configured mask and change the rate indexes 
    2590 +        * if needed. 
    2591 +        */ 
    2592 +       chan_width = sdata->vif.bss_conf.chandef.width; 
    2593 +       for (i = 0; i < max_rates; i++) { 
    2594 +               /* Skip invalid rates */ 
    2595 +               if (rates[i].idx < 0) 
    2596 +                       break; 
    2597 + 
    2598 +               rate_idx_match_mask(&rates[i], sband, chan_width, mask, 
    2599 +                                   mcs_mask); 
    2600 +       } 
    2601 +} 
    2602 + 
    2603 +void ieee80211_get_tx_rates(struct ieee80211_vif *vif, 
    2604 +                           struct ieee80211_sta *sta, 
    2605 +                           struct sk_buff *skb, 
    2606 +                           struct ieee80211_tx_rate *dest, 
    2607 +                           int max_rates) 
    2608 +{ 
    2609 +       struct ieee80211_sub_if_data *sdata; 
    2610 +       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 
    2611 +       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 
    2612 +       struct ieee80211_supported_band *sband; 
    2613 + 
    2614 +       rate_control_fill_sta_table(sta, info, dest, max_rates); 
    2615 + 
    2616 +       if (!vif) 
    2617 +               return; 
    2618 + 
    2619 +       sdata = vif_to_sdata(vif); 
    2620 +       sband = sdata->local->hw.wiphy->bands[info->band]; 
    2621 + 
    2622 +       if (ieee80211_is_data(hdr->frame_control)) 
    2623 +               rate_control_apply_mask(sdata, sta, sband, info, dest, max_rates); 
    2624 + 
    2625 +       if (dest[0].idx < 0) 
    2626 +               __rate_control_send_low(&sdata->local->hw, sband, sta, info); 
    2627 + 
    2628 +       if (sta) 
    2629 +               rate_fixup_ratelist(vif, sband, info, dest, max_rates); 
    2630 +} 
    2631 +EXPORT_SYMBOL(ieee80211_get_tx_rates); 
    2632 + 
    2633  void rate_control_get_rate(struct ieee80211_sub_if_data *sdata, 
    2634                            struct sta_info *sta, 
    2635                            struct ieee80211_tx_rate_control *txrc) 
    2636 @@ -435,8 +659,6 @@ void rate_control_get_rate(struct ieee80 
    2637         struct ieee80211_sta *ista = NULL; 
    2638         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb); 
    2639         int i; 
    2640 -       u32 mask; 
    2641 -       u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN]; 
    2642   
    2643         if (sta && test_sta_flag(sta, WLAN_STA_RATE_CONTROL)) { 
    2644                 ista = &sta->sta; 
    2645 @@ -454,37 +676,27 @@ void rate_control_get_rate(struct ieee80 
    2646   
    2647         ref->ops->get_rate(ref->priv, ista, priv_sta, txrc); 
    2648   
    2649 -       /* 
    2650 -        * Try to enforce the rateidx mask the user wanted. skip this if the 
    2651 -        * default mask (allow all rates) is used to save some processing for 
    2652 -        * the common case. 
    2653 -        */ 
    2654 -       mask = sdata->rc_rateidx_mask[info->band]; 
    2655 -       memcpy(mcs_mask, sdata->rc_rateidx_mcs_mask[info->band], 
    2656 -              sizeof(mcs_mask)); 
    2657 -       if (mask != (1 << txrc->sband->n_bitrates) - 1) { 
    2658 -               if (sta) { 
    2659 -                       /* Filter out rates that the STA does not support */ 
    2660 -                       mask &= sta->sta.supp_rates[info->band]; 
    2661 -                       for (i = 0; i < sizeof(mcs_mask); i++) 
    2662 -                               mcs_mask[i] &= sta->sta.ht_cap.mcs.rx_mask[i]; 
    2663 -               } 
    2664 -               /* 
    2665 -                * Make sure the rate index selected for each TX rate is 
    2666 -                * included in the configured mask and change the rate indexes 
    2667 -                * if needed. 
    2668 -                */ 
    2669 -               for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) { 
    2670 -                       /* Skip invalid rates */ 
    2671 -                       if (info->control.rates[i].idx < 0) 
    2672 -                               break; 
    2673 -                       rate_idx_match_mask(&info->control.rates[i], txrc, 
    2674 -                                           mask, mcs_mask); 
    2675 -               } 
    2676 -       } 
    2677 +       if (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_RC_TABLE) 
    2678 +               return; 
    2679   
    2680 -       BUG_ON(info->control.rates[0].idx < 0); 
    2681 +       ieee80211_get_tx_rates(&sdata->vif, ista, txrc->skb, 
    2682 +                              info->control.rates, 
    2683 +                              ARRAY_SIZE(info->control.rates)); 
    2684 +} 
    2685 + 
    2686 +int rate_control_set_rates(struct ieee80211_hw *hw, 
    2687 +                          struct ieee80211_sta *pubsta, 
    2688 +                          struct ieee80211_sta_rates *rates) 
    2689 +{ 
    2690 +       struct ieee80211_sta_rates *old = rcu_dereference(pubsta->rates); 
    2691 + 
    2692 +       rcu_assign_pointer(pubsta->rates, rates); 
    2693 +       if (old) 
    2694 +               kfree_rcu(old, rcu_head); 
    2695 + 
    2696 +       return 0; 
    2697  } 
    2698 +EXPORT_SYMBOL(rate_control_set_rates); 
    2699   
    2700  int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local, 
    2701                                  const char *name) 
    2702 --- a/net/mac80211/rc80211_minstrel.c 
    2703 +++ b/net/mac80211/rc80211_minstrel.c 
    2704 @@ -84,6 +84,50 @@ minstrel_sort_best_tp_rates(struct minst 
    2705  } 
    2706   
    2707  static void 
    2708 +minstrel_set_rate(struct minstrel_sta_info *mi, struct ieee80211_sta_rates *ratetbl, 
    2709 +                 int offset, int idx) 
    2710 +{ 
    2711 +       struct minstrel_rate *r = &mi->r[idx]; 
    2712 + 
    2713 +       ratetbl->rate[offset].idx = r->rix; 
    2714 +       ratetbl->rate[offset].count = r->adjusted_retry_count; 
    2715 +       ratetbl->rate[offset].count_cts = r->retry_count_cts; 
    2716 +       ratetbl->rate[offset].count_rts = r->retry_count_rtscts; 
    2717 +} 
    2718 + 
    2719 +static void 
    2720 +minstrel_update_rates(struct minstrel_priv *mp, struct minstrel_sta_info *mi) 
    2721 +{ 
    2722 +       struct ieee80211_sta_rates *ratetbl; 
    2723 +       int i = 0; 
    2724 + 
    2725 +       ratetbl = kzalloc(sizeof(*ratetbl), GFP_ATOMIC); 
    2726 +       if (!ratetbl) 
    2727 +               return; 
    2728 + 
    2729 +       /* Start with max_tp_rate */ 
    2730 +       minstrel_set_rate(mi, ratetbl, i++, mi->max_tp_rate[0]); 
    2731 + 
    2732 +       if (mp->hw->max_rates >= 3) { 
    2733 +               /* At least 3 tx rates supported, use max_tp_rate2 next */ 
    2734 +               minstrel_set_rate(mi, ratetbl, i++, mi->max_tp_rate[1]); 
    2735 +       } 
    2736 + 
    2737 +       if (mp->hw->max_rates >= 2) { 
    2738 +               /* At least 2 tx rates supported, use max_prob_rate next */ 
    2739 +               minstrel_set_rate(mi, ratetbl, i++, mi->max_prob_rate); 
    2740 +       } 
    2741 + 
    2742 +       /* Use lowest rate last */ 
    2743 +       ratetbl->rate[i].idx = mi->lowest_rix; 
    2744 +       ratetbl->rate[i].count = mp->max_retry; 
    2745 +       ratetbl->rate[i].count_cts = mp->max_retry; 
    2746 +       ratetbl->rate[i].count_rts = mp->max_retry; 
    2747 + 
    2748 +       rate_control_set_rates(mp->hw, mi->sta, ratetbl); 
    2749 +} 
    2750 + 
    2751 +static void 
    2752  minstrel_update_stats(struct minstrel_priv *mp, struct minstrel_sta_info *mi) 
    2753  { 
    2754         u8 tmp_tp_rate[MAX_THR_RATES]; 
    2755 @@ -161,6 +205,8 @@ minstrel_update_stats(struct minstrel_pr 
    2756   
    2757         /* Reset update timer */ 
    2758         mi->stats_update = jiffies; 
    2759 + 
    2760 +       minstrel_update_rates(mp, mi); 
    2761  } 
    2762   
    2763  static void 
    2764 @@ -209,9 +255,9 @@ minstrel_get_retry_count(struct minstrel 
    2765  { 
    2766         unsigned int retry = mr->adjusted_retry_count; 
    2767   
    2768 -       if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) 
    2769 +       if (info->control.use_rts) 
    2770                 retry = max(2U, min(mr->retry_count_rtscts, retry)); 
    2771 -       else if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) 
    2772 +       else if (info->control.use_cts_prot) 
    2773                 retry = max(2U, min(mr->retry_count_cts, retry)); 
    2774         return retry; 
    2775  } 
    2776 @@ -240,13 +286,12 @@ minstrel_get_rate(void *priv, struct iee 
    2777         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 
    2778         struct minstrel_sta_info *mi = priv_sta; 
    2779         struct minstrel_priv *mp = priv; 
    2780 -       struct ieee80211_tx_rate *ar = info->control.rates; 
    2781 -       unsigned int ndx, sample_ndx = 0; 
    2782 +       struct ieee80211_tx_rate *rate = &info->control.rates[0]; 
    2783 +       struct minstrel_rate *msr, *mr; 
    2784 +       unsigned int ndx; 
    2785         bool mrr_capable; 
    2786 -       bool indirect_rate_sampling = false; 
    2787 -       bool rate_sampling = false; 
    2788 -       int i, delta; 
    2789 -       int mrr_ndx[3]; 
    2790 +       bool prev_sample = mi->prev_sample; 
    2791 +       int delta; 
    2792         int sampling_ratio; 
    2793   
    2794         /* management/no-ack frames do not use rate control */ 
    2795 @@ -262,107 +307,75 @@ minstrel_get_rate(void *priv, struct iee 
    2796         else 
    2797                 sampling_ratio = mp->lookaround_rate; 
    2798   
    2799 -       /* init rateindex [ndx] with max throughput rate */ 
    2800 -       ndx = mi->max_tp_rate[0]; 
    2801 - 
    2802         /* increase sum packet counter */ 
    2803         mi->packet_count++; 
    2804   
    2805         delta = (mi->packet_count * sampling_ratio / 100) - 
    2806                         (mi->sample_count + mi->sample_deferred / 2); 
    2807   
    2808 -       /* delta > 0: sampling required */ 
    2809 -       if ((delta > 0) && (mrr_capable || !mi->prev_sample)) { 
    2810 -               struct minstrel_rate *msr; 
    2811 -               if (mi->packet_count >= 10000) { 
    2812 -                       mi->sample_deferred = 0; 
    2813 -                       mi->sample_count = 0; 
    2814 -                       mi->packet_count = 0; 
    2815 -               } else if (delta > mi->n_rates * 2) { 
    2816 -                       /* With multi-rate retry, not every planned sample 
    2817 -                        * attempt actually gets used, due to the way the retry 
    2818 -                        * chain is set up - [max_tp,sample,prob,lowest] for 
    2819 -                        * sample_rate < max_tp. 
    2820 -                        * 
    2821 -                        * If there's too much sampling backlog and the link 
    2822 -                        * starts getting worse, minstrel would start bursting 
    2823 -                        * out lots of sampling frames, which would result 
    2824 -                        * in a large throughput loss. */ 
    2825 -                       mi->sample_count += (delta - mi->n_rates * 2); 
    2826 -               } 
    2827 +       /* delta < 0: no sampling required */ 
    2828 +       mi->prev_sample = false; 
    2829 +       if (delta < 0 || (!mrr_capable && prev_sample)) 
    2830 +               return; 
    2831   
    2832 -               /* get next random rate sample */ 
    2833 -               sample_ndx = minstrel_get_next_sample(mi); 
    2834 -               msr = &mi->r[sample_ndx]; 
    2835 -               rate_sampling = true; 
    2836 - 
    2837 -               /* Decide if direct ( 1st mrr stage) or indirect (2nd mrr stage) 
    2838 -                * rate sampling method should be used. 
    2839 -                * Respect such rates that are not sampled for 20 interations. 
    2840 -                */ 
    2841 -               if (mrr_capable && 
    2842 -                   msr->perfect_tx_time > mi->r[ndx].perfect_tx_time && 
    2843 -                   msr->sample_skipped < 20) 
    2844 -                               indirect_rate_sampling = true; 
    2845 - 
    2846 -               if (!indirect_rate_sampling) { 
    2847 -                       if (msr->sample_limit != 0) { 
    2848 -                               ndx = sample_ndx; 
    2849 -                               mi->sample_count++; 
    2850 -                               if (msr->sample_limit > 0) 
    2851 -                                       msr->sample_limit--; 
    2852 -                       } else 
    2853 -                               rate_sampling = false; 
    2854 -               } else { 
    2855 -                       /* Only use IEEE80211_TX_CTL_RATE_CTRL_PROBE to mark 
    2856 -                        * packets that have the sampling rate deferred to the 
    2857 -                        * second MRR stage. Increase the sample counter only 
    2858 -                        * if the deferred sample rate was actually used. 
    2859 -                        * Use the sample_deferred counter to make sure that 
    2860 -                        * the sampling is not done in large bursts */ 
    2861 -                       info->flags |= IEEE80211_TX_CTL_RATE_CTRL_PROBE; 
    2862 -                       mi->sample_deferred++; 
    2863 -               } 
    2864 +       if (mi->packet_count >= 10000) { 
    2865 +               mi->sample_deferred = 0; 
    2866 +               mi->sample_count = 0; 
    2867 +               mi->packet_count = 0; 
    2868 +       } else if (delta > mi->n_rates * 2) { 
    2869 +               /* With multi-rate retry, not every planned sample 
    2870 +                * attempt actually gets used, due to the way the retry 
    2871 +                * chain is set up - [max_tp,sample,prob,lowest] for 
    2872 +                * sample_rate < max_tp. 
    2873 +                * 
    2874 +                * If there's too much sampling backlog and the link 
    2875 +                * starts getting worse, minstrel would start bursting 
    2876 +                * out lots of sampling frames, which would result 
    2877 +                * in a large throughput loss. */ 
    2878 +               mi->sample_count += (delta - mi->n_rates * 2); 
    2879 +       } 
    2880 + 
    2881 +       /* get next random rate sample */ 
    2882 +       ndx = minstrel_get_next_sample(mi); 
    2883 +       msr = &mi->r[ndx]; 
    2884 +       mr = &mi->r[mi->max_tp_rate[0]]; 
    2885 + 
    2886 +       /* Decide if direct ( 1st mrr stage) or indirect (2nd mrr stage) 
    2887 +        * rate sampling method should be used. 
    2888 +        * Respect such rates that are not sampled for 20 interations. 
    2889 +        */ 
    2890 +       if (mrr_capable && 
    2891 +           msr->perfect_tx_time > mr->perfect_tx_time && 
    2892 +           msr->sample_skipped < 20) { 
    2893 +               /* Only use IEEE80211_TX_CTL_RATE_CTRL_PROBE to mark 
    2894 +                * packets that have the sampling rate deferred to the 
    2895 +                * second MRR stage. Increase the sample counter only 
    2896 +                * if the deferred sample rate was actually used. 
    2897 +                * Use the sample_deferred counter to make sure that 
    2898 +                * the sampling is not done in large bursts */ 
    2899 +               info->flags |= IEEE80211_TX_CTL_RATE_CTRL_PROBE; 
    2900 +               rate++; 
    2901 +               mi->sample_deferred++; 
    2902 +       } else { 
    2903 +               if (!msr->sample_limit != 0) 
    2904 +                       return; 
    2905 + 
    2906 +               mi->sample_count++; 
    2907 +               if (msr->sample_limit > 0) 
    2908 +                       msr->sample_limit--; 
    2909         } 
    2910 -       mi->prev_sample = rate_sampling; 
    2911   
    2912         /* If we're not using MRR and the sampling rate already 
    2913          * has a probability of >95%, we shouldn't be attempting 
    2914          * to use it, as this only wastes precious airtime */ 
    2915 -       if (!mrr_capable && rate_sampling && 
    2916 +       if (!mrr_capable && 
    2917            (mi->r[ndx].probability > MINSTREL_FRAC(95, 100))) 
    2918 -               ndx = mi->max_tp_rate[0]; 
    2919 - 
    2920 -       /* mrr setup for 1st stage */ 
    2921 -       ar[0].idx = mi->r[ndx].rix; 
    2922 -       ar[0].count = minstrel_get_retry_count(&mi->r[ndx], info); 
    2923 - 
    2924 -       /* non mrr setup for 2nd stage */ 
    2925 -       if (!mrr_capable) { 
    2926 -               if (!rate_sampling) 
    2927 -                       ar[0].count = mp->max_retry; 
    2928 -               ar[1].idx = mi->lowest_rix; 
    2929 -               ar[1].count = mp->max_retry; 
    2930                 return; 
    2931 -       } 
    2932   
    2933 -       /* mrr setup for 2nd stage */ 
    2934 -       if (rate_sampling) { 
    2935 -               if (indirect_rate_sampling) 
    2936 -                       mrr_ndx[0] = sample_ndx; 
    2937 -               else 
    2938 -                       mrr_ndx[0] = mi->max_tp_rate[0]; 
    2939 -       } else { 
    2940 -               mrr_ndx[0] = mi->max_tp_rate[1]; 
    2941 -       } 
    2942 +       mi->prev_sample = true; 
    2943   
    2944 -       /* mrr setup for 3rd & 4th stage */ 
    2945 -       mrr_ndx[1] = mi->max_prob_rate; 
    2946 -       mrr_ndx[2] = 0; 
    2947 -       for (i = 1; i < 4; i++) { 
    2948 -               ar[i].idx = mi->r[mrr_ndx[i - 1]].rix; 
    2949 -               ar[i].count = mi->r[mrr_ndx[i - 1]].adjusted_retry_count; 
    2950 -       } 
    2951 +       rate->idx = mi->r[ndx].rix; 
    2952 +       rate->count = minstrel_get_retry_count(&mi->r[ndx], info); 
    2953  } 
    2954   
    2955   
    2956 @@ -412,12 +425,16 @@ minstrel_rate_init(void *priv, struct ie 
    2957         unsigned int i, n = 0; 
    2958         unsigned int t_slot = 9; /* FIXME: get real slot time */ 
    2959   
    2960 +       mi->sta = sta; 
    2961         mi->lowest_rix = rate_lowest_index(sband, sta); 
    2962         ctl_rate = &sband->bitrates[mi->lowest_rix]; 
    2963         mi->sp_ack_dur = ieee80211_frame_duration(sband->band, 10, 
    2964                                 ctl_rate->bitrate, 
    2965                                 !!(ctl_rate->flags & IEEE80211_RATE_ERP_G), 1); 
    2966   
    2967 +       memset(mi->max_tp_rate, 0, sizeof(mi->max_tp_rate)); 
    2968 +       mi->max_prob_rate = 0; 
    2969 + 
    2970         for (i = 0; i < sband->n_bitrates; i++) { 
    2971                 struct minstrel_rate *mr = &mi->r[n]; 
    2972                 unsigned int tx_time = 0, tx_time_cts = 0, tx_time_rtscts = 0; 
    2973 @@ -460,6 +477,8 @@ minstrel_rate_init(void *priv, struct ie 
    2974                 } while ((tx_time < mp->segment_size) && 
    2975                                 (++mr->retry_count < mp->max_retry)); 
    2976                 mr->adjusted_retry_count = mr->retry_count; 
    2977 +               if (!(sband->bitrates[i].flags & IEEE80211_RATE_ERP_G)) 
    2978 +                       mr->retry_count_cts = mr->retry_count; 
    2979         } 
    2980   
    2981         for (i = n; i < sband->n_bitrates; i++) { 
    2982 @@ -471,6 +490,7 @@ minstrel_rate_init(void *priv, struct ie 
    2983         mi->stats_update = jiffies; 
    2984   
    2985         init_sample_table(mi); 
    2986 +       minstrel_update_rates(mp, mi); 
    2987  } 
    2988   
    2989  static void * 
    2990 --- a/net/mac80211/rc80211_minstrel.h 
    2991 +++ b/net/mac80211/rc80211_minstrel.h 
    2992 @@ -9,7 +9,8 @@ 
    2993  #ifndef __RC_MINSTREL_H 
    2994  #define __RC_MINSTREL_H 
    2995   
    2996 -#define EWMA_LEVEL     75      /* ewma weighting factor [%] */ 
    2997 +#define EWMA_LEVEL     96      /* ewma weighting factor [/EWMA_DIV] */ 
    2998 +#define EWMA_DIV       128 
    2999  #define SAMPLE_COLUMNS 10      /* number of columns in sample table */ 
    3000   
    3001   
    3002 @@ -27,7 +28,7 @@ 
    3003  static inline int 
    3004  minstrel_ewma(int old, int new, int weight) 
    3005  { 
    3006 -       return (new * (100 - weight) + old * weight) / 100; 
    3007 +       return (new * (EWMA_DIV - weight) + old * weight) / EWMA_DIV; 
    3008  } 
    3009   
    3010   
    3011 @@ -62,6 +63,8 @@ struct minstrel_rate { 
    3012  }; 
    3013   
    3014  struct minstrel_sta_info { 
    3015 +       struct ieee80211_sta *sta; 
    3016 + 
    3017         unsigned long stats_update; 
    3018         unsigned int sp_ack_dur; 
    3019         unsigned int rate_avg; 
    3020 --- a/net/mac80211/rc80211_minstrel_debugfs.c 
    3021 +++ b/net/mac80211/rc80211_minstrel_debugfs.c 
    3022 @@ -68,7 +68,7 @@ minstrel_stats_open(struct inode *inode, 
    3023   
    3024         file->private_data = ms; 
    3025         p = ms->buf; 
    3026 -       p += sprintf(p, "rate     throughput  ewma prob   this prob  " 
    3027 +       p += sprintf(p, "rate      throughput  ewma prob  this prob  " 
    3028                         "this succ/attempt   success    attempts\n"); 
    3029         for (i = 0; i < mi->n_rates; i++) { 
    3030                 struct minstrel_rate *mr = &mi->r[i]; 
    3031 @@ -86,7 +86,7 @@ minstrel_stats_open(struct inode *inode, 
    3032                 eprob = MINSTREL_TRUNC(mr->probability * 1000); 
    3033   
    3034                 p += sprintf(p, "  %6u.%1u   %6u.%1u   %6u.%1u        " 
    3035 -                               "%3u(%3u)   %8llu    %8llu\n", 
    3036 +                               "   %3u(%3u)  %8llu    %8llu\n", 
    3037                                 tp / 10, tp % 10, 
    3038                                 eprob / 10, eprob % 10, 
    3039                                 prob / 10, prob % 10, 
    3040 --- a/net/mac80211/rc80211_minstrel_ht.c 
    3041 +++ b/net/mac80211/rc80211_minstrel_ht.c 
    3042 @@ -126,6 +126,9 @@ const struct mcs_group minstrel_mcs_grou 
    3043   
    3044  static u8 sample_table[SAMPLE_COLUMNS][MCS_GROUP_RATES]; 
    3045   
    3046 +static void 
    3047 +minstrel_ht_update_rates(struct minstrel_priv *mp, struct minstrel_ht_sta *mi); 
    3048 + 
    3049  /* 
    3050   * Look up an MCS group index based on mac80211 rate information 
    3051   */ 
    3052 @@ -244,6 +247,7 @@ minstrel_ht_update_stats(struct minstrel 
    3053         struct minstrel_rate_stats *mr; 
    3054         int cur_prob, cur_prob_tp, cur_tp, cur_tp2; 
    3055         int group, i, index; 
    3056 +       bool mi_rates_valid = false; 
    3057   
    3058         if (mi->ampdu_packets > 0) { 
    3059                 mi->avg_ampdu_len = minstrel_ewma(mi->avg_ampdu_len, 
    3060 @@ -254,11 +258,10 @@ minstrel_ht_update_stats(struct minstrel 
    3061   
    3062         mi->sample_slow = 0; 
    3063         mi->sample_count = 0; 
    3064 -       mi->max_tp_rate = 0; 
    3065 -       mi->max_tp_rate2 = 0; 
    3066 -       mi->max_prob_rate = 0; 
    3067   
    3068         for (group = 0; group < ARRAY_SIZE(minstrel_mcs_groups); group++) { 
    3069 +               bool mg_rates_valid = false; 
    3070 + 
    3071                 cur_prob = 0; 
    3072                 cur_prob_tp = 0; 
    3073                 cur_tp = 0; 
    3074 @@ -268,15 +271,24 @@ minstrel_ht_update_stats(struct minstrel 
    3075                 if (!mg->supported) 
    3076                         continue; 
    3077   
    3078 -               mg->max_tp_rate = 0; 
    3079 -               mg->max_tp_rate2 = 0; 
    3080 -               mg->max_prob_rate = 0; 
    3081                 mi->sample_count++; 
    3082   
    3083                 for (i = 0; i < MCS_GROUP_RATES; i++) { 
    3084                         if (!(mg->supported & BIT(i))) 
    3085                                 continue; 
    3086   
    3087 +                       /* initialize rates selections starting indexes */ 
    3088 +                       if (!mg_rates_valid) { 
    3089 +                               mg->max_tp_rate = mg->max_tp_rate2 = 
    3090 +                                       mg->max_prob_rate = i; 
    3091 +                               if (!mi_rates_valid) { 
    3092 +                                       mi->max_tp_rate = mi->max_tp_rate2 = 
    3093 +                                               mi->max_prob_rate = i; 
    3094 +                                       mi_rates_valid = true; 
    3095 +                               } 
    3096 +                               mg_rates_valid = true; 
    3097 +                       } 
    3098 + 
    3099                         mr = &mg->rates[i]; 
    3100                         mr->retry_updated = false; 
    3101                         index = MCS_GROUP_RATES * group + i; 
    3102 @@ -456,7 +468,7 @@ minstrel_ht_tx_status(void *priv, struct 
    3103         struct ieee80211_tx_rate *ar = info->status.rates; 
    3104         struct minstrel_rate_stats *rate, *rate2; 
    3105         struct minstrel_priv *mp = priv; 
    3106 -       bool last; 
    3107 +       bool last, update = false; 
    3108         int i; 
    3109   
    3110         if (!msp->is_ht) 
    3111 @@ -505,21 +517,29 @@ minstrel_ht_tx_status(void *priv, struct 
    3112         rate = minstrel_get_ratestats(mi, mi->max_tp_rate); 
    3113         if (rate->attempts > 30 && 
    3114             MINSTREL_FRAC(rate->success, rate->attempts) < 
    3115 -           MINSTREL_FRAC(20, 100)) 
    3116 +           MINSTREL_FRAC(20, 100)) { 
    3117                 minstrel_downgrade_rate(mi, &mi->max_tp_rate, true); 
    3118 +               update = true; 
    3119 +       } 
    3120   
    3121         rate2 = minstrel_get_ratestats(mi, mi->max_tp_rate2); 
    3122         if (rate2->attempts > 30 && 
    3123             MINSTREL_FRAC(rate2->success, rate2->attempts) < 
    3124 -           MINSTREL_FRAC(20, 100)) 
    3125 +           MINSTREL_FRAC(20, 100)) { 
    3126                 minstrel_downgrade_rate(mi, &mi->max_tp_rate2, false); 
    3127 +               update = true; 
    3128 +       } 
    3129   
    3130         if (time_after(jiffies, mi->stats_update + (mp->update_interval / 2 * HZ) / 1000)) { 
    3131 +               update = true; 
    3132                 minstrel_ht_update_stats(mp, mi); 
    3133                 if (!(info->flags & IEEE80211_TX_CTL_AMPDU) && 
    3134                     mi->max_prob_rate / MCS_GROUP_RATES != MINSTREL_CCK_GROUP) 
    3135                         minstrel_aggr_check(sta, skb); 
    3136         } 
    3137 + 
    3138 +       if (update) 
    3139 +               minstrel_ht_update_rates(mp, mi); 
    3140  } 
    3141   
    3142  static void 
    3143 @@ -580,39 +600,73 @@ minstrel_calc_retransmit(struct minstrel 
    3144                  (++mr->retry_count < mp->max_retry)); 
    3145  } 
    3146   
    3147 - 
    3148  static void 
    3149  minstrel_ht_set_rate(struct minstrel_priv *mp, struct minstrel_ht_sta *mi, 
    3150 -                     struct ieee80211_tx_rate *rate, int index, 
    3151 -                     bool sample, bool rtscts) 
    3152 +                     struct ieee80211_sta_rates *ratetbl, int offset, int index) 
    3153  { 
    3154         const struct mcs_group *group = &minstrel_mcs_groups[index / MCS_GROUP_RATES]; 
    3155         struct minstrel_rate_stats *mr; 
    3156 +       u8 idx; 
    3157 +       u16 flags; 
    3158   
    3159         mr = minstrel_get_ratestats(mi, index); 
    3160         if (!mr->retry_updated) 
    3161                 minstrel_calc_retransmit(mp, mi, index); 
    3162   
    3163 -       if (sample) 
    3164 -               rate->count = 1; 
    3165 -       else if (mr->probability < MINSTREL_FRAC(20, 100)) 
    3166 -               rate->count = 2; 
    3167 -       else if (rtscts) 
    3168 -               rate->count = mr->retry_count_rtscts; 
    3169 -       else 
    3170 -               rate->count = mr->retry_count; 
    3171 - 
    3172 -       rate->flags = 0; 
    3173 -       if (rtscts) 
    3174 -               rate->flags |= IEEE80211_TX_RC_USE_RTS_CTS; 
    3175 +       if (mr->probability < MINSTREL_FRAC(20, 100) || !mr->retry_count) { 
    3176 +               ratetbl->rate[offset].count = 2; 
    3177 +               ratetbl->rate[offset].count_rts = 2; 
    3178 +               ratetbl->rate[offset].count_cts = 2; 
    3179 +       } else { 
    3180 +               ratetbl->rate[offset].count = mr->retry_count; 
    3181 +               ratetbl->rate[offset].count_cts = mr->retry_count; 
    3182 +               ratetbl->rate[offset].count_rts = mr->retry_count_rtscts; 
    3183 +       } 
    3184   
    3185         if (index / MCS_GROUP_RATES == MINSTREL_CCK_GROUP) { 
    3186 -               rate->idx = mp->cck_rates[index % ARRAY_SIZE(mp->cck_rates)]; 
    3187 +               idx = mp->cck_rates[index % ARRAY_SIZE(mp->cck_rates)]; 
    3188 +               flags = 0; 
    3189 +       } else { 
    3190 +               idx = index % MCS_GROUP_RATES + 
    3191 +                     (group->streams - 1) * MCS_GROUP_RATES; 
    3192 +               flags = IEEE80211_TX_RC_MCS | group->flags; 
    3193 +       } 
    3194 + 
    3195 +       if (offset > 0) { 
    3196 +               ratetbl->rate[offset].count = ratetbl->rate[offset].count_rts; 
    3197 +               flags |= IEEE80211_TX_RC_USE_RTS_CTS; 
    3198 +       } 
    3199 + 
    3200 +       ratetbl->rate[offset].idx = idx; 
    3201 +       ratetbl->rate[offset].flags = flags; 
    3202 +} 
    3203 + 
    3204 +static void 
    3205 +minstrel_ht_update_rates(struct minstrel_priv *mp, struct minstrel_ht_sta *mi) 
    3206 +{ 
    3207 +       struct ieee80211_sta_rates *rates; 
    3208 +       int i = 0; 
    3209 + 
    3210 +       rates = kzalloc(sizeof(*rates), GFP_ATOMIC); 
    3211 +       if (!rates) 
    3212                 return; 
    3213 + 
    3214 +       /* Start with max_tp_rate */ 
    3215 +       minstrel_ht_set_rate(mp, mi, rates, i++, mi->max_tp_rate); 
    3216 + 
    3217 +       if (mp->hw->max_rates >= 3) { 
    3218 +               /* At least 3 tx rates supported, use max_tp_rate2 next */ 
    3219 +               minstrel_ht_set_rate(mp, mi, rates, i++, mi->max_tp_rate2); 
    3220 +       } 
    3221 + 
    3222 +       if (mp->hw->max_rates >= 2) { 
    3223 +               /* 
    3224 +                * At least 2 tx rates supported, use max_prob_rate next */ 
    3225 +               minstrel_ht_set_rate(mp, mi, rates, i++, mi->max_prob_rate); 
    3226         } 
    3227   
    3228 -       rate->flags |= IEEE80211_TX_RC_MCS | group->flags; 
    3229 -       rate->idx = index % MCS_GROUP_RATES + (group->streams - 1) * MCS_GROUP_RATES; 
    3230 +       rates->rate[i].idx = -1; 
    3231 +       rate_control_set_rates(mp->hw, mi->sta, rates); 
    3232  } 
    3233   
    3234  static inline int 
    3235 @@ -702,13 +756,13 @@ static void 
    3236  minstrel_ht_get_rate(void *priv, struct ieee80211_sta *sta, void *priv_sta, 
    3237                       struct ieee80211_tx_rate_control *txrc) 
    3238  { 
    3239 +       const struct mcs_group *sample_group; 
    3240         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb); 
    3241 -       struct ieee80211_tx_rate *ar = info->status.rates; 
    3242 +       struct ieee80211_tx_rate *rate = &info->status.rates[0]; 
    3243         struct minstrel_ht_sta_priv *msp = priv_sta; 
    3244         struct minstrel_ht_sta *mi = &msp->ht; 
    3245         struct minstrel_priv *mp = priv; 
    3246         int sample_idx; 
    3247 -       bool sample = false; 
    3248   
    3249         if (rate_control_send_low(sta, priv_sta, txrc)) 
    3250                 return; 
    3251 @@ -736,51 +790,6 @@ minstrel_ht_get_rate(void *priv, struct  
    3252         } 
    3253  #endif 
    3254   
    3255 -       if (sample_idx >= 0) { 
    3256 -               sample = true; 
    3257 -               minstrel_ht_set_rate(mp, mi, &ar[0], sample_idx, 
    3258 -                       true, false); 
    3259 -               info->flags |= IEEE80211_TX_CTL_RATE_CTRL_PROBE; 
    3260 -       } else { 
    3261 -               minstrel_ht_set_rate(mp, mi, &ar[0], mi->max_tp_rate, 
    3262 -                       false, false); 
    3263 -       } 
    3264 - 
    3265 -       if (mp->hw->max_rates >= 3) { 
    3266 -               /* 
    3267 -                * At least 3 tx rates supported, use 
    3268 -                * sample_rate -> max_tp_rate -> max_prob_rate for sampling and 
    3269 -                * max_tp_rate -> max_tp_rate2 -> max_prob_rate by default. 
    3270 -                */ 
    3271 -               if (sample_idx >= 0) 
    3272 -                       minstrel_ht_set_rate(mp, mi, &ar[1], mi->max_tp_rate, 
    3273 -                               false, false); 
    3274 -               else 
    3275 -                       minstrel_ht_set_rate(mp, mi, &ar[1], mi->max_tp_rate2, 
    3276 -                               false, true); 
    3277 - 
    3278 -               minstrel_ht_set_rate(mp, mi, &ar[2], mi->max_prob_rate, 
    3279 -                                    false, !sample); 
    3280 - 
    3281 -               ar[3].count = 0; 
    3282 -               ar[3].idx = -1; 
    3283 -       } else if (mp->hw->max_rates == 2) { 
    3284 -               /* 
    3285 -                * Only 2 tx rates supported, use 
    3286 -                * sample_rate -> max_prob_rate for sampling and 
    3287 -                * max_tp_rate -> max_prob_rate by default. 
    3288 -                */ 
    3289 -               minstrel_ht_set_rate(mp, mi, &ar[1], mi->max_prob_rate, 
    3290 -                                    false, !sample); 
    3291 - 
    3292 -               ar[2].count = 0; 
    3293 -               ar[2].idx = -1; 
    3294 -       } else { 
    3295 -               /* Not using MRR, only use the first rate */ 
    3296 -               ar[1].count = 0; 
    3297 -               ar[1].idx = -1; 
    3298 -       } 
    3299 - 
    3300         mi->total_packets++; 
    3301   
    3302         /* wraparound */ 
    3303 @@ -788,6 +797,16 @@ minstrel_ht_get_rate(void *priv, struct  
    3304                 mi->total_packets = 0; 
    3305                 mi->sample_packets = 0; 
    3306         } 
    3307 + 
    3308 +       if (sample_idx < 0) 
    3309 +               return; 
    3310 + 
    3311 +       sample_group = &minstrel_mcs_groups[sample_idx / MCS_GROUP_RATES]; 
    3312 +       info->flags |= IEEE80211_TX_CTL_RATE_CTRL_PROBE; 
    3313 +       rate->idx = sample_idx % MCS_GROUP_RATES + 
    3314 +                   (sample_group->streams - 1) * MCS_GROUP_RATES; 
    3315 +       rate->flags = IEEE80211_TX_RC_MCS | sample_group->flags; 
    3316 +       rate->count = 1; 
    3317  } 
    3318   
    3319  static void 
    3320 @@ -837,6 +856,8 @@ minstrel_ht_update_caps(void *priv, stru 
    3321   
    3322         msp->is_ht = true; 
    3323         memset(mi, 0, sizeof(*mi)); 
    3324 + 
    3325 +       mi->sta = sta; 
    3326         mi->stats_update = jiffies; 
    3327   
    3328         ack_dur = ieee80211_frame_duration(sband->band, 10, 60, 1, 1); 
    3329 @@ -898,6 +919,9 @@ minstrel_ht_update_caps(void *priv, stru 
    3330         if (!n_supported) 
    3331                 goto use_legacy; 
    3332   
    3333 +       minstrel_ht_update_stats(mp, mi); 
    3334 +       minstrel_ht_update_rates(mp, mi); 
    3335 + 
    3336         return; 
    3337   
    3338  use_legacy: 
    3339 --- a/net/mac80211/rc80211_minstrel_ht.h 
    3340 +++ b/net/mac80211/rc80211_minstrel_ht.h 
    3341 @@ -65,6 +65,8 @@ struct minstrel_mcs_group_data { 
    3342  }; 
    3343   
    3344  struct minstrel_ht_sta { 
    3345 +       struct ieee80211_sta *sta; 
    3346 + 
    3347         /* ampdu length (average, per sampling interval) */ 
    3348         unsigned int ampdu_len; 
    3349         unsigned int ampdu_packets; 
    3350201--- a/net/mac80211/rx.c 
    3351202+++ b/net/mac80211/rx.c 
    3352 @@ -1372,6 +1372,7 @@ ieee80211_rx_h_sta_process(struct ieee80 
    3353         struct sk_buff *skb = rx->skb; 
    3354         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 
    3355         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 
    3356 +       int i; 
    3357   
    3358         if (!sta) 
    3359                 return RX_CONTINUE; 
    3360 @@ -1422,6 +1423,19 @@ ieee80211_rx_h_sta_process(struct ieee80 
    3361                 ewma_add(&sta->avg_signal, -status->signal); 
    3362         } 
    3363   
    3364 +       if (status->chains) { 
    3365 +               sta->chains = status->chains; 
    3366 +               for (i = 0; i < ARRAY_SIZE(status->chain_signal); i++) { 
    3367 +                       int signal = status->chain_signal[i]; 
    3368 + 
    3369 +                       if (!(status->chains & BIT(i))) 
    3370 +                               continue; 
    3371 + 
    3372 +                       sta->chain_signal_last[i] = signal; 
    3373 +                       ewma_add(&sta->chain_signal_avg[i], -signal); 
    3374 +               } 
    3375 +       } 
    3376 + 
    3377         /* 
    3378          * Change STA power saving mode only at the end of a frame 
    3379          * exchange sequence. 
    3380 @@ -2085,6 +2099,7 @@ ieee80211_rx_h_mesh_fwding(struct ieee80 
    3381         } 
    3382   
    3383         fwd_hdr =  (struct ieee80211_hdr *) fwd_skb->data; 
    3384 +       fwd_hdr->frame_control &= ~cpu_to_le16(IEEE80211_FCTL_RETRY); 
    3385         info = IEEE80211_SKB_CB(fwd_skb); 
    3386         memset(info, 0, sizeof(*info)); 
    3387         info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING; 
    3388 @@ -2356,6 +2371,7 @@ ieee80211_rx_h_action(struct ieee80211_r 
     203@@ -2369,6 +2369,7 @@ ieee80211_rx_h_action(struct ieee80211_r 
    3389204                    sdata->vif.type != NL80211_IFTYPE_MESH_POINT && 
    3390205                    sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 
     
    3394209                        break; 
    3395210  
    3396 @@ -2423,6 +2439,22 @@ ieee80211_rx_h_action(struct ieee80211_r 
    3397                 } 
    3398   
    3399                 break; 
    3400 +       case WLAN_CATEGORY_PUBLIC: 
    3401 +               if (len < IEEE80211_MIN_ACTION_SIZE + 1) 
    3402 +                       goto invalid; 
    3403 +               if (sdata->vif.type != NL80211_IFTYPE_STATION) 
    3404 +                       break; 
    3405 +               if (!rx->sta) 
    3406 +                       break; 
    3407 +               if (!ether_addr_equal(mgmt->bssid, sdata->u.mgd.bssid)) 
    3408 +                       break; 
    3409 +               if (mgmt->u.action.u.ext_chan_switch.action_code != 
    3410 +                               WLAN_PUB_ACTION_EXT_CHANSW_ANN) 
    3411 +                       break; 
    3412 +               if (len < offsetof(struct ieee80211_mgmt, 
    3413 +                                  u.action.u.ext_chan_switch.variable)) 
    3414 +                       goto invalid; 
    3415 +               goto queue; 
    3416         case WLAN_CATEGORY_VHT: 
    3417                 if (sdata->vif.type != NL80211_IFTYPE_STATION && 
    3418                     sdata->vif.type != NL80211_IFTYPE_MESH_POINT && 
    3419 @@ -2506,10 +2538,6 @@ ieee80211_rx_h_action(struct ieee80211_r 
    3420                         ieee80211_process_measurement_req(sdata, mgmt, len); 
    3421                         goto handled; 
    3422                 case WLAN_ACTION_SPCT_CHL_SWITCH: 
    3423 -                       if (len < (IEEE80211_MIN_ACTION_SIZE + 
    3424 -                                  sizeof(mgmt->u.action.u.chan_switch))) 
    3425 -                               break; 
    3426 - 
    3427                         if (sdata->vif.type != NL80211_IFTYPE_STATION) 
    3428                                 break; 
    3429   
    3430 @@ -2695,14 +2723,15 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_ 
     211@@ -2720,14 +2721,15 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_ 
    3431212  
    3432213        if (!ieee80211_vif_is_mesh(&sdata->vif) && 
     
    3446227        case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP): 
    3447228        case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP): 
    3448 @@ -3023,6 +3052,9 @@ static int prepare_for_handlers(struct i 
    3449                          * and location updates. Note that mac80211 
    3450                          * itself never looks at these frames. 
    3451                          */ 
    3452 +                       if (!multicast && 
    3453 +                           !ether_addr_equal(sdata->vif.addr, hdr->addr1)) 
    3454 +                               return 0; 
    3455                         if (ieee80211_is_public_action(hdr, skb->len)) 
    3456                                 return 1; 
    3457                         if (!ieee80211_is_beacon(hdr->frame_control)) 
    3458 @@ -3031,10 +3063,16 @@ static int prepare_for_handlers(struct i 
     229@@ -3059,10 +3061,16 @@ static int prepare_for_handlers(struct i 
    3459230                } 
    3460231                break; 
     
    3475246        case NL80211_IFTYPE_P2P_DEVICE: 
    3476247                if (!ieee80211_is_public_action(hdr, skb->len) && 
    3477 --- a/net/mac80211/scan.c 
    3478 +++ b/net/mac80211/scan.c 
    3479 @@ -181,7 +181,7 @@ void ieee80211_scan_rx(struct ieee80211_ 
    3480         if (baselen > skb->len) 
    3481                 return; 
    3482   
    3483 -       ieee802_11_parse_elems(elements, skb->len - baselen, &elems); 
    3484 +       ieee802_11_parse_elems(elements, skb->len - baselen, false, &elems); 
    3485   
    3486         channel = ieee80211_get_channel(local->hw.wiphy, rx_status->freq); 
    3487   
     248--- a/net/mac80211/sta_info.c 
     249+++ b/net/mac80211/sta_info.c 
     250@@ -149,6 +149,7 @@ static void cleanup_single_sta(struct st 
     251         * directly by station destruction. 
     252         */ 
     253        for (i = 0; i < IEEE80211_NUM_TIDS; i++) { 
     254+               kfree(sta->ampdu_mlme.tid_start_tx[i]); 
     255                tid_tx = rcu_dereference_raw(sta->ampdu_mlme.tid_tx[i]); 
     256                if (!tid_tx) 
     257                        continue; 
    3488258--- a/net/mac80211/sta_info.h 
    3489259+++ b/net/mac80211/sta_info.h 
     
    3504274        WLAN_STA_MFP, 
    3505275        WLAN_STA_BLOCK_BA, 
    3506 @@ -344,6 +342,11 @@ struct sta_info { 
    3507         int last_signal; 
    3508         struct ewma avg_signal; 
    3509         int last_ack_signal; 
    3510 + 
    3511 +       u8 chains; 
    3512 +       s8 chain_signal_last[IEEE80211_MAX_CHAINS]; 
    3513 +       struct ewma chain_signal_avg[IEEE80211_MAX_CHAINS]; 
    3514 + 
    3515         /* Plus 1 for non-QoS frames */ 
    3516         __le16 last_seq_ctrl[IEEE80211_NUM_TIDS + 1]; 
    3517   
    3518 --- a/net/mac80211/trace.h 
    3519 +++ b/net/mac80211/trace.h 
    3520 @@ -990,23 +990,23 @@ TRACE_EVENT(drv_channel_switch, 
    3521   
    3522         TP_STRUCT__entry( 
    3523                 LOCAL_ENTRY 
    3524 +               CHANDEF_ENTRY 
    3525                 __field(u64, timestamp) 
    3526                 __field(bool, block_tx) 
    3527 -               __field(u16, freq) 
    3528                 __field(u8, count) 
    3529         ), 
    3530   
    3531         TP_fast_assign( 
    3532                 LOCAL_ASSIGN; 
    3533 +               CHANDEF_ASSIGN(&ch_switch->chandef) 
    3534                 __entry->timestamp = ch_switch->timestamp; 
    3535                 __entry->block_tx = ch_switch->block_tx; 
    3536 -               __entry->freq = ch_switch->channel->center_freq; 
    3537                 __entry->count = ch_switch->count; 
    3538         ), 
    3539   
    3540         TP_printk( 
    3541 -               LOCAL_PR_FMT " new freq:%u count:%d", 
    3542 -               LOCAL_PR_ARG, __entry->freq, __entry->count 
    3543 +               LOCAL_PR_FMT " new " CHANDEF_PR_FMT " count:%d", 
    3544 +               LOCAL_PR_ARG, CHANDEF_PR_ARG, __entry->count 
    3545         ) 
    3546  ); 
    3547   
    3548 --- a/net/mac80211/tx.c 
    3549 +++ b/net/mac80211/tx.c 
    3550 @@ -48,15 +48,15 @@ static __le16 ieee80211_duration(struct  
    3551         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 
    3552   
    3553         /* assume HW handles this */ 
    3554 -       if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS) 
    3555 +       if (tx->rate.flags & IEEE80211_TX_RC_MCS) 
    3556                 return 0; 
    3557   
    3558         /* uh huh? */ 
    3559 -       if (WARN_ON_ONCE(info->control.rates[0].idx < 0)) 
    3560 +       if (WARN_ON_ONCE(tx->rate.idx < 0)) 
    3561                 return 0; 
    3562   
    3563         sband = local->hw.wiphy->bands[info->band]; 
    3564 -       txrate = &sband->bitrates[info->control.rates[0].idx]; 
    3565 +       txrate = &sband->bitrates[tx->rate.idx]; 
    3566   
    3567         erp = txrate->flags & IEEE80211_RATE_ERP_G; 
    3568   
    3569 @@ -617,11 +617,9 @@ ieee80211_tx_h_rate_ctrl(struct ieee8021 
    3570         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); 
    3571         struct ieee80211_hdr *hdr = (void *)tx->skb->data; 
    3572         struct ieee80211_supported_band *sband; 
    3573 -       struct ieee80211_rate *rate; 
    3574 -       int i; 
    3575         u32 len; 
    3576 -       bool inval = false, rts = false, short_preamble = false; 
    3577         struct ieee80211_tx_rate_control txrc; 
    3578 +       struct ieee80211_sta_rates *ratetbl = NULL; 
    3579         bool assoc = false; 
    3580   
    3581         memset(&txrc, 0, sizeof(txrc)); 
    3582 @@ -642,18 +640,23 @@ ieee80211_tx_h_rate_ctrl(struct ieee8021 
    3583                 txrc.max_rate_idx = -1; 
    3584         else 
    3585                 txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1; 
    3586 -       memcpy(txrc.rate_idx_mcs_mask, 
    3587 -              tx->sdata->rc_rateidx_mcs_mask[info->band], 
    3588 -              sizeof(txrc.rate_idx_mcs_mask)); 
    3589 + 
    3590 +       if (tx->sdata->rc_has_mcs_mask[info->band]) 
    3591 +               txrc.rate_idx_mcs_mask = 
    3592 +                       tx->sdata->rc_rateidx_mcs_mask[info->band]; 
    3593 + 
    3594         txrc.bss = (tx->sdata->vif.type == NL80211_IFTYPE_AP || 
    3595                     tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT || 
    3596                     tx->sdata->vif.type == NL80211_IFTYPE_ADHOC); 
    3597   
    3598         /* set up RTS protection if desired */ 
    3599         if (len > tx->local->hw.wiphy->rts_threshold) { 
    3600 -               txrc.rts = rts = true; 
    3601 +               txrc.rts = true; 
    3602         } 
    3603   
    3604 +       info->control.use_rts = txrc.rts; 
    3605 +       info->control.use_cts_prot = tx->sdata->vif.bss_conf.use_cts_prot; 
    3606 + 
    3607         /* 
    3608          * Use short preamble if the BSS can handle it, but not for 
    3609          * management frames unless we know the receiver can handle 
    3610 @@ -663,7 +666,9 @@ ieee80211_tx_h_rate_ctrl(struct ieee8021 
    3611         if (tx->sdata->vif.bss_conf.use_short_preamble && 
    3612             (ieee80211_is_data(hdr->frame_control) || 
    3613              (tx->sta && test_sta_flag(tx->sta, WLAN_STA_SHORT_PREAMBLE)))) 
    3614 -               txrc.short_preamble = short_preamble = true; 
    3615 +               txrc.short_preamble = true; 
    3616 + 
    3617 +       info->control.short_preamble = txrc.short_preamble; 
    3618   
    3619         if (tx->sta) 
    3620                 assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC); 
    3621 @@ -687,16 +692,38 @@ ieee80211_tx_h_rate_ctrl(struct ieee8021 
    3622          */ 
    3623         rate_control_get_rate(tx->sdata, tx->sta, &txrc); 
    3624   
    3625 -       if (unlikely(info->control.rates[0].idx < 0)) 
    3626 -               return TX_DROP; 
    3627 +       if (tx->sta && !info->control.skip_table) 
    3628 +               ratetbl = rcu_dereference(tx->sta->sta.rates); 
    3629 + 
    3630 +       if (unlikely(info->control.rates[0].idx < 0)) { 
    3631 +               if (ratetbl) { 
    3632 +                       struct ieee80211_tx_rate rate = { 
    3633 +                               .idx = ratetbl->rate[0].idx, 
    3634 +                               .flags = ratetbl->rate[0].flags, 
    3635 +                               .count = ratetbl->rate[0].count 
    3636 +                       }; 
    3637 + 
    3638 +                       if (ratetbl->rate[0].idx < 0) 
    3639 +                               return TX_DROP; 
    3640 + 
    3641 +                       tx->rate = rate; 
    3642 +               } else { 
    3643 +                       return TX_DROP; 
    3644 +               } 
    3645 +       } else { 
    3646 +               tx->rate = info->control.rates[0]; 
    3647 +       } 
    3648   
    3649         if (txrc.reported_rate.idx < 0) { 
    3650 -               txrc.reported_rate = info->control.rates[0]; 
    3651 +               txrc.reported_rate = tx->rate; 
    3652                 if (tx->sta && ieee80211_is_data(hdr->frame_control)) 
    3653                         tx->sta->last_tx_rate = txrc.reported_rate; 
    3654         } else if (tx->sta) 
    3655                 tx->sta->last_tx_rate = txrc.reported_rate; 
    3656   
    3657 +       if (ratetbl) 
    3658 +               return TX_CONTINUE; 
    3659 + 
    3660         if (unlikely(!info->control.rates[0].count)) 
    3661                 info->control.rates[0].count = 1; 
    3662   
    3663 @@ -704,91 +731,6 @@ ieee80211_tx_h_rate_ctrl(struct ieee8021 
    3664                          (info->flags & IEEE80211_TX_CTL_NO_ACK))) 
    3665                 info->control.rates[0].count = 1; 
    3666   
    3667 -       if (is_multicast_ether_addr(hdr->addr1)) { 
    3668 -               /* 
    3669 -                * XXX: verify the rate is in the basic rateset 
    3670 -                */ 
    3671 -               return TX_CONTINUE; 
    3672 -       } 
    3673 - 
    3674 -       /* 
    3675 -        * set up the RTS/CTS rate as the fastest basic rate 
    3676 -        * that is not faster than the data rate 
    3677 -        * 
    3678 -        * XXX: Should this check all retry rates? 
    3679 -        */ 
    3680 -       if (!(info->control.rates[0].flags & IEEE80211_TX_RC_MCS)) { 
    3681 -               s8 baserate = 0; 
    3682 - 
    3683 -               rate = &sband->bitrates[info->control.rates[0].idx]; 
    3684 - 
    3685 -               for (i = 0; i < sband->n_bitrates; i++) { 
    3686 -                       /* must be a basic rate */ 
    3687 -                       if (!(tx->sdata->vif.bss_conf.basic_rates & BIT(i))) 
    3688 -                               continue; 
    3689 -                       /* must not be faster than the data rate */ 
    3690 -                       if (sband->bitrates[i].bitrate > rate->bitrate) 
    3691 -                               continue; 
    3692 -                       /* maximum */ 
    3693 -                       if (sband->bitrates[baserate].bitrate < 
    3694 -                            sband->bitrates[i].bitrate) 
    3695 -                               baserate = i; 
    3696 -               } 
    3697 - 
    3698 -               info->control.rts_cts_rate_idx = baserate; 
    3699 -       } 
    3700 - 
    3701 -       for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) { 
    3702 -               /* 
    3703 -                * make sure there's no valid rate following 
    3704 -                * an invalid one, just in case drivers don't 
    3705 -                * take the API seriously to stop at -1. 
    3706 -                */ 
    3707 -               if (inval) { 
    3708 -                       info->control.rates[i].idx = -1; 
    3709 -                       continue; 
    3710 -               } 
    3711 -               if (info->control.rates[i].idx < 0) { 
    3712 -                       inval = true; 
    3713 -                       continue; 
    3714 -               } 
    3715 - 
    3716 -               /* 
    3717 -                * For now assume MCS is already set up correctly, this 
    3718 -                * needs to be fixed. 
    3719 -                */ 
    3720 -               if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS) { 
    3721 -                       WARN_ON(info->control.rates[i].idx > 76); 
    3722 -                       continue; 
    3723 -               } 
    3724 - 
    3725 -               /* set up RTS protection if desired */ 
    3726 -               if (rts) 
    3727 -                       info->control.rates[i].flags |= 
    3728 -                               IEEE80211_TX_RC_USE_RTS_CTS; 
    3729 - 
    3730 -               /* RC is busted */ 
    3731 -               if (WARN_ON_ONCE(info->control.rates[i].idx >= 
    3732 -                                sband->n_bitrates)) { 
    3733 -                       info->control.rates[i].idx = -1; 
    3734 -                       continue; 
    3735 -               } 
    3736 - 
    3737 -               rate = &sband->bitrates[info->control.rates[i].idx]; 
    3738 - 
    3739 -               /* set up short preamble */ 
    3740 -               if (short_preamble && 
    3741 -                   rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) 
    3742 -                       info->control.rates[i].flags |= 
    3743 -                               IEEE80211_TX_RC_USE_SHORT_PREAMBLE; 
    3744 - 
    3745 -               /* set up G protection */ 
    3746 -               if (!rts && tx->sdata->vif.bss_conf.use_cts_prot && 
    3747 -                   rate->flags & IEEE80211_RATE_ERP_G) 
    3748 -                       info->control.rates[i].flags |= 
    3749 -                               IEEE80211_TX_RC_USE_CTS_PROTECT; 
    3750 -       } 
    3751 - 
    3752         return TX_CONTINUE; 
    3753  } 
    3754   
    3755 @@ -2508,8 +2450,6 @@ struct sk_buff *ieee80211_beacon_get_tim 
    3756                 txrc.max_rate_idx = -1; 
    3757         else 
    3758                 txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1; 
    3759 -       memcpy(txrc.rate_idx_mcs_mask, sdata->rc_rateidx_mcs_mask[band], 
    3760 -              sizeof(txrc.rate_idx_mcs_mask)); 
    3761         txrc.bss = true; 
    3762         rate_control_get_rate(sdata, NULL, &txrc); 
    3763   
    3764 --- a/net/mac80211/util.c 
    3765 +++ b/net/mac80211/util.c 
    3766 @@ -485,7 +485,8 @@ int ieee80211_queue_stopped(struct ieee8 
    3767                 return true; 
    3768   
    3769         spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 
    3770 -       ret = !!local->queue_stop_reasons[queue]; 
    3771 +       ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER, 
    3772 +                      &local->queue_stop_reasons[queue]); 
    3773         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 
    3774         return ret; 
    3775  } 
    3776 @@ -559,6 +560,9 @@ void ieee80211_iterate_active_interfaces 
    3777         list_for_each_entry(sdata, &local->interfaces, list) { 
    3778                 switch (sdata->vif.type) { 
    3779                 case NL80211_IFTYPE_MONITOR: 
    3780 +                       if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE)) 
    3781 +                               continue; 
    3782 +                       break; 
    3783                 case NL80211_IFTYPE_AP_VLAN: 
    3784                         continue; 
    3785                 default: 
    3786 @@ -597,6 +601,9 @@ void ieee80211_iterate_active_interfaces 
    3787         list_for_each_entry_rcu(sdata, &local->interfaces, list) { 
    3788                 switch (sdata->vif.type) { 
    3789                 case NL80211_IFTYPE_MONITOR: 
    3790 +                       if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE)) 
    3791 +                               continue; 
    3792 +                       break; 
    3793                 case NL80211_IFTYPE_AP_VLAN: 
    3794                         continue; 
    3795                 default: 
    3796 @@ -660,7 +667,7 @@ void ieee80211_queue_delayed_work(struct 
    3797  } 
    3798  EXPORT_SYMBOL(ieee80211_queue_delayed_work); 
    3799   
    3800 -u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, 
    3801 +u32 ieee802_11_parse_elems_crc(u8 *start, size_t len, bool action, 
    3802                                struct ieee802_11_elems *elems, 
    3803                                u64 filter, u32 crc) 
    3804  { 
    3805 @@ -668,6 +675,7 @@ u32 ieee802_11_parse_elems_crc(u8 *start 
    3806         u8 *pos = start; 
    3807         bool calc_crc = filter != 0; 
    3808         DECLARE_BITMAP(seen_elems, 256); 
    3809 +       const u8 *ie; 
    3810   
    3811         bitmap_zero(seen_elems, 256); 
    3812         memset(elems, 0, sizeof(*elems)); 
    3813 @@ -715,6 +723,12 @@ u32 ieee802_11_parse_elems_crc(u8 *start 
    3814                 case WLAN_EID_COUNTRY: 
    3815                 case WLAN_EID_PWR_CONSTRAINT: 
    3816                 case WLAN_EID_TIMEOUT_INTERVAL: 
    3817 +               case WLAN_EID_SECONDARY_CHANNEL_OFFSET: 
    3818 +               case WLAN_EID_WIDE_BW_CHANNEL_SWITCH: 
    3819 +               /* 
    3820 +                * not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible 
    3821 +                * that if the content gets bigger it might be needed more than once 
    3822 +                */ 
    3823                         if (test_bit(id, seen_elems)) { 
    3824                                 elems->parse_error = true; 
    3825                                 left -= elen; 
    3826 @@ -862,6 +876,48 @@ u32 ieee802_11_parse_elems_crc(u8 *start 
    3827                         } 
    3828                         elems->ch_switch_ie = (void *)pos; 
    3829                         break; 
    3830 +               case WLAN_EID_EXT_CHANSWITCH_ANN: 
    3831 +                       if (elen != sizeof(struct ieee80211_ext_chansw_ie)) { 
    3832 +                               elem_parse_failed = true; 
    3833 +                               break; 
    3834 +                       } 
    3835 +                       elems->ext_chansw_ie = (void *)pos; 
    3836 +                       break; 
    3837 +               case WLAN_EID_SECONDARY_CHANNEL_OFFSET: 
    3838 +                       if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) { 
    3839 +                               elem_parse_failed = true; 
    3840 +                               break; 
    3841 +                       } 
    3842 +                       elems->sec_chan_offs = (void *)pos; 
    3843 +                       break; 
    3844 +               case WLAN_EID_WIDE_BW_CHANNEL_SWITCH: 
    3845 +                       if (!action || 
    3846 +                           elen != sizeof(*elems->wide_bw_chansw_ie)) { 
    3847 +                               elem_parse_failed = true; 
    3848 +                               break; 
    3849 +                       } 
    3850 +                       elems->wide_bw_chansw_ie = (void *)pos; 
    3851 +                       break; 
    3852 +               case WLAN_EID_CHANNEL_SWITCH_WRAPPER: 
    3853 +                       if (action) { 
    3854 +                               elem_parse_failed = true; 
    3855 +                               break; 
    3856 +                       } 
    3857 +                       /* 
    3858 +                        * This is a bit tricky, but as we only care about 
    3859 +                        * the wide bandwidth channel switch element, so 
    3860 +                        * just parse it out manually. 
    3861 +                        */ 
    3862 +                       ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH, 
    3863 +                                             pos, elen); 
    3864 +                       if (ie) { 
    3865 +                               if (ie[1] == sizeof(*elems->wide_bw_chansw_ie)) 
    3866 +                                       elems->wide_bw_chansw_ie = 
    3867 +                                               (void *)(ie + 2); 
    3868 +                               else 
    3869 +                                       elem_parse_failed = true; 
    3870 +                       } 
    3871 +                       break; 
    3872                 case WLAN_EID_COUNTRY: 
    3873                         elems->country_elem = pos; 
    3874                         elems->country_elem_len = elen; 
    3875 --- a/net/wireless/reg.c 
    3876 +++ b/net/wireless/reg.c 
    3877 @@ -857,7 +857,7 @@ static void handle_channel(struct wiphy  
    3878                         return; 
    3879   
    3880                 REG_DBG_PRINT("Disabling freq %d MHz\n", chan->center_freq); 
    3881 -               chan->flags = IEEE80211_CHAN_DISABLED; 
    3882 +               chan->flags |= IEEE80211_CHAN_DISABLED; 
    3883                 return; 
    3884         } 
    3885   
    3886 --- a/net/wireless/util.c 
    3887 +++ b/net/wireless/util.c 
    3888 @@ -1156,6 +1156,26 @@ int cfg80211_get_p2p_attr(const u8 *ies, 
    3889  } 
    3890  EXPORT_SYMBOL(cfg80211_get_p2p_attr); 
    3891   
    3892 +bool ieee80211_operating_class_to_band(u8 operating_class, 
    3893 +                                      enum ieee80211_band *band) 
    3894 +{ 
    3895 +       switch (operating_class) { 
    3896 +       case 112: 
    3897 +       case 115 ... 127: 
    3898 +               *band = IEEE80211_BAND_5GHZ; 
    3899 +               return true; 
    3900 +       case 81: 
    3901 +       case 82: 
    3902 +       case 83: 
    3903 +       case 84: 
    3904 +               *band = IEEE80211_BAND_2GHZ; 
    3905 +               return true; 
    3906 +       } 
    3907 + 
    3908 +       return false; 
    3909 +} 
    3910 +EXPORT_SYMBOL(ieee80211_operating_class_to_band); 
    3911 + 
    3912  int cfg80211_validate_beacon_int(struct cfg80211_registered_device *rdev, 
    3913                                  u32 beacon_int) 
    3914  { 
    3915 --- a/include/uapi/linux/nl80211.h 
    3916 +++ b/include/uapi/linux/nl80211.h 
    3917 @@ -1973,6 +1973,10 @@ enum nl80211_sta_bss_param { 
    3918   * @NL80211_STA_INFO_PEER_PM: peer mesh STA link-specific power mode 
    3919   * @NL80211_STA_INFO_NONPEER_PM: neighbor mesh STA power save mode towards 
    3920   *     non-peer STA 
    3921 + * @NL80211_STA_INFO_CHAIN_SIGNAL: per-chain signal strength of last PPDU 
    3922 + *     Contains a nested array of signal strength attributes (u8, dBm) 
    3923 + * @NL80211_STA_INFO_CHAIN_SIGNAL_AVG: per-chain signal strength average 
    3924 + *     Same format as NL80211_STA_INFO_CHAIN_SIGNAL. 
    3925   * @__NL80211_STA_INFO_AFTER_LAST: internal 
    3926   * @NL80211_STA_INFO_MAX: highest possible station info attribute 
     276@@ -203,6 +201,7 @@ struct tid_ampdu_rx { 
     277  *     driver requested to close until the work for it runs 
     278  * @mtx: mutex to protect all TX data (except non-NULL assignments 
     279  *     to tid_tx[idx], which are protected by the sta spinlock) 
     280+ *     tid_start_tx is also protected by sta->lock. 
    3927281  */ 
    3928 @@ -2002,6 +2006,8 @@ enum nl80211_sta_info { 
    3929         NL80211_STA_INFO_NONPEER_PM, 
    3930         NL80211_STA_INFO_RX_BYTES64, 
    3931         NL80211_STA_INFO_TX_BYTES64, 
    3932 +       NL80211_STA_INFO_CHAIN_SIGNAL, 
    3933 +       NL80211_STA_INFO_CHAIN_SIGNAL_AVG, 
    3934   
    3935         /* keep last */ 
    3936         __NL80211_STA_INFO_AFTER_LAST, 
    3937 @@ -2395,6 +2401,8 @@ enum nl80211_survey_info { 
    3938   * @NL80211_MNTR_FLAG_OTHER_BSS: disable BSSID filtering 
    3939   * @NL80211_MNTR_FLAG_COOK_FRAMES: report frames after processing. 
    3940   *     overrides all other flags. 
    3941 + * @NL80211_MNTR_FLAG_ACTIVE: use the configured MAC address 
    3942 + *     and ACK incoming unicast packets. 
    3943   * 
    3944   * @__NL80211_MNTR_FLAG_AFTER_LAST: internal use 
    3945   * @NL80211_MNTR_FLAG_MAX: highest possible monitor flag 
    3946 @@ -2406,6 +2414,7 @@ enum nl80211_mntr_flags { 
    3947         NL80211_MNTR_FLAG_CONTROL, 
    3948         NL80211_MNTR_FLAG_OTHER_BSS, 
    3949         NL80211_MNTR_FLAG_COOK_FRAMES, 
    3950 +       NL80211_MNTR_FLAG_ACTIVE, 
    3951   
    3952         /* keep last */ 
    3953         __NL80211_MNTR_FLAG_AFTER_LAST, 
    3954 @@ -3557,6 +3566,7 @@ enum nl80211_feature_flags { 
    3955         NL80211_FEATURE_ADVERTISE_CHAN_LIMITS           = 1 << 14, 
    3956         NL80211_FEATURE_FULL_AP_CLIENT_STATE            = 1 << 15, 
    3957         NL80211_FEATURE_USERSPACE_MPM                   = 1 << 16, 
    3958 +       NL80211_FEATURE_ACTIVE_MONITOR                  = 1 << 17, 
    3959  }; 
    3960   
    3961  /** 
    3962 --- a/net/mac80211/sta_info.c 
    3963 +++ b/net/mac80211/sta_info.c 
    3964 @@ -358,6 +358,8 @@ struct sta_info *sta_info_alloc(struct i 
    3965         do_posix_clock_monotonic_gettime(&uptime); 
    3966         sta->last_connected = uptime.tv_sec; 
    3967         ewma_init(&sta->avg_signal, 1024, 8); 
    3968 +       for (i = 0; i < ARRAY_SIZE(sta->chain_signal_avg); i++) 
    3969 +               ewma_init(&sta->chain_signal_avg[i], 1024, 8); 
    3970   
    3971         if (sta_prepare_rate_control(local, sta, gfp)) { 
    3972                 kfree(sta); 
    3973 @@ -1130,6 +1132,7 @@ static void ieee80211_send_null_response 
    3974          * ends the poll/service period. 
    3975          */ 
    3976         info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER | 
    3977 +                      IEEE80211_TX_CTL_PS_RESPONSE | 
    3978                        IEEE80211_TX_STATUS_EOSP | 
    3979                        IEEE80211_TX_CTL_REQ_TX_STATUS; 
    3980   
    3981 @@ -1267,7 +1270,8 @@ ieee80211_sta_ps_deliver_response(struct 
    3982                          * STA may still remain is PS mode after this frame 
    3983                          * exchange. 
    3984                          */ 
    3985 -                       info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER; 
    3986 +                       info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER | 
    3987 +                                      IEEE80211_TX_CTL_PS_RESPONSE; 
    3988   
    3989                         /* 
    3990                          * Use MoreData flag to indicate whether there are 
    3991 --- a/net/wireless/nl80211.c 
    3992 +++ b/net/wireless/nl80211.c 
    3993 @@ -2270,6 +2270,7 @@ static const struct nla_policy mntr_flag 
    3994         [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG }, 
    3995         [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG }, 
    3996         [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG }, 
    3997 +       [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG }, 
    3998  }; 
    3999   
    4000  static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags) 
    4001 @@ -2381,6 +2382,10 @@ static int nl80211_set_interface(struct  
    4002                 change = true; 
    4003         } 
    4004   
    4005 +       if (flags && (*flags & NL80211_MNTR_FLAG_ACTIVE) && 
    4006 +           !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR)) 
    4007 +               return -EOPNOTSUPP; 
    4008 + 
    4009         if (change) 
    4010                 err = cfg80211_change_iface(rdev, dev, ntype, flags, &params); 
    4011         else 
    4012 @@ -2438,6 +2443,11 @@ static int nl80211_new_interface(struct  
    4013         err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ? 
    4014                                   info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL, 
    4015                                   &flags); 
    4016 + 
    4017 +       if (!err && (flags & NL80211_MNTR_FLAG_ACTIVE) && 
    4018 +           !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR)) 
    4019 +               return -EOPNOTSUPP; 
    4020 + 
    4021         wdev = rdev_add_virtual_intf(rdev, 
    4022                                 nla_data(info->attrs[NL80211_ATTR_IFNAME]), 
    4023                                 type, err ? NULL : &flags, &params); 
    4024 @@ -3367,6 +3377,32 @@ static bool nl80211_put_sta_rate(struct  
    4025         return true; 
    4026  } 
    4027   
    4028 +static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal, 
    4029 +                              int id) 
    4030 +{ 
    4031 +       void *attr; 
    4032 +       int i = 0; 
    4033 + 
    4034 +       if (!mask) 
    4035 +               return true; 
    4036 + 
    4037 +       attr = nla_nest_start(msg, id); 
    4038 +       if (!attr) 
    4039 +               return false; 
    4040 + 
    4041 +       for (i = 0; i < IEEE80211_MAX_CHAINS; i++) { 
    4042 +               if (!(mask & BIT(i))) 
    4043 +                       continue; 
    4044 + 
    4045 +               if (nla_put_u8(msg, i, signal[i])) 
    4046 +                       return false; 
    4047 +       } 
    4048 + 
    4049 +       nla_nest_end(msg, attr); 
    4050 + 
    4051 +       return true; 
    4052 +} 
    4053 + 
    4054  static int nl80211_send_station(struct sk_buff *msg, u32 portid, u32 seq, 
    4055                                 int flags, 
    4056                                 struct cfg80211_registered_device *rdev, 
    4057 @@ -3402,7 +3438,7 @@ static int nl80211_send_station(struct s 
    4058                         (u32)sinfo->rx_bytes)) 
    4059                 goto nla_put_failure; 
    4060         if ((sinfo->filled & (STATION_INFO_TX_BYTES | 
    4061 -                             NL80211_STA_INFO_TX_BYTES64)) && 
    4062 +                             STATION_INFO_TX_BYTES64)) && 
    4063             nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES, 
    4064                         (u32)sinfo->tx_bytes)) 
    4065                 goto nla_put_failure; 
    4066 @@ -3438,6 +3474,18 @@ static int nl80211_send_station(struct s 
    4067         default: 
    4068                 break; 
    4069         } 
    4070 +       if (sinfo->filled & STATION_INFO_CHAIN_SIGNAL) { 
    4071 +               if (!nl80211_put_signal(msg, sinfo->chains, 
    4072 +                                       sinfo->chain_signal, 
    4073 +                                       NL80211_STA_INFO_CHAIN_SIGNAL)) 
    4074 +                       goto nla_put_failure; 
    4075 +       } 
    4076 +       if (sinfo->filled & STATION_INFO_CHAIN_SIGNAL_AVG) { 
    4077 +               if (!nl80211_put_signal(msg, sinfo->chains, 
    4078 +                                       sinfo->chain_signal_avg, 
    4079 +                                       NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) 
    4080 +                       goto nla_put_failure; 
    4081 +       } 
    4082         if (sinfo->filled & STATION_INFO_TX_BITRATE) { 
    4083                 if (!nl80211_put_sta_rate(msg, &sinfo->txrate, 
    4084                                           NL80211_STA_INFO_TX_BITRATE)) 
    4085 --- a/drivers/net/wireless/ath/ath9k/init.c 
    4086 +++ b/drivers/net/wireless/ath/ath9k/init.c 
    4087 @@ -433,6 +433,8 @@ static int ath9k_init_queues(struct ath_ 
    4088         sc->config.cabqReadytime = ATH_CABQ_READY_TIME; 
    4089         ath_cabq_update(sc); 
    4090   
    4091 +       sc->tx.uapsdq = ath_txq_setup(sc, ATH9K_TX_QUEUE_UAPSD, 0); 
    4092 + 
    4093         for (i = 0; i < IEEE80211_NUM_ACS; i++) { 
    4094                 sc->tx.txq_map[i] = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, i); 
    4095                 sc->tx.txq_map[i]->mac80211_qnum = i; 
    4096 @@ -768,7 +770,8 @@ void ath9k_set_hw_capab(struct ath_softc 
    4097                 IEEE80211_HW_SUPPORTS_PS | 
    4098                 IEEE80211_HW_PS_NULLFUNC_STACK | 
    4099                 IEEE80211_HW_SPECTRUM_MGMT | 
    4100 -               IEEE80211_HW_REPORTS_TX_ACK_STATUS; 
    4101 +               IEEE80211_HW_REPORTS_TX_ACK_STATUS | 
    4102 +               IEEE80211_HW_SUPPORTS_RC_TABLE; 
    4103   
    4104         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) 
    4105                  hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION; 
    4106 @@ -776,6 +779,8 @@ void ath9k_set_hw_capab(struct ath_softc 
    4107         if (AR_SREV_9160_10_OR_LATER(sc->sc_ah) || ath9k_modparam_nohwcrypt) 
    4108                 hw->flags |= IEEE80211_HW_MFP_CAPABLE; 
    4109   
    4110 +       hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR; 
    4111 + 
    4112         hw->wiphy->interface_modes = 
    4113                 BIT(NL80211_IFTYPE_P2P_GO) | 
    4114                 BIT(NL80211_IFTYPE_P2P_CLIENT) | 
    4115 --- a/drivers/net/wireless/ath/ath9k/xmit.c 
    4116 +++ b/drivers/net/wireless/ath/ath9k/xmit.c 
    4117 @@ -125,24 +125,6 @@ static void ath_tx_queue_tid(struct ath_ 
    4118         list_add_tail(&ac->list, &txq->axq_acq); 
    4119  } 
    4120   
    4121 -static void ath_tx_resume_tid(struct ath_softc *sc, struct ath_atx_tid *tid) 
    4122 -{ 
    4123 -       struct ath_txq *txq = tid->ac->txq; 
    4124 - 
    4125 -       WARN_ON(!tid->paused); 
    4126 - 
    4127 -       ath_txq_lock(sc, txq); 
    4128 -       tid->paused = false; 
    4129 - 
    4130 -       if (skb_queue_empty(&tid->buf_q)) 
    4131 -               goto unlock; 
    4132 - 
    4133 -       ath_tx_queue_tid(txq, tid); 
    4134 -       ath_txq_schedule(sc, txq); 
    4135 -unlock: 
    4136 -       ath_txq_unlock_complete(sc, txq); 
    4137 -} 
    4138 - 
    4139  static struct ath_frame_info *get_frame_info(struct sk_buff *skb) 
    4140  { 
    4141         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 
    4142 @@ -157,6 +139,13 @@ static void ath_send_bar(struct ath_atx_ 
    4143                            seqno << IEEE80211_SEQ_SEQ_SHIFT); 
    4144  } 
    4145   
    4146 +static void ath_set_rates(struct ieee80211_vif *vif, struct ieee80211_sta *sta, 
    4147 +                         struct ath_buf *bf) 
    4148 +{ 
    4149 +       ieee80211_get_tx_rates(vif, sta, bf->bf_mpdu, bf->rates, 
    4150 +                              ARRAY_SIZE(bf->rates)); 
    4151 +} 
    4152 + 
    4153  static void ath_tx_flush_tid(struct ath_softc *sc, struct ath_atx_tid *tid) 
    4154  { 
    4155         struct ath_txq *txq = tid->ac->txq; 
    4156 @@ -189,15 +178,11 @@ static void ath_tx_flush_tid(struct ath_ 
    4157                         ath_tx_complete_buf(sc, bf, txq, &bf_head, &ts, 0); 
    4158                         sendbar = true; 
    4159                 } else { 
    4160 +                       ath_set_rates(tid->an->vif, tid->an->sta, bf); 
    4161                         ath_tx_send_normal(sc, txq, NULL, skb); 
    4162                 } 
    4163         } 
    4164   
    4165 -       if (tid->baw_head == tid->baw_tail) { 
    4166 -               tid->state &= ~AGGR_ADDBA_COMPLETE; 
    4167 -               tid->state &= ~AGGR_CLEANUP; 
    4168 -       } 
    4169 - 
    4170         if (sendbar) { 
    4171                 ath_txq_unlock(sc, txq); 
    4172                 ath_send_bar(tid, tid->seq_start); 
    4173 @@ -269,9 +254,7 @@ static void ath_tid_drain(struct ath_sof 
    4174   
    4175                 list_add_tail(&bf->list, &bf_head); 
    4176   
    4177 -               if (fi->retries) 
    4178 -                       ath_tx_update_baw(sc, tid, bf->bf_state.seqno); 
    4179 - 
    4180 +               ath_tx_update_baw(sc, tid, bf->bf_state.seqno); 
    4181                 ath_tx_complete_buf(sc, bf, txq, &bf_head, &ts, 0); 
    4182         } 
    4183   
    4184 @@ -407,7 +390,7 @@ static void ath_tx_complete_aggr(struct  
    4185   
    4186         tx_info = IEEE80211_SKB_CB(skb); 
    4187   
    4188 -       memcpy(rates, tx_info->control.rates, sizeof(rates)); 
    4189 +       memcpy(rates, bf->rates, sizeof(rates)); 
    4190   
    4191         retries = ts->ts_longretry + 1; 
    4192         for (i = 0; i < ts->ts_rateindex; i++) 
    4193 @@ -483,19 +466,19 @@ static void ath_tx_complete_aggr(struct  
    4194                 tx_info = IEEE80211_SKB_CB(skb); 
    4195                 fi = get_frame_info(skb); 
    4196   
    4197 -               if (ATH_BA_ISSET(ba, ATH_BA_INDEX(seq_st, seqno))) { 
    4198 +               if (!BAW_WITHIN(tid->seq_start, tid->baw_size, seqno)) { 
    4199 +                       /* 
    4200 +                        * Outside of the current BlockAck window, 
    4201 +                        * maybe part of a previous session 
    4202 +                        */ 
    4203 +                       txfail = 1; 
    4204 +               } else if (ATH_BA_ISSET(ba, ATH_BA_INDEX(seq_st, seqno))) { 
    4205                         /* transmit completion, subframe is 
    4206                          * acked by block ack */ 
    4207                         acked_cnt++; 
    4208                 } else if (!isaggr && txok) { 
    4209                         /* transmit completion */ 
    4210                         acked_cnt++; 
    4211 -               } else if (tid->state & AGGR_CLEANUP) { 
    4212 -                       /* 
    4213 -                        * cleanup in progress, just fail 
    4214 -                        * the un-acked sub-frames 
    4215 -                        */ 
    4216 -                       txfail = 1; 
    4217                 } else if (flush) { 
    4218                         txpending = 1; 
    4219                 } else if (fi->retries < ATH_MAX_SW_RETRIES) { 
    4220 @@ -519,7 +502,7 @@ static void ath_tx_complete_aggr(struct  
    4221                 if (bf_next != NULL || !bf_last->bf_stale) 
    4222                         list_move_tail(&bf->list, &bf_head); 
    4223   
    4224 -               if (!txpending || (tid->state & AGGR_CLEANUP)) { 
    4225 +               if (!txpending) { 
    4226                         /* 
    4227                          * complete the acked-ones/xretried ones; update 
    4228                          * block-ack window 
    4229 @@ -535,6 +518,10 @@ static void ath_tx_complete_aggr(struct  
    4230                         ath_tx_complete_buf(sc, bf, txq, &bf_head, ts, 
    4231                                 !txfail); 
    4232                 } else { 
    4233 +                       if (tx_info->flags & IEEE80211_TX_STATUS_EOSP) { 
    4234 +                               tx_info->flags &= ~IEEE80211_TX_STATUS_EOSP; 
    4235 +                               ieee80211_sta_eosp(sta); 
    4236 +                       } 
    4237                         /* retry the un-acked ones */ 
    4238                         if (bf->bf_next == NULL && bf_last->bf_stale) { 
    4239                                 struct ath_buf *tbf; 
    4240 @@ -593,9 +580,6 @@ static void ath_tx_complete_aggr(struct  
    4241                 ath_txq_lock(sc, txq); 
    4242         } 
    4243   
    4244 -       if (tid->state & AGGR_CLEANUP) 
    4245 -               ath_tx_flush_tid(sc, tid); 
    4246 - 
    4247         rcu_read_unlock(); 
    4248   
    4249         if (needreset) 
    4250 @@ -612,6 +596,7 @@ static void ath_tx_process_buffer(struct 
    4251                                   struct ath_tx_status *ts, struct ath_buf *bf, 
    4252                                   struct list_head *bf_head) 
    4253  { 
    4254 +       struct ieee80211_tx_info *info; 
    4255         bool txok, flush; 
    4256   
    4257         txok = !(ts->ts_status & ATH9K_TXERR_MASK); 
    4258 @@ -623,8 +608,12 @@ static void ath_tx_process_buffer(struct 
    4259                 txq->axq_ampdu_depth--; 
    4260   
    4261         if (!bf_isampdu(bf)) { 
    4262 -               if (!flush) 
    4263 +               if (!flush) { 
    4264 +                       info = IEEE80211_SKB_CB(bf->bf_mpdu); 
    4265 +                       memcpy(info->control.rates, bf->rates, 
    4266 +                              sizeof(info->control.rates)); 
    4267                         ath_tx_rc_status(sc, bf, ts, 1, txok ? 0 : 1, txok); 
    4268 +               } 
    4269                 ath_tx_complete_buf(sc, bf, txq, bf_head, ts, txok); 
    4270         } else 
    4271                 ath_tx_complete_aggr(sc, txq, bf, bf_head, ts, txok); 
    4272 @@ -668,7 +657,7 @@ static u32 ath_lookup_rate(struct ath_so 
    4273   
    4274         skb = bf->bf_mpdu; 
    4275         tx_info = IEEE80211_SKB_CB(skb); 
    4276 -       rates = tx_info->control.rates; 
    4277 +       rates = bf->rates; 
    4278   
    4279         /* 
    4280          * Find the lowest frame length among the rate series that will have a 
    4281 @@ -736,8 +725,6 @@ static int ath_compute_num_delims(struct 
    4282                                   bool first_subfrm) 
    4283  { 
    4284  #define FIRST_DESC_NDELIMS 60 
    4285 -       struct sk_buff *skb = bf->bf_mpdu; 
    4286 -       struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 
    4287         u32 nsymbits, nsymbols; 
    4288         u16 minlen; 
    4289         u8 flags, rix; 
    4290 @@ -778,8 +765,8 @@ static int ath_compute_num_delims(struct 
    4291         if (tid->an->mpdudensity == 0) 
    4292                 return ndelim; 
    4293   
    4294 -       rix = tx_info->control.rates[0].idx; 
    4295 -       flags = tx_info->control.rates[0].flags; 
    4296 +       rix = bf->rates[0].idx; 
    4297 +       flags = bf->rates[0].flags; 
    4298         width = (flags & IEEE80211_TX_RC_40_MHZ_WIDTH) ? 1 : 0; 
    4299         half_gi = (flags & IEEE80211_TX_RC_SHORT_GI) ? 1 : 0; 
    4300   
    4301 @@ -803,25 +790,20 @@ static int ath_compute_num_delims(struct 
    4302         return ndelim; 
    4303  } 
    4304   
    4305 -static enum ATH_AGGR_STATUS ath_tx_form_aggr(struct ath_softc *sc, 
    4306 -                                            struct ath_txq *txq, 
    4307 -                                            struct ath_atx_tid *tid, 
    4308 -                                            struct list_head *bf_q, 
    4309 -                                            int *aggr_len) 
    4310 +static struct ath_buf * 
    4311 +ath_tx_get_tid_subframe(struct ath_softc *sc, struct ath_txq *txq, 
    4312 +                       struct ath_atx_tid *tid) 
    4313  { 
    4314 -#define PADBYTES(_len) ((4 - ((_len) % 4)) % 4) 
    4315 -       struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL; 
    4316 -       int rl = 0, nframes = 0, ndelim, prev_al = 0; 
    4317 -       u16 aggr_limit = 0, al = 0, bpad = 0, 
    4318 -               al_delta, h_baw = tid->baw_size / 2; 
    4319 -       enum ATH_AGGR_STATUS status = ATH_AGGR_DONE; 
    4320 -       struct ieee80211_tx_info *tx_info; 
    4321         struct ath_frame_info *fi; 
    4322         struct sk_buff *skb; 
    4323 +       struct ath_buf *bf; 
    4324         u16 seqno; 
    4325   
    4326 -       do { 
    4327 +       while (1) { 
    4328                 skb = skb_peek(&tid->buf_q); 
    4329 +               if (!skb) 
    4330 +                       break; 
    4331 + 
    4332                 fi = get_frame_info(skb); 
    4333                 bf = fi->bf; 
    4334                 if (!fi->bf) 
    4335 @@ -837,10 +819,8 @@ static enum ATH_AGGR_STATUS ath_tx_form_ 
    4336                 seqno = bf->bf_state.seqno; 
    4337   
    4338                 /* do not step over block-ack window */ 
    4339 -               if (!BAW_WITHIN(tid->seq_start, tid->baw_size, seqno)) { 
    4340 -                       status = ATH_AGGR_BAW_CLOSED; 
    4341 +               if (!BAW_WITHIN(tid->seq_start, tid->baw_size, seqno)) 
    4342                         break; 
    4343 -               } 
    4344   
    4345                 if (tid->bar_index > ATH_BA_INDEX(tid->seq_start, seqno)) { 
    4346                         struct ath_tx_status ts = {}; 
    4347 @@ -854,10 +834,45 @@ static enum ATH_AGGR_STATUS ath_tx_form_ 
    4348                         continue; 
    4349                 } 
    4350   
    4351 +               bf->bf_next = NULL; 
    4352 +               bf->bf_lastbf = bf; 
    4353 +               return bf; 
    4354 +       } 
    4355 + 
    4356 +       return NULL; 
    4357 +} 
    4358 + 
    4359 +static enum ATH_AGGR_STATUS ath_tx_form_aggr(struct ath_softc *sc, 
    4360 +                                            struct ath_txq *txq, 
    4361 +                                            struct ath_atx_tid *tid, 
    4362 +                                            struct list_head *bf_q, 
    4363 +                                            int *aggr_len) 
    4364 +{ 
    4365 +#define PADBYTES(_len) ((4 - ((_len) % 4)) % 4) 
    4366 +       struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL; 
    4367 +       int rl = 0, nframes = 0, ndelim, prev_al = 0; 
    4368 +       u16 aggr_limit = 0, al = 0, bpad = 0, 
    4369 +               al_delta, h_baw = tid->baw_size / 2; 
    4370 +       enum ATH_AGGR_STATUS status = ATH_AGGR_DONE; 
    4371 +       struct ieee80211_tx_info *tx_info; 
    4372 +       struct ath_frame_info *fi; 
    4373 +       struct sk_buff *skb; 
    4374 + 
    4375 +       do { 
    4376 +               bf = ath_tx_get_tid_subframe(sc, txq, tid); 
    4377 +               if (!bf) { 
    4378 +                       status = ATH_AGGR_BAW_CLOSED; 
    4379 +                       break; 
    4380 +               } 
    4381 + 
    4382 +               skb = bf->bf_mpdu; 
    4383 +               fi = get_frame_info(skb); 
    4384 + 
    4385                 if (!bf_first) 
    4386                         bf_first = bf; 
    4387   
    4388                 if (!rl) { 
    4389 +                       ath_set_rates(tid->an->vif, tid->an->sta, bf); 
    4390                         aggr_limit = ath_lookup_rate(sc, bf, tid); 
    4391                         rl = 1; 
    4392                 } 
    4393 @@ -898,7 +913,7 @@ static enum ATH_AGGR_STATUS ath_tx_form_ 
    4394   
    4395                 /* link buffers of this frame to the aggregate */ 
    4396                 if (!fi->retries) 
    4397 -                       ath_tx_addto_baw(sc, tid, seqno); 
    4398 +                       ath_tx_addto_baw(sc, tid, bf->bf_state.seqno); 
    4399                 bf->bf_state.ndelim = ndelim; 
    4400   
    4401                 __skb_unlink(skb, &tid->buf_q); 
    4402 @@ -998,14 +1013,14 @@ static void ath_buf_set_rate(struct ath_ 
    4403   
    4404         skb = bf->bf_mpdu; 
    4405         tx_info = IEEE80211_SKB_CB(skb); 
    4406 -       rates = tx_info->control.rates; 
    4407 +       rates = bf->rates; 
    4408         hdr = (struct ieee80211_hdr *)skb->data; 
    4409   
    4410         /* set dur_update_en for l-sig computation except for PS-Poll frames */ 
    4411         info->dur_update = !ieee80211_is_pspoll(hdr->frame_control); 
    4412         info->rtscts_rate = fi->rtscts_rate; 
    4413   
    4414 -       for (i = 0; i < 4; i++) { 
    4415 +       for (i = 0; i < ARRAY_SIZE(bf->rates); i++) { 
    4416                 bool is_40, is_sgi, is_sp; 
    4417                 int phy; 
    4418   
    4419 @@ -1106,10 +1121,8 @@ static void ath_tx_fill_desc(struct ath_ 
    4420                              struct ath_txq *txq, int len) 
    4421  { 
    4422         struct ath_hw *ah = sc->sc_ah; 
    4423 -       struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(bf->bf_mpdu); 
    4424 -       struct ath_buf *bf_first = bf; 
    4425 +       struct ath_buf *bf_first = NULL; 
    4426         struct ath_tx_info info; 
    4427 -       bool aggr = !!(bf->bf_state.bf_type & BUF_AGGR); 
    4428   
    4429         memset(&info, 0, sizeof(info)); 
    4430         info.is_first = true; 
    4431 @@ -1117,24 +1130,11 @@ static void ath_tx_fill_desc(struct ath_ 
    4432         info.txpower = MAX_RATE_POWER; 
    4433         info.qcu = txq->axq_qnum; 
    4434   
    4435 -       info.flags = ATH9K_TXDESC_INTREQ; 
    4436 -       if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK) 
    4437 -               info.flags |= ATH9K_TXDESC_NOACK; 
    4438 -       if (tx_info->flags & IEEE80211_TX_CTL_LDPC) 
    4439 -               info.flags |= ATH9K_TXDESC_LDPC; 
    4440 - 
    4441 -       ath_buf_set_rate(sc, bf, &info, len); 
    4442 - 
    4443 -       if (tx_info->flags & IEEE80211_TX_CTL_CLEAR_PS_FILT) 
    4444 -               info.flags |= ATH9K_TXDESC_CLRDMASK; 
    4445 - 
    4446 -       if (bf->bf_state.bfs_paprd) 
    4447 -               info.flags |= (u32) bf->bf_state.bfs_paprd << ATH9K_TXDESC_PAPRD_S; 
    4448 - 
    4449 - 
    4450         while (bf) { 
    4451                 struct sk_buff *skb = bf->bf_mpdu; 
    4452 +               struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 
    4453                 struct ath_frame_info *fi = get_frame_info(skb); 
    4454 +               bool aggr = !!(bf->bf_state.bf_type & BUF_AGGR); 
    4455   
    4456                 info.type = get_hw_packet_type(skb); 
    4457                 if (bf->bf_next) 
    4458 @@ -1142,6 +1142,26 @@ static void ath_tx_fill_desc(struct ath_ 
    4459                 else 
    4460                         info.link = 0; 
    4461   
    4462 +               if (!bf_first) { 
    4463 +                       bf_first = bf; 
    4464 + 
    4465 +                       info.flags = ATH9K_TXDESC_INTREQ; 
    4466 +                       if ((tx_info->flags & IEEE80211_TX_CTL_CLEAR_PS_FILT) || 
    4467 +                           txq == sc->tx.uapsdq) 
    4468 +                               info.flags |= ATH9K_TXDESC_CLRDMASK; 
    4469 + 
    4470 +                       if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK) 
    4471 +                               info.flags |= ATH9K_TXDESC_NOACK; 
    4472 +                       if (tx_info->flags & IEEE80211_TX_CTL_LDPC) 
    4473 +                               info.flags |= ATH9K_TXDESC_LDPC; 
    4474 + 
    4475 +                       if (bf->bf_state.bfs_paprd) 
    4476 +                               info.flags |= (u32) bf->bf_state.bfs_paprd << 
    4477 +                                             ATH9K_TXDESC_PAPRD_S; 
    4478 + 
    4479 +                       ath_buf_set_rate(sc, bf, &info, len); 
    4480 +               } 
    4481 + 
    4482                 info.buf_addr[0] = bf->bf_buf_addr; 
    4483                 info.buf_len[0] = skb->len; 
    4484                 info.pkt_len = fi->framelen; 
    4485 @@ -1151,7 +1171,7 @@ static void ath_tx_fill_desc(struct ath_ 
    4486                 if (aggr) { 
    4487                         if (bf == bf_first) 
    4488                                 info.aggr = AGGR_BUF_FIRST; 
    4489 -                       else if (!bf->bf_next) 
    4490 +                       else if (bf == bf_first->bf_lastbf) 
    4491                                 info.aggr = AGGR_BUF_LAST; 
    4492                         else 
    4493                                 info.aggr = AGGR_BUF_MIDDLE; 
    4494 @@ -1160,6 +1180,9 @@ static void ath_tx_fill_desc(struct ath_ 
    4495                         info.aggr_len = len; 
    4496                 } 
    4497   
    4498 +               if (bf == bf_first->bf_lastbf) 
    4499 +                       bf_first = NULL; 
    4500 + 
    4501                 ath9k_hw_set_txdesc(ah, bf->bf_desc, &info); 
    4502                 bf = bf->bf_next; 
    4503         } 
    4504 @@ -1224,9 +1247,6 @@ int ath_tx_aggr_start(struct ath_softc * 
    4505         an = (struct ath_node *)sta->drv_priv; 
    4506         txtid = ATH_AN_2_TID(an, tid); 
    4507   
    4508 -       if (txtid->state & (AGGR_CLEANUP | AGGR_ADDBA_COMPLETE)) 
    4509 -               return -EAGAIN; 
    4510 - 
    4511         /* update ampdu factor/density, they may have changed. This may happen 
    4512          * in HT IBSS when a beacon with HT-info is received after the station 
    4513          * has already been added. 
    4514 @@ -1238,7 +1258,7 @@ int ath_tx_aggr_start(struct ath_softc * 
    4515                 an->mpdudensity = density; 
    4516         } 
    4517   
    4518 -       txtid->state |= AGGR_ADDBA_PROGRESS; 
    4519 +       txtid->active = true; 
    4520         txtid->paused = true; 
    4521         *ssn = txtid->seq_start = txtid->seq_next; 
    4522         txtid->bar_index = -1; 
    4523 @@ -1255,28 +1275,9 @@ void ath_tx_aggr_stop(struct ath_softc * 
    4524         struct ath_atx_tid *txtid = ATH_AN_2_TID(an, tid); 
    4525         struct ath_txq *txq = txtid->ac->txq; 
    4526   
    4527 -       if (txtid->state & AGGR_CLEANUP) 
    4528 -               return; 
    4529 - 
    4530 -       if (!(txtid->state & AGGR_ADDBA_COMPLETE)) { 
    4531 -               txtid->state &= ~AGGR_ADDBA_PROGRESS; 
    4532 -               return; 
    4533 -       } 
    4534 - 
    4535         ath_txq_lock(sc, txq); 
    4536 +       txtid->active = false; 
    4537         txtid->paused = true; 
    4538 - 
    4539 -       /* 
    4540 -        * If frames are still being transmitted for this TID, they will be 
    4541 -        * cleaned up during tx completion. To prevent race conditions, this 
    4542 -        * TID can only be reused after all in-progress subframes have been 
    4543 -        * completed. 
    4544 -        */ 
    4545 -       if (txtid->baw_head != txtid->baw_tail) 
    4546 -               txtid->state |= AGGR_CLEANUP; 
    4547 -       else 
    4548 -               txtid->state &= ~AGGR_ADDBA_COMPLETE; 
    4549 - 
    4550         ath_tx_flush_tid(sc, txtid); 
    4551         ath_txq_unlock_complete(sc, txq); 
    4552  } 
    4553 @@ -1342,18 +1343,92 @@ void ath_tx_aggr_wakeup(struct ath_softc 
    4554         } 
    4555  } 
    4556   
    4557 -void ath_tx_aggr_resume(struct ath_softc *sc, struct ieee80211_sta *sta, u16 tid) 
    4558 +void ath_tx_aggr_resume(struct ath_softc *sc, struct ieee80211_sta *sta, 
    4559 +                       u16 tidno) 
    4560  { 
    4561 -       struct ath_atx_tid *txtid; 
    4562 +       struct ath_atx_tid *tid; 
    4563         struct ath_node *an; 
    4564 +       struct ath_txq *txq; 
    4565   
    4566         an = (struct ath_node *)sta->drv_priv; 
    4567 +       tid = ATH_AN_2_TID(an, tidno); 
    4568 +       txq = tid->ac->txq; 
    4569   
    4570 -       txtid = ATH_AN_2_TID(an, tid); 
    4571 -       txtid->baw_size = IEEE80211_MIN_AMPDU_BUF << sta->ht_cap.ampdu_factor; 
    4572 -       txtid->state |= AGGR_ADDBA_COMPLETE; 
    4573 -       txtid->state &= ~AGGR_ADDBA_PROGRESS; 
    4574 -       ath_tx_resume_tid(sc, txtid); 
    4575 +       ath_txq_lock(sc, txq); 
    4576 + 
    4577 +       tid->baw_size = IEEE80211_MIN_AMPDU_BUF << sta->ht_cap.ampdu_factor; 
    4578 +       tid->paused = false; 
    4579 + 
    4580 +       if (!skb_queue_empty(&tid->buf_q)) { 
    4581 +               ath_tx_queue_tid(txq, tid); 
    4582 +               ath_txq_schedule(sc, txq); 
    4583 +       } 
    4584 + 
    4585 +       ath_txq_unlock_complete(sc, txq); 
    4586 +} 
    4587 + 
    4588 +void ath9k_release_buffered_frames(struct ieee80211_hw *hw, 
    4589 +                                  struct ieee80211_sta *sta, 
    4590 +                                  u16 tids, int nframes, 
    4591 +                                  enum ieee80211_frame_release_type reason, 
    4592 +                                  bool more_data) 
    4593 +{ 
    4594 +       struct ath_softc *sc = hw->priv; 
    4595 +       struct ath_node *an = (struct ath_node *)sta->drv_priv; 
    4596 +       struct ath_txq *txq = sc->tx.uapsdq; 
    4597 +       struct ieee80211_tx_info *info; 
    4598 +       struct list_head bf_q; 
    4599 +       struct ath_buf *bf_tail = NULL, *bf; 
    4600 +       int sent = 0; 
    4601 +       int i; 
    4602 + 
    4603 +       INIT_LIST_HEAD(&bf_q); 
    4604 +       for (i = 0; tids && nframes; i++, tids >>= 1) { 
    4605 +               struct ath_atx_tid *tid; 
    4606 + 
    4607 +               if (!(tids & 1)) 
    4608 +                       continue; 
    4609 + 
    4610 +               tid = ATH_AN_2_TID(an, i); 
    4611 +               if (tid->paused) 
    4612 +                       continue; 
    4613 + 
    4614 +               ath_txq_lock(sc, tid->ac->txq); 
    4615 +               while (!skb_queue_empty(&tid->buf_q) && nframes > 0) { 
    4616 +                       bf = ath_tx_get_tid_subframe(sc, sc->tx.uapsdq, tid); 
    4617 +                       if (!bf) 
    4618 +                               break; 
    4619 + 
    4620 +                       __skb_unlink(bf->bf_mpdu, &tid->buf_q); 
    4621 +                       list_add_tail(&bf->list, &bf_q); 
    4622 +                       ath_set_rates(tid->an->vif, tid->an->sta, bf); 
    4623 +                       ath_tx_addto_baw(sc, tid, bf->bf_state.seqno); 
    4624 +                       bf->bf_state.bf_type &= ~BUF_AGGR; 
    4625 +                       if (bf_tail) 
    4626 +                               bf_tail->bf_next = bf; 
    4627 + 
    4628 +                       bf_tail = bf; 
    4629 +                       nframes--; 
    4630 +                       sent++; 
    4631 +                       TX_STAT_INC(txq->axq_qnum, a_queued_hw); 
    4632 + 
    4633 +                       if (skb_queue_empty(&tid->buf_q)) 
    4634 +                               ieee80211_sta_set_buffered(an->sta, i, false); 
    4635 +               } 
    4636 +               ath_txq_unlock_complete(sc, tid->ac->txq); 
    4637 +       } 
    4638 + 
    4639 +       if (list_empty(&bf_q)) 
    4640 +               return; 
    4641 + 
    4642 +       info = IEEE80211_SKB_CB(bf_tail->bf_mpdu); 
    4643 +       info->flags |= IEEE80211_TX_STATUS_EOSP; 
    4644 + 
    4645 +       bf = list_first_entry(&bf_q, struct ath_buf, list); 
    4646 +       ath_txq_lock(sc, txq); 
    4647 +       ath_tx_fill_desc(sc, bf, txq, 0); 
    4648 +       ath_tx_txqaddbuf(sc, txq, &bf_q, false); 
    4649 +       ath_txq_unlock(sc, txq); 
    4650  } 
    4651   
    4652  /********************/ 
    4653 @@ -1709,8 +1784,9 @@ static void ath_tx_txqaddbuf(struct ath_ 
    4654         } 
    4655  } 
    4656   
    4657 -static void ath_tx_send_ampdu(struct ath_softc *sc, struct ath_atx_tid *tid, 
    4658 -                             struct sk_buff *skb, struct ath_tx_control *txctl) 
    4659 +static void ath_tx_send_ampdu(struct ath_softc *sc, struct ath_txq *txq, 
    4660 +                             struct ath_atx_tid *tid, struct sk_buff *skb, 
    4661 +                             struct ath_tx_control *txctl) 
    4662  { 
    4663         struct ath_frame_info *fi = get_frame_info(skb); 
    4664         struct list_head bf_head; 
    4665 @@ -1723,26 +1799,28 @@ static void ath_tx_send_ampdu(struct ath 
    4666          * - seqno is not within block-ack window 
    4667          * - h/w queue depth exceeds low water mark 
    4668          */ 
    4669 -       if (!skb_queue_empty(&tid->buf_q) || tid->paused || 
    4670 -           !BAW_WITHIN(tid->seq_start, tid->baw_size, tid->seq_next) || 
    4671 -           txctl->txq->axq_ampdu_depth >= ATH_AGGR_MIN_QDEPTH) { 
    4672 +       if ((!skb_queue_empty(&tid->buf_q) || tid->paused || 
    4673 +            !BAW_WITHIN(tid->seq_start, tid->baw_size, tid->seq_next) || 
    4674 +            txq->axq_ampdu_depth >= ATH_AGGR_MIN_QDEPTH) && 
    4675 +           txq != sc->tx.uapsdq) { 
    4676                 /* 
    4677                  * Add this frame to software queue for scheduling later 
    4678                  * for aggregation. 
    4679                  */ 
    4680 -               TX_STAT_INC(txctl->txq->axq_qnum, a_queued_sw); 
    4681 +               TX_STAT_INC(txq->axq_qnum, a_queued_sw); 
    4682                 __skb_queue_tail(&tid->buf_q, skb); 
    4683                 if (!txctl->an || !txctl->an->sleeping) 
    4684 -                       ath_tx_queue_tid(txctl->txq, tid); 
    4685 +                       ath_tx_queue_tid(txq, tid); 
    4686                 return; 
    4687         } 
    4688   
    4689 -       bf = ath_tx_setup_buffer(sc, txctl->txq, tid, skb); 
    4690 +       bf = ath_tx_setup_buffer(sc, txq, tid, skb); 
    4691         if (!bf) { 
    4692                 ieee80211_free_txskb(sc->hw, skb); 
    4693                 return; 
    4694         } 
    4695   
    4696 +       ath_set_rates(tid->an->vif, tid->an->sta, bf); 
    4697         bf->bf_state.bf_type = BUF_AMPDU; 
    4698         INIT_LIST_HEAD(&bf_head); 
    4699         list_add(&bf->list, &bf_head); 
    4700 @@ -1751,10 +1829,10 @@ static void ath_tx_send_ampdu(struct ath 
    4701         ath_tx_addto_baw(sc, tid, bf->bf_state.seqno); 
    4702   
    4703         /* Queue to h/w without aggregation */ 
    4704 -       TX_STAT_INC(txctl->txq->axq_qnum, a_queued_hw); 
    4705 +       TX_STAT_INC(txq->axq_qnum, a_queued_hw); 
    4706         bf->bf_lastbf = bf; 
    4707 -       ath_tx_fill_desc(sc, bf, txctl->txq, fi->framelen); 
    4708 -       ath_tx_txqaddbuf(sc, txctl->txq, &bf_head, false); 
    4709 +       ath_tx_fill_desc(sc, bf, txq, fi->framelen); 
    4710 +       ath_tx_txqaddbuf(sc, txq, &bf_head, false); 
    4711  } 
    4712   
    4713  static void ath_tx_send_normal(struct ath_softc *sc, struct ath_txq *txq, 
    4714 @@ -1892,62 +1970,16 @@ static struct ath_buf *ath_tx_setup_buff 
    4715         return bf; 
    4716  } 
    4717   
    4718 -/* FIXME: tx power */ 
    4719 -static void ath_tx_start_dma(struct ath_softc *sc, struct sk_buff *skb, 
    4720 -                            struct ath_tx_control *txctl) 
    4721 -{ 
    4722 -       struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 
    4723 -       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 
    4724 -       struct ath_atx_tid *tid = NULL; 
    4725 -       struct ath_buf *bf; 
    4726 -       u8 tidno; 
    4727 - 
    4728 -       if (txctl->an && ieee80211_is_data_qos(hdr->frame_control)) { 
    4729 -               tidno = ieee80211_get_qos_ctl(hdr)[0] & 
    4730 -                       IEEE80211_QOS_CTL_TID_MASK; 
    4731 -               tid = ATH_AN_2_TID(txctl->an, tidno); 
    4732 - 
    4733 -               WARN_ON(tid->ac->txq != txctl->txq); 
    4734 -       } 
    4735 - 
    4736 -       if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) && tid) { 
    4737 -               /* 
    4738 -                * Try aggregation if it's a unicast data frame 
    4739 -                * and the destination is HT capable. 
    4740 -                */ 
    4741 -               ath_tx_send_ampdu(sc, tid, skb, txctl); 
    4742 -       } else { 
    4743 -               bf = ath_tx_setup_buffer(sc, txctl->txq, tid, skb); 
    4744 -               if (!bf) { 
    4745 -                       if (txctl->paprd) 
    4746 -                               dev_kfree_skb_any(skb); 
    4747 -                       else 
    4748 -                               ieee80211_free_txskb(sc->hw, skb); 
    4749 -                       return; 
    4750 -               } 
    4751 - 
    4752 -               bf->bf_state.bfs_paprd = txctl->paprd; 
    4753 - 
    4754 -               if (txctl->paprd) 
    4755 -                       bf->bf_state.bfs_paprd_timestamp = jiffies; 
    4756 - 
    4757 -               ath_tx_send_normal(sc, txctl->txq, tid, skb); 
    4758 -       } 
    4759 -} 
    4760 - 
    4761 -/* Upon failure caller should free skb */ 
    4762 -int ath_tx_start(struct ieee80211_hw *hw, struct sk_buff *skb, 
    4763 -                struct ath_tx_control *txctl) 
    4764 +static int ath_tx_prepare(struct ieee80211_hw *hw, struct sk_buff *skb, 
    4765 +                         struct ath_tx_control *txctl) 
    4766  { 
    4767         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 
    4768         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 
    4769         struct ieee80211_sta *sta = txctl->sta; 
    4770         struct ieee80211_vif *vif = info->control.vif; 
    4771         struct ath_softc *sc = hw->priv; 
    4772 -       struct ath_txq *txq = txctl->txq; 
    4773 -       int padpos, padsize; 
    4774         int frmlen = skb->len + FCS_LEN; 
    4775 -       int q; 
    4776 +       int padpos, padsize; 
    4777   
    4778         /* NOTE:  sta can be NULL according to net/mac80211.h */ 
    4779         if (sta) 
    4780 @@ -1968,6 +2000,11 @@ int ath_tx_start(struct ieee80211_hw *hw 
    4781                 hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no); 
    4782         } 
    4783   
    4784 +       if ((vif && vif->type != NL80211_IFTYPE_AP && 
    4785 +                   vif->type != NL80211_IFTYPE_AP_VLAN) || 
    4786 +           !ieee80211_is_data(hdr->frame_control)) 
    4787 +               info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT; 
    4788 + 
    4789         /* Add the padding after the header if this is not already done */ 
    4790         padpos = ieee80211_hdrlen(hdr->frame_control); 
    4791         padsize = padpos & 3; 
    4792 @@ -1977,16 +2014,34 @@ int ath_tx_start(struct ieee80211_hw *hw 
    4793   
    4794                 skb_push(skb, padsize); 
    4795                 memmove(skb->data, skb->data + padsize, padpos); 
    4796 -               hdr = (struct ieee80211_hdr *) skb->data; 
    4797         } 
    4798   
    4799 -       if ((vif && vif->type != NL80211_IFTYPE_AP && 
    4800 -                   vif->type != NL80211_IFTYPE_AP_VLAN) || 
    4801 -           !ieee80211_is_data(hdr->frame_control)) 
    4802 -               info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT; 
    4803 - 
    4804         setup_frame_info(hw, sta, skb, frmlen); 
    4805 +       return 0; 
    4806 +} 
    4807   
    4808 + 
    4809 +/* Upon failure caller should free skb */ 
    4810 +int ath_tx_start(struct ieee80211_hw *hw, struct sk_buff *skb, 
    4811 +                struct ath_tx_control *txctl) 
    4812 +{ 
    4813 +       struct ieee80211_hdr *hdr; 
    4814 +       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 
    4815 +       struct ieee80211_sta *sta = txctl->sta; 
    4816 +       struct ieee80211_vif *vif = info->control.vif; 
    4817 +       struct ath_softc *sc = hw->priv; 
    4818 +       struct ath_txq *txq = txctl->txq; 
    4819 +       struct ath_atx_tid *tid = NULL; 
    4820 +       struct ath_buf *bf; 
    4821 +       u8 tidno; 
    4822 +       int q; 
    4823 +       int ret; 
    4824 + 
    4825 +       ret = ath_tx_prepare(hw, skb, txctl); 
    4826 +       if (ret) 
    4827 +           return ret; 
    4828 + 
    4829 +       hdr = (struct ieee80211_hdr *) skb->data; 
    4830         /* 
    4831          * At this point, the vif, hw_key and sta pointers in the tx control 
    4832          * info are no longer valid (overwritten by the ath_frame_info data. 
    4833 @@ -2002,13 +2057,120 @@ int ath_tx_start(struct ieee80211_hw *hw 
    4834                 txq->stopped = true; 
    4835         } 
    4836   
    4837 -       ath_tx_start_dma(sc, skb, txctl); 
    4838 +       if (info->flags & IEEE80211_TX_CTL_PS_RESPONSE) { 
    4839 +               ath_txq_unlock(sc, txq); 
    4840 +               txq = sc->tx.uapsdq; 
    4841 +               ath_txq_lock(sc, txq); 
    4842 +       } 
    4843 + 
    4844 +       if (txctl->an && ieee80211_is_data_qos(hdr->frame_control)) { 
    4845 +               tidno = ieee80211_get_qos_ctl(hdr)[0] & 
    4846 +                       IEEE80211_QOS_CTL_TID_MASK; 
    4847 +               tid = ATH_AN_2_TID(txctl->an, tidno); 
    4848 + 
    4849 +               WARN_ON(tid->ac->txq != txctl->txq); 
    4850 +       } 
    4851 + 
    4852 +       if ((info->flags & IEEE80211_TX_CTL_AMPDU) && tid) { 
    4853 +               /* 
    4854 +                * Try aggregation if it's a unicast data frame 
    4855 +                * and the destination is HT capable. 
    4856 +                */ 
    4857 +               ath_tx_send_ampdu(sc, txq, tid, skb, txctl); 
    4858 +               goto out; 
    4859 +       } 
    4860 + 
    4861 +       bf = ath_tx_setup_buffer(sc, txq, tid, skb); 
    4862 +       if (!bf) { 
    4863 +               if (txctl->paprd) 
    4864 +                       dev_kfree_skb_any(skb); 
    4865 +               else 
    4866 +                       ieee80211_free_txskb(sc->hw, skb); 
    4867 +               goto out; 
    4868 +       } 
    4869 + 
    4870 +       bf->bf_state.bfs_paprd = txctl->paprd; 
    4871   
    4872 +       if (txctl->paprd) 
    4873 +               bf->bf_state.bfs_paprd_timestamp = jiffies; 
    4874 + 
    4875 +       ath_set_rates(vif, sta, bf); 
    4876 +       ath_tx_send_normal(sc, txq, tid, skb); 
    4877 + 
    4878 +out: 
    4879         ath_txq_unlock(sc, txq); 
    4880   
    4881         return 0; 
    4882  } 
    4883   
    4884 +void ath_tx_cabq(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 
    4885 +                struct sk_buff *skb) 
    4886 +{ 
    4887 +       struct ath_softc *sc = hw->priv; 
    4888 +       struct ath_tx_control txctl = { 
    4889 +               .txq = sc->beacon.cabq 
    4890 +       }; 
    4891 +       struct ath_tx_info info = {}; 
    4892 +       struct ieee80211_hdr *hdr; 
    4893 +       struct ath_buf *bf_tail = NULL; 
    4894 +       struct ath_buf *bf; 
    4895 +       LIST_HEAD(bf_q); 
    4896 +       int duration = 0; 
    4897 +       int max_duration; 
    4898 + 
    4899 +       max_duration = 
    4900 +               sc->cur_beacon_conf.beacon_interval * 1000 * 
    4901 +               sc->cur_beacon_conf.dtim_period / ATH_BCBUF; 
    4902 + 
    4903 +       do { 
    4904 +               struct ath_frame_info *fi = get_frame_info(skb); 
    4905 + 
    4906 +               if (ath_tx_prepare(hw, skb, &txctl)) 
    4907 +                       break; 
    4908 + 
    4909 +               bf = ath_tx_setup_buffer(sc, txctl.txq, NULL, skb); 
    4910 +               if (!bf) 
    4911 +                       break; 
    4912 + 
    4913 +               bf->bf_lastbf = bf; 
    4914 +               ath_set_rates(vif, NULL, bf); 
    4915 +               ath_buf_set_rate(sc, bf, &info, fi->framelen); 
    4916 +               duration += info.rates[0].PktDuration; 
    4917 +               if (bf_tail) 
    4918 +                       bf_tail->bf_next = bf; 
    4919 + 
    4920 +               list_add_tail(&bf->list, &bf_q); 
    4921 +               bf_tail = bf; 
    4922 +               skb = NULL; 
    4923 + 
    4924 +               if (duration > max_duration) 
    4925 +                       break; 
    4926 + 
    4927 +               skb = ieee80211_get_buffered_bc(hw, vif); 
    4928 +       } while(skb); 
    4929 + 
    4930 +       if (skb) 
    4931 +               ieee80211_free_txskb(hw, skb); 
    4932 + 
    4933 +       if (list_empty(&bf_q)) 
    4934 +               return; 
    4935 + 
    4936 +       bf = list_first_entry(&bf_q, struct ath_buf, list); 
    4937 +       hdr = (struct ieee80211_hdr *) bf->bf_mpdu->data; 
    4938 + 
    4939 +       if (hdr->frame_control & IEEE80211_FCTL_MOREDATA) { 
    4940 +               hdr->frame_control &= ~IEEE80211_FCTL_MOREDATA; 
    4941 +               dma_sync_single_for_device(sc->dev, bf->bf_buf_addr, 
    4942 +                       sizeof(*hdr), DMA_TO_DEVICE); 
    4943 +       } 
    4944 + 
    4945 +       ath_txq_lock(sc, txctl.txq); 
    4946 +       ath_tx_fill_desc(sc, bf, txctl.txq, 0); 
    4947 +       ath_tx_txqaddbuf(sc, txctl.txq, &bf_q, false); 
    4948 +       TX_STAT_INC(txctl.txq->axq_qnum, queued); 
    4949 +       ath_txq_unlock(sc, txctl.txq); 
    4950 +} 
    4951 + 
    4952  /*****************/ 
    4953  /* TX Completion */ 
    4954  /*****************/ 
    4955 @@ -2054,7 +2216,12 @@ static void ath_tx_complete(struct ath_s 
    4956         } 
    4957         spin_unlock_irqrestore(&sc->sc_pm_lock, flags); 
    4958   
    4959 +       __skb_queue_tail(&txq->complete_q, skb); 
    4960 + 
    4961         q = skb_get_queue_mapping(skb); 
    4962 +       if (txq == sc->tx.uapsdq) 
    4963 +               txq = sc->tx.txq_map[q]; 
    4964 + 
    4965         if (txq == sc->tx.txq_map[q]) { 
    4966                 if (WARN_ON(--txq->pending_frames < 0)) 
    4967                         txq->pending_frames = 0; 
    4968 @@ -2065,8 +2232,6 @@ static void ath_tx_complete(struct ath_s 
    4969                         txq->stopped = false; 
    4970                 } 
    4971         } 
    4972 - 
    4973 -       __skb_queue_tail(&txq->complete_q, skb); 
    4974  } 
    4975   
    4976  static void ath_tx_complete_buf(struct ath_softc *sc, struct ath_buf *bf, 
    4977 @@ -2408,12 +2573,10 @@ void ath_tx_node_init(struct ath_softc * 
    4978                 tid->baw_head  = tid->baw_tail = 0; 
    4979                 tid->sched     = false; 
    4980                 tid->paused    = false; 
    4981 -               tid->state &= ~AGGR_CLEANUP; 
    4982 +               tid->active        = false; 
    4983                 __skb_queue_head_init(&tid->buf_q); 
    4984                 acno = TID_TO_WME_AC(tidno); 
    4985                 tid->ac = &an->ac[acno]; 
    4986 -               tid->state &= ~AGGR_ADDBA_COMPLETE; 
    4987 -               tid->state &= ~AGGR_ADDBA_PROGRESS; 
    4988         } 
    4989   
    4990         for (acno = 0, ac = &an->ac[acno]; 
    4991 @@ -2450,9 +2613,9 @@ void ath_tx_node_cleanup(struct ath_soft 
    4992                 } 
    4993   
    4994                 ath_tid_drain(sc, txq, tid); 
    4995 -               tid->state &= ~AGGR_ADDBA_COMPLETE; 
    4996 -               tid->state &= ~AGGR_CLEANUP; 
    4997 +               tid->active = false; 
    4998   
    4999                 ath_txq_unlock(sc, txq); 
    5000         } 
    5001  } 
    5002 + 
    5003 --- a/drivers/net/wireless/ath/ath9k/recv.c 
    5004 +++ b/drivers/net/wireless/ath/ath9k/recv.c 
    5005 @@ -124,7 +124,7 @@ static bool ath_rx_edma_buf_link(struct  
    5006   
    5007         SKB_CB_ATHBUF(skb) = bf; 
    5008         ath9k_hw_addrxbuf_edma(ah, bf->bf_buf_addr, qtype); 
    5009 -       skb_queue_tail(&rx_edma->rx_fifo, skb); 
    5010 +       __skb_queue_tail(&rx_edma->rx_fifo, skb); 
    5011   
    5012         return true; 
    5013  } 
    5014 @@ -155,7 +155,7 @@ static void ath_rx_remove_buffer(struct  
    5015   
    5016         rx_edma = &sc->rx.rx_edma[qtype]; 
    5017   
    5018 -       while ((skb = skb_dequeue(&rx_edma->rx_fifo)) != NULL) { 
    5019 +       while ((skb = __skb_dequeue(&rx_edma->rx_fifo)) != NULL) { 
    5020                 bf = SKB_CB_ATHBUF(skb); 
    5021                 BUG_ON(!bf); 
    5022                 list_add_tail(&bf->list, &sc->rx.rxbuf); 
    5023 @@ -1287,13 +1287,13 @@ int ath_rx_tasklet(struct ath_softc *sc, 
    5024                         goto requeue_drop_frag; 
    5025                 } 
    5026   
    5027 -               bf->bf_mpdu = requeue_skb; 
    5028 -               bf->bf_buf_addr = new_buf_addr; 
    5029 - 
    5030                 /* Unmap the frame */ 
    5031                 dma_unmap_single(sc->dev, bf->bf_buf_addr, 
    5032                                  common->rx_bufsize, dma_type); 
    5033   
    5034 +               bf->bf_mpdu = requeue_skb; 
    5035 +               bf->bf_buf_addr = new_buf_addr; 
    5036 + 
    5037                 skb_put(skb, rs.rs_datalen + ah->caps.rx_status_len); 
    5038                 if (ah->caps.rx_status_len) 
    5039                         skb_pull(skb, ah->caps.rx_status_len); 
    5040 --- a/net/wireless/core.c 
    5041 +++ b/net/wireless/core.c 
    5042 @@ -885,7 +885,6 @@ void cfg80211_leave(struct cfg80211_regi 
    5043  #endif 
    5044                 __cfg80211_disconnect(rdev, dev, 
    5045                                       WLAN_REASON_DEAUTH_LEAVING, true); 
    5046 -               cfg80211_mlme_down(rdev, dev); 
    5047                 wdev_unlock(wdev); 
    5048                 break; 
    5049         case NL80211_IFTYPE_MESH_POINT: 
    5050 --- a/net/wireless/sme.c 
    5051 +++ b/net/wireless/sme.c 
    5052 @@ -961,7 +961,7 @@ int __cfg80211_disconnect(struct cfg8021 
    5053                 /* was it connected by userspace SME? */ 
    5054                 if (!wdev->conn) { 
    5055                         cfg80211_mlme_down(rdev, dev); 
    5056 -                       return 0; 
    5057 +                       goto disconnect; 
    5058                 } 
    5059   
    5060                 if (wdev->sme_state == CFG80211_SME_CONNECTING && 
    5061 @@ -987,6 +987,7 @@ int __cfg80211_disconnect(struct cfg8021 
    5062                         return err; 
    5063         } 
    5064   
    5065 + disconnect: 
    5066         if (wdev->sme_state == CFG80211_SME_CONNECTED) 
    5067                 __cfg80211_disconnected(dev, NULL, 0, 0, false); 
    5068         else if (wdev->sme_state == CFG80211_SME_CONNECTING) 
    5069 --- a/drivers/net/wireless/ath/ath9k/rc.c 
    5070 +++ b/drivers/net/wireless/ath/ath9k/rc.c 
    5071 @@ -1227,10 +1227,7 @@ static bool ath_tx_aggr_check(struct ath 
    5072                 return false; 
    5073   
    5074         txtid = ATH_AN_2_TID(an, tidno); 
    5075 - 
    5076 -       if (!(txtid->state & (AGGR_ADDBA_COMPLETE | AGGR_ADDBA_PROGRESS))) 
    5077 -                       return true; 
    5078 -       return false; 
    5079 +       return !txtid->active; 
    5080  } 
    5081   
    5082   
    5083 --- a/drivers/net/wireless/ath/ath9k/ar9003_phy.c 
    5084 +++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c 
    5085 @@ -334,7 +334,8 @@ static void ar9003_hw_spur_ofdm(struct a 
    5086         REG_RMW_FIELD(ah, AR_PHY_SPUR_REG, 
    5087                       AR_PHY_SPUR_REG_EN_VIT_SPUR_RSSI, 1); 
    5088   
    5089 -       if (REG_READ_FIELD(ah, AR_PHY_MODE, 
    5090 +       if (!AR_SREV_9340(ah) && 
    5091 +           REG_READ_FIELD(ah, AR_PHY_MODE, 
    5092                            AR_PHY_MODE_DYNAMIC) == 0x1) 
    5093                 REG_RMW_FIELD(ah, AR_PHY_SPUR_REG, 
    5094                               AR_PHY_SPUR_REG_ENABLE_NF_RSSI_SPUR_MIT, 1); 
    5095 --- a/drivers/net/wireless/ath/ath9k/mac.c 
    5096 +++ b/drivers/net/wireless/ath/ath9k/mac.c 
    5097 @@ -410,7 +410,7 @@ bool ath9k_hw_resettxqueue(struct ath_hw 
    5098   
    5099         REG_WRITE(ah, AR_QMISC(q), AR_Q_MISC_DCU_EARLY_TERM_REQ); 
    5100   
    5101 -       if (AR_SREV_9340(ah)) 
    5102 +       if (AR_SREV_9340(ah) && !AR_SREV_9340_13_OR_LATER(ah)) 
    5103                 REG_WRITE(ah, AR_DMISC(q), 
    5104                           AR_D_MISC_CW_BKOFF_EN | AR_D_MISC_FRAG_WAIT_EN | 0x1); 
    5105         else 
    5106 --- a/net/mac80211/driver-ops.h 
    5107 +++ b/net/mac80211/driver-ops.h 
    5108 @@ -146,7 +146,8 @@ static inline int drv_add_interface(stru 
    5109   
    5110         if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 
    5111                     (sdata->vif.type == NL80211_IFTYPE_MONITOR && 
    5112 -                    !(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF)))) 
    5113 +                    !(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF) && 
    5114 +                    !(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE)))) 
    5115                 return -EINVAL; 
    5116   
    5117         trace_drv_add_interface(local, sdata); 
    5118 --- a/drivers/net/wireless/ath/ath9k/ar9003_paprd.c 
    5119 +++ b/drivers/net/wireless/ath/ath9k/ar9003_paprd.c 
    5120 @@ -454,6 +454,8 @@ static bool create_pa_curve(u32 *data_L, 
    5121                 if (accum_cnt <= thresh_accum_cnt) 
    5122                         continue; 
    5123   
    5124 +               max_index++; 
    5125 + 
    5126                 /* sum(tx amplitude) */ 
    5127                 accum_tx = ((data_L[i] >> 16) & 0xffff) | 
    5128                     ((data_U[i] & 0x7ff) << 16); 
    5129 @@ -468,20 +470,21 @@ static bool create_pa_curve(u32 *data_L, 
    5130   
    5131                 accum_tx <<= scale_factor; 
    5132                 accum_rx <<= scale_factor; 
    5133 -               x_est[i + 1] = (((accum_tx + accum_cnt) / accum_cnt) + 32) >> 
    5134 -                   scale_factor; 
    5135 +               x_est[max_index] = 
    5136 +                       (((accum_tx + accum_cnt) / accum_cnt) + 32) >> 
    5137 +                       scale_factor; 
    5138   
    5139 -               Y[i + 1] = ((((accum_rx + accum_cnt) / accum_cnt) + 32) >> 
    5140 +               Y[max_index] = 
    5141 +                       ((((accum_rx + accum_cnt) / accum_cnt) + 32) >> 
    5142                             scale_factor) + 
    5143 -                           (1 << scale_factor) * max_index + 16; 
    5144 +                       (1 << scale_factor) * i + 16; 
    5145   
    5146                 if (accum_ang >= (1 << 26)) 
    5147                         accum_ang -= 1 << 27; 
    5148   
    5149 -               theta[i + 1] = ((accum_ang * (1 << scale_factor)) + accum_cnt) / 
    5150 -                   accum_cnt; 
    5151 - 
    5152 -               max_index++; 
    5153 +               theta[max_index] = 
    5154 +                       ((accum_ang * (1 << scale_factor)) + accum_cnt) / 
    5155 +                       accum_cnt; 
    5156         } 
    5157   
    5158         /* 
    5159 --- a/drivers/net/wireless/ath/ath9k/beacon.c 
    5160 +++ b/drivers/net/wireless/ath/ath9k/beacon.c 
    5161 @@ -107,23 +107,6 @@ static void ath9k_beacon_setup(struct at 
    5162         ath9k_hw_set_txdesc(ah, bf->bf_desc, &info); 
    5163  } 
    5164   
    5165 -static void ath9k_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb) 
    5166 -{ 
    5167 -       struct ath_softc *sc = hw->priv; 
    5168 -       struct ath_common *common = ath9k_hw_common(sc->sc_ah); 
    5169 -       struct ath_tx_control txctl; 
    5170 - 
    5171 -       memset(&txctl, 0, sizeof(struct ath_tx_control)); 
    5172 -       txctl.txq = sc->beacon.cabq; 
    5173 - 
    5174 -       ath_dbg(common, XMIT, "transmitting CABQ packet, skb: %p\n", skb); 
    5175 - 
    5176 -       if (ath_tx_start(hw, skb, &txctl) != 0) { 
    5177 -               ath_dbg(common, XMIT, "CABQ TX failed\n"); 
    5178 -               ieee80211_free_txskb(hw, skb); 
    5179 -       } 
    5180 -} 
    5181 - 
    5182  static struct ath_buf *ath9k_beacon_generate(struct ieee80211_hw *hw, 
    5183                                              struct ieee80211_vif *vif) 
    5184  { 
    5185 @@ -205,10 +188,8 @@ static struct ath_buf *ath9k_beacon_gene 
    5186   
    5187         ath9k_beacon_setup(sc, vif, bf, info->control.rates[0].idx); 
    5188   
    5189 -       while (skb) { 
    5190 -               ath9k_tx_cabq(hw, skb); 
    5191 -               skb = ieee80211_get_buffered_bc(hw, vif); 
    5192 -       } 
    5193 +       if (skb) 
    5194 +               ath_tx_cabq(hw, vif, skb); 
    5195   
    5196         return bf; 
    5197  } 
    5198 --- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h 
    5199 +++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h 
    5200 @@ -68,13 +68,16 @@ 
    5201  #define AR9300_BASE_ADDR 0x3ff 
    5202  #define AR9300_BASE_ADDR_512 0x1ff 
    5203   
    5204 -#define AR9300_OTP_BASE                        (AR_SREV_9340(ah) ? 0x30000 : 0x14000) 
    5205 -#define AR9300_OTP_STATUS              (AR_SREV_9340(ah) ? 0x30018 : 0x15f18) 
    5206 +#define AR9300_OTP_BASE \ 
    5207 +               ((AR_SREV_9340(ah) || AR_SREV_9550(ah)) ? 0x30000 : 0x14000) 
    5208 +#define AR9300_OTP_STATUS \ 
    5209 +               ((AR_SREV_9340(ah) || AR_SREV_9550(ah)) ? 0x30018 : 0x15f18) 
    5210  #define AR9300_OTP_STATUS_TYPE         0x7 
    5211  #define AR9300_OTP_STATUS_VALID                0x4 
    5212  #define AR9300_OTP_STATUS_ACCESS_BUSY  0x2 
    5213  #define AR9300_OTP_STATUS_SM_BUSY      0x1 
    5214 -#define AR9300_OTP_READ_DATA           (AR_SREV_9340(ah) ? 0x3001c : 0x15f1c) 
    5215 +#define AR9300_OTP_READ_DATA \ 
    5216 +               ((AR_SREV_9340(ah) || AR_SREV_9550(ah)) ? 0x3001c : 0x15f1c) 
    5217   
    5218  enum targetPowerHTRates { 
    5219         HT_TARGET_RATE_0_8_16, 
     282 struct sta_ampdu_mlme { 
     283        struct mutex mtx; 
  • trunk/package/mac80211/patches/310-ap_scan.patch

    r36743 r36939  
    11--- a/net/mac80211/cfg.c 
    22+++ b/net/mac80211/cfg.c 
    3 @@ -2081,7 +2081,7 @@ static int ieee80211_scan(struct wiphy * 
     3@@ -2092,7 +2092,7 @@ static int ieee80211_scan(struct wiphy * 
    44                 * the  frames sent while scanning on other channel will be 
    55                 * lost) 
  • trunk/package/mac80211/patches/400-ath_move_debug_code.patch

    r35063 r36939  
    11--- a/drivers/net/wireless/ath/Makefile 
    22+++ b/drivers/net/wireless/ath/Makefile 
    3 @@ -10,7 +10,7 @@ obj-$(CONFIG_ATH_COMMON)      += ath.o 
     3@@ -11,7 +11,7 @@ obj-$(CPTCFG_ATH_COMMON)      += ath.o 
    44 ath-objs :=    main.o \ 
    55                regd.o \ 
     
    99+               debug.o 
    1010  
    11 -ath-$(CONFIG_ATH_DEBUG) += debug.o 
     11-ath-$(CPTCFG_ATH_DEBUG) += debug.o 
    1212 ccflags-y += -D__CHECK_ENDIAN__ 
    1313--- a/drivers/net/wireless/ath/ath.h 
    1414+++ b/drivers/net/wireless/ath/ath.h 
    1515@@ -281,13 +281,6 @@ void _ath_dbg(struct ath_common *common, 
    16  #endif /* CONFIG_ATH_DEBUG */ 
     16 #endif /* CPTCFG_ATH_DEBUG */ 
    1717  
    1818 /** Returns string describing opmode, or NULL if unknown mode. */ 
    19 -#ifdef CONFIG_ATH_DEBUG 
     19-#ifdef CPTCFG_ATH_DEBUG 
    2020 const char *ath_opmode_to_string(enum nl80211_iftype opmode); 
    2121-#else 
  • trunk/package/mac80211/patches/401-ath9k_blink_default.patch

    r35753 r36939  
    11--- a/drivers/net/wireless/ath/ath9k/init.c 
    22+++ b/drivers/net/wireless/ath/ath9k/init.c 
    3 @@ -46,7 +46,7 @@ int ath9k_modparam_nohwcrypt; 
     3@@ -45,7 +45,7 @@ int ath9k_modparam_nohwcrypt; 
    44 module_param_named(nohwcrypt, ath9k_modparam_nohwcrypt, int, 0444); 
    55 MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption");