10332 lines · c
1// SPDX-License-Identifier: ISC2/*3 * Copyright (c) 2005-2011 Atheros Communications Inc.4 * Copyright (c) 2011-2017 Qualcomm Atheros, Inc.5 * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.6 * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.7 */8 9#include "mac.h"10 11#include <net/cfg80211.h>12#include <net/mac80211.h>13#include <linux/etherdevice.h>14#include <linux/acpi.h>15#include <linux/of.h>16#include <linux/bitfield.h>17 18#include "hif.h"19#include "core.h"20#include "debug.h"21#include "wmi.h"22#include "htt.h"23#include "txrx.h"24#include "testmode.h"25#include "wmi-tlv.h"26#include "wmi-ops.h"27#include "wow.h"28#include "leds.h"29 30/*********/31/* Rates */32/*********/33 34static struct ieee80211_rate ath10k_rates[] = {35 { .bitrate = 10,36 .hw_value = ATH10K_HW_RATE_CCK_LP_1M },37 { .bitrate = 20,38 .hw_value = ATH10K_HW_RATE_CCK_LP_2M,39 .hw_value_short = ATH10K_HW_RATE_CCK_SP_2M,40 .flags = IEEE80211_RATE_SHORT_PREAMBLE },41 { .bitrate = 55,42 .hw_value = ATH10K_HW_RATE_CCK_LP_5_5M,43 .hw_value_short = ATH10K_HW_RATE_CCK_SP_5_5M,44 .flags = IEEE80211_RATE_SHORT_PREAMBLE },45 { .bitrate = 110,46 .hw_value = ATH10K_HW_RATE_CCK_LP_11M,47 .hw_value_short = ATH10K_HW_RATE_CCK_SP_11M,48 .flags = IEEE80211_RATE_SHORT_PREAMBLE },49 50 { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M },51 { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M },52 { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M },53 { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M },54 { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M },55 { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M },56 { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M },57 { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M },58};59 60static struct ieee80211_rate ath10k_rates_rev2[] = {61 { .bitrate = 10,62 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_1M },63 { .bitrate = 20,64 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_2M,65 .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_2M,66 .flags = IEEE80211_RATE_SHORT_PREAMBLE },67 { .bitrate = 55,68 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_5_5M,69 .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_5_5M,70 .flags = IEEE80211_RATE_SHORT_PREAMBLE },71 { .bitrate = 110,72 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_11M,73 .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_11M,74 .flags = IEEE80211_RATE_SHORT_PREAMBLE },75 76 { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M },77 { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M },78 { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M },79 { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M },80 { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M },81 { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M },82 { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M },83 { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M },84};85 86static const struct cfg80211_sar_freq_ranges ath10k_sar_freq_ranges[] = {87 {.start_freq = 2402, .end_freq = 2494 },88 {.start_freq = 5170, .end_freq = 5875 },89};90 91static const struct cfg80211_sar_capa ath10k_sar_capa = {92 .type = NL80211_SAR_TYPE_POWER,93 .num_freq_ranges = (ARRAY_SIZE(ath10k_sar_freq_ranges)),94 .freq_ranges = &ath10k_sar_freq_ranges[0],95};96 97#define ATH10K_MAC_FIRST_OFDM_RATE_IDX 498 99#define ath10k_a_rates (ath10k_rates + ATH10K_MAC_FIRST_OFDM_RATE_IDX)100#define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - \101 ATH10K_MAC_FIRST_OFDM_RATE_IDX)102#define ath10k_g_rates (ath10k_rates + 0)103#define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))104 105#define ath10k_g_rates_rev2 (ath10k_rates_rev2 + 0)106#define ath10k_g_rates_rev2_size (ARRAY_SIZE(ath10k_rates_rev2))107 108#define ath10k_wmi_legacy_rates ath10k_rates109 110static bool ath10k_mac_bitrate_is_cck(int bitrate)111{112 switch (bitrate) {113 case 10:114 case 20:115 case 55:116 case 110:117 return true;118 }119 120 return false;121}122 123static u8 ath10k_mac_bitrate_to_rate(int bitrate)124{125 return DIV_ROUND_UP(bitrate, 5) |126 (ath10k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);127}128 129u8 ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,130 u8 hw_rate, bool cck)131{132 const struct ieee80211_rate *rate;133 int i;134 135 for (i = 0; i < sband->n_bitrates; i++) {136 rate = &sband->bitrates[i];137 138 if (ath10k_mac_bitrate_is_cck(rate->bitrate) != cck)139 continue;140 141 if (rate->hw_value == hw_rate)142 return i;143 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&144 rate->hw_value_short == hw_rate)145 return i;146 }147 148 return 0;149}150 151u8 ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,152 u32 bitrate)153{154 int i;155 156 for (i = 0; i < sband->n_bitrates; i++)157 if (sband->bitrates[i].bitrate == bitrate)158 return i;159 160 return 0;161}162 163static int ath10k_mac_get_rate_hw_value(int bitrate)164{165 int i;166 u8 hw_value_prefix = 0;167 168 if (ath10k_mac_bitrate_is_cck(bitrate))169 hw_value_prefix = WMI_RATE_PREAMBLE_CCK << 6;170 171 for (i = 0; i < ARRAY_SIZE(ath10k_rates); i++) {172 if (ath10k_rates[i].bitrate == bitrate)173 return hw_value_prefix | ath10k_rates[i].hw_value;174 }175 176 return -EINVAL;177}178 179static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)180{181 switch ((mcs_map >> (2 * nss)) & 0x3) {182 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;183 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;184 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;185 }186 return 0;187}188 189static u32190ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])191{192 int nss;193 194 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)195 if (ht_mcs_mask[nss])196 return nss + 1;197 198 return 1;199}200 201static u32202ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])203{204 int nss;205 206 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)207 if (vht_mcs_mask[nss])208 return nss + 1;209 210 return 1;211}212 213int ath10k_mac_ext_resource_config(struct ath10k *ar, u32 val)214{215 enum wmi_host_platform_type platform_type;216 int ret;217 218 if (test_bit(WMI_SERVICE_TX_MODE_DYNAMIC, ar->wmi.svc_map))219 platform_type = WMI_HOST_PLATFORM_LOW_PERF;220 else221 platform_type = WMI_HOST_PLATFORM_HIGH_PERF;222 223 ret = ath10k_wmi_ext_resource_config(ar, platform_type, val);224 225 if (ret && ret != -EOPNOTSUPP) {226 ath10k_warn(ar, "failed to configure ext resource: %d\n", ret);227 return ret;228 }229 230 return 0;231}232 233/**********/234/* Crypto */235/**********/236 237static int ath10k_send_key(struct ath10k_vif *arvif,238 struct ieee80211_key_conf *key,239 enum set_key_cmd cmd,240 const u8 *macaddr, u32 flags)241{242 struct ath10k *ar = arvif->ar;243 struct wmi_vdev_install_key_arg arg = {244 .vdev_id = arvif->vdev_id,245 .key_idx = key->keyidx,246 .key_len = key->keylen,247 .key_data = key->key,248 .key_flags = flags,249 .macaddr = macaddr,250 };251 252 lockdep_assert_held(&arvif->ar->conf_mutex);253 254 switch (key->cipher) {255 case WLAN_CIPHER_SUITE_CCMP:256 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_CCM];257 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;258 break;259 case WLAN_CIPHER_SUITE_TKIP:260 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_TKIP];261 arg.key_txmic_len = 8;262 arg.key_rxmic_len = 8;263 break;264 case WLAN_CIPHER_SUITE_WEP40:265 case WLAN_CIPHER_SUITE_WEP104:266 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_WEP];267 break;268 case WLAN_CIPHER_SUITE_CCMP_256:269 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_CCM];270 break;271 case WLAN_CIPHER_SUITE_GCMP:272 case WLAN_CIPHER_SUITE_GCMP_256:273 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_GCM];274 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;275 break;276 case WLAN_CIPHER_SUITE_BIP_GMAC_128:277 case WLAN_CIPHER_SUITE_BIP_GMAC_256:278 case WLAN_CIPHER_SUITE_BIP_CMAC_256:279 case WLAN_CIPHER_SUITE_AES_CMAC:280 WARN_ON(1);281 return -EINVAL;282 default:283 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);284 return -EOPNOTSUPP;285 }286 287 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))288 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;289 290 if (cmd == DISABLE_KEY) {291 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_NONE];292 arg.key_data = NULL;293 }294 295 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);296}297 298static int ath10k_install_key(struct ath10k_vif *arvif,299 struct ieee80211_key_conf *key,300 enum set_key_cmd cmd,301 const u8 *macaddr, u32 flags)302{303 struct ath10k *ar = arvif->ar;304 int ret;305 unsigned long time_left;306 307 lockdep_assert_held(&ar->conf_mutex);308 309 reinit_completion(&ar->install_key_done);310 311 if (arvif->nohwcrypt)312 return 1;313 314 ret = ath10k_send_key(arvif, key, cmd, macaddr, flags);315 if (ret)316 return ret;317 318 time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ);319 if (time_left == 0)320 return -ETIMEDOUT;321 322 return 0;323}324 325static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,326 const u8 *addr)327{328 struct ath10k *ar = arvif->ar;329 struct ath10k_peer *peer;330 int ret;331 int i;332 u32 flags;333 334 lockdep_assert_held(&ar->conf_mutex);335 336 if (WARN_ON(arvif->vif->type != NL80211_IFTYPE_AP &&337 arvif->vif->type != NL80211_IFTYPE_ADHOC &&338 arvif->vif->type != NL80211_IFTYPE_MESH_POINT))339 return -EINVAL;340 341 spin_lock_bh(&ar->data_lock);342 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);343 spin_unlock_bh(&ar->data_lock);344 345 if (!peer)346 return -ENOENT;347 348 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {349 if (arvif->wep_keys[i] == NULL)350 continue;351 352 switch (arvif->vif->type) {353 case NL80211_IFTYPE_AP:354 flags = WMI_KEY_PAIRWISE;355 356 if (arvif->def_wep_key_idx == i)357 flags |= WMI_KEY_TX_USAGE;358 359 ret = ath10k_install_key(arvif, arvif->wep_keys[i],360 SET_KEY, addr, flags);361 if (ret < 0)362 return ret;363 break;364 case NL80211_IFTYPE_ADHOC:365 ret = ath10k_install_key(arvif, arvif->wep_keys[i],366 SET_KEY, addr,367 WMI_KEY_PAIRWISE);368 if (ret < 0)369 return ret;370 371 ret = ath10k_install_key(arvif, arvif->wep_keys[i],372 SET_KEY, addr, WMI_KEY_GROUP);373 if (ret < 0)374 return ret;375 break;376 default:377 WARN_ON(1);378 return -EINVAL;379 }380 381 spin_lock_bh(&ar->data_lock);382 peer->keys[i] = arvif->wep_keys[i];383 spin_unlock_bh(&ar->data_lock);384 }385 386 /* In some cases (notably with static WEP IBSS with multiple keys)387 * multicast Tx becomes broken. Both pairwise and groupwise keys are388 * installed already. Using WMI_KEY_TX_USAGE in different combinations389 * didn't seem help. Using def_keyid vdev parameter seems to be390 * effective so use that.391 *392 * FIXME: Revisit. Perhaps this can be done in a less hacky way.393 */394 if (arvif->vif->type != NL80211_IFTYPE_ADHOC)395 return 0;396 397 if (arvif->def_wep_key_idx == -1)398 return 0;399 400 ret = ath10k_wmi_vdev_set_param(arvif->ar,401 arvif->vdev_id,402 arvif->ar->wmi.vdev_param->def_keyid,403 arvif->def_wep_key_idx);404 if (ret) {405 ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n",406 arvif->vdev_id, ret);407 return ret;408 }409 410 return 0;411}412 413static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,414 const u8 *addr)415{416 struct ath10k *ar = arvif->ar;417 struct ath10k_peer *peer;418 int first_errno = 0;419 int ret;420 int i;421 u32 flags = 0;422 423 lockdep_assert_held(&ar->conf_mutex);424 425 spin_lock_bh(&ar->data_lock);426 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);427 spin_unlock_bh(&ar->data_lock);428 429 if (!peer)430 return -ENOENT;431 432 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {433 if (peer->keys[i] == NULL)434 continue;435 436 /* key flags are not required to delete the key */437 ret = ath10k_install_key(arvif, peer->keys[i],438 DISABLE_KEY, addr, flags);439 if (ret < 0 && first_errno == 0)440 first_errno = ret;441 442 if (ret < 0)443 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",444 i, ret);445 446 spin_lock_bh(&ar->data_lock);447 peer->keys[i] = NULL;448 spin_unlock_bh(&ar->data_lock);449 }450 451 return first_errno;452}453 454bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,455 u8 keyidx)456{457 struct ath10k_peer *peer;458 int i;459 460 lockdep_assert_held(&ar->data_lock);461 462 /* We don't know which vdev this peer belongs to,463 * since WMI doesn't give us that information.464 *465 * FIXME: multi-bss needs to be handled.466 */467 peer = ath10k_peer_find(ar, 0, addr);468 if (!peer)469 return false;470 471 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {472 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)473 return true;474 }475 476 return false;477}478 479static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,480 struct ieee80211_key_conf *key)481{482 struct ath10k *ar = arvif->ar;483 struct ath10k_peer *peer;484 u8 addr[ETH_ALEN];485 int first_errno = 0;486 int ret;487 int i;488 u32 flags = 0;489 490 lockdep_assert_held(&ar->conf_mutex);491 492 for (;;) {493 /* since ath10k_install_key we can't hold data_lock all the494 * time, so we try to remove the keys incrementally495 */496 spin_lock_bh(&ar->data_lock);497 i = 0;498 list_for_each_entry(peer, &ar->peers, list) {499 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {500 if (peer->keys[i] == key) {501 ether_addr_copy(addr, peer->addr);502 peer->keys[i] = NULL;503 break;504 }505 }506 507 if (i < ARRAY_SIZE(peer->keys))508 break;509 }510 spin_unlock_bh(&ar->data_lock);511 512 if (i == ARRAY_SIZE(peer->keys))513 break;514 /* key flags are not required to delete the key */515 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags);516 if (ret < 0 && first_errno == 0)517 first_errno = ret;518 519 if (ret)520 ath10k_warn(ar, "failed to remove key for %pM: %d\n",521 addr, ret);522 }523 524 return first_errno;525}526 527static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif,528 struct ieee80211_key_conf *key)529{530 struct ath10k *ar = arvif->ar;531 struct ath10k_peer *peer;532 int ret;533 534 lockdep_assert_held(&ar->conf_mutex);535 536 list_for_each_entry(peer, &ar->peers, list) {537 if (ether_addr_equal(peer->addr, arvif->vif->addr))538 continue;539 540 if (ether_addr_equal(peer->addr, arvif->bssid))541 continue;542 543 if (peer->keys[key->keyidx] == key)544 continue;545 546 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n",547 arvif->vdev_id, key->keyidx);548 549 ret = ath10k_install_peer_wep_keys(arvif, peer->addr);550 if (ret) {551 ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n",552 arvif->vdev_id, peer->addr, ret);553 return ret;554 }555 }556 557 return 0;558}559 560/*********************/561/* General utilities */562/*********************/563 564static inline enum wmi_phy_mode565chan_to_phymode(const struct cfg80211_chan_def *chandef)566{567 enum wmi_phy_mode phymode = MODE_UNKNOWN;568 569 switch (chandef->chan->band) {570 case NL80211_BAND_2GHZ:571 switch (chandef->width) {572 case NL80211_CHAN_WIDTH_20_NOHT:573 if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)574 phymode = MODE_11B;575 else576 phymode = MODE_11G;577 break;578 case NL80211_CHAN_WIDTH_20:579 phymode = MODE_11NG_HT20;580 break;581 case NL80211_CHAN_WIDTH_40:582 phymode = MODE_11NG_HT40;583 break;584 default:585 phymode = MODE_UNKNOWN;586 break;587 }588 break;589 case NL80211_BAND_5GHZ:590 switch (chandef->width) {591 case NL80211_CHAN_WIDTH_20_NOHT:592 phymode = MODE_11A;593 break;594 case NL80211_CHAN_WIDTH_20:595 phymode = MODE_11NA_HT20;596 break;597 case NL80211_CHAN_WIDTH_40:598 phymode = MODE_11NA_HT40;599 break;600 case NL80211_CHAN_WIDTH_80:601 phymode = MODE_11AC_VHT80;602 break;603 case NL80211_CHAN_WIDTH_160:604 phymode = MODE_11AC_VHT160;605 break;606 case NL80211_CHAN_WIDTH_80P80:607 phymode = MODE_11AC_VHT80_80;608 break;609 default:610 phymode = MODE_UNKNOWN;611 break;612 }613 break;614 default:615 break;616 }617 618 WARN_ON(phymode == MODE_UNKNOWN);619 return phymode;620}621 622static u8 ath10k_parse_mpdudensity(u8 mpdudensity)623{624/*625 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":626 * 0 for no restriction627 * 1 for 1/4 us628 * 2 for 1/2 us629 * 3 for 1 us630 * 4 for 2 us631 * 5 for 4 us632 * 6 for 8 us633 * 7 for 16 us634 */635 switch (mpdudensity) {636 case 0:637 return 0;638 case 1:639 case 2:640 case 3:641 /* Our lower layer calculations limit our precision to642 * 1 microsecond643 */644 return 1;645 case 4:646 return 2;647 case 5:648 return 4;649 case 6:650 return 8;651 case 7:652 return 16;653 default:654 return 0;655 }656}657 658int ath10k_mac_vif_chan(struct ieee80211_vif *vif,659 struct cfg80211_chan_def *def)660{661 struct ieee80211_chanctx_conf *conf;662 663 rcu_read_lock();664 conf = rcu_dereference(vif->bss_conf.chanctx_conf);665 if (!conf) {666 rcu_read_unlock();667 return -ENOENT;668 }669 670 *def = conf->def;671 rcu_read_unlock();672 673 return 0;674}675 676static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw,677 struct ieee80211_chanctx_conf *conf,678 void *data)679{680 int *num = data;681 682 (*num)++;683}684 685static int ath10k_mac_num_chanctxs(struct ath10k *ar)686{687 int num = 0;688 689 ieee80211_iter_chan_contexts_atomic(ar->hw,690 ath10k_mac_num_chanctxs_iter,691 &num);692 693 return num;694}695 696static void697ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,698 struct ieee80211_chanctx_conf *conf,699 void *data)700{701 struct cfg80211_chan_def **def = data;702 703 *def = &conf->def;704}705 706static void ath10k_wait_for_peer_delete_done(struct ath10k *ar, u32 vdev_id,707 const u8 *addr)708{709 unsigned long time_left;710 int ret;711 712 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) {713 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);714 if (ret) {715 ath10k_warn(ar, "failed wait for peer deleted");716 return;717 }718 719 time_left = wait_for_completion_timeout(&ar->peer_delete_done,720 5 * HZ);721 if (!time_left)722 ath10k_warn(ar, "Timeout in receiving peer delete response\n");723 }724}725 726static int ath10k_peer_create(struct ath10k *ar,727 struct ieee80211_vif *vif,728 struct ieee80211_sta *sta,729 u32 vdev_id,730 const u8 *addr,731 enum wmi_peer_type peer_type)732{733 struct ath10k_peer *peer;734 int ret;735 736 lockdep_assert_held(&ar->conf_mutex);737 738 /* Each vdev consumes a peer entry as well. */739 if (ar->num_peers + list_count_nodes(&ar->arvifs) >= ar->max_num_peers)740 return -ENOBUFS;741 742 ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type);743 if (ret) {744 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",745 addr, vdev_id, ret);746 return ret;747 }748 749 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);750 if (ret) {751 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",752 addr, vdev_id, ret);753 return ret;754 }755 756 spin_lock_bh(&ar->data_lock);757 758 peer = ath10k_peer_find(ar, vdev_id, addr);759 if (!peer) {760 spin_unlock_bh(&ar->data_lock);761 ath10k_warn(ar, "failed to find peer %pM on vdev %i after creation\n",762 addr, vdev_id);763 ath10k_wait_for_peer_delete_done(ar, vdev_id, addr);764 return -ENOENT;765 }766 767 peer->vif = vif;768 peer->sta = sta;769 770 spin_unlock_bh(&ar->data_lock);771 772 ar->num_peers++;773 774 return 0;775}776 777static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)778{779 struct ath10k *ar = arvif->ar;780 u32 param;781 int ret;782 783 param = ar->wmi.pdev_param->sta_kickout_th;784 ret = ath10k_wmi_pdev_set_param(ar, param,785 ATH10K_KICKOUT_THRESHOLD);786 if (ret) {787 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",788 arvif->vdev_id, ret);789 return ret;790 }791 792 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;793 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,794 ATH10K_KEEPALIVE_MIN_IDLE);795 if (ret) {796 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",797 arvif->vdev_id, ret);798 return ret;799 }800 801 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;802 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,803 ATH10K_KEEPALIVE_MAX_IDLE);804 if (ret) {805 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",806 arvif->vdev_id, ret);807 return ret;808 }809 810 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;811 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,812 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);813 if (ret) {814 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",815 arvif->vdev_id, ret);816 return ret;817 }818 819 return 0;820}821 822static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)823{824 struct ath10k *ar = arvif->ar;825 u32 vdev_param;826 827 vdev_param = ar->wmi.vdev_param->rts_threshold;828 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);829}830 831static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)832{833 int ret;834 835 lockdep_assert_held(&ar->conf_mutex);836 837 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);838 if (ret)839 return ret;840 841 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);842 if (ret)843 return ret;844 845 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) {846 unsigned long time_left;847 848 time_left = wait_for_completion_timeout849 (&ar->peer_delete_done, 5 * HZ);850 851 if (!time_left) {852 ath10k_warn(ar, "Timeout in receiving peer delete response\n");853 return -ETIMEDOUT;854 }855 }856 857 ar->num_peers--;858 859 return 0;860}861 862static void ath10k_peer_map_cleanup(struct ath10k *ar, struct ath10k_peer *peer)863{864 int peer_id, i;865 866 lockdep_assert_held(&ar->conf_mutex);867 868 for_each_set_bit(peer_id, peer->peer_ids,869 ATH10K_MAX_NUM_PEER_IDS) {870 ar->peer_map[peer_id] = NULL;871 }872 873 /* Double check that peer is properly un-referenced from874 * the peer_map875 */876 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {877 if (ar->peer_map[i] == peer) {878 ath10k_warn(ar, "removing stale peer_map entry for %pM (ptr %pK idx %d)\n",879 peer->addr, peer, i);880 ar->peer_map[i] = NULL;881 }882 }883 884 list_del(&peer->list);885 kfree(peer);886 ar->num_peers--;887}888 889static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)890{891 struct ath10k_peer *peer, *tmp;892 893 lockdep_assert_held(&ar->conf_mutex);894 895 spin_lock_bh(&ar->data_lock);896 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {897 if (peer->vdev_id != vdev_id)898 continue;899 900 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",901 peer->addr, vdev_id);902 903 ath10k_peer_map_cleanup(ar, peer);904 }905 spin_unlock_bh(&ar->data_lock);906}907 908static void ath10k_peer_cleanup_all(struct ath10k *ar)909{910 struct ath10k_peer *peer, *tmp;911 int i;912 913 lockdep_assert_held(&ar->conf_mutex);914 915 spin_lock_bh(&ar->data_lock);916 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {917 list_del(&peer->list);918 kfree(peer);919 }920 921 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++)922 ar->peer_map[i] = NULL;923 924 spin_unlock_bh(&ar->data_lock);925 926 ar->num_peers = 0;927 ar->num_stations = 0;928}929 930static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id,931 struct ieee80211_sta *sta,932 enum wmi_tdls_peer_state state)933{934 int ret;935 struct wmi_tdls_peer_update_cmd_arg arg = {};936 struct wmi_tdls_peer_capab_arg cap = {};937 struct wmi_channel_arg chan_arg = {};938 939 lockdep_assert_held(&ar->conf_mutex);940 941 arg.vdev_id = vdev_id;942 arg.peer_state = state;943 ether_addr_copy(arg.addr, sta->addr);944 945 cap.peer_max_sp = sta->max_sp;946 cap.peer_uapsd_queues = sta->uapsd_queues;947 948 if (state == WMI_TDLS_PEER_STATE_CONNECTED &&949 !sta->tdls_initiator)950 cap.is_peer_responder = 1;951 952 ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg);953 if (ret) {954 ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n",955 arg.addr, vdev_id, ret);956 return ret;957 }958 959 return 0;960}961 962/************************/963/* Interface management */964/************************/965 966void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)967{968 struct ath10k *ar = arvif->ar;969 970 lockdep_assert_held(&ar->data_lock);971 972 if (!arvif->beacon)973 return;974 975 if (!arvif->beacon_buf)976 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,977 arvif->beacon->len, DMA_TO_DEVICE);978 979 if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED &&980 arvif->beacon_state != ATH10K_BEACON_SENT))981 return;982 983 dev_kfree_skb_any(arvif->beacon);984 985 arvif->beacon = NULL;986 arvif->beacon_state = ATH10K_BEACON_SCHEDULED;987}988 989static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)990{991 struct ath10k *ar = arvif->ar;992 993 lockdep_assert_held(&ar->data_lock);994 995 ath10k_mac_vif_beacon_free(arvif);996 997 if (arvif->beacon_buf) {998 if (ar->bus_param.dev_type == ATH10K_DEV_TYPE_HL)999 kfree(arvif->beacon_buf);1000 else1001 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,1002 arvif->beacon_buf,1003 arvif->beacon_paddr);1004 arvif->beacon_buf = NULL;1005 }1006}1007 1008static inline int ath10k_vdev_setup_sync(struct ath10k *ar)1009{1010 unsigned long time_left;1011 1012 lockdep_assert_held(&ar->conf_mutex);1013 1014 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))1015 return -ESHUTDOWN;1016 1017 time_left = wait_for_completion_timeout(&ar->vdev_setup_done,1018 ATH10K_VDEV_SETUP_TIMEOUT_HZ);1019 if (time_left == 0)1020 return -ETIMEDOUT;1021 1022 return ar->last_wmi_vdev_start_status;1023}1024 1025static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)1026{1027 struct cfg80211_chan_def *chandef = NULL;1028 struct ieee80211_channel *channel = NULL;1029 struct wmi_vdev_start_request_arg arg = {};1030 int ret = 0;1031 1032 lockdep_assert_held(&ar->conf_mutex);1033 1034 ieee80211_iter_chan_contexts_atomic(ar->hw,1035 ath10k_mac_get_any_chandef_iter,1036 &chandef);1037 if (WARN_ON_ONCE(!chandef))1038 return -ENOENT;1039 1040 channel = chandef->chan;1041 1042 arg.vdev_id = vdev_id;1043 arg.channel.freq = channel->center_freq;1044 arg.channel.band_center_freq1 = chandef->center_freq1;1045 arg.channel.band_center_freq2 = chandef->center_freq2;1046 1047 /* TODO setup this dynamically, what in case we1048 * don't have any vifs?1049 */1050 arg.channel.mode = chan_to_phymode(chandef);1051 arg.channel.chan_radar =1052 !!(channel->flags & IEEE80211_CHAN_RADAR);1053 1054 arg.channel.min_power = 0;1055 arg.channel.max_power = channel->max_power * 2;1056 arg.channel.max_reg_power = channel->max_reg_power * 2;1057 arg.channel.max_antenna_gain = channel->max_antenna_gain;1058 1059 reinit_completion(&ar->vdev_setup_done);1060 reinit_completion(&ar->vdev_delete_done);1061 1062 ret = ath10k_wmi_vdev_start(ar, &arg);1063 if (ret) {1064 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",1065 vdev_id, ret);1066 return ret;1067 }1068 1069 ret = ath10k_vdev_setup_sync(ar);1070 if (ret) {1071 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n",1072 vdev_id, ret);1073 return ret;1074 }1075 1076 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);1077 if (ret) {1078 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",1079 vdev_id, ret);1080 goto vdev_stop;1081 }1082 1083 ar->monitor_vdev_id = vdev_id;1084 1085 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",1086 ar->monitor_vdev_id);1087 return 0;1088 1089vdev_stop:1090 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);1091 if (ret)1092 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",1093 ar->monitor_vdev_id, ret);1094 1095 return ret;1096}1097 1098static int ath10k_monitor_vdev_stop(struct ath10k *ar)1099{1100 int ret = 0;1101 1102 lockdep_assert_held(&ar->conf_mutex);1103 1104 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);1105 if (ret)1106 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",1107 ar->monitor_vdev_id, ret);1108 1109 reinit_completion(&ar->vdev_setup_done);1110 reinit_completion(&ar->vdev_delete_done);1111 1112 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);1113 if (ret)1114 ath10k_warn(ar, "failed to request monitor vdev %i stop: %d\n",1115 ar->monitor_vdev_id, ret);1116 1117 ret = ath10k_vdev_setup_sync(ar);1118 if (ret)1119 ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n",1120 ar->monitor_vdev_id, ret);1121 1122 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",1123 ar->monitor_vdev_id);1124 return ret;1125}1126 1127static int ath10k_monitor_vdev_create(struct ath10k *ar)1128{1129 int bit, ret = 0;1130 1131 lockdep_assert_held(&ar->conf_mutex);1132 1133 if (ar->free_vdev_map == 0) {1134 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");1135 return -ENOMEM;1136 }1137 1138 bit = __ffs64(ar->free_vdev_map);1139 1140 ar->monitor_vdev_id = bit;1141 1142 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,1143 WMI_VDEV_TYPE_MONITOR,1144 0, ar->mac_addr);1145 if (ret) {1146 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",1147 ar->monitor_vdev_id, ret);1148 return ret;1149 }1150 1151 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);1152 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",1153 ar->monitor_vdev_id);1154 1155 return 0;1156}1157 1158static int ath10k_monitor_vdev_delete(struct ath10k *ar)1159{1160 int ret = 0;1161 1162 lockdep_assert_held(&ar->conf_mutex);1163 1164 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);1165 if (ret) {1166 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",1167 ar->monitor_vdev_id, ret);1168 return ret;1169 }1170 1171 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;1172 1173 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",1174 ar->monitor_vdev_id);1175 return ret;1176}1177 1178static int ath10k_monitor_start(struct ath10k *ar)1179{1180 int ret;1181 1182 lockdep_assert_held(&ar->conf_mutex);1183 1184 ret = ath10k_monitor_vdev_create(ar);1185 if (ret) {1186 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);1187 return ret;1188 }1189 1190 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);1191 if (ret) {1192 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);1193 ath10k_monitor_vdev_delete(ar);1194 return ret;1195 }1196 1197 ar->monitor_started = true;1198 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");1199 1200 return 0;1201}1202 1203static int ath10k_monitor_stop(struct ath10k *ar)1204{1205 int ret;1206 1207 lockdep_assert_held(&ar->conf_mutex);1208 1209 ret = ath10k_monitor_vdev_stop(ar);1210 if (ret) {1211 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);1212 return ret;1213 }1214 1215 ret = ath10k_monitor_vdev_delete(ar);1216 if (ret) {1217 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);1218 return ret;1219 }1220 1221 ar->monitor_started = false;1222 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");1223 1224 return 0;1225}1226 1227static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar)1228{1229 int num_ctx;1230 1231 /* At least one chanctx is required to derive a channel to start1232 * monitor vdev on.1233 */1234 num_ctx = ath10k_mac_num_chanctxs(ar);1235 if (num_ctx == 0)1236 return false;1237 1238 /* If there's already an existing special monitor interface then don't1239 * bother creating another monitor vdev.1240 */1241 if (ar->monitor_arvif)1242 return false;1243 1244 return ar->monitor ||1245 (!test_bit(ATH10K_FW_FEATURE_ALLOWS_MESH_BCAST,1246 ar->running_fw->fw_file.fw_features) &&1247 (ar->filter_flags & (FIF_OTHER_BSS | FIF_MCAST_ACTION))) ||1248 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);1249}1250 1251static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k *ar)1252{1253 int num_ctx;1254 1255 num_ctx = ath10k_mac_num_chanctxs(ar);1256 1257 /* FIXME: Current interface combinations and cfg80211/mac80211 code1258 * shouldn't allow this but make sure to prevent handling the following1259 * case anyway since multi-channel DFS hasn't been tested at all.1260 */1261 if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags) && num_ctx > 1)1262 return false;1263 1264 return true;1265}1266 1267static int ath10k_monitor_recalc(struct ath10k *ar)1268{1269 bool needed;1270 bool allowed;1271 int ret;1272 1273 lockdep_assert_held(&ar->conf_mutex);1274 1275 needed = ath10k_mac_monitor_vdev_is_needed(ar);1276 allowed = ath10k_mac_monitor_vdev_is_allowed(ar);1277 1278 ath10k_dbg(ar, ATH10K_DBG_MAC,1279 "mac monitor recalc started? %d needed? %d allowed? %d\n",1280 ar->monitor_started, needed, allowed);1281 1282 if (WARN_ON(needed && !allowed)) {1283 if (ar->monitor_started) {1284 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopping disallowed monitor\n");1285 1286 ret = ath10k_monitor_stop(ar);1287 if (ret)1288 ath10k_warn(ar, "failed to stop disallowed monitor: %d\n",1289 ret);1290 /* not serious */1291 }1292 1293 return -EPERM;1294 }1295 1296 if (needed == ar->monitor_started)1297 return 0;1298 1299 if (needed)1300 return ath10k_monitor_start(ar);1301 else1302 return ath10k_monitor_stop(ar);1303}1304 1305static bool ath10k_mac_can_set_cts_prot(struct ath10k_vif *arvif)1306{1307 struct ath10k *ar = arvif->ar;1308 1309 lockdep_assert_held(&ar->conf_mutex);1310 1311 if (!arvif->is_started) {1312 ath10k_dbg(ar, ATH10K_DBG_MAC, "defer cts setup, vdev is not ready yet\n");1313 return false;1314 }1315 1316 return true;1317}1318 1319static int ath10k_mac_set_cts_prot(struct ath10k_vif *arvif)1320{1321 struct ath10k *ar = arvif->ar;1322 u32 vdev_param;1323 1324 lockdep_assert_held(&ar->conf_mutex);1325 1326 vdev_param = ar->wmi.vdev_param->protection_mode;1327 1328 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_protection %d\n",1329 arvif->vdev_id, arvif->use_cts_prot);1330 1331 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,1332 arvif->use_cts_prot ? 1 : 0);1333}1334 1335static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)1336{1337 struct ath10k *ar = arvif->ar;1338 u32 vdev_param, rts_cts = 0;1339 1340 lockdep_assert_held(&ar->conf_mutex);1341 1342 vdev_param = ar->wmi.vdev_param->enable_rtscts;1343 1344 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);1345 1346 if (arvif->num_legacy_stations > 0)1347 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,1348 WMI_RTSCTS_PROFILE);1349 else1350 rts_cts |= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES,1351 WMI_RTSCTS_PROFILE);1352 1353 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d recalc rts/cts prot %d\n",1354 arvif->vdev_id, rts_cts);1355 1356 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,1357 rts_cts);1358}1359 1360static int ath10k_start_cac(struct ath10k *ar)1361{1362 int ret;1363 1364 lockdep_assert_held(&ar->conf_mutex);1365 1366 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);1367 1368 ret = ath10k_monitor_recalc(ar);1369 if (ret) {1370 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);1371 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);1372 return ret;1373 }1374 1375 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",1376 ar->monitor_vdev_id);1377 1378 return 0;1379}1380 1381static int ath10k_stop_cac(struct ath10k *ar)1382{1383 lockdep_assert_held(&ar->conf_mutex);1384 1385 /* CAC is not running - do nothing */1386 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))1387 return 0;1388 1389 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);1390 ath10k_monitor_stop(ar);1391 1392 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");1393 1394 return 0;1395}1396 1397static void ath10k_mac_has_radar_iter(struct ieee80211_hw *hw,1398 struct ieee80211_chanctx_conf *conf,1399 void *data)1400{1401 bool *ret = data;1402 1403 if (!*ret && conf->radar_enabled)1404 *ret = true;1405}1406 1407static bool ath10k_mac_has_radar_enabled(struct ath10k *ar)1408{1409 bool has_radar = false;1410 1411 ieee80211_iter_chan_contexts_atomic(ar->hw,1412 ath10k_mac_has_radar_iter,1413 &has_radar);1414 1415 return has_radar;1416}1417 1418static void ath10k_recalc_radar_detection(struct ath10k *ar)1419{1420 int ret;1421 1422 lockdep_assert_held(&ar->conf_mutex);1423 1424 ath10k_stop_cac(ar);1425 1426 if (!ath10k_mac_has_radar_enabled(ar))1427 return;1428 1429 if (ar->num_started_vdevs > 0)1430 return;1431 1432 ret = ath10k_start_cac(ar);1433 if (ret) {1434 /*1435 * Not possible to start CAC on current channel so starting1436 * radiation is not allowed, make this channel DFS_UNAVAILABLE1437 * by indicating that radar was detected.1438 */1439 ath10k_warn(ar, "failed to start CAC: %d\n", ret);1440 ieee80211_radar_detected(ar->hw, NULL);1441 }1442}1443 1444static int ath10k_vdev_stop(struct ath10k_vif *arvif)1445{1446 struct ath10k *ar = arvif->ar;1447 int ret;1448 1449 lockdep_assert_held(&ar->conf_mutex);1450 1451 reinit_completion(&ar->vdev_setup_done);1452 reinit_completion(&ar->vdev_delete_done);1453 1454 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);1455 if (ret) {1456 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",1457 arvif->vdev_id, ret);1458 return ret;1459 }1460 1461 ret = ath10k_vdev_setup_sync(ar);1462 if (ret) {1463 ath10k_warn(ar, "failed to synchronize setup for vdev %i: %d\n",1464 arvif->vdev_id, ret);1465 return ret;1466 }1467 1468 WARN_ON(ar->num_started_vdevs == 0);1469 1470 if (ar->num_started_vdevs != 0) {1471 ar->num_started_vdevs--;1472 ath10k_recalc_radar_detection(ar);1473 }1474 1475 return ret;1476}1477 1478static int ath10k_vdev_start_restart(struct ath10k_vif *arvif,1479 const struct cfg80211_chan_def *chandef,1480 bool restart)1481{1482 struct ath10k *ar = arvif->ar;1483 struct wmi_vdev_start_request_arg arg = {};1484 int ret = 0;1485 1486 lockdep_assert_held(&ar->conf_mutex);1487 1488 reinit_completion(&ar->vdev_setup_done);1489 reinit_completion(&ar->vdev_delete_done);1490 1491 arg.vdev_id = arvif->vdev_id;1492 arg.dtim_period = arvif->dtim_period;1493 arg.bcn_intval = arvif->beacon_interval;1494 1495 arg.channel.freq = chandef->chan->center_freq;1496 arg.channel.band_center_freq1 = chandef->center_freq1;1497 arg.channel.band_center_freq2 = chandef->center_freq2;1498 arg.channel.mode = chan_to_phymode(chandef);1499 1500 arg.channel.min_power = 0;1501 arg.channel.max_power = chandef->chan->max_power * 2;1502 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;1503 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;1504 1505 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {1506 arg.ssid = arvif->u.ap.ssid;1507 arg.ssid_len = arvif->u.ap.ssid_len;1508 arg.hidden_ssid = arvif->u.ap.hidden_ssid;1509 1510 /* For now allow DFS for AP mode */1511 arg.channel.chan_radar =1512 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);1513 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {1514 arg.ssid = arvif->vif->cfg.ssid;1515 arg.ssid_len = arvif->vif->cfg.ssid_len;1516 }1517 1518 ath10k_dbg(ar, ATH10K_DBG_MAC,1519 "mac vdev %d start center_freq %d phymode %s\n",1520 arg.vdev_id, arg.channel.freq,1521 ath10k_wmi_phymode_str(arg.channel.mode));1522 1523 if (restart)1524 ret = ath10k_wmi_vdev_restart(ar, &arg);1525 else1526 ret = ath10k_wmi_vdev_start(ar, &arg);1527 1528 if (ret) {1529 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",1530 arg.vdev_id, ret);1531 return ret;1532 }1533 1534 ret = ath10k_vdev_setup_sync(ar);1535 if (ret) {1536 ath10k_warn(ar,1537 "failed to synchronize setup for vdev %i restart %d: %d\n",1538 arg.vdev_id, restart, ret);1539 return ret;1540 }1541 1542 ar->num_started_vdevs++;1543 ath10k_recalc_radar_detection(ar);1544 1545 return ret;1546}1547 1548static int ath10k_vdev_start(struct ath10k_vif *arvif,1549 const struct cfg80211_chan_def *def)1550{1551 return ath10k_vdev_start_restart(arvif, def, false);1552}1553 1554static int ath10k_vdev_restart(struct ath10k_vif *arvif,1555 const struct cfg80211_chan_def *def)1556{1557 return ath10k_vdev_start_restart(arvif, def, true);1558}1559 1560static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif,1561 struct sk_buff *bcn)1562{1563 struct ath10k *ar = arvif->ar;1564 struct ieee80211_mgmt *mgmt;1565 const u8 *p2p_ie;1566 int ret;1567 1568 if (arvif->vif->type != NL80211_IFTYPE_AP || !arvif->vif->p2p)1569 return 0;1570 1571 mgmt = (void *)bcn->data;1572 p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,1573 mgmt->u.beacon.variable,1574 bcn->len - (mgmt->u.beacon.variable -1575 bcn->data));1576 if (!p2p_ie)1577 return -ENOENT;1578 1579 ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie);1580 if (ret) {1581 ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n",1582 arvif->vdev_id, ret);1583 return ret;1584 }1585 1586 return 0;1587}1588 1589static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui,1590 u8 oui_type, size_t ie_offset)1591{1592 size_t len;1593 const u8 *next;1594 const u8 *end;1595 u8 *ie;1596 1597 if (WARN_ON(skb->len < ie_offset))1598 return -EINVAL;1599 1600 ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,1601 skb->data + ie_offset,1602 skb->len - ie_offset);1603 if (!ie)1604 return -ENOENT;1605 1606 len = ie[1] + 2;1607 end = skb->data + skb->len;1608 next = ie + len;1609 1610 if (WARN_ON(next > end))1611 return -EINVAL;1612 1613 memmove(ie, next, end - next);1614 skb_trim(skb, skb->len - len);1615 1616 return 0;1617}1618 1619static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif)1620{1621 struct ath10k *ar = arvif->ar;1622 struct ieee80211_hw *hw = ar->hw;1623 struct ieee80211_vif *vif = arvif->vif;1624 struct ieee80211_mutable_offsets offs = {};1625 struct sk_buff *bcn;1626 int ret;1627 1628 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))1629 return 0;1630 1631 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&1632 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)1633 return 0;1634 1635 bcn = ieee80211_beacon_get_template(hw, vif, &offs, 0);1636 if (!bcn) {1637 ath10k_warn(ar, "failed to get beacon template from mac80211\n");1638 return -EPERM;1639 }1640 1641 ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn);1642 if (ret) {1643 ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret);1644 kfree_skb(bcn);1645 return ret;1646 }1647 1648 /* P2P IE is inserted by firmware automatically (as configured above)1649 * so remove it from the base beacon template to avoid duplicate P2P1650 * IEs in beacon frames.1651 */1652 ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,1653 offsetof(struct ieee80211_mgmt,1654 u.beacon.variable));1655 1656 ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0,1657 0, NULL, 0);1658 kfree_skb(bcn);1659 1660 if (ret) {1661 ath10k_warn(ar, "failed to submit beacon template command: %d\n",1662 ret);1663 return ret;1664 }1665 1666 return 0;1667}1668 1669static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif)1670{1671 struct ath10k *ar = arvif->ar;1672 struct ieee80211_hw *hw = ar->hw;1673 struct ieee80211_vif *vif = arvif->vif;1674 struct sk_buff *prb;1675 int ret;1676 1677 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))1678 return 0;1679 1680 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)1681 return 0;1682 1683 /* For mesh, probe response and beacon share the same template */1684 if (ieee80211_vif_is_mesh(vif))1685 return 0;1686 1687 prb = ieee80211_proberesp_get(hw, vif);1688 if (!prb) {1689 ath10k_warn(ar, "failed to get probe resp template from mac80211\n");1690 return -EPERM;1691 }1692 1693 ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb);1694 kfree_skb(prb);1695 1696 if (ret) {1697 ath10k_warn(ar, "failed to submit probe resp template command: %d\n",1698 ret);1699 return ret;1700 }1701 1702 return 0;1703}1704 1705static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif *arvif)1706{1707 struct ath10k *ar = arvif->ar;1708 struct cfg80211_chan_def def;1709 int ret;1710 1711 /* When originally vdev is started during assign_vif_chanctx() some1712 * information is missing, notably SSID. Firmware revisions with beacon1713 * offloading require the SSID to be provided during vdev (re)start to1714 * handle hidden SSID properly.1715 *1716 * Vdev restart must be done after vdev has been both started and1717 * upped. Otherwise some firmware revisions (at least 10.2) fail to1718 * deliver vdev restart response event causing timeouts during vdev1719 * syncing in ath10k.1720 *1721 * Note: The vdev down/up and template reinstallation could be skipped1722 * since only wmi-tlv firmware are known to have beacon offload and1723 * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart1724 * response delivery. It's probably more robust to keep it as is.1725 */1726 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))1727 return 0;1728 1729 if (WARN_ON(!arvif->is_started))1730 return -EINVAL;1731 1732 if (WARN_ON(!arvif->is_up))1733 return -EINVAL;1734 1735 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))1736 return -EINVAL;1737 1738 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);1739 if (ret) {1740 ath10k_warn(ar, "failed to bring down ap vdev %i: %d\n",1741 arvif->vdev_id, ret);1742 return ret;1743 }1744 1745 /* Vdev down reset beacon & presp templates. Reinstall them. Otherwise1746 * firmware will crash upon vdev up.1747 */1748 1749 ret = ath10k_mac_setup_bcn_tmpl(arvif);1750 if (ret) {1751 ath10k_warn(ar, "failed to update beacon template: %d\n", ret);1752 return ret;1753 }1754 1755 ret = ath10k_mac_setup_prb_tmpl(arvif);1756 if (ret) {1757 ath10k_warn(ar, "failed to update presp template: %d\n", ret);1758 return ret;1759 }1760 1761 ret = ath10k_vdev_restart(arvif, &def);1762 if (ret) {1763 ath10k_warn(ar, "failed to restart ap vdev %i: %d\n",1764 arvif->vdev_id, ret);1765 return ret;1766 }1767 1768 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,1769 arvif->bssid);1770 if (ret) {1771 ath10k_warn(ar, "failed to bring up ap vdev %i: %d\n",1772 arvif->vdev_id, ret);1773 return ret;1774 }1775 1776 return 0;1777}1778 1779static void ath10k_control_beaconing(struct ath10k_vif *arvif,1780 struct ieee80211_bss_conf *info)1781{1782 struct ath10k *ar = arvif->ar;1783 int ret = 0;1784 1785 lockdep_assert_held(&arvif->ar->conf_mutex);1786 1787 if (!info->enable_beacon) {1788 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);1789 if (ret)1790 ath10k_warn(ar, "failed to down vdev_id %i: %d\n",1791 arvif->vdev_id, ret);1792 1793 arvif->is_up = false;1794 1795 spin_lock_bh(&arvif->ar->data_lock);1796 ath10k_mac_vif_beacon_free(arvif);1797 spin_unlock_bh(&arvif->ar->data_lock);1798 1799 return;1800 }1801 1802 arvif->tx_seq_no = 0x1000;1803 1804 arvif->aid = 0;1805 ether_addr_copy(arvif->bssid, info->bssid);1806 1807 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,1808 arvif->bssid);1809 if (ret) {1810 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",1811 arvif->vdev_id, ret);1812 return;1813 }1814 1815 arvif->is_up = true;1816 1817 ret = ath10k_mac_vif_fix_hidden_ssid(arvif);1818 if (ret) {1819 ath10k_warn(ar, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n",1820 arvif->vdev_id, ret);1821 return;1822 }1823 1824 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);1825}1826 1827static void ath10k_control_ibss(struct ath10k_vif *arvif,1828 struct ieee80211_vif *vif)1829{1830 struct ath10k *ar = arvif->ar;1831 u32 vdev_param;1832 int ret = 0;1833 1834 lockdep_assert_held(&arvif->ar->conf_mutex);1835 1836 if (!vif->cfg.ibss_joined) {1837 if (is_zero_ether_addr(arvif->bssid))1838 return;1839 1840 eth_zero_addr(arvif->bssid);1841 1842 return;1843 }1844 1845 vdev_param = arvif->ar->wmi.vdev_param->atim_window;1846 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,1847 ATH10K_DEFAULT_ATIM);1848 if (ret)1849 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",1850 arvif->vdev_id, ret);1851}1852 1853static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif)1854{1855 struct ath10k *ar = arvif->ar;1856 u32 param;1857 u32 value;1858 int ret;1859 1860 lockdep_assert_held(&arvif->ar->conf_mutex);1861 1862 if (arvif->u.sta.uapsd)1863 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER;1864 else1865 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;1866 1867 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;1868 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value);1869 if (ret) {1870 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n",1871 value, arvif->vdev_id, ret);1872 return ret;1873 }1874 1875 return 0;1876}1877 1878static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif)1879{1880 struct ath10k *ar = arvif->ar;1881 u32 param;1882 u32 value;1883 int ret;1884 1885 lockdep_assert_held(&arvif->ar->conf_mutex);1886 1887 if (arvif->u.sta.uapsd)1888 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD;1889 else1890 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;1891 1892 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;1893 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,1894 param, value);1895 if (ret) {1896 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n",1897 value, arvif->vdev_id, ret);1898 return ret;1899 }1900 1901 return 0;1902}1903 1904static int ath10k_mac_num_vifs_started(struct ath10k *ar)1905{1906 struct ath10k_vif *arvif;1907 int num = 0;1908 1909 lockdep_assert_held(&ar->conf_mutex);1910 1911 list_for_each_entry(arvif, &ar->arvifs, list)1912 if (arvif->is_started)1913 num++;1914 1915 return num;1916}1917 1918static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)1919{1920 struct ath10k *ar = arvif->ar;1921 struct ieee80211_vif *vif = arvif->vif;1922 struct ieee80211_conf *conf = &ar->hw->conf;1923 enum wmi_sta_powersave_param param;1924 enum wmi_sta_ps_mode psmode;1925 int ret;1926 int ps_timeout;1927 bool enable_ps;1928 1929 lockdep_assert_held(&arvif->ar->conf_mutex);1930 1931 if (arvif->vif->type != NL80211_IFTYPE_STATION)1932 return 0;1933 1934 enable_ps = arvif->ps;1935 1936 if (enable_ps && ath10k_mac_num_vifs_started(ar) > 1 &&1937 !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT,1938 ar->running_fw->fw_file.fw_features)) {1939 ath10k_warn(ar, "refusing to enable ps on vdev %i: not supported by fw\n",1940 arvif->vdev_id);1941 enable_ps = false;1942 }1943 1944 if (!arvif->is_started) {1945 /* mac80211 can update vif powersave state while disconnected.1946 * Firmware doesn't behave nicely and consumes more power than1947 * necessary if PS is disabled on a non-started vdev. Hence1948 * force-enable PS for non-running vdevs.1949 */1950 psmode = WMI_STA_PS_MODE_ENABLED;1951 } else if (enable_ps) {1952 psmode = WMI_STA_PS_MODE_ENABLED;1953 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;1954 1955 ps_timeout = conf->dynamic_ps_timeout;1956 if (ps_timeout == 0) {1957 /* Firmware doesn't like 0 */1958 ps_timeout = ieee80211_tu_to_usec(1959 vif->bss_conf.beacon_int) / 1000;1960 }1961 1962 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,1963 ps_timeout);1964 if (ret) {1965 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",1966 arvif->vdev_id, ret);1967 return ret;1968 }1969 } else {1970 psmode = WMI_STA_PS_MODE_DISABLED;1971 }1972 1973 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",1974 arvif->vdev_id, psmode ? "enable" : "disable");1975 1976 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);1977 if (ret) {1978 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",1979 psmode, arvif->vdev_id, ret);1980 return ret;1981 }1982 1983 return 0;1984}1985 1986static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif)1987{1988 struct ath10k *ar = arvif->ar;1989 struct wmi_sta_keepalive_arg arg = {};1990 int ret;1991 1992 lockdep_assert_held(&arvif->ar->conf_mutex);1993 1994 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)1995 return 0;1996 1997 if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map))1998 return 0;1999 2000 /* Some firmware revisions have a bug and ignore the `enabled` field.2001 * Instead use the interval to disable the keepalive.2002 */2003 arg.vdev_id = arvif->vdev_id;2004 arg.enabled = 1;2005 arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;2006 arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE;2007 2008 ret = ath10k_wmi_sta_keepalive(ar, &arg);2009 if (ret) {2010 ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n",2011 arvif->vdev_id, ret);2012 return ret;2013 }2014 2015 return 0;2016}2017 2018static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif *arvif)2019{2020 struct ath10k *ar = arvif->ar;2021 struct ieee80211_vif *vif = arvif->vif;2022 int ret;2023 2024 lockdep_assert_held(&arvif->ar->conf_mutex);2025 2026 if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)))2027 return;2028 2029 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)2030 return;2031 2032 if (!vif->bss_conf.csa_active)2033 return;2034 2035 if (!arvif->is_up)2036 return;2037 2038 if (!ieee80211_beacon_cntdwn_is_complete(vif, 0)) {2039 ieee80211_beacon_update_cntdwn(vif, 0);2040 2041 ret = ath10k_mac_setup_bcn_tmpl(arvif);2042 if (ret)2043 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",2044 ret);2045 2046 ret = ath10k_mac_setup_prb_tmpl(arvif);2047 if (ret)2048 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",2049 ret);2050 } else {2051 ieee80211_csa_finish(vif, 0);2052 }2053}2054 2055static void ath10k_mac_vif_ap_csa_work(struct work_struct *work)2056{2057 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,2058 ap_csa_work);2059 struct ath10k *ar = arvif->ar;2060 2061 mutex_lock(&ar->conf_mutex);2062 ath10k_mac_vif_ap_csa_count_down(arvif);2063 mutex_unlock(&ar->conf_mutex);2064}2065 2066static void ath10k_mac_handle_beacon_iter(void *data, u8 *mac,2067 struct ieee80211_vif *vif)2068{2069 struct sk_buff *skb = data;2070 struct ieee80211_mgmt *mgmt = (void *)skb->data;2071 struct ath10k_vif *arvif = (void *)vif->drv_priv;2072 2073 if (vif->type != NL80211_IFTYPE_STATION)2074 return;2075 2076 if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))2077 return;2078 2079 cancel_delayed_work(&arvif->connection_loss_work);2080}2081 2082void ath10k_mac_handle_beacon(struct ath10k *ar, struct sk_buff *skb)2083{2084 ieee80211_iterate_active_interfaces_atomic(ar->hw,2085 ATH10K_ITER_NORMAL_FLAGS,2086 ath10k_mac_handle_beacon_iter,2087 skb);2088}2089 2090static void ath10k_mac_handle_beacon_miss_iter(void *data, u8 *mac,2091 struct ieee80211_vif *vif)2092{2093 u32 *vdev_id = data;2094 struct ath10k_vif *arvif = (void *)vif->drv_priv;2095 struct ath10k *ar = arvif->ar;2096 struct ieee80211_hw *hw = ar->hw;2097 2098 if (arvif->vdev_id != *vdev_id)2099 return;2100 2101 if (!arvif->is_up)2102 return;2103 2104 ieee80211_beacon_loss(vif);2105 2106 /* Firmware doesn't report beacon loss events repeatedly. If AP probe2107 * (done by mac80211) succeeds but beacons do not resume then it2108 * doesn't make sense to continue operation. Queue connection loss work2109 * which can be cancelled when beacon is received.2110 */2111 ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,2112 ATH10K_CONNECTION_LOSS_HZ);2113}2114 2115void ath10k_mac_handle_beacon_miss(struct ath10k *ar, u32 vdev_id)2116{2117 ieee80211_iterate_active_interfaces_atomic(ar->hw,2118 ATH10K_ITER_NORMAL_FLAGS,2119 ath10k_mac_handle_beacon_miss_iter,2120 &vdev_id);2121}2122 2123static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct *work)2124{2125 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,2126 connection_loss_work.work);2127 struct ieee80211_vif *vif = arvif->vif;2128 2129 if (!arvif->is_up)2130 return;2131 2132 ieee80211_connection_loss(vif);2133}2134 2135/**********************/2136/* Station management */2137/**********************/2138 2139static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,2140 struct ieee80211_vif *vif)2141{2142 /* Some firmware revisions have unstable STA powersave when listen2143 * interval is set too high (e.g. 5). The symptoms are firmware doesn't2144 * generate NullFunc frames properly even if buffered frames have been2145 * indicated in Beacon TIM. Firmware would seldom wake up to pull2146 * buffered frames. Often pinging the device from AP would simply fail.2147 *2148 * As a workaround set it to 1.2149 */2150 if (vif->type == NL80211_IFTYPE_STATION)2151 return 1;2152 2153 return ar->hw->conf.listen_interval;2154}2155 2156static void ath10k_peer_assoc_h_basic(struct ath10k *ar,2157 struct ieee80211_vif *vif,2158 struct ieee80211_sta *sta,2159 struct wmi_peer_assoc_complete_arg *arg)2160{2161 struct ath10k_vif *arvif = (void *)vif->drv_priv;2162 u32 aid;2163 2164 lockdep_assert_held(&ar->conf_mutex);2165 2166 if (vif->type == NL80211_IFTYPE_STATION)2167 aid = vif->cfg.aid;2168 else2169 aid = sta->aid;2170 2171 ether_addr_copy(arg->addr, sta->addr);2172 arg->vdev_id = arvif->vdev_id;2173 arg->peer_aid = aid;2174 arg->peer_flags |= arvif->ar->wmi.peer_flags->auth;2175 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);2176 arg->peer_num_spatial_streams = 1;2177 arg->peer_caps = vif->bss_conf.assoc_capability;2178}2179 2180static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,2181 struct ieee80211_vif *vif,2182 struct ieee80211_sta *sta,2183 struct wmi_peer_assoc_complete_arg *arg)2184{2185 struct ieee80211_bss_conf *info = &vif->bss_conf;2186 struct cfg80211_chan_def def;2187 struct cfg80211_bss *bss;2188 const u8 *rsnie = NULL;2189 const u8 *wpaie = NULL;2190 2191 lockdep_assert_held(&ar->conf_mutex);2192 2193 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))2194 return;2195 2196 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid,2197 vif->cfg.ssid_len ? vif->cfg.ssid : NULL,2198 vif->cfg.ssid_len,2199 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);2200 if (bss) {2201 const struct cfg80211_bss_ies *ies;2202 2203 rcu_read_lock();2204 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);2205 2206 ies = rcu_dereference(bss->ies);2207 2208 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,2209 WLAN_OUI_TYPE_MICROSOFT_WPA,2210 ies->data,2211 ies->len);2212 rcu_read_unlock();2213 cfg80211_put_bss(ar->hw->wiphy, bss);2214 }2215 2216 /* FIXME: base on RSN IE/WPA IE is a correct idea? */2217 if (rsnie || wpaie) {2218 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);2219 arg->peer_flags |= ar->wmi.peer_flags->need_ptk_4_way;2220 }2221 2222 if (wpaie) {2223 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);2224 arg->peer_flags |= ar->wmi.peer_flags->need_gtk_2_way;2225 }2226 2227 if (sta->mfp &&2228 test_bit(ATH10K_FW_FEATURE_MFP_SUPPORT,2229 ar->running_fw->fw_file.fw_features)) {2230 arg->peer_flags |= ar->wmi.peer_flags->pmf;2231 }2232}2233 2234static void ath10k_peer_assoc_h_rates(struct ath10k *ar,2235 struct ieee80211_vif *vif,2236 struct ieee80211_sta *sta,2237 struct wmi_peer_assoc_complete_arg *arg)2238{2239 struct ath10k_vif *arvif = (void *)vif->drv_priv;2240 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;2241 struct cfg80211_chan_def def;2242 const struct ieee80211_supported_band *sband;2243 const struct ieee80211_rate *rates;2244 enum nl80211_band band;2245 u32 ratemask;2246 u8 rate;2247 int i;2248 2249 lockdep_assert_held(&ar->conf_mutex);2250 2251 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))2252 return;2253 2254 band = def.chan->band;2255 sband = ar->hw->wiphy->bands[band];2256 ratemask = sta->deflink.supp_rates[band];2257 ratemask &= arvif->bitrate_mask.control[band].legacy;2258 rates = sband->bitrates;2259 2260 rateset->num_rates = 0;2261 2262 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {2263 if (!(ratemask & 1))2264 continue;2265 2266 rate = ath10k_mac_bitrate_to_rate(rates->bitrate);2267 rateset->rates[rateset->num_rates] = rate;2268 rateset->num_rates++;2269 }2270}2271 2272static bool2273ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])2274{2275 int nss;2276 2277 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)2278 if (ht_mcs_mask[nss])2279 return false;2280 2281 return true;2282}2283 2284static bool2285ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])2286{2287 int nss;2288 2289 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)2290 if (vht_mcs_mask[nss])2291 return false;2292 2293 return true;2294}2295 2296static void ath10k_peer_assoc_h_ht(struct ath10k *ar,2297 struct ieee80211_vif *vif,2298 struct ieee80211_sta *sta,2299 struct wmi_peer_assoc_complete_arg *arg)2300{2301 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;2302 struct ath10k_vif *arvif = (void *)vif->drv_priv;2303 struct cfg80211_chan_def def;2304 enum nl80211_band band;2305 const u8 *ht_mcs_mask;2306 const u16 *vht_mcs_mask;2307 int i, n;2308 u8 max_nss;2309 u32 stbc;2310 2311 lockdep_assert_held(&ar->conf_mutex);2312 2313 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))2314 return;2315 2316 if (!ht_cap->ht_supported)2317 return;2318 2319 band = def.chan->band;2320 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;2321 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;2322 2323 if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask) &&2324 ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))2325 return;2326 2327 arg->peer_flags |= ar->wmi.peer_flags->ht;2328 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +2329 ht_cap->ampdu_factor)) - 1;2330 2331 arg->peer_mpdu_density =2332 ath10k_parse_mpdudensity(ht_cap->ampdu_density);2333 2334 arg->peer_ht_caps = ht_cap->cap;2335 arg->peer_rate_caps |= WMI_RC_HT_FLAG;2336 2337 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)2338 arg->peer_flags |= ar->wmi.peer_flags->ldbc;2339 2340 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) {2341 arg->peer_flags |= ar->wmi.peer_flags->bw40;2342 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;2343 }2344 2345 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {2346 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)2347 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;2348 2349 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)2350 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;2351 }2352 2353 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {2354 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;2355 arg->peer_flags |= ar->wmi.peer_flags->stbc;2356 }2357 2358 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {2359 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;2360 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;2361 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;2362 arg->peer_rate_caps |= stbc;2363 arg->peer_flags |= ar->wmi.peer_flags->stbc;2364 }2365 2366 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])2367 arg->peer_rate_caps |= WMI_RC_TS_FLAG;2368 else if (ht_cap->mcs.rx_mask[1])2369 arg->peer_rate_caps |= WMI_RC_DS_FLAG;2370 2371 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)2372 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&2373 (ht_mcs_mask[i / 8] & BIT(i % 8))) {2374 max_nss = (i / 8) + 1;2375 arg->peer_ht_rates.rates[n++] = i;2376 }2377 2378 /*2379 * This is a workaround for HT-enabled STAs which break the spec2380 * and have no HT capabilities RX mask (no HT RX MCS map).2381 *2382 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),2383 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.2384 *2385 * Firmware asserts if such situation occurs.2386 */2387 if (n == 0) {2388 arg->peer_ht_rates.num_rates = 8;2389 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)2390 arg->peer_ht_rates.rates[i] = i;2391 } else {2392 arg->peer_ht_rates.num_rates = n;2393 arg->peer_num_spatial_streams = min(sta->deflink.rx_nss,2394 max_nss);2395 }2396 2397 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",2398 arg->addr,2399 arg->peer_ht_rates.num_rates,2400 arg->peer_num_spatial_streams);2401}2402 2403static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,2404 struct ath10k_vif *arvif,2405 struct ieee80211_sta *sta)2406{2407 u32 uapsd = 0;2408 u32 max_sp = 0;2409 int ret = 0;2410 2411 lockdep_assert_held(&ar->conf_mutex);2412 2413 if (sta->wme && sta->uapsd_queues) {2414 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",2415 sta->uapsd_queues, sta->max_sp);2416 2417 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)2418 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |2419 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;2420 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)2421 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |2422 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;2423 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)2424 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |2425 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;2426 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)2427 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |2428 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;2429 2430 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)2431 max_sp = sta->max_sp;2432 2433 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,2434 sta->addr,2435 WMI_AP_PS_PEER_PARAM_UAPSD,2436 uapsd);2437 if (ret) {2438 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",2439 arvif->vdev_id, ret);2440 return ret;2441 }2442 2443 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,2444 sta->addr,2445 WMI_AP_PS_PEER_PARAM_MAX_SP,2446 max_sp);2447 if (ret) {2448 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",2449 arvif->vdev_id, ret);2450 return ret;2451 }2452 2453 /* TODO setup this based on STA listen interval and2454 * beacon interval. Currently we don't know2455 * sta->listen_interval - mac80211 patch required.2456 * Currently use 10 seconds2457 */2458 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,2459 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,2460 10);2461 if (ret) {2462 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",2463 arvif->vdev_id, ret);2464 return ret;2465 }2466 }2467 2468 return 0;2469}2470 2471static u162472ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set,2473 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])2474{2475 int idx_limit;2476 int nss;2477 u16 mcs_map;2478 u16 mcs;2479 2480 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {2481 mcs_map = ath10k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &2482 vht_mcs_limit[nss];2483 2484 if (mcs_map)2485 idx_limit = fls(mcs_map) - 1;2486 else2487 idx_limit = -1;2488 2489 switch (idx_limit) {2490 case 0:2491 case 1:2492 case 2:2493 case 3:2494 case 4:2495 case 5:2496 case 6:2497 default:2498 /* see ath10k_mac_can_set_bitrate_mask() */2499 WARN_ON(1);2500 fallthrough;2501 case -1:2502 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;2503 break;2504 case 7:2505 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;2506 break;2507 case 8:2508 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;2509 break;2510 case 9:2511 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;2512 break;2513 }2514 2515 tx_mcs_set &= ~(0x3 << (nss * 2));2516 tx_mcs_set |= mcs << (nss * 2);2517 }2518 2519 return tx_mcs_set;2520}2521 2522static u32 get_160mhz_nss_from_maxrate(int rate)2523{2524 u32 nss;2525 2526 switch (rate) {2527 case 780:2528 nss = 1;2529 break;2530 case 1560:2531 nss = 2;2532 break;2533 case 2106:2534 nss = 3; /* not support MCS9 from spec*/2535 break;2536 case 3120:2537 nss = 4;2538 break;2539 default:2540 nss = 1;2541 }2542 2543 return nss;2544}2545 2546static void ath10k_peer_assoc_h_vht(struct ath10k *ar,2547 struct ieee80211_vif *vif,2548 struct ieee80211_sta *sta,2549 struct wmi_peer_assoc_complete_arg *arg)2550{2551 const struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;2552 struct ath10k_vif *arvif = (void *)vif->drv_priv;2553 struct ath10k_hw_params *hw = &ar->hw_params;2554 struct cfg80211_chan_def def;2555 enum nl80211_band band;2556 const u16 *vht_mcs_mask;2557 u8 ampdu_factor;2558 u8 max_nss, vht_mcs;2559 int i;2560 2561 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))2562 return;2563 2564 if (!vht_cap->vht_supported)2565 return;2566 2567 band = def.chan->band;2568 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;2569 2570 if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))2571 return;2572 2573 arg->peer_flags |= ar->wmi.peer_flags->vht;2574 2575 if (def.chan->band == NL80211_BAND_2GHZ)2576 arg->peer_flags |= ar->wmi.peer_flags->vht_2g;2577 2578 arg->peer_vht_caps = vht_cap->cap;2579 2580 ampdu_factor = (vht_cap->cap &2581 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>2582 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;2583 2584 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to2585 * zero in VHT IE. Using it would result in degraded throughput.2586 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep2587 * it if VHT max_mpdu is smaller.2588 */2589 arg->peer_max_mpdu = max(arg->peer_max_mpdu,2590 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +2591 ampdu_factor)) - 1);2592 2593 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)2594 arg->peer_flags |= ar->wmi.peer_flags->bw80;2595 2596 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)2597 arg->peer_flags |= ar->wmi.peer_flags->bw160;2598 2599 /* Calculate peer NSS capability from VHT capabilities if STA2600 * supports VHT.2601 */2602 for (i = 0, max_nss = 0, vht_mcs = 0; i < NL80211_VHT_NSS_MAX; i++) {2603 vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >>2604 (2 * i) & 3;2605 2606 if ((vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED) &&2607 vht_mcs_mask[i])2608 max_nss = i + 1;2609 }2610 arg->peer_num_spatial_streams = min(sta->deflink.rx_nss, max_nss);2611 arg->peer_vht_rates.rx_max_rate =2612 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);2613 arg->peer_vht_rates.rx_mcs_set =2614 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);2615 arg->peer_vht_rates.tx_max_rate =2616 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);2617 arg->peer_vht_rates.tx_mcs_set = ath10k_peer_assoc_h_vht_limit(2618 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);2619 2620 /* Configure bandwidth-NSS mapping to FW2621 * for the chip's tx chains setting on 160Mhz bw2622 */2623 if (arg->peer_phymode == MODE_11AC_VHT160 ||2624 arg->peer_phymode == MODE_11AC_VHT80_80) {2625 u32 rx_nss;2626 u32 max_rate;2627 2628 max_rate = arg->peer_vht_rates.rx_max_rate;2629 rx_nss = get_160mhz_nss_from_maxrate(max_rate);2630 2631 if (rx_nss == 0)2632 rx_nss = arg->peer_num_spatial_streams;2633 else2634 rx_nss = min(arg->peer_num_spatial_streams, rx_nss);2635 2636 max_rate = hw->vht160_mcs_tx_highest;2637 rx_nss = min(rx_nss, get_160mhz_nss_from_maxrate(max_rate));2638 2639 arg->peer_bw_rxnss_override =2640 FIELD_PREP(WMI_PEER_NSS_MAP_ENABLE, 1) |2641 FIELD_PREP(WMI_PEER_NSS_160MHZ_MASK, (rx_nss - 1));2642 2643 if (arg->peer_phymode == MODE_11AC_VHT80_80) {2644 arg->peer_bw_rxnss_override |=2645 FIELD_PREP(WMI_PEER_NSS_80_80MHZ_MASK, (rx_nss - 1));2646 }2647 }2648 ath10k_dbg(ar, ATH10K_DBG_MAC,2649 "mac vht peer %pM max_mpdu %d flags 0x%x peer_rx_nss_override 0x%x\n",2650 sta->addr, arg->peer_max_mpdu,2651 arg->peer_flags, arg->peer_bw_rxnss_override);2652}2653 2654static void ath10k_peer_assoc_h_qos(struct ath10k *ar,2655 struct ieee80211_vif *vif,2656 struct ieee80211_sta *sta,2657 struct wmi_peer_assoc_complete_arg *arg)2658{2659 struct ath10k_vif *arvif = (void *)vif->drv_priv;2660 2661 switch (arvif->vdev_type) {2662 case WMI_VDEV_TYPE_AP:2663 if (sta->wme)2664 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;2665 2666 if (sta->wme && sta->uapsd_queues) {2667 arg->peer_flags |= arvif->ar->wmi.peer_flags->apsd;2668 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;2669 }2670 break;2671 case WMI_VDEV_TYPE_STA:2672 if (sta->wme)2673 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;2674 break;2675 case WMI_VDEV_TYPE_IBSS:2676 if (sta->wme)2677 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;2678 break;2679 default:2680 break;2681 }2682 2683 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n",2684 sta->addr, !!(arg->peer_flags &2685 arvif->ar->wmi.peer_flags->qos));2686}2687 2688static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)2689{2690 return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >>2691 ATH10K_MAC_FIRST_OFDM_RATE_IDX;2692}2693 2694static enum wmi_phy_mode ath10k_mac_get_phymode_vht(struct ath10k *ar,2695 struct ieee80211_sta *sta)2696{2697 struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;2698 2699 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {2700 switch (vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {2701 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:2702 return MODE_11AC_VHT160;2703 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:2704 return MODE_11AC_VHT80_80;2705 default:2706 /* not sure if this is a valid case? */2707 return MODE_11AC_VHT160;2708 }2709 }2710 2711 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)2712 return MODE_11AC_VHT80;2713 2714 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)2715 return MODE_11AC_VHT40;2716 2717 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)2718 return MODE_11AC_VHT20;2719 2720 return MODE_UNKNOWN;2721}2722 2723static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,2724 struct ieee80211_vif *vif,2725 struct ieee80211_sta *sta,2726 struct wmi_peer_assoc_complete_arg *arg)2727{2728 struct ath10k_vif *arvif = (void *)vif->drv_priv;2729 struct cfg80211_chan_def def;2730 enum nl80211_band band;2731 const u8 *ht_mcs_mask;2732 const u16 *vht_mcs_mask;2733 enum wmi_phy_mode phymode = MODE_UNKNOWN;2734 2735 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))2736 return;2737 2738 band = def.chan->band;2739 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;2740 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;2741 2742 switch (band) {2743 case NL80211_BAND_2GHZ:2744 if (sta->deflink.vht_cap.vht_supported &&2745 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {2746 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)2747 phymode = MODE_11AC_VHT40;2748 else2749 phymode = MODE_11AC_VHT20;2750 } else if (sta->deflink.ht_cap.ht_supported &&2751 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {2752 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)2753 phymode = MODE_11NG_HT40;2754 else2755 phymode = MODE_11NG_HT20;2756 } else if (ath10k_mac_sta_has_ofdm_only(sta)) {2757 phymode = MODE_11G;2758 } else {2759 phymode = MODE_11B;2760 }2761 2762 break;2763 case NL80211_BAND_5GHZ:2764 /*2765 * Check VHT first.2766 */2767 if (sta->deflink.vht_cap.vht_supported &&2768 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {2769 phymode = ath10k_mac_get_phymode_vht(ar, sta);2770 } else if (sta->deflink.ht_cap.ht_supported &&2771 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {2772 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40)2773 phymode = MODE_11NA_HT40;2774 else2775 phymode = MODE_11NA_HT20;2776 } else {2777 phymode = MODE_11A;2778 }2779 2780 break;2781 default:2782 break;2783 }2784 2785 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",2786 sta->addr, ath10k_wmi_phymode_str(phymode));2787 2788 arg->peer_phymode = phymode;2789 WARN_ON(phymode == MODE_UNKNOWN);2790}2791 2792static int ath10k_peer_assoc_prepare(struct ath10k *ar,2793 struct ieee80211_vif *vif,2794 struct ieee80211_sta *sta,2795 struct wmi_peer_assoc_complete_arg *arg)2796{2797 lockdep_assert_held(&ar->conf_mutex);2798 2799 memset(arg, 0, sizeof(*arg));2800 2801 ath10k_peer_assoc_h_basic(ar, vif, sta, arg);2802 ath10k_peer_assoc_h_crypto(ar, vif, sta, arg);2803 ath10k_peer_assoc_h_rates(ar, vif, sta, arg);2804 ath10k_peer_assoc_h_ht(ar, vif, sta, arg);2805 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);2806 ath10k_peer_assoc_h_vht(ar, vif, sta, arg);2807 ath10k_peer_assoc_h_qos(ar, vif, sta, arg);2808 2809 return 0;2810}2811 2812static const u32 ath10k_smps_map[] = {2813 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,2814 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,2815 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,2816 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,2817};2818 2819static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,2820 const u8 *addr,2821 const struct ieee80211_sta_ht_cap *ht_cap)2822{2823 int smps;2824 2825 if (!ht_cap->ht_supported)2826 return 0;2827 2828 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;2829 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;2830 2831 if (smps >= ARRAY_SIZE(ath10k_smps_map))2832 return -EINVAL;2833 2834 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,2835 ar->wmi.peer_param->smps_state,2836 ath10k_smps_map[smps]);2837}2838 2839static int ath10k_mac_vif_recalc_txbf(struct ath10k *ar,2840 struct ieee80211_vif *vif,2841 struct ieee80211_sta_vht_cap vht_cap)2842{2843 struct ath10k_vif *arvif = (void *)vif->drv_priv;2844 int ret;2845 u32 param;2846 u32 value;2847 2848 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_AFTER_ASSOC)2849 return 0;2850 2851 if (!(ar->vht_cap_info &2852 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |2853 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE |2854 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |2855 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)))2856 return 0;2857 2858 param = ar->wmi.vdev_param->txbf;2859 value = 0;2860 2861 if (WARN_ON(param == WMI_VDEV_PARAM_UNSUPPORTED))2862 return 0;2863 2864 /* The following logic is correct. If a remote STA advertises support2865 * for being a beamformer then we should enable us being a beamformee.2866 */2867 2868 if (ar->vht_cap_info &2869 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |2870 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {2871 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)2872 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;2873 2874 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)2875 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;2876 }2877 2878 if (ar->vht_cap_info &2879 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |2880 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {2881 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)2882 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;2883 2884 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)2885 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;2886 }2887 2888 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFEE)2889 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;2890 2891 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFER)2892 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;2893 2894 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, value);2895 if (ret) {2896 ath10k_warn(ar, "failed to submit vdev param txbf 0x%x: %d\n",2897 value, ret);2898 return ret;2899 }2900 2901 return 0;2902}2903 2904static bool ath10k_mac_is_connected(struct ath10k *ar)2905{2906 struct ath10k_vif *arvif;2907 2908 list_for_each_entry(arvif, &ar->arvifs, list) {2909 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_STA)2910 return true;2911 }2912 2913 return false;2914}2915 2916static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)2917{2918 int ret;2919 u32 param;2920 int tx_power_2g, tx_power_5g;2921 bool connected;2922 2923 lockdep_assert_held(&ar->conf_mutex);2924 2925 /* ath10k internally uses unit of 0.5 dBm so multiply by 2 */2926 tx_power_2g = txpower * 2;2927 tx_power_5g = txpower * 2;2928 2929 connected = ath10k_mac_is_connected(ar);2930 2931 if (connected && ar->tx_power_2g_limit)2932 if (tx_power_2g > ar->tx_power_2g_limit)2933 tx_power_2g = ar->tx_power_2g_limit;2934 2935 if (connected && ar->tx_power_5g_limit)2936 if (tx_power_5g > ar->tx_power_5g_limit)2937 tx_power_5g = ar->tx_power_5g_limit;2938 2939 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower 2g: %d, 5g: %d\n",2940 tx_power_2g, tx_power_5g);2941 2942 param = ar->wmi.pdev_param->txpower_limit2g;2943 ret = ath10k_wmi_pdev_set_param(ar, param, tx_power_2g);2944 if (ret) {2945 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",2946 tx_power_2g, ret);2947 return ret;2948 }2949 2950 param = ar->wmi.pdev_param->txpower_limit5g;2951 ret = ath10k_wmi_pdev_set_param(ar, param, tx_power_5g);2952 if (ret) {2953 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",2954 tx_power_5g, ret);2955 return ret;2956 }2957 2958 return 0;2959}2960 2961static int ath10k_mac_txpower_recalc(struct ath10k *ar)2962{2963 struct ath10k_vif *arvif;2964 int ret, txpower = -1;2965 2966 lockdep_assert_held(&ar->conf_mutex);2967 2968 list_for_each_entry(arvif, &ar->arvifs, list) {2969 /* txpower not initialized yet? */2970 if (arvif->txpower == INT_MIN)2971 continue;2972 2973 if (txpower == -1)2974 txpower = arvif->txpower;2975 else2976 txpower = min(txpower, arvif->txpower);2977 }2978 2979 if (txpower == -1)2980 return 0;2981 2982 ret = ath10k_mac_txpower_setup(ar, txpower);2983 if (ret) {2984 ath10k_warn(ar, "failed to setup tx power %d: %d\n",2985 txpower, ret);2986 return ret;2987 }2988 2989 return 0;2990}2991 2992static int ath10k_mac_set_sar_power(struct ath10k *ar)2993{2994 if (!ar->hw_params.dynamic_sar_support)2995 return -EOPNOTSUPP;2996 2997 if (!ath10k_mac_is_connected(ar))2998 return 0;2999 3000 /* if connected, then arvif->txpower must be valid */3001 return ath10k_mac_txpower_recalc(ar);3002}3003 3004static int ath10k_mac_set_sar_specs(struct ieee80211_hw *hw,3005 const struct cfg80211_sar_specs *sar)3006{3007 const struct cfg80211_sar_sub_specs *sub_specs;3008 struct ath10k *ar = hw->priv;3009 u32 i;3010 int ret;3011 3012 mutex_lock(&ar->conf_mutex);3013 3014 if (!ar->hw_params.dynamic_sar_support) {3015 ret = -EOPNOTSUPP;3016 goto err;3017 }3018 3019 if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||3020 sar->num_sub_specs == 0) {3021 ret = -EINVAL;3022 goto err;3023 }3024 3025 sub_specs = sar->sub_specs;3026 3027 /* 0dbm is not a practical value for ath10k, so use 03028 * as no SAR limitation on it.3029 */3030 ar->tx_power_2g_limit = 0;3031 ar->tx_power_5g_limit = 0;3032 3033 /* note the power is in 0.25dbm unit, while ath10k uses3034 * 0.5dbm unit.3035 */3036 for (i = 0; i < sar->num_sub_specs; i++) {3037 if (sub_specs->freq_range_index == 0)3038 ar->tx_power_2g_limit = sub_specs->power / 2;3039 else if (sub_specs->freq_range_index == 1)3040 ar->tx_power_5g_limit = sub_specs->power / 2;3041 3042 sub_specs++;3043 }3044 3045 ret = ath10k_mac_set_sar_power(ar);3046 if (ret) {3047 ath10k_warn(ar, "failed to set sar power: %d", ret);3048 goto err;3049 }3050 3051err:3052 mutex_unlock(&ar->conf_mutex);3053 return ret;3054}3055 3056/* can be called only in mac80211 callbacks due to `key_count` usage */3057static void ath10k_bss_assoc(struct ieee80211_hw *hw,3058 struct ieee80211_vif *vif,3059 struct ieee80211_bss_conf *bss_conf)3060{3061 struct ath10k *ar = hw->priv;3062 struct ath10k_vif *arvif = (void *)vif->drv_priv;3063 struct ieee80211_sta_ht_cap ht_cap;3064 struct ieee80211_sta_vht_cap vht_cap;3065 struct wmi_peer_assoc_complete_arg peer_arg;3066 struct ieee80211_sta *ap_sta;3067 int ret;3068 3069 lockdep_assert_held(&ar->conf_mutex);3070 3071 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",3072 arvif->vdev_id, arvif->bssid, arvif->aid);3073 3074 rcu_read_lock();3075 3076 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);3077 if (!ap_sta) {3078 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",3079 bss_conf->bssid, arvif->vdev_id);3080 rcu_read_unlock();3081 return;3082 }3083 3084 /* ap_sta must be accessed only within rcu section which must be left3085 * before calling ath10k_setup_peer_smps() which might sleep.3086 */3087 ht_cap = ap_sta->deflink.ht_cap;3088 vht_cap = ap_sta->deflink.vht_cap;3089 3090 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);3091 if (ret) {3092 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",3093 bss_conf->bssid, arvif->vdev_id, ret);3094 rcu_read_unlock();3095 return;3096 }3097 3098 rcu_read_unlock();3099 3100 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);3101 if (ret) {3102 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",3103 bss_conf->bssid, arvif->vdev_id, ret);3104 return;3105 }3106 3107 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);3108 if (ret) {3109 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",3110 arvif->vdev_id, ret);3111 return;3112 }3113 3114 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);3115 if (ret) {3116 ath10k_warn(ar, "failed to recalc txbf for vdev %i on bss %pM: %d\n",3117 arvif->vdev_id, bss_conf->bssid, ret);3118 return;3119 }3120 3121 ath10k_dbg(ar, ATH10K_DBG_MAC,3122 "mac vdev %d up (associated) bssid %pM aid %d\n",3123 arvif->vdev_id, bss_conf->bssid, vif->cfg.aid);3124 3125 WARN_ON(arvif->is_up);3126 3127 arvif->aid = vif->cfg.aid;3128 ether_addr_copy(arvif->bssid, bss_conf->bssid);3129 3130 ret = ath10k_wmi_pdev_set_param(ar,3131 ar->wmi.pdev_param->peer_stats_info_enable, 1);3132 if (ret)3133 ath10k_warn(ar, "failed to enable peer stats info: %d\n", ret);3134 3135 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);3136 if (ret) {3137 ath10k_warn(ar, "failed to set vdev %d up: %d\n",3138 arvif->vdev_id, ret);3139 return;3140 }3141 3142 arvif->is_up = true;3143 3144 ath10k_mac_set_sar_power(ar);3145 3146 /* Workaround: Some firmware revisions (tested with qca61743147 * WLAN.RM.2.0-00073) have buggy powersave state machine and must be3148 * poked with peer param command.3149 */3150 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid,3151 ar->wmi.peer_param->dummy_var, 1);3152 if (ret) {3153 ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n",3154 arvif->bssid, arvif->vdev_id, ret);3155 return;3156 }3157}3158 3159static void ath10k_bss_disassoc(struct ieee80211_hw *hw,3160 struct ieee80211_vif *vif)3161{3162 struct ath10k *ar = hw->priv;3163 struct ath10k_vif *arvif = (void *)vif->drv_priv;3164 struct ieee80211_sta_vht_cap vht_cap = {};3165 int ret;3166 3167 lockdep_assert_held(&ar->conf_mutex);3168 3169 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",3170 arvif->vdev_id, arvif->bssid);3171 3172 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);3173 if (ret)3174 ath10k_warn(ar, "failed to down vdev %i: %d\n",3175 arvif->vdev_id, ret);3176 3177 arvif->def_wep_key_idx = -1;3178 3179 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);3180 if (ret) {3181 ath10k_warn(ar, "failed to recalc txbf for vdev %i: %d\n",3182 arvif->vdev_id, ret);3183 return;3184 }3185 3186 arvif->is_up = false;3187 3188 ath10k_mac_txpower_recalc(ar);3189 3190 cancel_delayed_work_sync(&arvif->connection_loss_work);3191}3192 3193static int ath10k_new_peer_tid_config(struct ath10k *ar,3194 struct ieee80211_sta *sta,3195 struct ath10k_vif *arvif)3196{3197 struct wmi_per_peer_per_tid_cfg_arg arg = {};3198 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;3199 bool config_apply;3200 int ret, i;3201 3202 for (i = 0; i < ATH10K_TID_MAX; i++) {3203 config_apply = false;3204 if (arvif->retry_long[i] || arvif->ampdu[i] ||3205 arvif->rate_ctrl[i] || arvif->rtscts[i]) {3206 config_apply = true;3207 arg.tid = i;3208 arg.vdev_id = arvif->vdev_id;3209 arg.retry_count = arvif->retry_long[i];3210 arg.aggr_control = arvif->ampdu[i];3211 arg.rate_ctrl = arvif->rate_ctrl[i];3212 arg.rcode_flags = arvif->rate_code[i];3213 3214 if (arvif->rtscts[i])3215 arg.ext_tid_cfg_bitmap =3216 WMI_EXT_TID_RTS_CTS_CONFIG;3217 else3218 arg.ext_tid_cfg_bitmap = 0;3219 3220 arg.rtscts_ctrl = arvif->rtscts[i];3221 }3222 3223 if (arvif->noack[i]) {3224 arg.ack_policy = arvif->noack[i];3225 arg.rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_DEFAULT_LOWEST_RATE;3226 arg.aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_DISABLE;3227 config_apply = true;3228 }3229 3230 /* Assign default value(-1) to newly connected station.3231 * This is to identify station specific tid configuration not3232 * configured for the station.3233 */3234 arsta->retry_long[i] = -1;3235 arsta->noack[i] = -1;3236 arsta->ampdu[i] = -1;3237 3238 if (!config_apply)3239 continue;3240 3241 ether_addr_copy(arg.peer_macaddr.addr, sta->addr);3242 3243 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg);3244 if (ret) {3245 ath10k_warn(ar, "failed to set per tid retry/aggr config for sta %pM: %d\n",3246 sta->addr, ret);3247 return ret;3248 }3249 3250 memset(&arg, 0, sizeof(arg));3251 }3252 3253 return 0;3254}3255 3256static int ath10k_station_assoc(struct ath10k *ar,3257 struct ieee80211_vif *vif,3258 struct ieee80211_sta *sta,3259 bool reassoc)3260{3261 struct ath10k_vif *arvif = (void *)vif->drv_priv;3262 struct wmi_peer_assoc_complete_arg peer_arg;3263 int ret = 0;3264 3265 lockdep_assert_held(&ar->conf_mutex);3266 3267 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);3268 if (ret) {3269 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",3270 sta->addr, arvif->vdev_id, ret);3271 return ret;3272 }3273 3274 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);3275 if (ret) {3276 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",3277 sta->addr, arvif->vdev_id, ret);3278 return ret;3279 }3280 3281 /* Re-assoc is run only to update supported rates for given station. It3282 * doesn't make much sense to reconfigure the peer completely.3283 */3284 if (!reassoc) {3285 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,3286 &sta->deflink.ht_cap);3287 if (ret) {3288 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",3289 arvif->vdev_id, ret);3290 return ret;3291 }3292 3293 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);3294 if (ret) {3295 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",3296 sta->addr, arvif->vdev_id, ret);3297 return ret;3298 }3299 3300 if (!sta->wme) {3301 arvif->num_legacy_stations++;3302 ret = ath10k_recalc_rtscts_prot(arvif);3303 if (ret) {3304 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",3305 arvif->vdev_id, ret);3306 return ret;3307 }3308 }3309 3310 /* Plumb cached keys only for static WEP */3311 if ((arvif->def_wep_key_idx != -1) && (!sta->tdls)) {3312 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);3313 if (ret) {3314 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",3315 arvif->vdev_id, ret);3316 return ret;3317 }3318 }3319 }3320 3321 if (!test_bit(WMI_SERVICE_PEER_TID_CONFIGS_SUPPORT, ar->wmi.svc_map))3322 return ret;3323 3324 return ath10k_new_peer_tid_config(ar, sta, arvif);3325}3326 3327static int ath10k_station_disassoc(struct ath10k *ar,3328 struct ieee80211_vif *vif,3329 struct ieee80211_sta *sta)3330{3331 struct ath10k_vif *arvif = (void *)vif->drv_priv;3332 int ret = 0;3333 3334 lockdep_assert_held(&ar->conf_mutex);3335 3336 if (!sta->wme) {3337 arvif->num_legacy_stations--;3338 ret = ath10k_recalc_rtscts_prot(arvif);3339 if (ret) {3340 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",3341 arvif->vdev_id, ret);3342 return ret;3343 }3344 }3345 3346 ret = ath10k_clear_peer_keys(arvif, sta->addr);3347 if (ret) {3348 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",3349 arvif->vdev_id, ret);3350 return ret;3351 }3352 3353 return ret;3354}3355 3356/**************/3357/* Regulatory */3358/**************/3359 3360static int ath10k_update_channel_list(struct ath10k *ar)3361{3362 struct ieee80211_hw *hw = ar->hw;3363 struct ieee80211_supported_band **bands;3364 enum nl80211_band band;3365 struct ieee80211_channel *channel;3366 struct wmi_scan_chan_list_arg arg = {0};3367 struct wmi_channel_arg *ch;3368 bool passive;3369 int len;3370 int ret;3371 int i;3372 3373 lockdep_assert_held(&ar->conf_mutex);3374 3375 bands = hw->wiphy->bands;3376 for (band = 0; band < NUM_NL80211_BANDS; band++) {3377 if (!bands[band])3378 continue;3379 3380 for (i = 0; i < bands[band]->n_channels; i++) {3381 if (bands[band]->channels[i].flags &3382 IEEE80211_CHAN_DISABLED)3383 continue;3384 3385 arg.n_channels++;3386 }3387 }3388 3389 len = sizeof(struct wmi_channel_arg) * arg.n_channels;3390 arg.channels = kzalloc(len, GFP_KERNEL);3391 if (!arg.channels)3392 return -ENOMEM;3393 3394 ch = arg.channels;3395 for (band = 0; band < NUM_NL80211_BANDS; band++) {3396 if (!bands[band])3397 continue;3398 3399 for (i = 0; i < bands[band]->n_channels; i++) {3400 channel = &bands[band]->channels[i];3401 3402 if (channel->flags & IEEE80211_CHAN_DISABLED)3403 continue;3404 3405 ch->allow_ht = true;3406 3407 /* FIXME: when should we really allow VHT? */3408 ch->allow_vht = true;3409 3410 ch->allow_ibss =3411 !(channel->flags & IEEE80211_CHAN_NO_IR);3412 3413 ch->ht40plus =3414 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);3415 3416 ch->chan_radar =3417 !!(channel->flags & IEEE80211_CHAN_RADAR);3418 3419 passive = channel->flags & IEEE80211_CHAN_NO_IR;3420 ch->passive = passive;3421 3422 /* the firmware is ignoring the "radar" flag of the3423 * channel and is scanning actively using Probe Requests3424 * on "Radar detection"/DFS channels which are not3425 * marked as "available"3426 */3427 ch->passive |= ch->chan_radar;3428 3429 ch->freq = channel->center_freq;3430 ch->band_center_freq1 = channel->center_freq;3431 ch->min_power = 0;3432 ch->max_power = channel->max_power * 2;3433 ch->max_reg_power = channel->max_reg_power * 2;3434 ch->max_antenna_gain = channel->max_antenna_gain;3435 ch->reg_class_id = 0; /* FIXME */3436 3437 /* FIXME: why use only legacy modes, why not any3438 * HT/VHT modes? Would that even make any3439 * difference?3440 */3441 if (channel->band == NL80211_BAND_2GHZ)3442 ch->mode = MODE_11G;3443 else3444 ch->mode = MODE_11A;3445 3446 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))3447 continue;3448 3449 ath10k_dbg(ar, ATH10K_DBG_WMI,3450 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",3451 ch - arg.channels, arg.n_channels,3452 ch->freq, ch->max_power, ch->max_reg_power,3453 ch->max_antenna_gain, ch->mode);3454 3455 ch++;3456 }3457 }3458 3459 ret = ath10k_wmi_scan_chan_list(ar, &arg);3460 kfree(arg.channels);3461 3462 return ret;3463}3464 3465static enum wmi_dfs_region3466ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)3467{3468 switch (dfs_region) {3469 case NL80211_DFS_UNSET:3470 return WMI_UNINIT_DFS_DOMAIN;3471 case NL80211_DFS_FCC:3472 return WMI_FCC_DFS_DOMAIN;3473 case NL80211_DFS_ETSI:3474 return WMI_ETSI_DFS_DOMAIN;3475 case NL80211_DFS_JP:3476 return WMI_MKK4_DFS_DOMAIN;3477 }3478 return WMI_UNINIT_DFS_DOMAIN;3479}3480 3481static void ath10k_regd_update(struct ath10k *ar)3482{3483 struct reg_dmn_pair_mapping *regpair;3484 int ret;3485 enum wmi_dfs_region wmi_dfs_reg;3486 enum nl80211_dfs_regions nl_dfs_reg;3487 3488 lockdep_assert_held(&ar->conf_mutex);3489 3490 ret = ath10k_update_channel_list(ar);3491 if (ret)3492 ath10k_warn(ar, "failed to update channel list: %d\n", ret);3493 3494 regpair = ar->ath_common.regulatory.regpair;3495 3496 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {3497 nl_dfs_reg = ar->dfs_detector->region;3498 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);3499 } else {3500 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;3501 }3502 3503 /* Target allows setting up per-band regdomain but ath_common provides3504 * a combined one only3505 */3506 ret = ath10k_wmi_pdev_set_regdomain(ar,3507 regpair->reg_domain,3508 regpair->reg_domain, /* 2ghz */3509 regpair->reg_domain, /* 5ghz */3510 regpair->reg_2ghz_ctl,3511 regpair->reg_5ghz_ctl,3512 wmi_dfs_reg);3513 if (ret)3514 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);3515}3516 3517static void ath10k_mac_update_channel_list(struct ath10k *ar,3518 struct ieee80211_supported_band *band)3519{3520 int i;3521 3522 if (ar->low_5ghz_chan && ar->high_5ghz_chan) {3523 for (i = 0; i < band->n_channels; i++) {3524 if (band->channels[i].center_freq < ar->low_5ghz_chan ||3525 band->channels[i].center_freq > ar->high_5ghz_chan)3526 band->channels[i].flags |=3527 IEEE80211_CHAN_DISABLED;3528 }3529 }3530}3531 3532static void ath10k_reg_notifier(struct wiphy *wiphy,3533 struct regulatory_request *request)3534{3535 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);3536 struct ath10k *ar = hw->priv;3537 bool result;3538 3539 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);3540 3541 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {3542 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",3543 request->dfs_region);3544 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,3545 request->dfs_region);3546 if (!result)3547 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",3548 request->dfs_region);3549 }3550 3551 mutex_lock(&ar->conf_mutex);3552 if (ar->state == ATH10K_STATE_ON)3553 ath10k_regd_update(ar);3554 mutex_unlock(&ar->conf_mutex);3555 3556 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY)3557 ath10k_mac_update_channel_list(ar,3558 ar->hw->wiphy->bands[NL80211_BAND_5GHZ]);3559}3560 3561static void ath10k_stop_radar_confirmation(struct ath10k *ar)3562{3563 spin_lock_bh(&ar->data_lock);3564 ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_STOPPED;3565 spin_unlock_bh(&ar->data_lock);3566 3567 cancel_work_sync(&ar->radar_confirmation_work);3568}3569 3570/***************/3571/* TX handlers */3572/***************/3573 3574enum ath10k_mac_tx_path {3575 ATH10K_MAC_TX_HTT,3576 ATH10K_MAC_TX_HTT_MGMT,3577 ATH10K_MAC_TX_WMI_MGMT,3578 ATH10K_MAC_TX_UNKNOWN,3579};3580 3581void ath10k_mac_tx_lock(struct ath10k *ar, int reason)3582{3583 lockdep_assert_held(&ar->htt.tx_lock);3584 3585 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);3586 ar->tx_paused |= BIT(reason);3587 ieee80211_stop_queues(ar->hw);3588}3589 3590static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac,3591 struct ieee80211_vif *vif)3592{3593 struct ath10k *ar = data;3594 struct ath10k_vif *arvif = (void *)vif->drv_priv;3595 3596 if (arvif->tx_paused)3597 return;3598 3599 ieee80211_wake_queue(ar->hw, arvif->vdev_id);3600}3601 3602void ath10k_mac_tx_unlock(struct ath10k *ar, int reason)3603{3604 lockdep_assert_held(&ar->htt.tx_lock);3605 3606 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);3607 ar->tx_paused &= ~BIT(reason);3608 3609 if (ar->tx_paused)3610 return;3611 3612 ieee80211_iterate_active_interfaces_atomic(ar->hw,3613 ATH10K_ITER_RESUME_FLAGS,3614 ath10k_mac_tx_unlock_iter,3615 ar);3616 3617 ieee80211_wake_queue(ar->hw, ar->hw->offchannel_tx_hw_queue);3618}3619 3620void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason)3621{3622 struct ath10k *ar = arvif->ar;3623 3624 lockdep_assert_held(&ar->htt.tx_lock);3625 3626 WARN_ON(reason >= BITS_PER_LONG);3627 arvif->tx_paused |= BIT(reason);3628 ieee80211_stop_queue(ar->hw, arvif->vdev_id);3629}3630 3631void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason)3632{3633 struct ath10k *ar = arvif->ar;3634 3635 lockdep_assert_held(&ar->htt.tx_lock);3636 3637 WARN_ON(reason >= BITS_PER_LONG);3638 arvif->tx_paused &= ~BIT(reason);3639 3640 if (ar->tx_paused)3641 return;3642 3643 if (arvif->tx_paused)3644 return;3645 3646 ieee80211_wake_queue(ar->hw, arvif->vdev_id);3647}3648 3649static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif,3650 enum wmi_tlv_tx_pause_id pause_id,3651 enum wmi_tlv_tx_pause_action action)3652{3653 struct ath10k *ar = arvif->ar;3654 3655 lockdep_assert_held(&ar->htt.tx_lock);3656 3657 switch (action) {3658 case WMI_TLV_TX_PAUSE_ACTION_STOP:3659 ath10k_mac_vif_tx_lock(arvif, pause_id);3660 break;3661 case WMI_TLV_TX_PAUSE_ACTION_WAKE:3662 ath10k_mac_vif_tx_unlock(arvif, pause_id);3663 break;3664 default:3665 ath10k_dbg(ar, ATH10K_DBG_BOOT,3666 "received unknown tx pause action %d on vdev %i, ignoring\n",3667 action, arvif->vdev_id);3668 break;3669 }3670}3671 3672struct ath10k_mac_tx_pause {3673 u32 vdev_id;3674 enum wmi_tlv_tx_pause_id pause_id;3675 enum wmi_tlv_tx_pause_action action;3676};3677 3678static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac,3679 struct ieee80211_vif *vif)3680{3681 struct ath10k_vif *arvif = (void *)vif->drv_priv;3682 struct ath10k_mac_tx_pause *arg = data;3683 3684 if (arvif->vdev_id != arg->vdev_id)3685 return;3686 3687 ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action);3688}3689 3690void ath10k_mac_handle_tx_pause_vdev(struct ath10k *ar, u32 vdev_id,3691 enum wmi_tlv_tx_pause_id pause_id,3692 enum wmi_tlv_tx_pause_action action)3693{3694 struct ath10k_mac_tx_pause arg = {3695 .vdev_id = vdev_id,3696 .pause_id = pause_id,3697 .action = action,3698 };3699 3700 spin_lock_bh(&ar->htt.tx_lock);3701 ieee80211_iterate_active_interfaces_atomic(ar->hw,3702 ATH10K_ITER_RESUME_FLAGS,3703 ath10k_mac_handle_tx_pause_iter,3704 &arg);3705 spin_unlock_bh(&ar->htt.tx_lock);3706}3707 3708static enum ath10k_hw_txrx_mode3709ath10k_mac_tx_h_get_txmode(struct ath10k *ar,3710 struct ieee80211_vif *vif,3711 struct ieee80211_sta *sta,3712 struct sk_buff *skb)3713{3714 const struct ieee80211_hdr *hdr = (void *)skb->data;3715 const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);3716 __le16 fc = hdr->frame_control;3717 3718 if (IEEE80211_SKB_CB(skb)->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)3719 return ATH10K_HW_TXRX_ETHERNET;3720 3721 if (!vif || vif->type == NL80211_IFTYPE_MONITOR)3722 return ATH10K_HW_TXRX_RAW;3723 3724 if (ieee80211_is_mgmt(fc))3725 return ATH10K_HW_TXRX_MGMT;3726 3727 /* Workaround:3728 *3729 * NullFunc frames are mostly used to ping if a client or AP are still3730 * reachable and responsive. This implies tx status reports must be3731 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can3732 * come to a conclusion that the other end disappeared and tear down3733 * BSS connection or it can never disconnect from BSS/client (which is3734 * the case).3735 *3736 * Firmware with HTT older than 3.0 delivers incorrect tx status for3737 * NullFunc frames to driver. However there's a HTT Mgmt Tx command3738 * which seems to deliver correct tx reports for NullFunc frames. The3739 * downside of using it is it ignores client powersave state so it can3740 * end up disconnecting sleeping clients in AP mode. It should fix STA3741 * mode though because AP don't sleep.3742 */3743 if (ar->htt.target_version_major < 3 &&3744 (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) &&3745 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,3746 ar->running_fw->fw_file.fw_features))3747 return ATH10K_HW_TXRX_MGMT;3748 3749 /* Workaround:3750 *3751 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for3752 * NativeWifi txmode - it selects AP key instead of peer key. It seems3753 * to work with Ethernet txmode so use it.3754 *3755 * FIXME: Check if raw mode works with TDLS.3756 */3757 if (ieee80211_is_data_present(fc) && sta && sta->tdls)3758 return ATH10K_HW_TXRX_ETHERNET;3759 3760 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) ||3761 skb_cb->flags & ATH10K_SKB_F_RAW_TX)3762 return ATH10K_HW_TXRX_RAW;3763 3764 return ATH10K_HW_TXRX_NATIVE_WIFI;3765}3766 3767static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif,3768 struct sk_buff *skb)3769{3770 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);3771 const struct ieee80211_hdr *hdr = (void *)skb->data;3772 const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT |3773 IEEE80211_TX_CTL_INJECTED;3774 3775 if (!ieee80211_has_protected(hdr->frame_control))3776 return false;3777 3778 if ((info->flags & mask) == mask)3779 return false;3780 3781 if (vif)3782 return !((struct ath10k_vif *)vif->drv_priv)->nohwcrypt;3783 3784 return true;3785}3786 3787/* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS3788 * Control in the header.3789 */3790static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)3791{3792 struct ieee80211_hdr *hdr = (void *)skb->data;3793 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);3794 u8 *qos_ctl;3795 3796 if (!ieee80211_is_data_qos(hdr->frame_control))3797 return;3798 3799 qos_ctl = ieee80211_get_qos_ctl(hdr);3800 memmove(skb->data + IEEE80211_QOS_CTL_LEN,3801 skb->data, (void *)qos_ctl - (void *)skb->data);3802 skb_pull(skb, IEEE80211_QOS_CTL_LEN);3803 3804 /* Some firmware revisions don't handle sending QoS NullFunc well.3805 * These frames are mainly used for CQM purposes so it doesn't really3806 * matter whether QoS NullFunc or NullFunc are sent.3807 */3808 hdr = (void *)skb->data;3809 if (ieee80211_is_qos_nullfunc(hdr->frame_control))3810 cb->flags &= ~ATH10K_SKB_F_QOS;3811 3812 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);3813}3814 3815static void ath10k_tx_h_8023(struct sk_buff *skb)3816{3817 struct ieee80211_hdr *hdr;3818 struct rfc1042_hdr *rfc1042;3819 struct ethhdr *eth;3820 size_t hdrlen;3821 u8 da[ETH_ALEN];3822 u8 sa[ETH_ALEN];3823 __be16 type;3824 3825 hdr = (void *)skb->data;3826 hdrlen = ieee80211_hdrlen(hdr->frame_control);3827 rfc1042 = (void *)skb->data + hdrlen;3828 3829 ether_addr_copy(da, ieee80211_get_DA(hdr));3830 ether_addr_copy(sa, ieee80211_get_SA(hdr));3831 type = rfc1042->snap_type;3832 3833 skb_pull(skb, hdrlen + sizeof(*rfc1042));3834 skb_push(skb, sizeof(*eth));3835 3836 eth = (void *)skb->data;3837 ether_addr_copy(eth->h_dest, da);3838 ether_addr_copy(eth->h_source, sa);3839 eth->h_proto = type;3840}3841 3842static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,3843 struct ieee80211_vif *vif,3844 struct sk_buff *skb)3845{3846 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;3847 struct ath10k_vif *arvif = (void *)vif->drv_priv;3848 3849 /* This is case only for P2P_GO */3850 if (vif->type != NL80211_IFTYPE_AP || !vif->p2p)3851 return;3852 3853 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {3854 spin_lock_bh(&ar->data_lock);3855 if (arvif->u.ap.noa_data)3856 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,3857 GFP_ATOMIC))3858 skb_put_data(skb, arvif->u.ap.noa_data,3859 arvif->u.ap.noa_len);3860 spin_unlock_bh(&ar->data_lock);3861 }3862}3863 3864static void ath10k_mac_tx_h_fill_cb(struct ath10k *ar,3865 struct ieee80211_vif *vif,3866 struct ieee80211_txq *txq,3867 struct ieee80211_sta *sta,3868 struct sk_buff *skb, u16 airtime)3869{3870 struct ieee80211_hdr *hdr = (void *)skb->data;3871 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);3872 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);3873 bool is_data = ieee80211_is_data(hdr->frame_control) ||3874 ieee80211_is_data_qos(hdr->frame_control);3875 struct ath10k_vif *arvif = (void *)vif->drv_priv;3876 struct ath10k_sta *arsta;3877 u8 tid, *qos_ctl;3878 bool noack = false;3879 3880 cb->flags = 0;3881 3882 if (info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {3883 cb->flags |= ATH10K_SKB_F_QOS; /* Assume data frames are QoS */3884 goto finish_cb_fill;3885 }3886 3887 if (!ath10k_tx_h_use_hwcrypto(vif, skb))3888 cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;3889 3890 if (ieee80211_is_mgmt(hdr->frame_control))3891 cb->flags |= ATH10K_SKB_F_MGMT;3892 3893 if (ieee80211_is_data_qos(hdr->frame_control)) {3894 cb->flags |= ATH10K_SKB_F_QOS;3895 qos_ctl = ieee80211_get_qos_ctl(hdr);3896 tid = (*qos_ctl) & IEEE80211_QOS_CTL_TID_MASK;3897 3898 if (arvif->noack[tid] == WMI_PEER_TID_CONFIG_NOACK)3899 noack = true;3900 3901 if (sta) {3902 arsta = (struct ath10k_sta *)sta->drv_priv;3903 3904 if (arsta->noack[tid] == WMI_PEER_TID_CONFIG_NOACK)3905 noack = true;3906 3907 if (arsta->noack[tid] == WMI_PEER_TID_CONFIG_ACK)3908 noack = false;3909 }3910 3911 if (noack)3912 cb->flags |= ATH10K_SKB_F_NOACK_TID;3913 }3914 3915 /* Data frames encrypted in software will be posted to firmware3916 * with tx encap mode set to RAW. Ex: Multicast traffic generated3917 * for a specific VLAN group will always be encrypted in software.3918 */3919 if (is_data && ieee80211_has_protected(hdr->frame_control) &&3920 !info->control.hw_key) {3921 cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;3922 cb->flags |= ATH10K_SKB_F_RAW_TX;3923 }3924 3925finish_cb_fill:3926 cb->vif = vif;3927 cb->txq = txq;3928 cb->airtime_est = airtime;3929 if (sta) {3930 arsta = (struct ath10k_sta *)sta->drv_priv;3931 spin_lock_bh(&ar->data_lock);3932 cb->ucast_cipher = arsta->ucast_cipher;3933 spin_unlock_bh(&ar->data_lock);3934 }3935}3936 3937bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar)3938{3939 /* FIXME: Not really sure since when the behaviour changed. At some3940 * point new firmware stopped requiring creation of peer entries for3941 * offchannel tx (and actually creating them causes issues with wmi-htc3942 * tx credit replenishment and reliability). Assuming it's at least 3.43943 * because that's when the `freq` was introduced to TX_FRM HTT command.3944 */3945 return (ar->htt.target_version_major >= 3 &&3946 ar->htt.target_version_minor >= 4 &&3947 ar->running_fw->fw_file.htt_op_version == ATH10K_FW_HTT_OP_VERSION_TLV);3948}3949 3950static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb)3951{3952 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;3953 3954 if (skb_queue_len_lockless(q) >= ATH10K_MAX_NUM_MGMT_PENDING) {3955 ath10k_warn(ar, "wmi mgmt tx queue is full\n");3956 return -ENOSPC;3957 }3958 3959 skb_queue_tail(q, skb);3960 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);3961 3962 return 0;3963}3964 3965static enum ath10k_mac_tx_path3966ath10k_mac_tx_h_get_txpath(struct ath10k *ar,3967 struct sk_buff *skb,3968 enum ath10k_hw_txrx_mode txmode)3969{3970 switch (txmode) {3971 case ATH10K_HW_TXRX_RAW:3972 case ATH10K_HW_TXRX_NATIVE_WIFI:3973 case ATH10K_HW_TXRX_ETHERNET:3974 return ATH10K_MAC_TX_HTT;3975 case ATH10K_HW_TXRX_MGMT:3976 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,3977 ar->running_fw->fw_file.fw_features) ||3978 test_bit(WMI_SERVICE_MGMT_TX_WMI,3979 ar->wmi.svc_map))3980 return ATH10K_MAC_TX_WMI_MGMT;3981 else if (ar->htt.target_version_major >= 3)3982 return ATH10K_MAC_TX_HTT;3983 else3984 return ATH10K_MAC_TX_HTT_MGMT;3985 }3986 3987 return ATH10K_MAC_TX_UNKNOWN;3988}3989 3990static int ath10k_mac_tx_submit(struct ath10k *ar,3991 enum ath10k_hw_txrx_mode txmode,3992 enum ath10k_mac_tx_path txpath,3993 struct sk_buff *skb)3994{3995 struct ath10k_htt *htt = &ar->htt;3996 int ret = -EINVAL;3997 3998 switch (txpath) {3999 case ATH10K_MAC_TX_HTT:4000 ret = ath10k_htt_tx(htt, txmode, skb);4001 break;4002 case ATH10K_MAC_TX_HTT_MGMT:4003 ret = ath10k_htt_mgmt_tx(htt, skb);4004 break;4005 case ATH10K_MAC_TX_WMI_MGMT:4006 ret = ath10k_mac_tx_wmi_mgmt(ar, skb);4007 break;4008 case ATH10K_MAC_TX_UNKNOWN:4009 WARN_ON_ONCE(1);4010 ret = -EINVAL;4011 break;4012 }4013 4014 if (ret) {4015 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",4016 ret);4017 ieee80211_free_txskb(ar->hw, skb);4018 }4019 4020 return ret;4021}4022 4023/* This function consumes the sk_buff regardless of return value as far as4024 * caller is concerned so no freeing is necessary afterwards.4025 */4026static int ath10k_mac_tx(struct ath10k *ar,4027 struct ieee80211_vif *vif,4028 enum ath10k_hw_txrx_mode txmode,4029 enum ath10k_mac_tx_path txpath,4030 struct sk_buff *skb, bool noque_offchan)4031{4032 struct ieee80211_hw *hw = ar->hw;4033 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);4034 const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);4035 int ret;4036 4037 /* We should disable CCK RATE due to P2P */4038 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)4039 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");4040 4041 switch (txmode) {4042 case ATH10K_HW_TXRX_MGMT:4043 case ATH10K_HW_TXRX_NATIVE_WIFI:4044 ath10k_tx_h_nwifi(hw, skb);4045 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);4046 ath10k_tx_h_seq_no(vif, skb);4047 break;4048 case ATH10K_HW_TXRX_ETHERNET:4049 /* Convert 802.11->802.3 header only if the frame was earlier4050 * encapsulated to 802.11 by mac80211. Otherwise pass it as is.4051 */4052 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP))4053 ath10k_tx_h_8023(skb);4054 break;4055 case ATH10K_HW_TXRX_RAW:4056 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) &&4057 !(skb_cb->flags & ATH10K_SKB_F_RAW_TX)) {4058 WARN_ON_ONCE(1);4059 ieee80211_free_txskb(hw, skb);4060 return -EOPNOTSUPP;4061 }4062 }4063 4064 if (!noque_offchan && info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {4065 if (!ath10k_mac_tx_frm_has_freq(ar)) {4066 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac queued offchannel skb %pK len %d\n",4067 skb, skb->len);4068 4069 skb_queue_tail(&ar->offchan_tx_queue, skb);4070 ieee80211_queue_work(hw, &ar->offchan_tx_work);4071 return 0;4072 }4073 }4074 4075 ret = ath10k_mac_tx_submit(ar, txmode, txpath, skb);4076 if (ret) {4077 ath10k_warn(ar, "failed to submit frame: %d\n", ret);4078 return ret;4079 }4080 4081 return 0;4082}4083 4084void ath10k_offchan_tx_purge(struct ath10k *ar)4085{4086 struct sk_buff *skb;4087 4088 for (;;) {4089 skb = skb_dequeue(&ar->offchan_tx_queue);4090 if (!skb)4091 break;4092 4093 ieee80211_free_txskb(ar->hw, skb);4094 }4095}4096 4097void ath10k_offchan_tx_work(struct work_struct *work)4098{4099 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);4100 struct ath10k_peer *peer;4101 struct ath10k_vif *arvif;4102 enum ath10k_hw_txrx_mode txmode;4103 enum ath10k_mac_tx_path txpath;4104 struct ieee80211_hdr *hdr;4105 struct ieee80211_vif *vif;4106 struct ieee80211_sta *sta;4107 struct sk_buff *skb;4108 const u8 *peer_addr;4109 int vdev_id;4110 int ret;4111 unsigned long time_left;4112 bool tmp_peer_created = false;4113 4114 /* FW requirement: We must create a peer before FW will send out4115 * an offchannel frame. Otherwise the frame will be stuck and4116 * never transmitted. We delete the peer upon tx completion.4117 * It is unlikely that a peer for offchannel tx will already be4118 * present. However it may be in some rare cases so account for that.4119 * Otherwise we might remove a legitimate peer and break stuff.4120 */4121 4122 for (;;) {4123 skb = skb_dequeue(&ar->offchan_tx_queue);4124 if (!skb)4125 break;4126 4127 mutex_lock(&ar->conf_mutex);4128 4129 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %pK len %d\n",4130 skb, skb->len);4131 4132 hdr = (struct ieee80211_hdr *)skb->data;4133 peer_addr = ieee80211_get_DA(hdr);4134 4135 spin_lock_bh(&ar->data_lock);4136 vdev_id = ar->scan.vdev_id;4137 peer = ath10k_peer_find(ar, vdev_id, peer_addr);4138 spin_unlock_bh(&ar->data_lock);4139 4140 if (peer) {4141 ath10k_warn(ar, "peer %pM on vdev %d already present\n",4142 peer_addr, vdev_id);4143 } else {4144 ret = ath10k_peer_create(ar, NULL, NULL, vdev_id,4145 peer_addr,4146 WMI_PEER_TYPE_DEFAULT);4147 if (ret)4148 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",4149 peer_addr, vdev_id, ret);4150 tmp_peer_created = (ret == 0);4151 }4152 4153 spin_lock_bh(&ar->data_lock);4154 reinit_completion(&ar->offchan_tx_completed);4155 ar->offchan_tx_skb = skb;4156 spin_unlock_bh(&ar->data_lock);4157 4158 /* It's safe to access vif and sta - conf_mutex guarantees that4159 * sta_state() and remove_interface() are locked exclusively4160 * out wrt to this offchannel worker.4161 */4162 arvif = ath10k_get_arvif(ar, vdev_id);4163 if (arvif) {4164 vif = arvif->vif;4165 sta = ieee80211_find_sta(vif, peer_addr);4166 } else {4167 vif = NULL;4168 sta = NULL;4169 }4170 4171 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);4172 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);4173 4174 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, true);4175 if (ret) {4176 ath10k_warn(ar, "failed to transmit offchannel frame: %d\n",4177 ret);4178 /* not serious */4179 }4180 4181 time_left =4182 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ);4183 if (time_left == 0)4184 ath10k_warn(ar, "timed out waiting for offchannel skb %pK, len: %d\n",4185 skb, skb->len);4186 4187 if (!peer && tmp_peer_created) {4188 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);4189 if (ret)4190 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",4191 peer_addr, vdev_id, ret);4192 }4193 4194 mutex_unlock(&ar->conf_mutex);4195 }4196}4197 4198void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)4199{4200 struct sk_buff *skb;4201 4202 for (;;) {4203 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);4204 if (!skb)4205 break;4206 4207 ieee80211_free_txskb(ar->hw, skb);4208 }4209}4210 4211void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)4212{4213 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);4214 struct sk_buff *skb;4215 dma_addr_t paddr;4216 int ret;4217 4218 for (;;) {4219 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);4220 if (!skb)4221 break;4222 4223 if (test_bit(ATH10K_FW_FEATURE_MGMT_TX_BY_REF,4224 ar->running_fw->fw_file.fw_features)) {4225 paddr = dma_map_single(ar->dev, skb->data,4226 skb->len, DMA_TO_DEVICE);4227 if (dma_mapping_error(ar->dev, paddr)) {4228 ieee80211_free_txskb(ar->hw, skb);4229 continue;4230 }4231 ret = ath10k_wmi_mgmt_tx_send(ar, skb, paddr);4232 if (ret) {4233 ath10k_warn(ar, "failed to transmit management frame by ref via WMI: %d\n",4234 ret);4235 /* remove this msdu from idr tracking */4236 ath10k_wmi_cleanup_mgmt_tx_send(ar, skb);4237 4238 dma_unmap_single(ar->dev, paddr, skb->len,4239 DMA_TO_DEVICE);4240 ieee80211_free_txskb(ar->hw, skb);4241 }4242 } else {4243 ret = ath10k_wmi_mgmt_tx(ar, skb);4244 if (ret) {4245 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",4246 ret);4247 ieee80211_free_txskb(ar->hw, skb);4248 }4249 }4250 }4251}4252 4253static void ath10k_mac_txq_init(struct ieee80211_txq *txq)4254{4255 struct ath10k_txq *artxq;4256 4257 if (!txq)4258 return;4259 4260 artxq = (void *)txq->drv_priv;4261 INIT_LIST_HEAD(&artxq->list);4262}4263 4264static void ath10k_mac_txq_unref(struct ath10k *ar, struct ieee80211_txq *txq)4265{4266 struct ath10k_skb_cb *cb;4267 struct sk_buff *msdu;4268 int msdu_id;4269 4270 if (!txq)4271 return;4272 4273 spin_lock_bh(&ar->htt.tx_lock);4274 idr_for_each_entry(&ar->htt.pending_tx, msdu, msdu_id) {4275 cb = ATH10K_SKB_CB(msdu);4276 if (cb->txq == txq)4277 cb->txq = NULL;4278 }4279 spin_unlock_bh(&ar->htt.tx_lock);4280}4281 4282struct ieee80211_txq *ath10k_mac_txq_lookup(struct ath10k *ar,4283 u16 peer_id,4284 u8 tid)4285{4286 struct ath10k_peer *peer;4287 4288 lockdep_assert_held(&ar->data_lock);4289 4290 peer = ar->peer_map[peer_id];4291 if (!peer)4292 return NULL;4293 4294 if (peer->removed)4295 return NULL;4296 4297 if (peer->sta)4298 return peer->sta->txq[tid];4299 else if (peer->vif)4300 return peer->vif->txq;4301 else4302 return NULL;4303}4304 4305static bool ath10k_mac_tx_can_push(struct ieee80211_hw *hw,4306 struct ieee80211_txq *txq)4307{4308 struct ath10k *ar = hw->priv;4309 struct ath10k_txq *artxq = (void *)txq->drv_priv;4310 4311 /* No need to get locks */4312 if (ar->htt.tx_q_state.mode == HTT_TX_MODE_SWITCH_PUSH)4313 return true;4314 4315 if (ar->htt.num_pending_tx < ar->htt.tx_q_state.num_push_allowed)4316 return true;4317 4318 if (artxq->num_fw_queued < artxq->num_push_allowed)4319 return true;4320 4321 return false;4322}4323 4324/* Return estimated airtime in microsecond, which is calculated using last4325 * reported TX rate. This is just a rough estimation because host driver has no4326 * knowledge of the actual transmit rate, retries or aggregation. If actual4327 * airtime can be reported by firmware, then delta between estimated and actual4328 * airtime can be adjusted from deficit.4329 */4330#define IEEE80211_ATF_OVERHEAD 100 /* IFS + some slot time */4331#define IEEE80211_ATF_OVERHEAD_IFS 16 /* IFS only */4332static u16 ath10k_mac_update_airtime(struct ath10k *ar,4333 struct ieee80211_txq *txq,4334 struct sk_buff *skb)4335{4336 struct ath10k_sta *arsta;4337 u32 pktlen;4338 u16 airtime = 0;4339 4340 if (!txq || !txq->sta)4341 return airtime;4342 4343 if (test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map))4344 return airtime;4345 4346 spin_lock_bh(&ar->data_lock);4347 arsta = (struct ath10k_sta *)txq->sta->drv_priv;4348 4349 pktlen = skb->len + 38; /* Assume MAC header 30, SNAP 8 for most case */4350 if (arsta->last_tx_bitrate) {4351 /* airtime in us, last_tx_bitrate in 100kbps */4352 airtime = (pktlen * 8 * (1000 / 100))4353 / arsta->last_tx_bitrate;4354 /* overhead for media access time and IFS */4355 airtime += IEEE80211_ATF_OVERHEAD_IFS;4356 } else {4357 /* This is mostly for throttle excessive BC/MC frames, and the4358 * airtime/rate doesn't need be exact. Airtime of BC/MC frames4359 * in 2G get some discount, which helps prevent very low rate4360 * frames from being blocked for too long.4361 */4362 airtime = (pktlen * 8 * (1000 / 100)) / 60; /* 6M */4363 airtime += IEEE80211_ATF_OVERHEAD;4364 }4365 spin_unlock_bh(&ar->data_lock);4366 4367 return airtime;4368}4369 4370int ath10k_mac_tx_push_txq(struct ieee80211_hw *hw,4371 struct ieee80211_txq *txq)4372{4373 struct ath10k *ar = hw->priv;4374 struct ath10k_htt *htt = &ar->htt;4375 struct ath10k_txq *artxq = (void *)txq->drv_priv;4376 struct ieee80211_vif *vif = txq->vif;4377 struct ieee80211_sta *sta = txq->sta;4378 enum ath10k_hw_txrx_mode txmode;4379 enum ath10k_mac_tx_path txpath;4380 struct sk_buff *skb;4381 struct ieee80211_hdr *hdr;4382 size_t skb_len;4383 bool is_mgmt, is_presp;4384 int ret;4385 u16 airtime;4386 4387 spin_lock_bh(&ar->htt.tx_lock);4388 ret = ath10k_htt_tx_inc_pending(htt);4389 spin_unlock_bh(&ar->htt.tx_lock);4390 4391 if (ret)4392 return ret;4393 4394 skb = ieee80211_tx_dequeue_ni(hw, txq);4395 if (!skb) {4396 spin_lock_bh(&ar->htt.tx_lock);4397 ath10k_htt_tx_dec_pending(htt);4398 spin_unlock_bh(&ar->htt.tx_lock);4399 4400 return -ENOENT;4401 }4402 4403 airtime = ath10k_mac_update_airtime(ar, txq, skb);4404 ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime);4405 4406 skb_len = skb->len;4407 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);4408 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);4409 is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT);4410 4411 if (is_mgmt) {4412 hdr = (struct ieee80211_hdr *)skb->data;4413 is_presp = ieee80211_is_probe_resp(hdr->frame_control);4414 4415 spin_lock_bh(&ar->htt.tx_lock);4416 ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp);4417 4418 if (ret) {4419 ath10k_htt_tx_dec_pending(htt);4420 spin_unlock_bh(&ar->htt.tx_lock);4421 return ret;4422 }4423 spin_unlock_bh(&ar->htt.tx_lock);4424 }4425 4426 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false);4427 if (unlikely(ret)) {4428 ath10k_warn(ar, "failed to push frame: %d\n", ret);4429 4430 spin_lock_bh(&ar->htt.tx_lock);4431 ath10k_htt_tx_dec_pending(htt);4432 if (is_mgmt)4433 ath10k_htt_tx_mgmt_dec_pending(htt);4434 spin_unlock_bh(&ar->htt.tx_lock);4435 4436 return ret;4437 }4438 4439 spin_lock_bh(&ar->htt.tx_lock);4440 artxq->num_fw_queued++;4441 spin_unlock_bh(&ar->htt.tx_lock);4442 4443 return skb_len;4444}4445 4446static int ath10k_mac_schedule_txq(struct ieee80211_hw *hw, u32 ac)4447{4448 struct ieee80211_txq *txq;4449 int ret = 0;4450 4451 ieee80211_txq_schedule_start(hw, ac);4452 while ((txq = ieee80211_next_txq(hw, ac))) {4453 while (ath10k_mac_tx_can_push(hw, txq)) {4454 ret = ath10k_mac_tx_push_txq(hw, txq);4455 if (ret < 0)4456 break;4457 }4458 ieee80211_return_txq(hw, txq, false);4459 ath10k_htt_tx_txq_update(hw, txq);4460 if (ret == -EBUSY)4461 break;4462 }4463 ieee80211_txq_schedule_end(hw, ac);4464 4465 return ret;4466}4467 4468void ath10k_mac_tx_push_pending(struct ath10k *ar)4469{4470 struct ieee80211_hw *hw = ar->hw;4471 u32 ac;4472 4473 if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH)4474 return;4475 4476 if (ar->htt.num_pending_tx >= (ar->htt.max_num_pending_tx / 2))4477 return;4478 4479 rcu_read_lock();4480 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {4481 if (ath10k_mac_schedule_txq(hw, ac) == -EBUSY)4482 break;4483 }4484 rcu_read_unlock();4485}4486EXPORT_SYMBOL(ath10k_mac_tx_push_pending);4487 4488/************/4489/* Scanning */4490/************/4491 4492void __ath10k_scan_finish(struct ath10k *ar)4493{4494 lockdep_assert_held(&ar->data_lock);4495 4496 switch (ar->scan.state) {4497 case ATH10K_SCAN_IDLE:4498 break;4499 case ATH10K_SCAN_RUNNING:4500 case ATH10K_SCAN_ABORTING:4501 if (ar->scan.is_roc && ar->scan.roc_notify)4502 ieee80211_remain_on_channel_expired(ar->hw);4503 fallthrough;4504 case ATH10K_SCAN_STARTING:4505 if (!ar->scan.is_roc) {4506 struct cfg80211_scan_info info = {4507 .aborted = ((ar->scan.state ==4508 ATH10K_SCAN_ABORTING) ||4509 (ar->scan.state ==4510 ATH10K_SCAN_STARTING)),4511 };4512 4513 ieee80211_scan_completed(ar->hw, &info);4514 }4515 4516 ar->scan.state = ATH10K_SCAN_IDLE;4517 ar->scan_channel = NULL;4518 ar->scan.roc_freq = 0;4519 ath10k_offchan_tx_purge(ar);4520 cancel_delayed_work(&ar->scan.timeout);4521 complete(&ar->scan.completed);4522 break;4523 }4524}4525 4526void ath10k_scan_finish(struct ath10k *ar)4527{4528 spin_lock_bh(&ar->data_lock);4529 __ath10k_scan_finish(ar);4530 spin_unlock_bh(&ar->data_lock);4531}4532 4533static int ath10k_scan_stop(struct ath10k *ar)4534{4535 struct wmi_stop_scan_arg arg = {4536 .req_id = 1, /* FIXME */4537 .req_type = WMI_SCAN_STOP_ONE,4538 .u.scan_id = ATH10K_SCAN_ID,4539 };4540 int ret;4541 4542 lockdep_assert_held(&ar->conf_mutex);4543 4544 ret = ath10k_wmi_stop_scan(ar, &arg);4545 if (ret) {4546 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);4547 goto out;4548 }4549 4550 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);4551 if (ret == 0) {4552 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");4553 ret = -ETIMEDOUT;4554 } else if (ret > 0) {4555 ret = 0;4556 }4557 4558out:4559 /* Scan state should be updated upon scan completion but in case4560 * firmware fails to deliver the event (for whatever reason) it is4561 * desired to clean up scan state anyway. Firmware may have just4562 * dropped the scan completion event delivery due to transport pipe4563 * being overflown with data and/or it can recover on its own before4564 * next scan request is submitted.4565 */4566 spin_lock_bh(&ar->data_lock);4567 if (ar->scan.state != ATH10K_SCAN_IDLE)4568 __ath10k_scan_finish(ar);4569 spin_unlock_bh(&ar->data_lock);4570 4571 return ret;4572}4573 4574static void ath10k_scan_abort(struct ath10k *ar)4575{4576 int ret;4577 4578 lockdep_assert_held(&ar->conf_mutex);4579 4580 spin_lock_bh(&ar->data_lock);4581 4582 switch (ar->scan.state) {4583 case ATH10K_SCAN_IDLE:4584 /* This can happen if timeout worker kicked in and called4585 * abortion while scan completion was being processed.4586 */4587 break;4588 case ATH10K_SCAN_STARTING:4589 case ATH10K_SCAN_ABORTING:4590 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",4591 ath10k_scan_state_str(ar->scan.state),4592 ar->scan.state);4593 break;4594 case ATH10K_SCAN_RUNNING:4595 ar->scan.state = ATH10K_SCAN_ABORTING;4596 spin_unlock_bh(&ar->data_lock);4597 4598 ret = ath10k_scan_stop(ar);4599 if (ret)4600 ath10k_warn(ar, "failed to abort scan: %d\n", ret);4601 4602 spin_lock_bh(&ar->data_lock);4603 break;4604 }4605 4606 spin_unlock_bh(&ar->data_lock);4607}4608 4609void ath10k_scan_timeout_work(struct work_struct *work)4610{4611 struct ath10k *ar = container_of(work, struct ath10k,4612 scan.timeout.work);4613 4614 mutex_lock(&ar->conf_mutex);4615 ath10k_scan_abort(ar);4616 mutex_unlock(&ar->conf_mutex);4617}4618 4619static int ath10k_start_scan(struct ath10k *ar,4620 const struct wmi_start_scan_arg *arg)4621{4622 int ret;4623 4624 lockdep_assert_held(&ar->conf_mutex);4625 4626 ret = ath10k_wmi_start_scan(ar, arg);4627 if (ret)4628 return ret;4629 4630 ret = wait_for_completion_timeout(&ar->scan.started, 1 * HZ);4631 if (ret == 0) {4632 ret = ath10k_scan_stop(ar);4633 if (ret)4634 ath10k_warn(ar, "failed to stop scan: %d\n", ret);4635 4636 return -ETIMEDOUT;4637 }4638 4639 /* If we failed to start the scan, return error code at4640 * this point. This is probably due to some issue in the4641 * firmware, but no need to wedge the driver due to that...4642 */4643 spin_lock_bh(&ar->data_lock);4644 if (ar->scan.state == ATH10K_SCAN_IDLE) {4645 spin_unlock_bh(&ar->data_lock);4646 return -EINVAL;4647 }4648 spin_unlock_bh(&ar->data_lock);4649 4650 return 0;4651}4652 4653/**********************/4654/* mac80211 callbacks */4655/**********************/4656 4657static void ath10k_mac_op_tx(struct ieee80211_hw *hw,4658 struct ieee80211_tx_control *control,4659 struct sk_buff *skb)4660{4661 struct ath10k *ar = hw->priv;4662 struct ath10k_htt *htt = &ar->htt;4663 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);4664 struct ieee80211_vif *vif = info->control.vif;4665 struct ieee80211_sta *sta = control->sta;4666 struct ieee80211_txq *txq = NULL;4667 enum ath10k_hw_txrx_mode txmode;4668 enum ath10k_mac_tx_path txpath;4669 bool is_htt;4670 bool is_mgmt;4671 int ret;4672 u16 airtime;4673 4674 airtime = ath10k_mac_update_airtime(ar, txq, skb);4675 ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime);4676 4677 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);4678 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);4679 is_htt = (txpath == ATH10K_MAC_TX_HTT ||4680 txpath == ATH10K_MAC_TX_HTT_MGMT);4681 is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT);4682 4683 if (is_htt) {4684 bool is_presp = false;4685 4686 spin_lock_bh(&ar->htt.tx_lock);4687 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {4688 struct ieee80211_hdr *hdr = (void *)skb->data;4689 4690 is_presp = ieee80211_is_probe_resp(hdr->frame_control);4691 }4692 4693 ret = ath10k_htt_tx_inc_pending(htt);4694 if (ret) {4695 ath10k_warn(ar, "failed to increase tx pending count: %d, dropping\n",4696 ret);4697 spin_unlock_bh(&ar->htt.tx_lock);4698 ieee80211_free_txskb(ar->hw, skb);4699 return;4700 }4701 4702 ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp);4703 if (ret) {4704 ath10k_dbg(ar, ATH10K_DBG_MAC, "failed to increase tx mgmt pending count: %d, dropping\n",4705 ret);4706 ath10k_htt_tx_dec_pending(htt);4707 spin_unlock_bh(&ar->htt.tx_lock);4708 ieee80211_free_txskb(ar->hw, skb);4709 return;4710 }4711 spin_unlock_bh(&ar->htt.tx_lock);4712 }4713 4714 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false);4715 if (ret) {4716 ath10k_warn(ar, "failed to transmit frame: %d\n", ret);4717 if (is_htt) {4718 spin_lock_bh(&ar->htt.tx_lock);4719 ath10k_htt_tx_dec_pending(htt);4720 if (is_mgmt)4721 ath10k_htt_tx_mgmt_dec_pending(htt);4722 spin_unlock_bh(&ar->htt.tx_lock);4723 }4724 return;4725 }4726}4727 4728static void ath10k_mac_op_wake_tx_queue(struct ieee80211_hw *hw,4729 struct ieee80211_txq *txq)4730{4731 struct ath10k *ar = hw->priv;4732 int ret;4733 u8 ac = txq->ac;4734 4735 ath10k_htt_tx_txq_update(hw, txq);4736 if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH)4737 return;4738 4739 spin_lock_bh(&ar->queue_lock[ac]);4740 4741 ieee80211_txq_schedule_start(hw, ac);4742 txq = ieee80211_next_txq(hw, ac);4743 if (!txq)4744 goto out;4745 4746 while (ath10k_mac_tx_can_push(hw, txq)) {4747 ret = ath10k_mac_tx_push_txq(hw, txq);4748 if (ret < 0)4749 break;4750 }4751 ieee80211_return_txq(hw, txq, false);4752 ath10k_htt_tx_txq_update(hw, txq);4753out:4754 ieee80211_txq_schedule_end(hw, ac);4755 spin_unlock_bh(&ar->queue_lock[ac]);4756}4757 4758/* Must not be called with conf_mutex held as workers can use that also. */4759void ath10k_drain_tx(struct ath10k *ar)4760{4761 lockdep_assert_not_held(&ar->conf_mutex);4762 4763 /* make sure rcu-protected mac80211 tx path itself is drained */4764 synchronize_net();4765 4766 ath10k_offchan_tx_purge(ar);4767 ath10k_mgmt_over_wmi_tx_purge(ar);4768 4769 cancel_work_sync(&ar->offchan_tx_work);4770 cancel_work_sync(&ar->wmi_mgmt_tx_work);4771}4772 4773void ath10k_halt(struct ath10k *ar)4774{4775 struct ath10k_vif *arvif;4776 4777 lockdep_assert_held(&ar->conf_mutex);4778 4779 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);4780 ar->filter_flags = 0;4781 ar->monitor = false;4782 ar->monitor_arvif = NULL;4783 4784 if (ar->monitor_started)4785 ath10k_monitor_stop(ar);4786 4787 ar->monitor_started = false;4788 ar->tx_paused = 0;4789 4790 ath10k_scan_finish(ar);4791 ath10k_peer_cleanup_all(ar);4792 ath10k_stop_radar_confirmation(ar);4793 ath10k_core_stop(ar);4794 ath10k_hif_power_down(ar);4795 4796 spin_lock_bh(&ar->data_lock);4797 list_for_each_entry(arvif, &ar->arvifs, list)4798 ath10k_mac_vif_beacon_cleanup(arvif);4799 spin_unlock_bh(&ar->data_lock);4800}4801 4802static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)4803{4804 struct ath10k *ar = hw->priv;4805 4806 mutex_lock(&ar->conf_mutex);4807 4808 *tx_ant = ar->cfg_tx_chainmask;4809 *rx_ant = ar->cfg_rx_chainmask;4810 4811 mutex_unlock(&ar->conf_mutex);4812 4813 return 0;4814}4815 4816static bool ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)4817{4818 /* It is not clear that allowing gaps in chainmask4819 * is helpful. Probably it will not do what user4820 * is hoping for, so warn in that case.4821 */4822 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)4823 return true;4824 4825 ath10k_warn(ar, "mac %s antenna chainmask is invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",4826 dbg, cm);4827 return false;4828}4829 4830static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar)4831{4832 int nsts = ar->vht_cap_info;4833 4834 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;4835 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;4836 4837 /* If firmware does not deliver to host number of space-time4838 * streams supported, assume it support up to 4 BF STS and return4839 * the value for VHT CAP: nsts-1)4840 */4841 if (nsts == 0)4842 return 3;4843 4844 return nsts;4845}4846 4847static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar)4848{4849 int sound_dim = ar->vht_cap_info;4850 4851 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;4852 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;4853 4854 /* If the sounding dimension is not advertised by the firmware,4855 * let's use a default value of 14856 */4857 if (sound_dim == 0)4858 return 1;4859 4860 return sound_dim;4861}4862 4863static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)4864{4865 struct ieee80211_sta_vht_cap vht_cap = {0};4866 struct ath10k_hw_params *hw = &ar->hw_params;4867 u16 mcs_map;4868 u32 val;4869 int i;4870 4871 vht_cap.vht_supported = 1;4872 vht_cap.cap = ar->vht_cap_info;4873 4874 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |4875 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {4876 val = ath10k_mac_get_vht_cap_bf_sts(ar);4877 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;4878 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;4879 4880 vht_cap.cap |= val;4881 }4882 4883 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |4884 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {4885 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar);4886 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;4887 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;4888 4889 vht_cap.cap |= val;4890 }4891 4892 mcs_map = 0;4893 for (i = 0; i < 8; i++) {4894 if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i)))4895 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);4896 else4897 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);4898 }4899 4900 if (ar->cfg_tx_chainmask <= 1)4901 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;4902 4903 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);4904 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);4905 4906 /* If we are supporting 160Mhz or 80+80, then the NIC may be able to do4907 * a restricted NSS for 160 or 80+80 vs what it can do for 80Mhz. Give4908 * user-space a clue if that is the case.4909 */4910 if ((vht_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) &&4911 (hw->vht160_mcs_rx_highest != 0 ||4912 hw->vht160_mcs_tx_highest != 0)) {4913 vht_cap.vht_mcs.rx_highest = cpu_to_le16(hw->vht160_mcs_rx_highest);4914 vht_cap.vht_mcs.tx_highest = cpu_to_le16(hw->vht160_mcs_tx_highest);4915 }4916 4917 return vht_cap;4918}4919 4920static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)4921{4922 int i;4923 struct ieee80211_sta_ht_cap ht_cap = {0};4924 4925 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))4926 return ht_cap;4927 4928 ht_cap.ht_supported = 1;4929 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;4930 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;4931 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;4932 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;4933 ht_cap.cap |=4934 WLAN_HT_CAP_SM_PS_DISABLED << IEEE80211_HT_CAP_SM_PS_SHIFT;4935 4936 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)4937 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;4938 4939 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)4940 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;4941 4942 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {4943 u32 smps;4944 4945 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;4946 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;4947 4948 ht_cap.cap |= smps;4949 }4950 4951 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC && (ar->cfg_tx_chainmask > 1))4952 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;4953 4954 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {4955 u32 stbc;4956 4957 stbc = ar->ht_cap_info;4958 stbc &= WMI_HT_CAP_RX_STBC;4959 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;4960 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;4961 stbc &= IEEE80211_HT_CAP_RX_STBC;4962 4963 ht_cap.cap |= stbc;4964 }4965 4966 if (ar->ht_cap_info & WMI_HT_CAP_LDPC || (ar->ht_cap_info &4967 WMI_HT_CAP_RX_LDPC && (ar->ht_cap_info & WMI_HT_CAP_TX_LDPC)))4968 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;4969 4970 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)4971 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;4972 4973 /* max AMSDU is implicitly taken from vht_cap_info */4974 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)4975 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;4976 4977 for (i = 0; i < ar->num_rf_chains; i++) {4978 if (ar->cfg_rx_chainmask & BIT(i))4979 ht_cap.mcs.rx_mask[i] = 0xFF;4980 }4981 4982 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;4983 4984 return ht_cap;4985}4986 4987static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar)4988{4989 struct ieee80211_supported_band *band;4990 struct ieee80211_sta_vht_cap vht_cap;4991 struct ieee80211_sta_ht_cap ht_cap;4992 4993 ht_cap = ath10k_get_ht_cap(ar);4994 vht_cap = ath10k_create_vht_cap(ar);4995 4996 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {4997 band = &ar->mac.sbands[NL80211_BAND_2GHZ];4998 band->ht_cap = ht_cap;4999 }5000 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {5001 band = &ar->mac.sbands[NL80211_BAND_5GHZ];5002 band->ht_cap = ht_cap;5003 band->vht_cap = vht_cap;5004 }5005}5006 5007static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)5008{5009 int ret;5010 bool is_valid_tx_chain_mask, is_valid_rx_chain_mask;5011 5012 lockdep_assert_held(&ar->conf_mutex);5013 5014 is_valid_tx_chain_mask = ath10k_check_chain_mask(ar, tx_ant, "tx");5015 is_valid_rx_chain_mask = ath10k_check_chain_mask(ar, rx_ant, "rx");5016 5017 if (!is_valid_tx_chain_mask || !is_valid_rx_chain_mask)5018 return -EINVAL;5019 5020 ar->cfg_tx_chainmask = tx_ant;5021 ar->cfg_rx_chainmask = rx_ant;5022 5023 if ((ar->state != ATH10K_STATE_ON) &&5024 (ar->state != ATH10K_STATE_RESTARTED))5025 return 0;5026 5027 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,5028 tx_ant);5029 if (ret) {5030 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",5031 ret, tx_ant);5032 return ret;5033 }5034 5035 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,5036 rx_ant);5037 if (ret) {5038 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",5039 ret, rx_ant);5040 return ret;5041 }5042 5043 /* Reload HT/VHT capability */5044 ath10k_mac_setup_ht_vht_cap(ar);5045 5046 return 0;5047}5048 5049static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)5050{5051 struct ath10k *ar = hw->priv;5052 int ret;5053 5054 mutex_lock(&ar->conf_mutex);5055 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);5056 mutex_unlock(&ar->conf_mutex);5057 return ret;5058}5059 5060static int __ath10k_fetch_bb_timing_dt(struct ath10k *ar,5061 struct wmi_bb_timing_cfg_arg *bb_timing)5062{5063 struct device_node *node;5064 const char *fem_name;5065 int ret;5066 5067 node = ar->dev->of_node;5068 if (!node)5069 return -ENOENT;5070 5071 ret = of_property_read_string_index(node, "ext-fem-name", 0, &fem_name);5072 if (ret)5073 return -ENOENT;5074 5075 /*5076 * If external Front End module used in hardware, then default base band timing5077 * parameter cannot be used since they were fine tuned for reference hardware,5078 * so choosing different value suitable for that external FEM.5079 */5080 if (!strcmp("microsemi-lx5586", fem_name)) {5081 bb_timing->bb_tx_timing = 0x00;5082 bb_timing->bb_xpa_timing = 0x0101;5083 } else {5084 return -ENOENT;5085 }5086 5087 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot bb_tx_timing 0x%x bb_xpa_timing 0x%x\n",5088 bb_timing->bb_tx_timing, bb_timing->bb_xpa_timing);5089 return 0;5090}5091 5092static int ath10k_mac_rfkill_config(struct ath10k *ar)5093{5094 u32 param;5095 int ret;5096 5097 if (ar->hw_values->rfkill_pin == 0) {5098 ath10k_warn(ar, "ath10k does not support hardware rfkill with this device\n");5099 return -EOPNOTSUPP;5100 }5101 5102 ath10k_dbg(ar, ATH10K_DBG_MAC,5103 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d",5104 ar->hw_values->rfkill_pin, ar->hw_values->rfkill_cfg,5105 ar->hw_values->rfkill_on_level);5106 5107 param = FIELD_PREP(WMI_TLV_RFKILL_CFG_RADIO_LEVEL,5108 ar->hw_values->rfkill_on_level) |5109 FIELD_PREP(WMI_TLV_RFKILL_CFG_GPIO_PIN_NUM,5110 ar->hw_values->rfkill_pin) |5111 FIELD_PREP(WMI_TLV_RFKILL_CFG_PIN_AS_GPIO,5112 ar->hw_values->rfkill_cfg);5113 5114 ret = ath10k_wmi_pdev_set_param(ar,5115 ar->wmi.pdev_param->rfkill_config,5116 param);5117 if (ret) {5118 ath10k_warn(ar,5119 "failed to set rfkill config 0x%x: %d\n",5120 param, ret);5121 return ret;5122 }5123 return 0;5124}5125 5126int ath10k_mac_rfkill_enable_radio(struct ath10k *ar, bool enable)5127{5128 enum wmi_tlv_rfkill_enable_radio param;5129 int ret;5130 5131 if (enable)5132 param = WMI_TLV_RFKILL_ENABLE_RADIO_ON;5133 else5134 param = WMI_TLV_RFKILL_ENABLE_RADIO_OFF;5135 5136 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac rfkill enable %d", param);5137 5138 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rfkill_enable,5139 param);5140 if (ret) {5141 ath10k_warn(ar, "failed to set rfkill enable param %d: %d\n",5142 param, ret);5143 return ret;5144 }5145 5146 return 0;5147}5148 5149static int ath10k_start(struct ieee80211_hw *hw)5150{5151 struct ath10k *ar = hw->priv;5152 u32 param;5153 int ret = 0;5154 struct wmi_bb_timing_cfg_arg bb_timing = {0};5155 5156 /*5157 * This makes sense only when restarting hw. It is harmless to call5158 * unconditionally. This is necessary to make sure no HTT/WMI tx5159 * commands will be submitted while restarting.5160 */5161 ath10k_drain_tx(ar);5162 5163 mutex_lock(&ar->conf_mutex);5164 5165 switch (ar->state) {5166 case ATH10K_STATE_OFF:5167 ar->state = ATH10K_STATE_ON;5168 break;5169 case ATH10K_STATE_RESTARTING:5170 ar->state = ATH10K_STATE_RESTARTED;5171 break;5172 case ATH10K_STATE_ON:5173 case ATH10K_STATE_RESTARTED:5174 case ATH10K_STATE_WEDGED:5175 WARN_ON(1);5176 ret = -EINVAL;5177 goto err;5178 case ATH10K_STATE_UTF:5179 ret = -EBUSY;5180 goto err;5181 }5182 5183 spin_lock_bh(&ar->data_lock);5184 5185 if (ar->hw_rfkill_on) {5186 ar->hw_rfkill_on = false;5187 spin_unlock_bh(&ar->data_lock);5188 goto err;5189 }5190 5191 spin_unlock_bh(&ar->data_lock);5192 5193 ret = ath10k_hif_power_up(ar, ATH10K_FIRMWARE_MODE_NORMAL);5194 if (ret) {5195 ath10k_err(ar, "Could not init hif: %d\n", ret);5196 goto err_off;5197 }5198 5199 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL,5200 &ar->normal_mode_fw);5201 if (ret) {5202 ath10k_err(ar, "Could not init core: %d\n", ret);5203 goto err_power_down;5204 }5205 5206 if (ar->sys_cap_info & WMI_TLV_SYS_CAP_INFO_RFKILL) {5207 ret = ath10k_mac_rfkill_config(ar);5208 if (ret && ret != -EOPNOTSUPP) {5209 ath10k_warn(ar, "failed to configure rfkill: %d", ret);5210 goto err_core_stop;5211 }5212 }5213 5214 param = ar->wmi.pdev_param->pmf_qos;5215 ret = ath10k_wmi_pdev_set_param(ar, param, 1);5216 if (ret) {5217 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);5218 goto err_core_stop;5219 }5220 5221 param = ar->wmi.pdev_param->dynamic_bw;5222 ret = ath10k_wmi_pdev_set_param(ar, param, 1);5223 if (ret) {5224 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);5225 goto err_core_stop;5226 }5227 5228 if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) {5229 ret = ath10k_wmi_scan_prob_req_oui(ar, ar->mac_addr);5230 if (ret) {5231 ath10k_err(ar, "failed to set prob req oui: %i\n", ret);5232 goto err_core_stop;5233 }5234 }5235 5236 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {5237 ret = ath10k_wmi_adaptive_qcs(ar, true);5238 if (ret) {5239 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",5240 ret);5241 goto err_core_stop;5242 }5243 }5244 5245 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {5246 param = ar->wmi.pdev_param->burst_enable;5247 ret = ath10k_wmi_pdev_set_param(ar, param, 0);5248 if (ret) {5249 ath10k_warn(ar, "failed to disable burst: %d\n", ret);5250 goto err_core_stop;5251 }5252 }5253 5254 param = ar->wmi.pdev_param->idle_ps_config;5255 ret = ath10k_wmi_pdev_set_param(ar, param, 1);5256 if (ret && ret != -EOPNOTSUPP) {5257 ath10k_warn(ar, "failed to enable idle_ps_config: %d\n", ret);5258 goto err_core_stop;5259 }5260 5261 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);5262 5263 /*5264 * By default FW set ARP frames ac to voice (6). In that case ARP5265 * exchange is not working properly for UAPSD enabled AP. ARP requests5266 * which arrives with access category 0 are processed by network stack5267 * and send back with access category 0, but FW changes access category5268 * to 6. Set ARP frames access category to best effort (0) solves5269 * this problem.5270 */5271 5272 param = ar->wmi.pdev_param->arp_ac_override;5273 ret = ath10k_wmi_pdev_set_param(ar, param, 0);5274 if (ret) {5275 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",5276 ret);5277 goto err_core_stop;5278 }5279 5280 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA,5281 ar->running_fw->fw_file.fw_features)) {5282 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1,5283 WMI_CCA_DETECT_LEVEL_AUTO,5284 WMI_CCA_DETECT_MARGIN_AUTO);5285 if (ret) {5286 ath10k_warn(ar, "failed to enable adaptive cca: %d\n",5287 ret);5288 goto err_core_stop;5289 }5290 }5291 5292 param = ar->wmi.pdev_param->ani_enable;5293 ret = ath10k_wmi_pdev_set_param(ar, param, 1);5294 if (ret) {5295 ath10k_warn(ar, "failed to enable ani by default: %d\n",5296 ret);5297 goto err_core_stop;5298 }5299 5300 ar->ani_enabled = true;5301 5302 if (ath10k_peer_stats_enabled(ar)) {5303 param = ar->wmi.pdev_param->peer_stats_update_period;5304 ret = ath10k_wmi_pdev_set_param(ar, param,5305 PEER_DEFAULT_STATS_UPDATE_PERIOD);5306 if (ret) {5307 ath10k_warn(ar,5308 "failed to set peer stats period : %d\n",5309 ret);5310 goto err_core_stop;5311 }5312 }5313 5314 param = ar->wmi.pdev_param->enable_btcoex;5315 if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map) &&5316 test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM,5317 ar->running_fw->fw_file.fw_features) &&5318 ar->coex_support) {5319 ret = ath10k_wmi_pdev_set_param(ar, param, 0);5320 if (ret) {5321 ath10k_warn(ar,5322 "failed to set btcoex param: %d\n", ret);5323 goto err_core_stop;5324 }5325 clear_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);5326 }5327 5328 if (test_bit(WMI_SERVICE_BB_TIMING_CONFIG_SUPPORT, ar->wmi.svc_map)) {5329 ret = __ath10k_fetch_bb_timing_dt(ar, &bb_timing);5330 if (!ret) {5331 ret = ath10k_wmi_pdev_bb_timing(ar, &bb_timing);5332 if (ret) {5333 ath10k_warn(ar,5334 "failed to set bb timings: %d\n",5335 ret);5336 goto err_core_stop;5337 }5338 }5339 }5340 5341 ar->num_started_vdevs = 0;5342 ath10k_regd_update(ar);5343 5344 ath10k_spectral_start(ar);5345 ath10k_thermal_set_throttling(ar);5346 5347 ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_IDLE;5348 5349 mutex_unlock(&ar->conf_mutex);5350 return 0;5351 5352err_core_stop:5353 ath10k_core_stop(ar);5354 5355err_power_down:5356 ath10k_hif_power_down(ar);5357 5358err_off:5359 ar->state = ATH10K_STATE_OFF;5360 5361err:5362 mutex_unlock(&ar->conf_mutex);5363 return ret;5364}5365 5366static void ath10k_stop(struct ieee80211_hw *hw, bool suspend)5367{5368 struct ath10k *ar = hw->priv;5369 u32 opt;5370 5371 ath10k_drain_tx(ar);5372 5373 mutex_lock(&ar->conf_mutex);5374 if (ar->state != ATH10K_STATE_OFF) {5375 if (!ar->hw_rfkill_on) {5376 /* If the current driver state is RESTARTING but not yet5377 * fully RESTARTED because of incoming suspend event,5378 * then ath10k_halt() is already called via5379 * ath10k_core_restart() and should not be called here.5380 */5381 if (ar->state != ATH10K_STATE_RESTARTING) {5382 ath10k_halt(ar);5383 } else {5384 /* Suspending here, because when in RESTARTING5385 * state, ath10k_core_stop() skips5386 * ath10k_wait_for_suspend().5387 */5388 opt = WMI_PDEV_SUSPEND_AND_DISABLE_INTR;5389 ath10k_wait_for_suspend(ar, opt);5390 }5391 }5392 ar->state = ATH10K_STATE_OFF;5393 }5394 mutex_unlock(&ar->conf_mutex);5395 5396 cancel_work_sync(&ar->set_coverage_class_work);5397 cancel_delayed_work_sync(&ar->scan.timeout);5398 cancel_work_sync(&ar->restart_work);5399}5400 5401static int ath10k_config_ps(struct ath10k *ar)5402{5403 struct ath10k_vif *arvif;5404 int ret = 0;5405 5406 lockdep_assert_held(&ar->conf_mutex);5407 5408 list_for_each_entry(arvif, &ar->arvifs, list) {5409 ret = ath10k_mac_vif_setup_ps(arvif);5410 if (ret) {5411 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);5412 break;5413 }5414 }5415 5416 return ret;5417}5418 5419static int ath10k_config(struct ieee80211_hw *hw, u32 changed)5420{5421 struct ath10k *ar = hw->priv;5422 struct ieee80211_conf *conf = &hw->conf;5423 int ret = 0;5424 5425 mutex_lock(&ar->conf_mutex);5426 5427 if (changed & IEEE80211_CONF_CHANGE_PS)5428 ath10k_config_ps(ar);5429 5430 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {5431 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;5432 ret = ath10k_monitor_recalc(ar);5433 if (ret)5434 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);5435 }5436 5437 mutex_unlock(&ar->conf_mutex);5438 return ret;5439}5440 5441static u32 get_nss_from_chainmask(u16 chain_mask)5442{5443 if ((chain_mask & 0xf) == 0xf)5444 return 4;5445 else if ((chain_mask & 0x7) == 0x7)5446 return 3;5447 else if ((chain_mask & 0x3) == 0x3)5448 return 2;5449 return 1;5450}5451 5452static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)5453{5454 u32 value = 0;5455 struct ath10k *ar = arvif->ar;5456 int nsts;5457 int sound_dim;5458 5459 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)5460 return 0;5461 5462 nsts = ath10k_mac_get_vht_cap_bf_sts(ar);5463 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |5464 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))5465 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);5466 5467 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar);5468 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |5469 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))5470 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);5471 5472 if (!value)5473 return 0;5474 5475 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)5476 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;5477 5478 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)5479 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |5480 WMI_VDEV_PARAM_TXBF_SU_TX_BFER);5481 5482 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)5483 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;5484 5485 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)5486 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |5487 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);5488 5489 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,5490 ar->wmi.vdev_param->txbf, value);5491}5492 5493static void ath10k_update_vif_offload(struct ieee80211_hw *hw,5494 struct ieee80211_vif *vif)5495{5496 struct ath10k_vif *arvif = (void *)vif->drv_priv;5497 struct ath10k *ar = hw->priv;5498 u32 vdev_param;5499 int ret;5500 5501 if (ath10k_frame_mode != ATH10K_HW_TXRX_ETHERNET ||5502 ar->wmi.vdev_param->tx_encap_type == WMI_VDEV_PARAM_UNSUPPORTED ||5503 (vif->type != NL80211_IFTYPE_STATION &&5504 vif->type != NL80211_IFTYPE_AP))5505 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;5506 5507 vdev_param = ar->wmi.vdev_param->tx_encap_type;5508 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,5509 ATH10K_HW_TXRX_NATIVE_WIFI);5510 /* 10.X firmware does not support this VDEV parameter. Do not warn */5511 if (ret && ret != -EOPNOTSUPP) {5512 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",5513 arvif->vdev_id, ret);5514 }5515}5516 5517/*5518 * TODO:5519 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,5520 * because we will send mgmt frames without CCK. This requirement5521 * for P2P_FIND/GO_NEG should be handled by checking CCK flag5522 * in the TX packet.5523 */5524static int ath10k_add_interface(struct ieee80211_hw *hw,5525 struct ieee80211_vif *vif)5526{5527 struct ath10k *ar = hw->priv;5528 struct ath10k_vif *arvif = (void *)vif->drv_priv;5529 struct ath10k_peer *peer;5530 enum wmi_sta_powersave_param param;5531 int ret = 0;5532 u32 value;5533 int bit;5534 int i;5535 u32 vdev_param;5536 5537 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;5538 5539 mutex_lock(&ar->conf_mutex);5540 5541 memset(arvif, 0, sizeof(*arvif));5542 ath10k_mac_txq_init(vif->txq);5543 5544 arvif->ar = ar;5545 arvif->vif = vif;5546 5547 INIT_LIST_HEAD(&arvif->list);5548 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);5549 INIT_DELAYED_WORK(&arvif->connection_loss_work,5550 ath10k_mac_vif_sta_connection_loss_work);5551 5552 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {5553 arvif->bitrate_mask.control[i].legacy = 0xffffffff;5554 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,5555 sizeof(arvif->bitrate_mask.control[i].ht_mcs));5556 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,5557 sizeof(arvif->bitrate_mask.control[i].vht_mcs));5558 }5559 5560 if (ar->num_peers >= ar->max_num_peers) {5561 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");5562 ret = -ENOBUFS;5563 goto err;5564 }5565 5566 if (ar->free_vdev_map == 0) {5567 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");5568 ret = -EBUSY;5569 goto err;5570 }5571 bit = __ffs64(ar->free_vdev_map);5572 5573 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",5574 bit, ar->free_vdev_map);5575 5576 arvif->vdev_id = bit;5577 arvif->vdev_subtype =5578 ath10k_wmi_get_vdev_subtype(ar, WMI_VDEV_SUBTYPE_NONE);5579 5580 switch (vif->type) {5581 case NL80211_IFTYPE_P2P_DEVICE:5582 arvif->vdev_type = WMI_VDEV_TYPE_STA;5583 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype5584 (ar, WMI_VDEV_SUBTYPE_P2P_DEVICE);5585 break;5586 case NL80211_IFTYPE_UNSPECIFIED:5587 case NL80211_IFTYPE_STATION:5588 arvif->vdev_type = WMI_VDEV_TYPE_STA;5589 if (vif->p2p)5590 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype5591 (ar, WMI_VDEV_SUBTYPE_P2P_CLIENT);5592 break;5593 case NL80211_IFTYPE_ADHOC:5594 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;5595 break;5596 case NL80211_IFTYPE_MESH_POINT:5597 if (test_bit(WMI_SERVICE_MESH_11S, ar->wmi.svc_map)) {5598 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype5599 (ar, WMI_VDEV_SUBTYPE_MESH_11S);5600 } else if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {5601 ret = -EINVAL;5602 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n");5603 goto err;5604 }5605 arvif->vdev_type = WMI_VDEV_TYPE_AP;5606 break;5607 case NL80211_IFTYPE_AP:5608 arvif->vdev_type = WMI_VDEV_TYPE_AP;5609 5610 if (vif->p2p)5611 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype5612 (ar, WMI_VDEV_SUBTYPE_P2P_GO);5613 break;5614 case NL80211_IFTYPE_MONITOR:5615 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;5616 break;5617 default:5618 WARN_ON(1);5619 break;5620 }5621 5622 /* Using vdev_id as queue number will make it very easy to do per-vif5623 * tx queue locking. This shouldn't wrap due to interface combinations5624 * but do a modulo for correctness sake and prevent using offchannel tx5625 * queues for regular vif tx.5626 */5627 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);5628 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)5629 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);5630 5631 /* Some firmware revisions don't wait for beacon tx completion before5632 * sending another SWBA event. This could lead to hardware using old5633 * (freed) beacon data in some cases, e.g. tx credit starvation5634 * combined with missed TBTT. This is very rare.5635 *5636 * On non-IOMMU-enabled hosts this could be a possible security issue5637 * because hw could beacon some random data on the air. On5638 * IOMMU-enabled hosts DMAR faults would occur in most cases and target5639 * device would crash.5640 *5641 * Since there are no beacon tx completions (implicit nor explicit)5642 * propagated to host the only workaround for this is to allocate a5643 * DMA-coherent buffer for a lifetime of a vif and use it for all5644 * beacon tx commands. Worst case for this approach is some beacons may5645 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.5646 */5647 if (vif->type == NL80211_IFTYPE_ADHOC ||5648 vif->type == NL80211_IFTYPE_MESH_POINT ||5649 vif->type == NL80211_IFTYPE_AP) {5650 if (ar->bus_param.dev_type == ATH10K_DEV_TYPE_HL) {5651 arvif->beacon_buf = kmalloc(IEEE80211_MAX_FRAME_LEN,5652 GFP_KERNEL);5653 5654 /* Using a kernel pointer in place of a dma_addr_t5655 * token can lead to undefined behavior if that5656 * makes it into cache management functions. Use a5657 * known-invalid address token instead, which5658 * avoids the warning and makes it easier to catch5659 * bugs if it does end up getting used.5660 */5661 arvif->beacon_paddr = DMA_MAPPING_ERROR;5662 } else {5663 arvif->beacon_buf =5664 dma_alloc_coherent(ar->dev,5665 IEEE80211_MAX_FRAME_LEN,5666 &arvif->beacon_paddr,5667 GFP_ATOMIC);5668 }5669 if (!arvif->beacon_buf) {5670 ret = -ENOMEM;5671 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",5672 ret);5673 goto err;5674 }5675 }5676 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))5677 arvif->nohwcrypt = true;5678 5679 if (arvif->nohwcrypt &&5680 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {5681 ret = -EINVAL;5682 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");5683 goto err;5684 }5685 5686 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",5687 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,5688 arvif->beacon_buf ? "single-buf" : "per-skb");5689 5690 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,5691 arvif->vdev_subtype, vif->addr);5692 if (ret) {5693 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",5694 arvif->vdev_id, ret);5695 goto err;5696 }5697 5698 if (test_bit(WMI_SERVICE_VDEV_DISABLE_4_ADDR_SRC_LRN_SUPPORT,5699 ar->wmi.svc_map)) {5700 vdev_param = ar->wmi.vdev_param->disable_4addr_src_lrn;5701 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,5702 WMI_VDEV_DISABLE_4_ADDR_SRC_LRN);5703 if (ret && ret != -EOPNOTSUPP) {5704 ath10k_warn(ar, "failed to disable 4addr src lrn vdev %i: %d\n",5705 arvif->vdev_id, ret);5706 }5707 }5708 5709 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);5710 spin_lock_bh(&ar->data_lock);5711 list_add(&arvif->list, &ar->arvifs);5712 spin_unlock_bh(&ar->data_lock);5713 5714 /* It makes no sense to have firmware do keepalives. mac80211 already5715 * takes care of this with idle connection polling.5716 */5717 ret = ath10k_mac_vif_disable_keepalive(arvif);5718 if (ret) {5719 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",5720 arvif->vdev_id, ret);5721 goto err_vdev_delete;5722 }5723 5724 arvif->def_wep_key_idx = -1;5725 5726 ath10k_update_vif_offload(hw, vif);5727 5728 /* Configuring number of spatial stream for monitor interface is causing5729 * target assert in qca9888 and qca6174.5730 */5731 if (ar->cfg_tx_chainmask && (vif->type != NL80211_IFTYPE_MONITOR)) {5732 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);5733 5734 vdev_param = ar->wmi.vdev_param->nss;5735 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,5736 nss);5737 if (ret) {5738 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",5739 arvif->vdev_id, ar->cfg_tx_chainmask, nss,5740 ret);5741 goto err_vdev_delete;5742 }5743 }5744 5745 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||5746 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {5747 ret = ath10k_peer_create(ar, vif, NULL, arvif->vdev_id,5748 vif->addr, WMI_PEER_TYPE_DEFAULT);5749 if (ret) {5750 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",5751 arvif->vdev_id, ret);5752 goto err_vdev_delete;5753 }5754 5755 spin_lock_bh(&ar->data_lock);5756 5757 peer = ath10k_peer_find(ar, arvif->vdev_id, vif->addr);5758 if (!peer) {5759 ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",5760 vif->addr, arvif->vdev_id);5761 spin_unlock_bh(&ar->data_lock);5762 ret = -ENOENT;5763 goto err_peer_delete;5764 }5765 5766 arvif->peer_id = find_first_bit(peer->peer_ids,5767 ATH10K_MAX_NUM_PEER_IDS);5768 5769 spin_unlock_bh(&ar->data_lock);5770 } else {5771 arvif->peer_id = HTT_INVALID_PEERID;5772 }5773 5774 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {5775 ret = ath10k_mac_set_kickout(arvif);5776 if (ret) {5777 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",5778 arvif->vdev_id, ret);5779 goto err_peer_delete;5780 }5781 }5782 5783 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {5784 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;5785 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;5786 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,5787 param, value);5788 if (ret) {5789 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",5790 arvif->vdev_id, ret);5791 goto err_peer_delete;5792 }5793 5794 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);5795 if (ret) {5796 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",5797 arvif->vdev_id, ret);5798 goto err_peer_delete;5799 }5800 5801 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);5802 if (ret) {5803 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",5804 arvif->vdev_id, ret);5805 goto err_peer_delete;5806 }5807 }5808 5809 ret = ath10k_mac_set_txbf_conf(arvif);5810 if (ret) {5811 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",5812 arvif->vdev_id, ret);5813 goto err_peer_delete;5814 }5815 5816 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);5817 if (ret) {5818 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",5819 arvif->vdev_id, ret);5820 goto err_peer_delete;5821 }5822 5823 arvif->txpower = vif->bss_conf.txpower;5824 ret = ath10k_mac_txpower_recalc(ar);5825 if (ret) {5826 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);5827 goto err_peer_delete;5828 }5829 5830 if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) {5831 vdev_param = ar->wmi.vdev_param->rtt_responder_role;5832 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,5833 arvif->ftm_responder);5834 5835 /* It is harmless to not set FTM role. Do not warn */5836 if (ret && ret != -EOPNOTSUPP)5837 ath10k_warn(ar, "failed to set vdev %i FTM Responder: %d\n",5838 arvif->vdev_id, ret);5839 }5840 5841 if (vif->type == NL80211_IFTYPE_MONITOR) {5842 ar->monitor_arvif = arvif;5843 ret = ath10k_monitor_recalc(ar);5844 if (ret) {5845 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);5846 goto err_peer_delete;5847 }5848 }5849 5850 spin_lock_bh(&ar->htt.tx_lock);5851 if (!ar->tx_paused)5852 ieee80211_wake_queue(ar->hw, arvif->vdev_id);5853 spin_unlock_bh(&ar->htt.tx_lock);5854 5855 mutex_unlock(&ar->conf_mutex);5856 return 0;5857 5858err_peer_delete:5859 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||5860 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {5861 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);5862 ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id,5863 vif->addr);5864 }5865 5866err_vdev_delete:5867 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);5868 ar->free_vdev_map |= 1LL << arvif->vdev_id;5869 spin_lock_bh(&ar->data_lock);5870 list_del(&arvif->list);5871 spin_unlock_bh(&ar->data_lock);5872 5873err:5874 if (arvif->beacon_buf) {5875 if (ar->bus_param.dev_type == ATH10K_DEV_TYPE_HL)5876 kfree(arvif->beacon_buf);5877 else5878 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,5879 arvif->beacon_buf,5880 arvif->beacon_paddr);5881 arvif->beacon_buf = NULL;5882 }5883 5884 mutex_unlock(&ar->conf_mutex);5885 5886 return ret;5887}5888 5889static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)5890{5891 int i;5892 5893 for (i = 0; i < BITS_PER_LONG; i++)5894 ath10k_mac_vif_tx_unlock(arvif, i);5895}5896 5897static void ath10k_remove_interface(struct ieee80211_hw *hw,5898 struct ieee80211_vif *vif)5899{5900 struct ath10k *ar = hw->priv;5901 struct ath10k_vif *arvif = (void *)vif->drv_priv;5902 struct ath10k_peer *peer;5903 unsigned long time_left;5904 int ret;5905 int i;5906 5907 cancel_work_sync(&arvif->ap_csa_work);5908 cancel_delayed_work_sync(&arvif->connection_loss_work);5909 5910 mutex_lock(&ar->conf_mutex);5911 5912 ret = ath10k_spectral_vif_stop(arvif);5913 if (ret)5914 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",5915 arvif->vdev_id, ret);5916 5917 ar->free_vdev_map |= 1LL << arvif->vdev_id;5918 spin_lock_bh(&ar->data_lock);5919 list_del(&arvif->list);5920 spin_unlock_bh(&ar->data_lock);5921 5922 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||5923 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {5924 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,5925 vif->addr);5926 if (ret)5927 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",5928 arvif->vdev_id, ret);5929 5930 ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id,5931 vif->addr);5932 kfree(arvif->u.ap.noa_data);5933 }5934 5935 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",5936 arvif->vdev_id);5937 5938 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);5939 if (ret)5940 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",5941 arvif->vdev_id, ret);5942 5943 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) {5944 time_left = wait_for_completion_timeout(&ar->vdev_delete_done,5945 ATH10K_VDEV_DELETE_TIMEOUT_HZ);5946 if (time_left == 0) {5947 ath10k_warn(ar, "Timeout in receiving vdev delete response\n");5948 goto out;5949 }5950 }5951 5952 /* Some firmware revisions don't notify host about self-peer removal5953 * until after associated vdev is deleted.5954 */5955 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||5956 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {5957 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,5958 vif->addr);5959 if (ret)5960 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",5961 arvif->vdev_id, ret);5962 5963 spin_lock_bh(&ar->data_lock);5964 ar->num_peers--;5965 spin_unlock_bh(&ar->data_lock);5966 }5967 5968 spin_lock_bh(&ar->data_lock);5969 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {5970 peer = ar->peer_map[i];5971 if (!peer)5972 continue;5973 5974 if (peer->vif == vif) {5975 ath10k_warn(ar, "found vif peer %pM entry on vdev %i after it was supposedly removed\n",5976 vif->addr, arvif->vdev_id);5977 peer->vif = NULL;5978 }5979 }5980 5981 /* Clean this up late, less opportunity for firmware to access5982 * DMA memory we have deleted.5983 */5984 ath10k_mac_vif_beacon_cleanup(arvif);5985 spin_unlock_bh(&ar->data_lock);5986 5987 ath10k_peer_cleanup(ar, arvif->vdev_id);5988 ath10k_mac_txq_unref(ar, vif->txq);5989 5990 if (vif->type == NL80211_IFTYPE_MONITOR) {5991 ar->monitor_arvif = NULL;5992 ret = ath10k_monitor_recalc(ar);5993 if (ret)5994 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);5995 }5996 5997 ret = ath10k_mac_txpower_recalc(ar);5998 if (ret)5999 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);6000 6001 spin_lock_bh(&ar->htt.tx_lock);6002 ath10k_mac_vif_tx_unlock_all(arvif);6003 spin_unlock_bh(&ar->htt.tx_lock);6004 6005 ath10k_mac_txq_unref(ar, vif->txq);6006 6007out:6008 mutex_unlock(&ar->conf_mutex);6009}6010 6011/*6012 * FIXME: Has to be verified.6013 */6014#define SUPPORTED_FILTERS \6015 (FIF_ALLMULTI | \6016 FIF_CONTROL | \6017 FIF_PSPOLL | \6018 FIF_OTHER_BSS | \6019 FIF_BCN_PRBRESP_PROMISC | \6020 FIF_PROBE_REQ | \6021 FIF_FCSFAIL)6022 6023static void ath10k_configure_filter(struct ieee80211_hw *hw,6024 unsigned int changed_flags,6025 unsigned int *total_flags,6026 u64 multicast)6027{6028 struct ath10k *ar = hw->priv;6029 int ret;6030 unsigned int supported = SUPPORTED_FILTERS;6031 6032 mutex_lock(&ar->conf_mutex);6033 6034 if (ar->hw_params.mcast_frame_registration)6035 supported |= FIF_MCAST_ACTION;6036 6037 *total_flags &= supported;6038 6039 ar->filter_flags = *total_flags;6040 6041 ret = ath10k_monitor_recalc(ar);6042 if (ret)6043 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);6044 6045 mutex_unlock(&ar->conf_mutex);6046}6047 6048static void ath10k_recalculate_mgmt_rate(struct ath10k *ar,6049 struct ieee80211_vif *vif,6050 struct cfg80211_chan_def *def)6051{6052 struct ath10k_vif *arvif = (void *)vif->drv_priv;6053 const struct ieee80211_supported_band *sband;6054 u8 basic_rate_idx;6055 int hw_rate_code;6056 u32 vdev_param;6057 u16 bitrate;6058 int ret;6059 6060 lockdep_assert_held(&ar->conf_mutex);6061 6062 sband = ar->hw->wiphy->bands[def->chan->band];6063 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;6064 bitrate = sband->bitrates[basic_rate_idx].bitrate;6065 6066 hw_rate_code = ath10k_mac_get_rate_hw_value(bitrate);6067 if (hw_rate_code < 0) {6068 ath10k_warn(ar, "bitrate not supported %d\n", bitrate);6069 return;6070 }6071 6072 vdev_param = ar->wmi.vdev_param->mgmt_rate;6073 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,6074 hw_rate_code);6075 if (ret)6076 ath10k_warn(ar, "failed to set mgmt tx rate %d\n", ret);6077}6078 6079static void ath10k_bss_info_changed(struct ieee80211_hw *hw,6080 struct ieee80211_vif *vif,6081 struct ieee80211_bss_conf *info,6082 u64 changed)6083{6084 struct ath10k *ar = hw->priv;6085 struct ath10k_vif *arvif = (void *)vif->drv_priv;6086 struct cfg80211_chan_def def;6087 u32 vdev_param, pdev_param, slottime, preamble;6088 u16 bitrate, hw_value;6089 u8 rate, rateidx;6090 int ret = 0, mcast_rate;6091 enum nl80211_band band;6092 6093 mutex_lock(&ar->conf_mutex);6094 6095 if (changed & BSS_CHANGED_IBSS)6096 ath10k_control_ibss(arvif, vif);6097 6098 if (changed & BSS_CHANGED_BEACON_INT) {6099 arvif->beacon_interval = info->beacon_int;6100 vdev_param = ar->wmi.vdev_param->beacon_interval;6101 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,6102 arvif->beacon_interval);6103 ath10k_dbg(ar, ATH10K_DBG_MAC,6104 "mac vdev %d beacon_interval %d\n",6105 arvif->vdev_id, arvif->beacon_interval);6106 6107 if (ret)6108 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",6109 arvif->vdev_id, ret);6110 }6111 6112 if (changed & BSS_CHANGED_BEACON) {6113 ath10k_dbg(ar, ATH10K_DBG_MAC,6114 "vdev %d set beacon tx mode to staggered\n",6115 arvif->vdev_id);6116 6117 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;6118 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,6119 WMI_BEACON_STAGGERED_MODE);6120 if (ret)6121 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",6122 arvif->vdev_id, ret);6123 6124 ret = ath10k_mac_setup_bcn_tmpl(arvif);6125 if (ret)6126 ath10k_warn(ar, "failed to update beacon template: %d\n",6127 ret);6128 6129 if (ieee80211_vif_is_mesh(vif)) {6130 /* mesh doesn't use SSID but firmware needs it */6131 arvif->u.ap.ssid_len = 4;6132 memcpy(arvif->u.ap.ssid, "mesh", arvif->u.ap.ssid_len);6133 }6134 }6135 6136 if (changed & BSS_CHANGED_AP_PROBE_RESP) {6137 ret = ath10k_mac_setup_prb_tmpl(arvif);6138 if (ret)6139 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",6140 arvif->vdev_id, ret);6141 }6142 6143 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {6144 arvif->dtim_period = info->dtim_period;6145 6146 ath10k_dbg(ar, ATH10K_DBG_MAC,6147 "mac vdev %d dtim_period %d\n",6148 arvif->vdev_id, arvif->dtim_period);6149 6150 vdev_param = ar->wmi.vdev_param->dtim_period;6151 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,6152 arvif->dtim_period);6153 if (ret)6154 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",6155 arvif->vdev_id, ret);6156 }6157 6158 if (changed & BSS_CHANGED_SSID &&6159 vif->type == NL80211_IFTYPE_AP) {6160 arvif->u.ap.ssid_len = vif->cfg.ssid_len;6161 if (vif->cfg.ssid_len)6162 memcpy(arvif->u.ap.ssid, vif->cfg.ssid,6163 vif->cfg.ssid_len);6164 arvif->u.ap.hidden_ssid = info->hidden_ssid;6165 }6166 6167 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))6168 ether_addr_copy(arvif->bssid, info->bssid);6169 6170 if (changed & BSS_CHANGED_FTM_RESPONDER &&6171 arvif->ftm_responder != info->ftm_responder &&6172 test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) {6173 arvif->ftm_responder = info->ftm_responder;6174 6175 vdev_param = ar->wmi.vdev_param->rtt_responder_role;6176 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,6177 arvif->ftm_responder);6178 6179 ath10k_dbg(ar, ATH10K_DBG_MAC,6180 "mac vdev %d ftm_responder %d:ret %d\n",6181 arvif->vdev_id, arvif->ftm_responder, ret);6182 }6183 6184 if (changed & BSS_CHANGED_BEACON_ENABLED)6185 ath10k_control_beaconing(arvif, info);6186 6187 if (changed & BSS_CHANGED_ERP_CTS_PROT) {6188 arvif->use_cts_prot = info->use_cts_prot;6189 6190 ret = ath10k_recalc_rtscts_prot(arvif);6191 if (ret)6192 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",6193 arvif->vdev_id, ret);6194 6195 if (ath10k_mac_can_set_cts_prot(arvif)) {6196 ret = ath10k_mac_set_cts_prot(arvif);6197 if (ret)6198 ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n",6199 arvif->vdev_id, ret);6200 }6201 }6202 6203 if (changed & BSS_CHANGED_ERP_SLOT) {6204 if (info->use_short_slot)6205 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */6206 6207 else6208 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */6209 6210 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",6211 arvif->vdev_id, slottime);6212 6213 vdev_param = ar->wmi.vdev_param->slot_time;6214 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,6215 slottime);6216 if (ret)6217 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",6218 arvif->vdev_id, ret);6219 }6220 6221 if (changed & BSS_CHANGED_ERP_PREAMBLE) {6222 if (info->use_short_preamble)6223 preamble = WMI_VDEV_PREAMBLE_SHORT;6224 else6225 preamble = WMI_VDEV_PREAMBLE_LONG;6226 6227 ath10k_dbg(ar, ATH10K_DBG_MAC,6228 "mac vdev %d preamble %dn",6229 arvif->vdev_id, preamble);6230 6231 vdev_param = ar->wmi.vdev_param->preamble;6232 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,6233 preamble);6234 if (ret)6235 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",6236 arvif->vdev_id, ret);6237 }6238 6239 if (changed & BSS_CHANGED_ASSOC) {6240 if (vif->cfg.assoc) {6241 /* Workaround: Make sure monitor vdev is not running6242 * when associating to prevent some firmware revisions6243 * (e.g. 10.1 and 10.2) from crashing.6244 */6245 if (ar->monitor_started)6246 ath10k_monitor_stop(ar);6247 ath10k_bss_assoc(hw, vif, info);6248 ath10k_monitor_recalc(ar);6249 } else {6250 ath10k_bss_disassoc(hw, vif);6251 }6252 }6253 6254 if (changed & BSS_CHANGED_TXPOWER) {6255 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",6256 arvif->vdev_id, info->txpower);6257 6258 arvif->txpower = info->txpower;6259 ret = ath10k_mac_txpower_recalc(ar);6260 if (ret)6261 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);6262 }6263 6264 if (changed & BSS_CHANGED_PS) {6265 arvif->ps = vif->cfg.ps;6266 6267 ret = ath10k_config_ps(ar);6268 if (ret)6269 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",6270 arvif->vdev_id, ret);6271 }6272 6273 if (changed & BSS_CHANGED_MCAST_RATE &&6274 !ath10k_mac_vif_chan(arvif->vif, &def)) {6275 band = def.chan->band;6276 mcast_rate = vif->bss_conf.mcast_rate[band];6277 if (mcast_rate > 0)6278 rateidx = mcast_rate - 1;6279 else6280 rateidx = ffs(vif->bss_conf.basic_rates) - 1;6281 6282 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY)6283 rateidx += ATH10K_MAC_FIRST_OFDM_RATE_IDX;6284 6285 bitrate = ath10k_wmi_legacy_rates[rateidx].bitrate;6286 hw_value = ath10k_wmi_legacy_rates[rateidx].hw_value;6287 if (ath10k_mac_bitrate_is_cck(bitrate))6288 preamble = WMI_RATE_PREAMBLE_CCK;6289 else6290 preamble = WMI_RATE_PREAMBLE_OFDM;6291 6292 rate = ATH10K_HW_RATECODE(hw_value, 0, preamble);6293 6294 ath10k_dbg(ar, ATH10K_DBG_MAC,6295 "mac vdev %d mcast_rate %x\n",6296 arvif->vdev_id, rate);6297 6298 vdev_param = ar->wmi.vdev_param->mcast_data_rate;6299 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,6300 vdev_param, rate);6301 if (ret)6302 ath10k_warn(ar,6303 "failed to set mcast rate on vdev %i: %d\n",6304 arvif->vdev_id, ret);6305 6306 vdev_param = ar->wmi.vdev_param->bcast_data_rate;6307 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,6308 vdev_param, rate);6309 if (ret)6310 ath10k_warn(ar,6311 "failed to set bcast rate on vdev %i: %d\n",6312 arvif->vdev_id, ret);6313 }6314 6315 if (changed & BSS_CHANGED_BASIC_RATES &&6316 !ath10k_mac_vif_chan(arvif->vif, &def))6317 ath10k_recalculate_mgmt_rate(ar, vif, &def);6318 6319 mutex_unlock(&ar->conf_mutex);6320}6321 6322static void ath10k_mac_op_set_coverage_class(struct ieee80211_hw *hw, s16 value)6323{6324 struct ath10k *ar = hw->priv;6325 6326 /* This function should never be called if setting the coverage class6327 * is not supported on this hardware.6328 */6329 if (!ar->hw_params.hw_ops->set_coverage_class) {6330 WARN_ON_ONCE(1);6331 return;6332 }6333 ar->hw_params.hw_ops->set_coverage_class(ar, value);6334}6335 6336struct ath10k_mac_tdls_iter_data {6337 u32 num_tdls_stations;6338 struct ieee80211_vif *curr_vif;6339};6340 6341static void ath10k_mac_tdls_vif_stations_count_iter(void *data,6342 struct ieee80211_sta *sta)6343{6344 struct ath10k_mac_tdls_iter_data *iter_data = data;6345 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;6346 struct ieee80211_vif *sta_vif = arsta->arvif->vif;6347 6348 if (sta->tdls && sta_vif == iter_data->curr_vif)6349 iter_data->num_tdls_stations++;6350}6351 6352static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,6353 struct ieee80211_vif *vif)6354{6355 struct ath10k_mac_tdls_iter_data data = {};6356 6357 data.curr_vif = vif;6358 6359 ieee80211_iterate_stations_atomic(hw,6360 ath10k_mac_tdls_vif_stations_count_iter,6361 &data);6362 return data.num_tdls_stations;6363}6364 6365static int ath10k_hw_scan(struct ieee80211_hw *hw,6366 struct ieee80211_vif *vif,6367 struct ieee80211_scan_request *hw_req)6368{6369 struct ath10k *ar = hw->priv;6370 struct ath10k_vif *arvif = (void *)vif->drv_priv;6371 struct cfg80211_scan_request *req = &hw_req->req;6372 struct wmi_start_scan_arg arg;6373 int ret = 0;6374 int i;6375 u32 scan_timeout;6376 6377 mutex_lock(&ar->conf_mutex);6378 6379 if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) {6380 ret = -EBUSY;6381 goto exit;6382 }6383 6384 spin_lock_bh(&ar->data_lock);6385 switch (ar->scan.state) {6386 case ATH10K_SCAN_IDLE:6387 reinit_completion(&ar->scan.started);6388 reinit_completion(&ar->scan.completed);6389 ar->scan.state = ATH10K_SCAN_STARTING;6390 ar->scan.is_roc = false;6391 ar->scan.vdev_id = arvif->vdev_id;6392 ret = 0;6393 break;6394 case ATH10K_SCAN_STARTING:6395 case ATH10K_SCAN_RUNNING:6396 case ATH10K_SCAN_ABORTING:6397 ret = -EBUSY;6398 break;6399 }6400 spin_unlock_bh(&ar->data_lock);6401 6402 if (ret)6403 goto exit;6404 6405 memset(&arg, 0, sizeof(arg));6406 ath10k_wmi_start_scan_init(ar, &arg);6407 arg.vdev_id = arvif->vdev_id;6408 arg.scan_id = ATH10K_SCAN_ID;6409 6410 if (req->ie_len) {6411 arg.ie_len = req->ie_len;6412 memcpy(arg.ie, req->ie, arg.ie_len);6413 }6414 6415 if (req->n_ssids) {6416 arg.n_ssids = req->n_ssids;6417 for (i = 0; i < arg.n_ssids; i++) {6418 arg.ssids[i].len = req->ssids[i].ssid_len;6419 arg.ssids[i].ssid = req->ssids[i].ssid;6420 }6421 } else {6422 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;6423 }6424 6425 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {6426 arg.scan_ctrl_flags |= WMI_SCAN_ADD_SPOOFED_MAC_IN_PROBE_REQ;6427 ether_addr_copy(arg.mac_addr.addr, req->mac_addr);6428 ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask);6429 }6430 6431 if (req->n_channels) {6432 arg.n_channels = req->n_channels;6433 for (i = 0; i < arg.n_channels; i++)6434 arg.channels[i] = req->channels[i]->center_freq;6435 }6436 6437 /* if duration is set, default dwell times will be overwritten */6438 if (req->duration) {6439 arg.dwell_time_active = req->duration;6440 arg.dwell_time_passive = req->duration;6441 arg.burst_duration_ms = req->duration;6442 6443 scan_timeout = min_t(u32, arg.max_rest_time *6444 (arg.n_channels - 1) + (req->duration +6445 ATH10K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD) *6446 arg.n_channels, arg.max_scan_time);6447 } else {6448 scan_timeout = arg.max_scan_time;6449 }6450 6451 /* Add a 200ms margin to account for event/command processing */6452 scan_timeout += 200;6453 6454 ret = ath10k_start_scan(ar, &arg);6455 if (ret) {6456 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);6457 spin_lock_bh(&ar->data_lock);6458 ar->scan.state = ATH10K_SCAN_IDLE;6459 spin_unlock_bh(&ar->data_lock);6460 }6461 6462 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,6463 msecs_to_jiffies(scan_timeout));6464 6465exit:6466 mutex_unlock(&ar->conf_mutex);6467 return ret;6468}6469 6470static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,6471 struct ieee80211_vif *vif)6472{6473 struct ath10k *ar = hw->priv;6474 6475 mutex_lock(&ar->conf_mutex);6476 ath10k_scan_abort(ar);6477 mutex_unlock(&ar->conf_mutex);6478 6479 cancel_delayed_work_sync(&ar->scan.timeout);6480}6481 6482static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,6483 struct ath10k_vif *arvif,6484 enum set_key_cmd cmd,6485 struct ieee80211_key_conf *key)6486{6487 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;6488 int ret;6489 6490 /* 10.1 firmware branch requires default key index to be set to group6491 * key index after installing it. Otherwise FW/HW Txes corrupted6492 * frames with multi-vif APs. This is not required for main firmware6493 * branch (e.g. 636).6494 *6495 * This is also needed for 636 fw for IBSS-RSN to work more reliably.6496 *6497 * FIXME: It remains unknown if this is required for multi-vif STA6498 * interfaces on 10.1.6499 */6500 6501 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&6502 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)6503 return;6504 6505 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)6506 return;6507 6508 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)6509 return;6510 6511 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)6512 return;6513 6514 if (cmd != SET_KEY)6515 return;6516 6517 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,6518 key->keyidx);6519 if (ret)6520 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",6521 arvif->vdev_id, ret);6522}6523 6524static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,6525 struct ieee80211_vif *vif, struct ieee80211_sta *sta,6526 struct ieee80211_key_conf *key)6527{6528 struct ath10k *ar = hw->priv;6529 struct ath10k_vif *arvif = (void *)vif->drv_priv;6530 struct ath10k_sta *arsta;6531 struct ath10k_peer *peer;6532 const u8 *peer_addr;6533 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||6534 key->cipher == WLAN_CIPHER_SUITE_WEP104;6535 int ret = 0;6536 int ret2;6537 u32 flags = 0;6538 u32 flags2;6539 6540 /* this one needs to be done in software */6541 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||6542 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||6543 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||6544 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)6545 return 1;6546 6547 if (arvif->nohwcrypt)6548 return 1;6549 6550 if (key->keyidx > WMI_MAX_KEY_INDEX)6551 return -ENOSPC;6552 6553 mutex_lock(&ar->conf_mutex);6554 6555 if (sta) {6556 arsta = (struct ath10k_sta *)sta->drv_priv;6557 peer_addr = sta->addr;6558 spin_lock_bh(&ar->data_lock);6559 arsta->ucast_cipher = key->cipher;6560 spin_unlock_bh(&ar->data_lock);6561 } else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {6562 peer_addr = vif->bss_conf.bssid;6563 } else {6564 peer_addr = vif->addr;6565 }6566 6567 key->hw_key_idx = key->keyidx;6568 6569 if (is_wep) {6570 if (cmd == SET_KEY)6571 arvif->wep_keys[key->keyidx] = key;6572 else6573 arvif->wep_keys[key->keyidx] = NULL;6574 }6575 6576 /* the peer should not disappear in mid-way (unless FW goes awry) since6577 * we already hold conf_mutex. we just make sure its there now.6578 */6579 spin_lock_bh(&ar->data_lock);6580 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);6581 spin_unlock_bh(&ar->data_lock);6582 6583 if (!peer) {6584 if (cmd == SET_KEY) {6585 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",6586 peer_addr);6587 ret = -EOPNOTSUPP;6588 goto exit;6589 } else {6590 /* if the peer doesn't exist there is no key to disable anymore */6591 goto exit;6592 }6593 }6594 6595 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)6596 flags |= WMI_KEY_PAIRWISE;6597 else6598 flags |= WMI_KEY_GROUP;6599 6600 if (is_wep) {6601 if (cmd == DISABLE_KEY)6602 ath10k_clear_vdev_key(arvif, key);6603 6604 /* When WEP keys are uploaded it's possible that there are6605 * stations associated already (e.g. when merging) without any6606 * keys. Static WEP needs an explicit per-peer key upload.6607 */6608 if (vif->type == NL80211_IFTYPE_ADHOC &&6609 cmd == SET_KEY)6610 ath10k_mac_vif_update_wep_key(arvif, key);6611 6612 /* 802.1x never sets the def_wep_key_idx so each set_key()6613 * call changes default tx key.6614 *6615 * Static WEP sets def_wep_key_idx via .set_default_unicast_key6616 * after first set_key().6617 */6618 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)6619 flags |= WMI_KEY_TX_USAGE;6620 }6621 6622 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);6623 if (ret) {6624 WARN_ON(ret > 0);6625 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",6626 arvif->vdev_id, peer_addr, ret);6627 goto exit;6628 }6629 6630 /* mac80211 sets static WEP keys as groupwise while firmware requires6631 * them to be installed twice as both pairwise and groupwise.6632 */6633 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {6634 flags2 = flags;6635 flags2 &= ~WMI_KEY_GROUP;6636 flags2 |= WMI_KEY_PAIRWISE;6637 6638 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);6639 if (ret) {6640 WARN_ON(ret > 0);6641 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",6642 arvif->vdev_id, peer_addr, ret);6643 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,6644 peer_addr, flags);6645 if (ret2) {6646 WARN_ON(ret2 > 0);6647 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",6648 arvif->vdev_id, peer_addr, ret2);6649 }6650 goto exit;6651 }6652 }6653 6654 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);6655 6656 spin_lock_bh(&ar->data_lock);6657 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);6658 if (peer && cmd == SET_KEY)6659 peer->keys[key->keyidx] = key;6660 else if (peer && cmd == DISABLE_KEY)6661 peer->keys[key->keyidx] = NULL;6662 else if (peer == NULL)6663 /* impossible unless FW goes crazy */6664 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);6665 spin_unlock_bh(&ar->data_lock);6666 6667 if (sta && sta->tdls)6668 ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,6669 ar->wmi.peer_param->authorize, 1);6670 else if (sta && cmd == SET_KEY && (key->flags & IEEE80211_KEY_FLAG_PAIRWISE))6671 ath10k_wmi_peer_set_param(ar, arvif->vdev_id, peer_addr,6672 ar->wmi.peer_param->authorize, 1);6673 6674exit:6675 mutex_unlock(&ar->conf_mutex);6676 return ret;6677}6678 6679static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,6680 struct ieee80211_vif *vif,6681 int keyidx)6682{6683 struct ath10k *ar = hw->priv;6684 struct ath10k_vif *arvif = (void *)vif->drv_priv;6685 int ret;6686 6687 mutex_lock(&arvif->ar->conf_mutex);6688 6689 if (arvif->ar->state != ATH10K_STATE_ON)6690 goto unlock;6691 6692 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",6693 arvif->vdev_id, keyidx);6694 6695 ret = ath10k_wmi_vdev_set_param(arvif->ar,6696 arvif->vdev_id,6697 arvif->ar->wmi.vdev_param->def_keyid,6698 keyidx);6699 6700 if (ret) {6701 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",6702 arvif->vdev_id,6703 ret);6704 goto unlock;6705 }6706 6707 arvif->def_wep_key_idx = keyidx;6708 6709unlock:6710 mutex_unlock(&arvif->ar->conf_mutex);6711}6712 6713static void ath10k_sta_rc_update_wk(struct work_struct *wk)6714{6715 struct ath10k *ar;6716 struct ath10k_vif *arvif;6717 struct ath10k_sta *arsta;6718 struct ieee80211_sta *sta;6719 struct cfg80211_chan_def def;6720 enum nl80211_band band;6721 const u8 *ht_mcs_mask;6722 const u16 *vht_mcs_mask;6723 u32 changed, bw, nss, smps;6724 int err;6725 6726 arsta = container_of(wk, struct ath10k_sta, update_wk);6727 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);6728 arvif = arsta->arvif;6729 ar = arvif->ar;6730 6731 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))6732 return;6733 6734 band = def.chan->band;6735 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;6736 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;6737 6738 spin_lock_bh(&ar->data_lock);6739 6740 changed = arsta->changed;6741 arsta->changed = 0;6742 6743 bw = arsta->bw;6744 nss = arsta->nss;6745 smps = arsta->smps;6746 6747 spin_unlock_bh(&ar->data_lock);6748 6749 mutex_lock(&ar->conf_mutex);6750 6751 nss = max_t(u32, 1, nss);6752 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),6753 ath10k_mac_max_vht_nss(vht_mcs_mask)));6754 6755 if (changed & IEEE80211_RC_BW_CHANGED) {6756 enum wmi_phy_mode mode;6757 6758 mode = chan_to_phymode(&def);6759 ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM peer bw %d phymode %d\n",6760 sta->addr, bw, mode);6761 6762 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,6763 ar->wmi.peer_param->phymode, mode);6764 if (err) {6765 ath10k_warn(ar, "failed to update STA %pM peer phymode %d: %d\n",6766 sta->addr, mode, err);6767 goto exit;6768 }6769 6770 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,6771 ar->wmi.peer_param->chan_width, bw);6772 if (err)6773 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",6774 sta->addr, bw, err);6775 }6776 6777 if (changed & IEEE80211_RC_NSS_CHANGED) {6778 ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM nss %d\n",6779 sta->addr, nss);6780 6781 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,6782 ar->wmi.peer_param->nss, nss);6783 if (err)6784 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",6785 sta->addr, nss, err);6786 }6787 6788 if (changed & IEEE80211_RC_SMPS_CHANGED) {6789 ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM smps %d\n",6790 sta->addr, smps);6791 6792 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,6793 ar->wmi.peer_param->smps_state, smps);6794 if (err)6795 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",6796 sta->addr, smps, err);6797 }6798 6799 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {6800 ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM supp rates\n",6801 sta->addr);6802 6803 err = ath10k_station_assoc(ar, arvif->vif, sta, true);6804 if (err)6805 ath10k_warn(ar, "failed to reassociate station: %pM\n",6806 sta->addr);6807 }6808 6809exit:6810 mutex_unlock(&ar->conf_mutex);6811}6812 6813static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,6814 struct ieee80211_sta *sta)6815{6816 struct ath10k *ar = arvif->ar;6817 6818 lockdep_assert_held(&ar->conf_mutex);6819 6820 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)6821 return 0;6822 6823 if (ar->num_stations >= ar->max_num_stations)6824 return -ENOBUFS;6825 6826 ar->num_stations++;6827 6828 return 0;6829}6830 6831static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,6832 struct ieee80211_sta *sta)6833{6834 struct ath10k *ar = arvif->ar;6835 6836 lockdep_assert_held(&ar->conf_mutex);6837 6838 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)6839 return;6840 6841 ar->num_stations--;6842}6843 6844static int ath10k_sta_set_txpwr(struct ieee80211_hw *hw,6845 struct ieee80211_vif *vif,6846 struct ieee80211_sta *sta)6847{6848 struct ath10k *ar = hw->priv;6849 struct ath10k_vif *arvif = (void *)vif->drv_priv;6850 int ret = 0;6851 s16 txpwr;6852 6853 if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) {6854 txpwr = 0;6855 } else {6856 txpwr = sta->deflink.txpwr.power;6857 if (!txpwr)6858 return -EINVAL;6859 }6860 6861 if (txpwr > ATH10K_TX_POWER_MAX_VAL || txpwr < ATH10K_TX_POWER_MIN_VAL)6862 return -EINVAL;6863 6864 mutex_lock(&ar->conf_mutex);6865 6866 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,6867 ar->wmi.peer_param->use_fixed_power, txpwr);6868 if (ret) {6869 ath10k_warn(ar, "failed to set tx power for station ret: %d\n",6870 ret);6871 goto out;6872 }6873 6874out:6875 mutex_unlock(&ar->conf_mutex);6876 return ret;6877}6878 6879struct ath10k_mac_iter_tid_conf_data {6880 struct ieee80211_vif *curr_vif;6881 struct ath10k *ar;6882 bool reset_config;6883};6884 6885static bool6886ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,6887 enum nl80211_band band,6888 const struct cfg80211_bitrate_mask *mask,6889 int *vht_num_rates)6890{6891 int num_rates = 0;6892 int i, tmp;6893 6894 num_rates += hweight32(mask->control[band].legacy);6895 6896 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)6897 num_rates += hweight8(mask->control[band].ht_mcs[i]);6898 6899 *vht_num_rates = 0;6900 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {6901 tmp = hweight16(mask->control[band].vht_mcs[i]);6902 num_rates += tmp;6903 *vht_num_rates += tmp;6904 }6905 6906 return num_rates == 1;6907}6908 6909static int6910ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,6911 enum nl80211_band band,6912 const struct cfg80211_bitrate_mask *mask,6913 u8 *rate, u8 *nss, bool vht_only)6914{6915 int rate_idx;6916 int i;6917 u16 bitrate;6918 u8 preamble;6919 u8 hw_rate;6920 6921 if (vht_only)6922 goto next;6923 6924 if (hweight32(mask->control[band].legacy) == 1) {6925 rate_idx = ffs(mask->control[band].legacy) - 1;6926 6927 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY)6928 rate_idx += ATH10K_MAC_FIRST_OFDM_RATE_IDX;6929 6930 hw_rate = ath10k_wmi_legacy_rates[rate_idx].hw_value;6931 bitrate = ath10k_wmi_legacy_rates[rate_idx].bitrate;6932 6933 if (ath10k_mac_bitrate_is_cck(bitrate))6934 preamble = WMI_RATE_PREAMBLE_CCK;6935 else6936 preamble = WMI_RATE_PREAMBLE_OFDM;6937 6938 *nss = 1;6939 *rate = preamble << 6 |6940 (*nss - 1) << 4 |6941 hw_rate << 0;6942 6943 return 0;6944 }6945 6946 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {6947 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {6948 *nss = i + 1;6949 *rate = WMI_RATE_PREAMBLE_HT << 6 |6950 (*nss - 1) << 4 |6951 (ffs(mask->control[band].ht_mcs[i]) - 1);6952 6953 return 0;6954 }6955 }6956 6957next:6958 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {6959 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {6960 *nss = i + 1;6961 *rate = WMI_RATE_PREAMBLE_VHT << 6 |6962 (*nss - 1) << 4 |6963 (ffs(mask->control[band].vht_mcs[i]) - 1);6964 6965 return 0;6966 }6967 }6968 6969 return -EINVAL;6970}6971 6972static int ath10k_mac_validate_rate_mask(struct ath10k *ar,6973 struct ieee80211_sta *sta,6974 u32 rate_ctrl_flag, u8 nss)6975{6976 struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;6977 struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;6978 6979 if (nss > sta->deflink.rx_nss) {6980 ath10k_warn(ar, "Invalid nss field, configured %u limit %u\n",6981 nss, sta->deflink.rx_nss);6982 return -EINVAL;6983 }6984 6985 if (ATH10K_HW_PREAMBLE(rate_ctrl_flag) == WMI_RATE_PREAMBLE_VHT) {6986 if (!vht_cap->vht_supported) {6987 ath10k_warn(ar, "Invalid VHT rate for sta %pM\n",6988 sta->addr);6989 return -EINVAL;6990 }6991 } else if (ATH10K_HW_PREAMBLE(rate_ctrl_flag) == WMI_RATE_PREAMBLE_HT) {6992 if (!ht_cap->ht_supported || vht_cap->vht_supported) {6993 ath10k_warn(ar, "Invalid HT rate for sta %pM\n",6994 sta->addr);6995 return -EINVAL;6996 }6997 } else {6998 if (ht_cap->ht_supported || vht_cap->vht_supported)6999 return -EINVAL;7000 }7001 7002 return 0;7003}7004 7005static int7006ath10k_mac_tid_bitrate_config(struct ath10k *ar,7007 struct ieee80211_vif *vif,7008 struct ieee80211_sta *sta,7009 u32 *rate_ctrl_flag, u8 *rate_ctrl,7010 enum nl80211_tx_rate_setting txrate_type,7011 const struct cfg80211_bitrate_mask *mask)7012{7013 struct cfg80211_chan_def def;7014 enum nl80211_band band;7015 u8 nss, rate;7016 int vht_num_rates, ret;7017 7018 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))7019 return -EINVAL;7020 7021 if (txrate_type == NL80211_TX_RATE_AUTOMATIC) {7022 *rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_AUTO;7023 *rate_ctrl_flag = 0;7024 return 0;7025 }7026 7027 band = def.chan->band;7028 7029 if (!ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask,7030 &vht_num_rates)) {7031 return -EINVAL;7032 }7033 7034 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,7035 &rate, &nss, false);7036 if (ret) {7037 ath10k_warn(ar, "failed to get single rate: %d\n",7038 ret);7039 return ret;7040 }7041 7042 *rate_ctrl_flag = rate;7043 7044 if (sta && ath10k_mac_validate_rate_mask(ar, sta, *rate_ctrl_flag, nss))7045 return -EINVAL;7046 7047 if (txrate_type == NL80211_TX_RATE_FIXED)7048 *rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_FIXED_RATE;7049 else if (txrate_type == NL80211_TX_RATE_LIMITED &&7050 (test_bit(WMI_SERVICE_EXT_PEER_TID_CONFIGS_SUPPORT,7051 ar->wmi.svc_map)))7052 *rate_ctrl = WMI_PEER_TID_CONFIG_RATE_UPPER_CAP;7053 else7054 return -EOPNOTSUPP;7055 7056 return 0;7057}7058 7059static int ath10k_mac_set_tid_config(struct ath10k *ar, struct ieee80211_sta *sta,7060 struct ieee80211_vif *vif, u32 changed,7061 struct wmi_per_peer_per_tid_cfg_arg *arg)7062{7063 struct ath10k_vif *arvif = (void *)vif->drv_priv;7064 struct ath10k_sta *arsta;7065 int ret;7066 7067 if (sta) {7068 if (!sta->wme)7069 return -EOPNOTSUPP;7070 7071 arsta = (struct ath10k_sta *)sta->drv_priv;7072 7073 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {7074 if ((arsta->retry_long[arg->tid] > 0 ||7075 arsta->rate_code[arg->tid] > 0 ||7076 arsta->ampdu[arg->tid] ==7077 WMI_TID_CONFIG_AGGR_CONTROL_ENABLE) &&7078 arg->ack_policy == WMI_PEER_TID_CONFIG_NOACK) {7079 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_NOACK);7080 arg->ack_policy = 0;7081 arg->aggr_control = 0;7082 arg->rate_ctrl = 0;7083 arg->rcode_flags = 0;7084 }7085 }7086 7087 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {7088 if (arsta->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK ||7089 arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) {7090 arg->aggr_control = 0;7091 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);7092 }7093 }7094 7095 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |7096 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {7097 if (arsta->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK ||7098 arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) {7099 arg->rate_ctrl = 0;7100 arg->rcode_flags = 0;7101 }7102 }7103 7104 ether_addr_copy(arg->peer_macaddr.addr, sta->addr);7105 7106 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, arg);7107 if (ret)7108 return ret;7109 7110 /* Store the configured parameters in success case */7111 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {7112 arsta->noack[arg->tid] = arg->ack_policy;7113 arg->ack_policy = 0;7114 arg->aggr_control = 0;7115 arg->rate_ctrl = 0;7116 arg->rcode_flags = 0;7117 }7118 7119 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) {7120 arsta->retry_long[arg->tid] = arg->retry_count;7121 arg->retry_count = 0;7122 }7123 7124 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {7125 arsta->ampdu[arg->tid] = arg->aggr_control;7126 arg->aggr_control = 0;7127 }7128 7129 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |7130 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {7131 arsta->rate_ctrl[arg->tid] = arg->rate_ctrl;7132 arg->rate_ctrl = 0;7133 arg->rcode_flags = 0;7134 }7135 7136 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {7137 arsta->rtscts[arg->tid] = arg->rtscts_ctrl;7138 arg->ext_tid_cfg_bitmap = 0;7139 }7140 } else {7141 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {7142 if ((arvif->retry_long[arg->tid] ||7143 arvif->rate_code[arg->tid] ||7144 arvif->ampdu[arg->tid] ==7145 WMI_TID_CONFIG_AGGR_CONTROL_ENABLE) &&7146 arg->ack_policy == WMI_PEER_TID_CONFIG_NOACK) {7147 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_NOACK);7148 } else {7149 arvif->noack[arg->tid] = arg->ack_policy;7150 arvif->ampdu[arg->tid] = arg->aggr_control;7151 arvif->rate_ctrl[arg->tid] = arg->rate_ctrl;7152 }7153 }7154 7155 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) {7156 if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK)7157 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);7158 else7159 arvif->retry_long[arg->tid] = arg->retry_count;7160 }7161 7162 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {7163 if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK)7164 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL);7165 else7166 arvif->ampdu[arg->tid] = arg->aggr_control;7167 }7168 7169 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |7170 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {7171 if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) {7172 changed &= ~(BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |7173 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE));7174 } else {7175 arvif->rate_ctrl[arg->tid] = arg->rate_ctrl;7176 arvif->rate_code[arg->tid] = arg->rcode_flags;7177 }7178 }7179 7180 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {7181 arvif->rtscts[arg->tid] = arg->rtscts_ctrl;7182 arg->ext_tid_cfg_bitmap = 0;7183 }7184 7185 if (changed)7186 arvif->tid_conf_changed[arg->tid] |= changed;7187 }7188 7189 return 0;7190}7191 7192static int7193ath10k_mac_parse_tid_config(struct ath10k *ar,7194 struct ieee80211_sta *sta,7195 struct ieee80211_vif *vif,7196 struct cfg80211_tid_cfg *tid_conf,7197 struct wmi_per_peer_per_tid_cfg_arg *arg)7198{7199 u32 changed = tid_conf->mask;7200 int ret = 0, i = 0;7201 7202 if (!changed)7203 return -EINVAL;7204 7205 while (i < ATH10K_TID_MAX) {7206 if (!(tid_conf->tids & BIT(i))) {7207 i++;7208 continue;7209 }7210 7211 arg->tid = i;7212 7213 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {7214 if (tid_conf->noack == NL80211_TID_CONFIG_ENABLE) {7215 arg->ack_policy = WMI_PEER_TID_CONFIG_NOACK;7216 arg->rate_ctrl =7217 WMI_TID_CONFIG_RATE_CONTROL_DEFAULT_LOWEST_RATE;7218 arg->aggr_control =7219 WMI_TID_CONFIG_AGGR_CONTROL_DISABLE;7220 } else {7221 arg->ack_policy =7222 WMI_PEER_TID_CONFIG_ACK;7223 arg->rate_ctrl =7224 WMI_TID_CONFIG_RATE_CONTROL_AUTO;7225 arg->aggr_control =7226 WMI_TID_CONFIG_AGGR_CONTROL_ENABLE;7227 }7228 }7229 7230 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG))7231 arg->retry_count = tid_conf->retry_long;7232 7233 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {7234 if (tid_conf->noack == NL80211_TID_CONFIG_ENABLE)7235 arg->aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_ENABLE;7236 else7237 arg->aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_DISABLE;7238 }7239 7240 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |7241 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {7242 ret = ath10k_mac_tid_bitrate_config(ar, vif, sta,7243 &arg->rcode_flags,7244 &arg->rate_ctrl,7245 tid_conf->txrate_type,7246 &tid_conf->txrate_mask);7247 if (ret) {7248 ath10k_warn(ar, "failed to configure bitrate mask %d\n",7249 ret);7250 arg->rcode_flags = 0;7251 arg->rate_ctrl = 0;7252 }7253 }7254 7255 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {7256 if (tid_conf->rtscts)7257 arg->rtscts_ctrl = tid_conf->rtscts;7258 7259 arg->ext_tid_cfg_bitmap = WMI_EXT_TID_RTS_CTS_CONFIG;7260 }7261 7262 ret = ath10k_mac_set_tid_config(ar, sta, vif, changed, arg);7263 if (ret)7264 return ret;7265 i++;7266 }7267 7268 return ret;7269}7270 7271static int ath10k_mac_reset_tid_config(struct ath10k *ar,7272 struct ieee80211_sta *sta,7273 struct ath10k_vif *arvif,7274 u8 tids)7275{7276 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;7277 struct wmi_per_peer_per_tid_cfg_arg arg;7278 int ret = 0, i = 0;7279 7280 arg.vdev_id = arvif->vdev_id;7281 while (i < ATH10K_TID_MAX) {7282 if (!(tids & BIT(i))) {7283 i++;7284 continue;7285 }7286 7287 arg.tid = i;7288 arg.ack_policy = WMI_PEER_TID_CONFIG_ACK;7289 arg.retry_count = ATH10K_MAX_RETRY_COUNT;7290 arg.rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_AUTO;7291 arg.aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_ENABLE;7292 arg.rtscts_ctrl = WMI_TID_CONFIG_RTSCTS_CONTROL_ENABLE;7293 arg.ext_tid_cfg_bitmap = WMI_EXT_TID_RTS_CTS_CONFIG;7294 7295 ether_addr_copy(arg.peer_macaddr.addr, sta->addr);7296 7297 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg);7298 if (ret)7299 return ret;7300 7301 if (!arvif->tids_rst) {7302 arsta->retry_long[i] = -1;7303 arsta->noack[i] = -1;7304 arsta->ampdu[i] = -1;7305 arsta->rate_code[i] = -1;7306 arsta->rate_ctrl[i] = 0;7307 arsta->rtscts[i] = -1;7308 } else {7309 arvif->retry_long[i] = 0;7310 arvif->noack[i] = 0;7311 arvif->ampdu[i] = 0;7312 arvif->rate_code[i] = 0;7313 arvif->rate_ctrl[i] = 0;7314 arvif->rtscts[i] = 0;7315 }7316 7317 i++;7318 }7319 7320 return ret;7321}7322 7323static void ath10k_sta_tid_cfg_wk(struct work_struct *wk)7324{7325 struct wmi_per_peer_per_tid_cfg_arg arg = {};7326 struct ieee80211_sta *sta;7327 struct ath10k_sta *arsta;7328 struct ath10k_vif *arvif;7329 struct ath10k *ar;7330 bool config_apply;7331 int ret, i;7332 u32 changed;7333 u8 nss;7334 7335 arsta = container_of(wk, struct ath10k_sta, tid_config_wk);7336 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);7337 arvif = arsta->arvif;7338 ar = arvif->ar;7339 7340 mutex_lock(&ar->conf_mutex);7341 7342 if (arvif->tids_rst) {7343 ret = ath10k_mac_reset_tid_config(ar, sta, arvif,7344 arvif->tids_rst);7345 goto exit;7346 }7347 7348 ether_addr_copy(arg.peer_macaddr.addr, sta->addr);7349 7350 for (i = 0; i < ATH10K_TID_MAX; i++) {7351 config_apply = false;7352 changed = arvif->tid_conf_changed[i];7353 7354 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {7355 if (arsta->noack[i] != -1) {7356 arg.ack_policy = 0;7357 } else {7358 config_apply = true;7359 arg.ack_policy = arvif->noack[i];7360 arg.aggr_control = arvif->ampdu[i];7361 arg.rate_ctrl = arvif->rate_ctrl[i];7362 }7363 }7364 7365 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) {7366 if (arsta->retry_long[i] != -1 ||7367 arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK ||7368 arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) {7369 arg.retry_count = 0;7370 } else {7371 arg.retry_count = arvif->retry_long[i];7372 config_apply = true;7373 }7374 }7375 7376 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {7377 if (arsta->ampdu[i] != -1 ||7378 arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK ||7379 arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) {7380 arg.aggr_control = 0;7381 } else {7382 arg.aggr_control = arvif->ampdu[i];7383 config_apply = true;7384 }7385 }7386 7387 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |7388 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {7389 nss = ATH10K_HW_NSS(arvif->rate_code[i]);7390 ret = ath10k_mac_validate_rate_mask(ar, sta,7391 arvif->rate_code[i],7392 nss);7393 if (ret &&7394 arvif->rate_ctrl[i] > WMI_TID_CONFIG_RATE_CONTROL_AUTO) {7395 arg.rate_ctrl = 0;7396 arg.rcode_flags = 0;7397 }7398 7399 if (arsta->rate_ctrl[i] >7400 WMI_TID_CONFIG_RATE_CONTROL_AUTO ||7401 arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK ||7402 arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) {7403 arg.rate_ctrl = 0;7404 arg.rcode_flags = 0;7405 } else {7406 arg.rate_ctrl = arvif->rate_ctrl[i];7407 arg.rcode_flags = arvif->rate_code[i];7408 config_apply = true;7409 }7410 }7411 7412 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {7413 if (arsta->rtscts[i]) {7414 arg.rtscts_ctrl = 0;7415 arg.ext_tid_cfg_bitmap = 0;7416 } else {7417 arg.rtscts_ctrl = arvif->rtscts[i] - 1;7418 arg.ext_tid_cfg_bitmap =7419 WMI_EXT_TID_RTS_CTS_CONFIG;7420 config_apply = true;7421 }7422 }7423 7424 arg.tid = i;7425 7426 if (config_apply) {7427 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg);7428 if (ret)7429 ath10k_warn(ar, "failed to set per tid config for sta %pM: %d\n",7430 sta->addr, ret);7431 }7432 7433 arg.ack_policy = 0;7434 arg.retry_count = 0;7435 arg.aggr_control = 0;7436 arg.rate_ctrl = 0;7437 arg.rcode_flags = 0;7438 }7439 7440exit:7441 mutex_unlock(&ar->conf_mutex);7442}7443 7444static void ath10k_mac_vif_stations_tid_conf(void *data,7445 struct ieee80211_sta *sta)7446{7447 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;7448 struct ath10k_mac_iter_tid_conf_data *iter_data = data;7449 struct ieee80211_vif *sta_vif = arsta->arvif->vif;7450 7451 if (sta_vif != iter_data->curr_vif || !sta->wme)7452 return;7453 7454 ieee80211_queue_work(iter_data->ar->hw, &arsta->tid_config_wk);7455}7456 7457static int ath10k_sta_state(struct ieee80211_hw *hw,7458 struct ieee80211_vif *vif,7459 struct ieee80211_sta *sta,7460 enum ieee80211_sta_state old_state,7461 enum ieee80211_sta_state new_state)7462{7463 struct ath10k *ar = hw->priv;7464 struct ath10k_vif *arvif = (void *)vif->drv_priv;7465 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;7466 struct ath10k_peer *peer;7467 int ret = 0;7468 int i;7469 7470 if (old_state == IEEE80211_STA_NOTEXIST &&7471 new_state == IEEE80211_STA_NONE) {7472 memset(arsta, 0, sizeof(*arsta));7473 arsta->arvif = arvif;7474 arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;7475 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);7476 INIT_WORK(&arsta->tid_config_wk, ath10k_sta_tid_cfg_wk);7477 7478 for (i = 0; i < ARRAY_SIZE(sta->txq); i++)7479 ath10k_mac_txq_init(sta->txq[i]);7480 }7481 7482 /* cancel must be done outside the mutex to avoid deadlock */7483 if ((old_state == IEEE80211_STA_NONE &&7484 new_state == IEEE80211_STA_NOTEXIST)) {7485 cancel_work_sync(&arsta->update_wk);7486 cancel_work_sync(&arsta->tid_config_wk);7487 }7488 7489 mutex_lock(&ar->conf_mutex);7490 7491 if (old_state == IEEE80211_STA_NOTEXIST &&7492 new_state == IEEE80211_STA_NONE) {7493 /*7494 * New station addition.7495 */7496 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;7497 u32 num_tdls_stations;7498 7499 ath10k_dbg(ar, ATH10K_DBG_STA,7500 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",7501 arvif->vdev_id, sta->addr,7502 ar->num_stations + 1, ar->max_num_stations,7503 ar->num_peers + 1, ar->max_num_peers);7504 7505 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);7506 7507 if (sta->tdls) {7508 if (num_tdls_stations >= ar->max_num_tdls_vdevs) {7509 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",7510 arvif->vdev_id,7511 ar->max_num_tdls_vdevs);7512 ret = -ELNRNG;7513 goto exit;7514 }7515 peer_type = WMI_PEER_TYPE_TDLS;7516 }7517 7518 ret = ath10k_mac_inc_num_stations(arvif, sta);7519 if (ret) {7520 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",7521 ar->max_num_stations);7522 goto exit;7523 }7524 7525 if (ath10k_debug_is_extd_tx_stats_enabled(ar)) {7526 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats),7527 GFP_KERNEL);7528 if (!arsta->tx_stats) {7529 ath10k_mac_dec_num_stations(arvif, sta);7530 ret = -ENOMEM;7531 goto exit;7532 }7533 }7534 7535 ret = ath10k_peer_create(ar, vif, sta, arvif->vdev_id,7536 sta->addr, peer_type);7537 if (ret) {7538 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",7539 sta->addr, arvif->vdev_id, ret);7540 ath10k_mac_dec_num_stations(arvif, sta);7541 kfree(arsta->tx_stats);7542 goto exit;7543 }7544 7545 spin_lock_bh(&ar->data_lock);7546 7547 peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr);7548 if (!peer) {7549 ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",7550 vif->addr, arvif->vdev_id);7551 spin_unlock_bh(&ar->data_lock);7552 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);7553 ath10k_mac_dec_num_stations(arvif, sta);7554 kfree(arsta->tx_stats);7555 ret = -ENOENT;7556 goto exit;7557 }7558 7559 arsta->peer_id = find_first_bit(peer->peer_ids,7560 ATH10K_MAX_NUM_PEER_IDS);7561 7562 spin_unlock_bh(&ar->data_lock);7563 7564 if (!sta->tdls)7565 goto exit;7566 7567 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,7568 WMI_TDLS_ENABLE_ACTIVE);7569 if (ret) {7570 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",7571 arvif->vdev_id, ret);7572 ath10k_peer_delete(ar, arvif->vdev_id,7573 sta->addr);7574 ath10k_mac_dec_num_stations(arvif, sta);7575 kfree(arsta->tx_stats);7576 goto exit;7577 }7578 7579 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,7580 WMI_TDLS_PEER_STATE_PEERING);7581 if (ret) {7582 ath10k_warn(ar,7583 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",7584 sta->addr, arvif->vdev_id, ret);7585 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);7586 ath10k_mac_dec_num_stations(arvif, sta);7587 kfree(arsta->tx_stats);7588 7589 if (num_tdls_stations != 0)7590 goto exit;7591 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,7592 WMI_TDLS_DISABLE);7593 }7594 } else if ((old_state == IEEE80211_STA_NONE &&7595 new_state == IEEE80211_STA_NOTEXIST)) {7596 /*7597 * Existing station deletion.7598 */7599 ath10k_dbg(ar, ATH10K_DBG_STA,7600 "mac vdev %d peer delete %pM sta %pK (sta gone)\n",7601 arvif->vdev_id, sta->addr, sta);7602 7603 if (sta->tdls) {7604 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id,7605 sta,7606 WMI_TDLS_PEER_STATE_TEARDOWN);7607 if (ret)7608 ath10k_warn(ar, "failed to update tdls peer state for %pM state %d: %i\n",7609 sta->addr,7610 WMI_TDLS_PEER_STATE_TEARDOWN, ret);7611 }7612 7613 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);7614 if (ret)7615 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",7616 sta->addr, arvif->vdev_id, ret);7617 7618 ath10k_mac_dec_num_stations(arvif, sta);7619 7620 spin_lock_bh(&ar->data_lock);7621 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {7622 peer = ar->peer_map[i];7623 if (!peer)7624 continue;7625 7626 if (peer->sta == sta) {7627 ath10k_warn(ar, "found sta peer %pM (ptr %pK id %d) entry on vdev %i after it was supposedly removed\n",7628 sta->addr, peer, i, arvif->vdev_id);7629 peer->sta = NULL;7630 7631 /* Clean up the peer object as well since we7632 * must have failed to do this above.7633 */7634 ath10k_peer_map_cleanup(ar, peer);7635 }7636 }7637 spin_unlock_bh(&ar->data_lock);7638 7639 if (ath10k_debug_is_extd_tx_stats_enabled(ar)) {7640 kfree(arsta->tx_stats);7641 arsta->tx_stats = NULL;7642 }7643 7644 for (i = 0; i < ARRAY_SIZE(sta->txq); i++)7645 ath10k_mac_txq_unref(ar, sta->txq[i]);7646 7647 if (!sta->tdls)7648 goto exit;7649 7650 if (ath10k_mac_tdls_vif_stations_count(hw, vif))7651 goto exit;7652 7653 /* This was the last tdls peer in current vif */7654 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,7655 WMI_TDLS_DISABLE);7656 if (ret) {7657 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",7658 arvif->vdev_id, ret);7659 }7660 } else if (old_state == IEEE80211_STA_AUTH &&7661 new_state == IEEE80211_STA_ASSOC &&7662 (vif->type == NL80211_IFTYPE_AP ||7663 vif->type == NL80211_IFTYPE_MESH_POINT ||7664 vif->type == NL80211_IFTYPE_ADHOC)) {7665 /*7666 * New association.7667 */7668 ath10k_dbg(ar, ATH10K_DBG_STA, "mac sta %pM associated\n",7669 sta->addr);7670 7671 ret = ath10k_station_assoc(ar, vif, sta, false);7672 if (ret)7673 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",7674 sta->addr, arvif->vdev_id, ret);7675 } else if (old_state == IEEE80211_STA_ASSOC &&7676 new_state == IEEE80211_STA_AUTHORIZED &&7677 sta->tdls) {7678 /*7679 * Tdls station authorized.7680 */7681 ath10k_dbg(ar, ATH10K_DBG_STA, "mac tdls sta %pM authorized\n",7682 sta->addr);7683 7684 ret = ath10k_station_assoc(ar, vif, sta, false);7685 if (ret) {7686 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",7687 sta->addr, arvif->vdev_id, ret);7688 goto exit;7689 }7690 7691 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,7692 WMI_TDLS_PEER_STATE_CONNECTED);7693 if (ret)7694 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",7695 sta->addr, arvif->vdev_id, ret);7696 } else if (old_state == IEEE80211_STA_ASSOC &&7697 new_state == IEEE80211_STA_AUTH &&7698 (vif->type == NL80211_IFTYPE_AP ||7699 vif->type == NL80211_IFTYPE_MESH_POINT ||7700 vif->type == NL80211_IFTYPE_ADHOC)) {7701 /*7702 * Disassociation.7703 */7704 ath10k_dbg(ar, ATH10K_DBG_STA, "mac sta %pM disassociated\n",7705 sta->addr);7706 7707 ret = ath10k_station_disassoc(ar, vif, sta);7708 if (ret)7709 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",7710 sta->addr, arvif->vdev_id, ret);7711 }7712exit:7713 mutex_unlock(&ar->conf_mutex);7714 return ret;7715}7716 7717static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,7718 u16 ac, bool enable)7719{7720 struct ath10k_vif *arvif = (void *)vif->drv_priv;7721 struct wmi_sta_uapsd_auto_trig_arg arg = {};7722 u32 prio = 0, acc = 0;7723 u32 value = 0;7724 int ret = 0;7725 7726 lockdep_assert_held(&ar->conf_mutex);7727 7728 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)7729 return 0;7730 7731 switch (ac) {7732 case IEEE80211_AC_VO:7733 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |7734 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;7735 prio = 7;7736 acc = 3;7737 break;7738 case IEEE80211_AC_VI:7739 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |7740 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;7741 prio = 5;7742 acc = 2;7743 break;7744 case IEEE80211_AC_BE:7745 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |7746 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;7747 prio = 2;7748 acc = 1;7749 break;7750 case IEEE80211_AC_BK:7751 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |7752 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;7753 prio = 0;7754 acc = 0;7755 break;7756 }7757 7758 if (enable)7759 arvif->u.sta.uapsd |= value;7760 else7761 arvif->u.sta.uapsd &= ~value;7762 7763 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,7764 WMI_STA_PS_PARAM_UAPSD,7765 arvif->u.sta.uapsd);7766 if (ret) {7767 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);7768 goto exit;7769 }7770 7771 if (arvif->u.sta.uapsd)7772 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;7773 else7774 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;7775 7776 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,7777 WMI_STA_PS_PARAM_RX_WAKE_POLICY,7778 value);7779 if (ret)7780 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);7781 7782 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);7783 if (ret) {7784 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",7785 arvif->vdev_id, ret);7786 return ret;7787 }7788 7789 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);7790 if (ret) {7791 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",7792 arvif->vdev_id, ret);7793 return ret;7794 }7795 7796 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||7797 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {7798 /* Only userspace can make an educated decision when to send7799 * trigger frame. The following effectively disables u-UAPSD7800 * autotrigger in firmware (which is enabled by default7801 * provided the autotrigger service is available).7802 */7803 7804 arg.wmm_ac = acc;7805 arg.user_priority = prio;7806 arg.service_interval = 0;7807 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;7808 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;7809 7810 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,7811 arvif->bssid, &arg, 1);7812 if (ret) {7813 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",7814 ret);7815 return ret;7816 }7817 }7818 7819exit:7820 return ret;7821}7822 7823static int ath10k_conf_tx(struct ieee80211_hw *hw,7824 struct ieee80211_vif *vif,7825 unsigned int link_id, u16 ac,7826 const struct ieee80211_tx_queue_params *params)7827{7828 struct ath10k *ar = hw->priv;7829 struct ath10k_vif *arvif = (void *)vif->drv_priv;7830 struct wmi_wmm_params_arg *p = NULL;7831 int ret;7832 7833 mutex_lock(&ar->conf_mutex);7834 7835 switch (ac) {7836 case IEEE80211_AC_VO:7837 p = &arvif->wmm_params.ac_vo;7838 break;7839 case IEEE80211_AC_VI:7840 p = &arvif->wmm_params.ac_vi;7841 break;7842 case IEEE80211_AC_BE:7843 p = &arvif->wmm_params.ac_be;7844 break;7845 case IEEE80211_AC_BK:7846 p = &arvif->wmm_params.ac_bk;7847 break;7848 }7849 7850 if (WARN_ON(!p)) {7851 ret = -EINVAL;7852 goto exit;7853 }7854 7855 p->cwmin = params->cw_min;7856 p->cwmax = params->cw_max;7857 p->aifs = params->aifs;7858 7859 /*7860 * The channel time duration programmed in the HW is in absolute7861 * microseconds, while mac80211 gives the txop in units of7862 * 32 microseconds.7863 */7864 p->txop = params->txop * 32;7865 7866 if (ar->wmi.ops->gen_vdev_wmm_conf) {7867 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,7868 &arvif->wmm_params);7869 if (ret) {7870 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",7871 arvif->vdev_id, ret);7872 goto exit;7873 }7874 } else {7875 /* This won't work well with multi-interface cases but it's7876 * better than nothing.7877 */7878 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);7879 if (ret) {7880 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);7881 goto exit;7882 }7883 }7884 7885 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);7886 if (ret)7887 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);7888 7889exit:7890 mutex_unlock(&ar->conf_mutex);7891 return ret;7892}7893 7894static int ath10k_remain_on_channel(struct ieee80211_hw *hw,7895 struct ieee80211_vif *vif,7896 struct ieee80211_channel *chan,7897 int duration,7898 enum ieee80211_roc_type type)7899{7900 struct ath10k *ar = hw->priv;7901 struct ath10k_vif *arvif = (void *)vif->drv_priv;7902 struct wmi_start_scan_arg arg;7903 int ret = 0;7904 u32 scan_time_msec;7905 7906 mutex_lock(&ar->conf_mutex);7907 7908 if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) {7909 ret = -EBUSY;7910 goto exit;7911 }7912 7913 spin_lock_bh(&ar->data_lock);7914 switch (ar->scan.state) {7915 case ATH10K_SCAN_IDLE:7916 reinit_completion(&ar->scan.started);7917 reinit_completion(&ar->scan.completed);7918 reinit_completion(&ar->scan.on_channel);7919 ar->scan.state = ATH10K_SCAN_STARTING;7920 ar->scan.is_roc = true;7921 ar->scan.vdev_id = arvif->vdev_id;7922 ar->scan.roc_freq = chan->center_freq;7923 ar->scan.roc_notify = true;7924 ret = 0;7925 break;7926 case ATH10K_SCAN_STARTING:7927 case ATH10K_SCAN_RUNNING:7928 case ATH10K_SCAN_ABORTING:7929 ret = -EBUSY;7930 break;7931 }7932 spin_unlock_bh(&ar->data_lock);7933 7934 if (ret)7935 goto exit;7936 7937 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;7938 7939 memset(&arg, 0, sizeof(arg));7940 ath10k_wmi_start_scan_init(ar, &arg);7941 arg.vdev_id = arvif->vdev_id;7942 arg.scan_id = ATH10K_SCAN_ID;7943 arg.n_channels = 1;7944 arg.channels[0] = chan->center_freq;7945 arg.dwell_time_active = scan_time_msec;7946 arg.dwell_time_passive = scan_time_msec;7947 arg.max_scan_time = scan_time_msec;7948 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;7949 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;7950 arg.burst_duration_ms = duration;7951 7952 ret = ath10k_start_scan(ar, &arg);7953 if (ret) {7954 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);7955 spin_lock_bh(&ar->data_lock);7956 ar->scan.state = ATH10K_SCAN_IDLE;7957 spin_unlock_bh(&ar->data_lock);7958 goto exit;7959 }7960 7961 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ);7962 if (ret == 0) {7963 ath10k_warn(ar, "failed to switch to channel for roc scan\n");7964 7965 ret = ath10k_scan_stop(ar);7966 if (ret)7967 ath10k_warn(ar, "failed to stop scan: %d\n", ret);7968 7969 ret = -ETIMEDOUT;7970 goto exit;7971 }7972 7973 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,7974 msecs_to_jiffies(duration));7975 7976 ret = 0;7977exit:7978 mutex_unlock(&ar->conf_mutex);7979 return ret;7980}7981 7982static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw,7983 struct ieee80211_vif *vif)7984{7985 struct ath10k *ar = hw->priv;7986 7987 mutex_lock(&ar->conf_mutex);7988 7989 spin_lock_bh(&ar->data_lock);7990 ar->scan.roc_notify = false;7991 spin_unlock_bh(&ar->data_lock);7992 7993 ath10k_scan_abort(ar);7994 7995 mutex_unlock(&ar->conf_mutex);7996 7997 cancel_delayed_work_sync(&ar->scan.timeout);7998 7999 return 0;8000}8001 8002/*8003 * Both RTS and Fragmentation threshold are interface-specific8004 * in ath10k, but device-specific in mac80211.8005 */8006 8007static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)8008{8009 struct ath10k *ar = hw->priv;8010 struct ath10k_vif *arvif;8011 int ret = 0;8012 8013 mutex_lock(&ar->conf_mutex);8014 list_for_each_entry(arvif, &ar->arvifs, list) {8015 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",8016 arvif->vdev_id, value);8017 8018 ret = ath10k_mac_set_rts(arvif, value);8019 if (ret) {8020 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",8021 arvif->vdev_id, ret);8022 break;8023 }8024 }8025 mutex_unlock(&ar->conf_mutex);8026 8027 return ret;8028}8029 8030static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)8031{8032 /* Even though there's a WMI enum for fragmentation threshold no known8033 * firmware actually implements it. Moreover it is not possible to rely8034 * frame fragmentation to mac80211 because firmware clears the "more8035 * fragments" bit in frame control making it impossible for remote8036 * devices to reassemble frames.8037 *8038 * Hence implement a dummy callback just to say fragmentation isn't8039 * supported. This effectively prevents mac80211 from doing frame8040 * fragmentation in software.8041 */8042 return -EOPNOTSUPP;8043}8044 8045void ath10k_mac_wait_tx_complete(struct ath10k *ar)8046{8047 bool skip;8048 long time_left;8049 8050 /* mac80211 doesn't care if we really xmit queued frames or not8051 * we'll collect those frames either way if we stop/delete vdevs8052 */8053 8054 if (ar->state == ATH10K_STATE_WEDGED)8055 return;8056 8057 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({8058 bool empty;8059 8060 spin_lock_bh(&ar->htt.tx_lock);8061 empty = (ar->htt.num_pending_tx == 0);8062 spin_unlock_bh(&ar->htt.tx_lock);8063 8064 skip = (ar->state == ATH10K_STATE_WEDGED) ||8065 test_bit(ATH10K_FLAG_CRASH_FLUSH,8066 &ar->dev_flags);8067 8068 (empty || skip);8069 }), ATH10K_FLUSH_TIMEOUT_HZ);8070 8071 if (time_left == 0 || skip)8072 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",8073 skip, ar->state, time_left);8074}8075 8076static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,8077 u32 queues, bool drop)8078{8079 struct ath10k *ar = hw->priv;8080 struct ath10k_vif *arvif;8081 u32 bitmap;8082 8083 if (drop) {8084 if (vif && vif->type == NL80211_IFTYPE_STATION) {8085 bitmap = ~(1 << WMI_MGMT_TID);8086 list_for_each_entry(arvif, &ar->arvifs, list) {8087 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)8088 ath10k_wmi_peer_flush(ar, arvif->vdev_id,8089 arvif->bssid, bitmap);8090 }8091 ath10k_htt_flush_tx(&ar->htt);8092 }8093 return;8094 }8095 8096 mutex_lock(&ar->conf_mutex);8097 ath10k_mac_wait_tx_complete(ar);8098 mutex_unlock(&ar->conf_mutex);8099}8100 8101/* TODO: Implement this function properly8102 * For now it is needed to reply to Probe Requests in IBSS mode.8103 * Probably we need this information from FW.8104 */8105static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)8106{8107 return 1;8108}8109 8110static void ath10k_reconfig_complete(struct ieee80211_hw *hw,8111 enum ieee80211_reconfig_type reconfig_type)8112{8113 struct ath10k *ar = hw->priv;8114 struct ath10k_vif *arvif;8115 8116 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)8117 return;8118 8119 mutex_lock(&ar->conf_mutex);8120 8121 /* If device failed to restart it will be in a different state, e.g.8122 * ATH10K_STATE_WEDGED8123 */8124 if (ar->state == ATH10K_STATE_RESTARTED) {8125 ath10k_info(ar, "device successfully recovered\n");8126 ar->state = ATH10K_STATE_ON;8127 ieee80211_wake_queues(ar->hw);8128 clear_bit(ATH10K_FLAG_RESTARTING, &ar->dev_flags);8129 if (ar->hw_params.hw_restart_disconnect) {8130 list_for_each_entry(arvif, &ar->arvifs, list) {8131 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_STA)8132 ieee80211_hw_restart_disconnect(arvif->vif);8133 }8134 }8135 }8136 8137 mutex_unlock(&ar->conf_mutex);8138}8139 8140static void8141ath10k_mac_update_bss_chan_survey(struct ath10k *ar,8142 struct ieee80211_channel *channel)8143{8144 int ret;8145 enum wmi_bss_survey_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;8146 8147 lockdep_assert_held(&ar->conf_mutex);8148 8149 if (!test_bit(WMI_SERVICE_BSS_CHANNEL_INFO_64, ar->wmi.svc_map) ||8150 (ar->rx_channel != channel))8151 return;8152 8153 if (ar->scan.state != ATH10K_SCAN_IDLE) {8154 ath10k_dbg(ar, ATH10K_DBG_MAC, "ignoring bss chan info request while scanning..\n");8155 return;8156 }8157 8158 reinit_completion(&ar->bss_survey_done);8159 8160 ret = ath10k_wmi_pdev_bss_chan_info_request(ar, type);8161 if (ret) {8162 ath10k_warn(ar, "failed to send pdev bss chan info request\n");8163 return;8164 }8165 8166 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);8167 if (!ret) {8168 ath10k_warn(ar, "bss channel survey timed out\n");8169 return;8170 }8171}8172 8173static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,8174 struct survey_info *survey)8175{8176 struct ath10k *ar = hw->priv;8177 struct ieee80211_supported_band *sband;8178 struct survey_info *ar_survey = &ar->survey[idx];8179 int ret = 0;8180 8181 mutex_lock(&ar->conf_mutex);8182 8183 sband = hw->wiphy->bands[NL80211_BAND_2GHZ];8184 if (sband && idx >= sband->n_channels) {8185 idx -= sband->n_channels;8186 sband = NULL;8187 }8188 8189 if (!sband)8190 sband = hw->wiphy->bands[NL80211_BAND_5GHZ];8191 8192 if (!sband || idx >= sband->n_channels) {8193 ret = -ENOENT;8194 goto exit;8195 }8196 8197 ath10k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);8198 8199 spin_lock_bh(&ar->data_lock);8200 memcpy(survey, ar_survey, sizeof(*survey));8201 spin_unlock_bh(&ar->data_lock);8202 8203 survey->channel = &sband->channels[idx];8204 8205 if (ar->rx_channel == survey->channel)8206 survey->filled |= SURVEY_INFO_IN_USE;8207 8208exit:8209 mutex_unlock(&ar->conf_mutex);8210 return ret;8211}8212 8213static bool8214ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,8215 enum nl80211_band band,8216 const struct cfg80211_bitrate_mask *mask,8217 int *nss)8218{8219 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];8220 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);8221 u8 ht_nss_mask = 0;8222 u8 vht_nss_mask = 0;8223 int i;8224 8225 if (mask->control[band].legacy)8226 return false;8227 8228 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {8229 if (mask->control[band].ht_mcs[i] == 0)8230 continue;8231 else if (mask->control[band].ht_mcs[i] ==8232 sband->ht_cap.mcs.rx_mask[i])8233 ht_nss_mask |= BIT(i);8234 else8235 return false;8236 }8237 8238 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {8239 if (mask->control[band].vht_mcs[i] == 0)8240 continue;8241 else if (mask->control[band].vht_mcs[i] ==8242 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))8243 vht_nss_mask |= BIT(i);8244 else8245 return false;8246 }8247 8248 if (ht_nss_mask != vht_nss_mask)8249 return false;8250 8251 if (ht_nss_mask == 0)8252 return false;8253 8254 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)8255 return false;8256 8257 *nss = fls(ht_nss_mask);8258 8259 return true;8260}8261 8262static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,8263 u8 rate, u8 nss, u8 sgi, u8 ldpc)8264{8265 struct ath10k *ar = arvif->ar;8266 u32 vdev_param;8267 int ret;8268 8269 lockdep_assert_held(&ar->conf_mutex);8270 8271 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02x nss %u sgi %u\n",8272 arvif->vdev_id, rate, nss, sgi);8273 8274 vdev_param = ar->wmi.vdev_param->fixed_rate;8275 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);8276 if (ret) {8277 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",8278 rate, ret);8279 return ret;8280 }8281 8282 vdev_param = ar->wmi.vdev_param->nss;8283 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);8284 if (ret) {8285 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);8286 return ret;8287 }8288 8289 vdev_param = ar->wmi.vdev_param->sgi;8290 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);8291 if (ret) {8292 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);8293 return ret;8294 }8295 8296 vdev_param = ar->wmi.vdev_param->ldpc;8297 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);8298 if (ret) {8299 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);8300 return ret;8301 }8302 8303 return 0;8304}8305 8306static bool8307ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,8308 enum nl80211_band band,8309 const struct cfg80211_bitrate_mask *mask,8310 bool allow_pfr)8311{8312 int i;8313 u16 vht_mcs;8314 8315 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible8316 * to express all VHT MCS rate masks. Effectively only the following8317 * ranges can be used: none, 0-7, 0-8 and 0-9.8318 */8319 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {8320 vht_mcs = mask->control[band].vht_mcs[i];8321 8322 switch (vht_mcs) {8323 case 0:8324 case BIT(8) - 1:8325 case BIT(9) - 1:8326 case BIT(10) - 1:8327 break;8328 default:8329 if (!allow_pfr)8330 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");8331 return false;8332 }8333 }8334 8335 return true;8336}8337 8338static bool ath10k_mac_set_vht_bitrate_mask_fixup(struct ath10k *ar,8339 struct ath10k_vif *arvif,8340 struct ieee80211_sta *sta)8341{8342 int err;8343 u8 rate = arvif->vht_pfr;8344 8345 /* skip non vht and multiple rate peers */8346 if (!sta->deflink.vht_cap.vht_supported || arvif->vht_num_rates != 1)8347 return false;8348 8349 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,8350 WMI_PEER_PARAM_FIXED_RATE, rate);8351 if (err)8352 ath10k_warn(ar, "failed to enable STA %pM peer fixed rate: %d\n",8353 sta->addr, err);8354 8355 return true;8356}8357 8358static void ath10k_mac_set_bitrate_mask_iter(void *data,8359 struct ieee80211_sta *sta)8360{8361 struct ath10k_vif *arvif = data;8362 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;8363 struct ath10k *ar = arvif->ar;8364 8365 if (arsta->arvif != arvif)8366 return;8367 8368 if (ath10k_mac_set_vht_bitrate_mask_fixup(ar, arvif, sta))8369 return;8370 8371 spin_lock_bh(&ar->data_lock);8372 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;8373 spin_unlock_bh(&ar->data_lock);8374 8375 ieee80211_queue_work(ar->hw, &arsta->update_wk);8376}8377 8378static void ath10k_mac_clr_bitrate_mask_iter(void *data,8379 struct ieee80211_sta *sta)8380{8381 struct ath10k_vif *arvif = data;8382 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;8383 struct ath10k *ar = arvif->ar;8384 int err;8385 8386 /* clear vht peers only */8387 if (arsta->arvif != arvif || !sta->deflink.vht_cap.vht_supported)8388 return;8389 8390 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,8391 WMI_PEER_PARAM_FIXED_RATE,8392 WMI_FIXED_RATE_NONE);8393 if (err)8394 ath10k_warn(ar, "failed to clear STA %pM peer fixed rate: %d\n",8395 sta->addr, err);8396}8397 8398static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,8399 struct ieee80211_vif *vif,8400 const struct cfg80211_bitrate_mask *mask)8401{8402 struct ath10k_vif *arvif = (void *)vif->drv_priv;8403 struct cfg80211_chan_def def;8404 struct ath10k *ar = arvif->ar;8405 enum nl80211_band band;8406 const u8 *ht_mcs_mask;8407 const u16 *vht_mcs_mask;8408 u8 rate;8409 u8 nss;8410 u8 sgi;8411 u8 ldpc;8412 int single_nss;8413 int ret;8414 int vht_num_rates, allow_pfr;8415 u8 vht_pfr;8416 bool update_bitrate_mask = true;8417 8418 if (ath10k_mac_vif_chan(vif, &def))8419 return -EPERM;8420 8421 band = def.chan->band;8422 ht_mcs_mask = mask->control[band].ht_mcs;8423 vht_mcs_mask = mask->control[band].vht_mcs;8424 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);8425 8426 sgi = mask->control[band].gi;8427 if (sgi == NL80211_TXRATE_FORCE_LGI)8428 return -EINVAL;8429 8430 allow_pfr = test_bit(ATH10K_FW_FEATURE_PEER_FIXED_RATE,8431 ar->normal_mode_fw.fw_file.fw_features);8432 if (allow_pfr) {8433 mutex_lock(&ar->conf_mutex);8434 ieee80211_iterate_stations_atomic(ar->hw,8435 ath10k_mac_clr_bitrate_mask_iter,8436 arvif);8437 mutex_unlock(&ar->conf_mutex);8438 }8439 8440 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask,8441 &vht_num_rates)) {8442 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,8443 &rate, &nss,8444 false);8445 if (ret) {8446 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",8447 arvif->vdev_id, ret);8448 return ret;8449 }8450 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,8451 &single_nss)) {8452 rate = WMI_FIXED_RATE_NONE;8453 nss = single_nss;8454 } else {8455 rate = WMI_FIXED_RATE_NONE;8456 nss = min(ar->num_rf_chains,8457 max(ath10k_mac_max_ht_nss(ht_mcs_mask),8458 ath10k_mac_max_vht_nss(vht_mcs_mask)));8459 8460 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask,8461 allow_pfr)) {8462 u8 vht_nss;8463 8464 if (!allow_pfr || vht_num_rates != 1)8465 return -EINVAL;8466 8467 /* Reach here, firmware supports peer fixed rate and has8468 * single vht rate, and don't update vif birate_mask, as8469 * the rate only for specific peer.8470 */8471 ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,8472 &vht_pfr,8473 &vht_nss,8474 true);8475 update_bitrate_mask = false;8476 } else {8477 vht_pfr = 0;8478 }8479 8480 mutex_lock(&ar->conf_mutex);8481 8482 if (update_bitrate_mask)8483 arvif->bitrate_mask = *mask;8484 arvif->vht_num_rates = vht_num_rates;8485 arvif->vht_pfr = vht_pfr;8486 ieee80211_iterate_stations_atomic(ar->hw,8487 ath10k_mac_set_bitrate_mask_iter,8488 arvif);8489 8490 mutex_unlock(&ar->conf_mutex);8491 }8492 8493 mutex_lock(&ar->conf_mutex);8494 8495 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);8496 if (ret) {8497 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",8498 arvif->vdev_id, ret);8499 goto exit;8500 }8501 8502exit:8503 mutex_unlock(&ar->conf_mutex);8504 8505 return ret;8506}8507 8508static void ath10k_sta_rc_update(struct ieee80211_hw *hw,8509 struct ieee80211_vif *vif,8510 struct ieee80211_sta *sta,8511 u32 changed)8512{8513 struct ath10k *ar = hw->priv;8514 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;8515 struct ath10k_vif *arvif = (void *)vif->drv_priv;8516 struct ath10k_peer *peer;8517 u32 bw, smps;8518 8519 spin_lock_bh(&ar->data_lock);8520 8521 peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr);8522 if (!peer) {8523 spin_unlock_bh(&ar->data_lock);8524 ath10k_warn(ar, "mac sta rc update failed to find peer %pM on vdev %i\n",8525 sta->addr, arvif->vdev_id);8526 return;8527 }8528 8529 ath10k_dbg(ar, ATH10K_DBG_STA,8530 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",8531 sta->addr, changed, sta->deflink.bandwidth,8532 sta->deflink.rx_nss,8533 sta->deflink.smps_mode);8534 8535 if (changed & IEEE80211_RC_BW_CHANGED) {8536 bw = WMI_PEER_CHWIDTH_20MHZ;8537 8538 switch (sta->deflink.bandwidth) {8539 case IEEE80211_STA_RX_BW_20:8540 bw = WMI_PEER_CHWIDTH_20MHZ;8541 break;8542 case IEEE80211_STA_RX_BW_40:8543 bw = WMI_PEER_CHWIDTH_40MHZ;8544 break;8545 case IEEE80211_STA_RX_BW_80:8546 bw = WMI_PEER_CHWIDTH_80MHZ;8547 break;8548 case IEEE80211_STA_RX_BW_160:8549 bw = WMI_PEER_CHWIDTH_160MHZ;8550 break;8551 default:8552 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",8553 sta->deflink.bandwidth, sta->addr);8554 bw = WMI_PEER_CHWIDTH_20MHZ;8555 break;8556 }8557 8558 arsta->bw = bw;8559 }8560 8561 if (changed & IEEE80211_RC_NSS_CHANGED)8562 arsta->nss = sta->deflink.rx_nss;8563 8564 if (changed & IEEE80211_RC_SMPS_CHANGED) {8565 smps = WMI_PEER_SMPS_PS_NONE;8566 8567 switch (sta->deflink.smps_mode) {8568 case IEEE80211_SMPS_AUTOMATIC:8569 case IEEE80211_SMPS_OFF:8570 smps = WMI_PEER_SMPS_PS_NONE;8571 break;8572 case IEEE80211_SMPS_STATIC:8573 smps = WMI_PEER_SMPS_STATIC;8574 break;8575 case IEEE80211_SMPS_DYNAMIC:8576 smps = WMI_PEER_SMPS_DYNAMIC;8577 break;8578 case IEEE80211_SMPS_NUM_MODES:8579 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",8580 sta->deflink.smps_mode, sta->addr);8581 smps = WMI_PEER_SMPS_PS_NONE;8582 break;8583 }8584 8585 arsta->smps = smps;8586 }8587 8588 arsta->changed |= changed;8589 8590 spin_unlock_bh(&ar->data_lock);8591 8592 ieee80211_queue_work(hw, &arsta->update_wk);8593}8594 8595static void ath10k_offset_tsf(struct ieee80211_hw *hw,8596 struct ieee80211_vif *vif, s64 tsf_offset)8597{8598 struct ath10k *ar = hw->priv;8599 struct ath10k_vif *arvif = (void *)vif->drv_priv;8600 u32 offset, vdev_param;8601 int ret;8602 8603 if (tsf_offset < 0) {8604 vdev_param = ar->wmi.vdev_param->dec_tsf;8605 offset = -tsf_offset;8606 } else {8607 vdev_param = ar->wmi.vdev_param->inc_tsf;8608 offset = tsf_offset;8609 }8610 8611 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,8612 vdev_param, offset);8613 8614 if (ret && ret != -EOPNOTSUPP)8615 ath10k_warn(ar, "failed to set tsf offset %d cmd %d: %d\n",8616 offset, vdev_param, ret);8617}8618 8619static int ath10k_ampdu_action(struct ieee80211_hw *hw,8620 struct ieee80211_vif *vif,8621 struct ieee80211_ampdu_params *params)8622{8623 struct ath10k *ar = hw->priv;8624 struct ath10k_vif *arvif = (void *)vif->drv_priv;8625 struct ieee80211_sta *sta = params->sta;8626 enum ieee80211_ampdu_mlme_action action = params->action;8627 u16 tid = params->tid;8628 8629 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %u action %d\n",8630 arvif->vdev_id, sta->addr, tid, action);8631 8632 switch (action) {8633 case IEEE80211_AMPDU_RX_START:8634 case IEEE80211_AMPDU_RX_STOP:8635 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session8636 * creation/removal. Do we need to verify this?8637 */8638 return 0;8639 case IEEE80211_AMPDU_TX_START:8640 case IEEE80211_AMPDU_TX_STOP_CONT:8641 case IEEE80211_AMPDU_TX_STOP_FLUSH:8642 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:8643 case IEEE80211_AMPDU_TX_OPERATIONAL:8644 /* Firmware offloads Tx aggregation entirely so deny mac802118645 * Tx aggregation requests.8646 */8647 return -EOPNOTSUPP;8648 }8649 8650 return -EINVAL;8651}8652 8653static void8654ath10k_mac_update_rx_channel(struct ath10k *ar,8655 struct ieee80211_chanctx_conf *ctx,8656 struct ieee80211_vif_chanctx_switch *vifs,8657 int n_vifs)8658{8659 struct cfg80211_chan_def *def = NULL;8660 8661 /* Both locks are required because ar->rx_channel is modified. This8662 * allows readers to hold either lock.8663 */8664 lockdep_assert_held(&ar->conf_mutex);8665 lockdep_assert_held(&ar->data_lock);8666 8667 WARN_ON(ctx && vifs);8668 WARN_ON(vifs && !n_vifs);8669 8670 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are8671 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each8672 * ppdu on Rx may reduce performance on low-end systems. It should be8673 * possible to make tables/hashmaps to speed the lookup up (be vary of8674 * cpu data cache lines though regarding sizes) but to keep the initial8675 * implementation simple and less intrusive fallback to the slow lookup8676 * only for multi-channel cases. Single-channel cases will remain to8677 * use the old channel derival and thus performance should not be8678 * affected much.8679 */8680 rcu_read_lock();8681 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {8682 ieee80211_iter_chan_contexts_atomic(ar->hw,8683 ath10k_mac_get_any_chandef_iter,8684 &def);8685 8686 if (vifs)8687 def = &vifs[0].new_ctx->def;8688 8689 ar->rx_channel = def->chan;8690 } else if ((ctx && ath10k_mac_num_chanctxs(ar) == 0) ||8691 (ctx && (ar->state == ATH10K_STATE_RESTARTED))) {8692 /* During driver restart due to firmware assert, since mac802118693 * already has valid channel context for given radio, channel8694 * context iteration return num_chanctx > 0. So fix rx_channel8695 * when restart is in progress.8696 */8697 ar->rx_channel = ctx->def.chan;8698 } else {8699 ar->rx_channel = NULL;8700 }8701 rcu_read_unlock();8702}8703 8704static void8705ath10k_mac_update_vif_chan(struct ath10k *ar,8706 struct ieee80211_vif_chanctx_switch *vifs,8707 int n_vifs)8708{8709 struct ath10k_vif *arvif;8710 int ret;8711 int i;8712 8713 lockdep_assert_held(&ar->conf_mutex);8714 8715 /* First stop monitor interface. Some FW versions crash if there's a8716 * lone monitor interface.8717 */8718 if (ar->monitor_started)8719 ath10k_monitor_stop(ar);8720 8721 for (i = 0; i < n_vifs; i++) {8722 arvif = (void *)vifs[i].vif->drv_priv;8723 8724 ath10k_dbg(ar, ATH10K_DBG_MAC,8725 "mac chanctx switch vdev_id %i freq %u->%u width %d->%d\n",8726 arvif->vdev_id,8727 vifs[i].old_ctx->def.chan->center_freq,8728 vifs[i].new_ctx->def.chan->center_freq,8729 vifs[i].old_ctx->def.width,8730 vifs[i].new_ctx->def.width);8731 8732 if (WARN_ON(!arvif->is_started))8733 continue;8734 8735 if (WARN_ON(!arvif->is_up))8736 continue;8737 8738 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);8739 if (ret) {8740 ath10k_warn(ar, "failed to down vdev %d: %d\n",8741 arvif->vdev_id, ret);8742 continue;8743 }8744 }8745 8746 /* All relevant vdevs are downed and associated channel resources8747 * should be available for the channel switch now.8748 */8749 8750 spin_lock_bh(&ar->data_lock);8751 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);8752 spin_unlock_bh(&ar->data_lock);8753 8754 for (i = 0; i < n_vifs; i++) {8755 arvif = (void *)vifs[i].vif->drv_priv;8756 8757 if (WARN_ON(!arvif->is_started))8758 continue;8759 8760 if (WARN_ON(!arvif->is_up))8761 continue;8762 8763 ret = ath10k_mac_setup_bcn_tmpl(arvif);8764 if (ret)8765 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",8766 ret);8767 8768 ret = ath10k_mac_setup_prb_tmpl(arvif);8769 if (ret)8770 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",8771 ret);8772 8773 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);8774 if (ret) {8775 ath10k_warn(ar, "failed to restart vdev %d: %d\n",8776 arvif->vdev_id, ret);8777 continue;8778 }8779 8780 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,8781 arvif->bssid);8782 if (ret) {8783 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",8784 arvif->vdev_id, ret);8785 continue;8786 }8787 }8788 8789 ath10k_monitor_recalc(ar);8790}8791 8792static int8793ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,8794 struct ieee80211_chanctx_conf *ctx)8795{8796 struct ath10k *ar = hw->priv;8797 8798 ath10k_dbg(ar, ATH10K_DBG_MAC,8799 "mac chanctx add freq %u width %d ptr %pK\n",8800 ctx->def.chan->center_freq, ctx->def.width, ctx);8801 8802 mutex_lock(&ar->conf_mutex);8803 8804 spin_lock_bh(&ar->data_lock);8805 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);8806 spin_unlock_bh(&ar->data_lock);8807 8808 ath10k_recalc_radar_detection(ar);8809 ath10k_monitor_recalc(ar);8810 8811 mutex_unlock(&ar->conf_mutex);8812 8813 return 0;8814}8815 8816static void8817ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,8818 struct ieee80211_chanctx_conf *ctx)8819{8820 struct ath10k *ar = hw->priv;8821 8822 ath10k_dbg(ar, ATH10K_DBG_MAC,8823 "mac chanctx remove freq %u width %d ptr %pK\n",8824 ctx->def.chan->center_freq, ctx->def.width, ctx);8825 8826 mutex_lock(&ar->conf_mutex);8827 8828 spin_lock_bh(&ar->data_lock);8829 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);8830 spin_unlock_bh(&ar->data_lock);8831 8832 ath10k_recalc_radar_detection(ar);8833 ath10k_monitor_recalc(ar);8834 8835 mutex_unlock(&ar->conf_mutex);8836}8837 8838struct ath10k_mac_change_chanctx_arg {8839 struct ieee80211_chanctx_conf *ctx;8840 struct ieee80211_vif_chanctx_switch *vifs;8841 int n_vifs;8842 int next_vif;8843};8844 8845static void8846ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,8847 struct ieee80211_vif *vif)8848{8849 struct ath10k_mac_change_chanctx_arg *arg = data;8850 8851 if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)8852 return;8853 8854 arg->n_vifs++;8855}8856 8857static void8858ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,8859 struct ieee80211_vif *vif)8860{8861 struct ath10k_mac_change_chanctx_arg *arg = data;8862 struct ieee80211_chanctx_conf *ctx;8863 8864 ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);8865 if (ctx != arg->ctx)8866 return;8867 8868 if (WARN_ON(arg->next_vif == arg->n_vifs))8869 return;8870 8871 arg->vifs[arg->next_vif].vif = vif;8872 arg->vifs[arg->next_vif].old_ctx = ctx;8873 arg->vifs[arg->next_vif].new_ctx = ctx;8874 arg->next_vif++;8875}8876 8877static void8878ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,8879 struct ieee80211_chanctx_conf *ctx,8880 u32 changed)8881{8882 struct ath10k *ar = hw->priv;8883 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };8884 8885 mutex_lock(&ar->conf_mutex);8886 8887 ath10k_dbg(ar, ATH10K_DBG_MAC,8888 "mac chanctx change freq %u width %d ptr %pK changed %x\n",8889 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);8890 8891 /* This shouldn't really happen because channel switching should use8892 * switch_vif_chanctx().8893 */8894 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))8895 goto unlock;8896 8897 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {8898 ieee80211_iterate_active_interfaces_atomic(8899 hw,8900 ATH10K_ITER_NORMAL_FLAGS,8901 ath10k_mac_change_chanctx_cnt_iter,8902 &arg);8903 if (arg.n_vifs == 0)8904 goto radar;8905 8906 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),8907 GFP_KERNEL);8908 if (!arg.vifs)8909 goto radar;8910 8911 ieee80211_iterate_active_interfaces_atomic(8912 hw,8913 ATH10K_ITER_NORMAL_FLAGS,8914 ath10k_mac_change_chanctx_fill_iter,8915 &arg);8916 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);8917 kfree(arg.vifs);8918 }8919 8920radar:8921 ath10k_recalc_radar_detection(ar);8922 8923 /* FIXME: How to configure Rx chains properly? */8924 8925 /* No other actions are actually necessary. Firmware maintains channel8926 * definitions per vdev internally and there's no host-side channel8927 * context abstraction to configure, e.g. channel width.8928 */8929 8930unlock:8931 mutex_unlock(&ar->conf_mutex);8932}8933 8934static int8935ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,8936 struct ieee80211_vif *vif,8937 struct ieee80211_bss_conf *link_conf,8938 struct ieee80211_chanctx_conf *ctx)8939{8940 struct ath10k *ar = hw->priv;8941 struct ath10k_vif *arvif = (void *)vif->drv_priv;8942 int ret;8943 8944 mutex_lock(&ar->conf_mutex);8945 8946 ath10k_dbg(ar, ATH10K_DBG_MAC,8947 "mac chanctx assign ptr %pK vdev_id %i\n",8948 ctx, arvif->vdev_id);8949 8950 if (WARN_ON(arvif->is_started)) {8951 mutex_unlock(&ar->conf_mutex);8952 return -EBUSY;8953 }8954 8955 ret = ath10k_vdev_start(arvif, &ctx->def);8956 if (ret) {8957 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",8958 arvif->vdev_id, vif->addr,8959 ctx->def.chan->center_freq, ret);8960 goto err;8961 }8962 8963 arvif->is_started = true;8964 8965 ret = ath10k_mac_vif_setup_ps(arvif);8966 if (ret) {8967 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",8968 arvif->vdev_id, ret);8969 goto err_stop;8970 }8971 8972 if (vif->type == NL80211_IFTYPE_MONITOR) {8973 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);8974 if (ret) {8975 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",8976 arvif->vdev_id, ret);8977 goto err_stop;8978 }8979 8980 arvif->is_up = true;8981 }8982 8983 if (ath10k_mac_can_set_cts_prot(arvif)) {8984 ret = ath10k_mac_set_cts_prot(arvif);8985 if (ret)8986 ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n",8987 arvif->vdev_id, ret);8988 }8989 8990 if (ath10k_peer_stats_enabled(ar) &&8991 ar->hw_params.tx_stats_over_pktlog) {8992 ar->pktlog_filter |= ATH10K_PKTLOG_PEER_STATS;8993 ret = ath10k_wmi_pdev_pktlog_enable(ar,8994 ar->pktlog_filter);8995 if (ret) {8996 ath10k_warn(ar, "failed to enable pktlog %d\n", ret);8997 goto err_stop;8998 }8999 }9000 9001 mutex_unlock(&ar->conf_mutex);9002 return 0;9003 9004err_stop:9005 ath10k_vdev_stop(arvif);9006 arvif->is_started = false;9007 ath10k_mac_vif_setup_ps(arvif);9008 9009err:9010 mutex_unlock(&ar->conf_mutex);9011 return ret;9012}9013 9014static void9015ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,9016 struct ieee80211_vif *vif,9017 struct ieee80211_bss_conf *link_conf,9018 struct ieee80211_chanctx_conf *ctx)9019{9020 struct ath10k *ar = hw->priv;9021 struct ath10k_vif *arvif = (void *)vif->drv_priv;9022 int ret;9023 9024 mutex_lock(&ar->conf_mutex);9025 9026 ath10k_dbg(ar, ATH10K_DBG_MAC,9027 "mac chanctx unassign ptr %pK vdev_id %i\n",9028 ctx, arvif->vdev_id);9029 9030 WARN_ON(!arvif->is_started);9031 9032 if (vif->type == NL80211_IFTYPE_MONITOR) {9033 WARN_ON(!arvif->is_up);9034 9035 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);9036 if (ret)9037 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",9038 arvif->vdev_id, ret);9039 9040 arvif->is_up = false;9041 }9042 9043 ret = ath10k_vdev_stop(arvif);9044 if (ret)9045 ath10k_warn(ar, "failed to stop vdev %i: %d\n",9046 arvif->vdev_id, ret);9047 9048 arvif->is_started = false;9049 9050 mutex_unlock(&ar->conf_mutex);9051}9052 9053static int9054ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,9055 struct ieee80211_vif_chanctx_switch *vifs,9056 int n_vifs,9057 enum ieee80211_chanctx_switch_mode mode)9058{9059 struct ath10k *ar = hw->priv;9060 9061 mutex_lock(&ar->conf_mutex);9062 9063 ath10k_dbg(ar, ATH10K_DBG_MAC,9064 "mac chanctx switch n_vifs %d mode %d\n",9065 n_vifs, mode);9066 ath10k_mac_update_vif_chan(ar, vifs, n_vifs);9067 9068 mutex_unlock(&ar->conf_mutex);9069 return 0;9070}9071 9072static void ath10k_mac_op_sta_pre_rcu_remove(struct ieee80211_hw *hw,9073 struct ieee80211_vif *vif,9074 struct ieee80211_sta *sta)9075{9076 struct ath10k *ar;9077 struct ath10k_peer *peer;9078 9079 ar = hw->priv;9080 9081 list_for_each_entry(peer, &ar->peers, list)9082 if (peer->sta == sta)9083 peer->removed = true;9084}9085 9086/* HT MCS parameters with Nss = 1 */9087static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss1[] = {9088 /* MCS L20 L40 S20 S40 */9089 {0, { 65, 135, 72, 150} },9090 {1, { 130, 270, 144, 300} },9091 {2, { 195, 405, 217, 450} },9092 {3, { 260, 540, 289, 600} },9093 {4, { 390, 810, 433, 900} },9094 {5, { 520, 1080, 578, 1200} },9095 {6, { 585, 1215, 650, 1350} },9096 {7, { 650, 1350, 722, 1500} }9097};9098 9099/* HT MCS parameters with Nss = 2 */9100static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss2[] = {9101 /* MCS L20 L40 S20 S40 */9102 {0, {130, 270, 144, 300} },9103 {1, {260, 540, 289, 600} },9104 {2, {390, 810, 433, 900} },9105 {3, {520, 1080, 578, 1200} },9106 {4, {780, 1620, 867, 1800} },9107 {5, {1040, 2160, 1156, 2400} },9108 {6, {1170, 2430, 1300, 2700} },9109 {7, {1300, 2700, 1444, 3000} }9110};9111 9112/* MCS parameters with Nss = 1 */9113static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss1[] = {9114 /* MCS L80 S80 L40 S40 L20 S20 */9115 {0, {293, 325}, {135, 150}, {65, 72} },9116 {1, {585, 650}, {270, 300}, {130, 144} },9117 {2, {878, 975}, {405, 450}, {195, 217} },9118 {3, {1170, 1300}, {540, 600}, {260, 289} },9119 {4, {1755, 1950}, {810, 900}, {390, 433} },9120 {5, {2340, 2600}, {1080, 1200}, {520, 578} },9121 {6, {2633, 2925}, {1215, 1350}, {585, 650} },9122 {7, {2925, 3250}, {1350, 1500}, {650, 722} },9123 {8, {3510, 3900}, {1620, 1800}, {780, 867} },9124 {9, {3900, 4333}, {1800, 2000}, {780, 867} }9125};9126 9127/*MCS parameters with Nss = 2 */9128static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss2[] = {9129 /* MCS L80 S80 L40 S40 L20 S20 */9130 {0, {585, 650}, {270, 300}, {130, 144} },9131 {1, {1170, 1300}, {540, 600}, {260, 289} },9132 {2, {1755, 1950}, {810, 900}, {390, 433} },9133 {3, {2340, 2600}, {1080, 1200}, {520, 578} },9134 {4, {3510, 3900}, {1620, 1800}, {780, 867} },9135 {5, {4680, 5200}, {2160, 2400}, {1040, 1156} },9136 {6, {5265, 5850}, {2430, 2700}, {1170, 1300} },9137 {7, {5850, 6500}, {2700, 3000}, {1300, 1444} },9138 {8, {7020, 7800}, {3240, 3600}, {1560, 1733} },9139 {9, {7800, 8667}, {3600, 4000}, {1560, 1733} }9140};9141 9142static void ath10k_mac_get_rate_flags_ht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs,9143 u8 *flags, u8 *bw)9144{9145 struct ath10k_index_ht_data_rate_type *mcs_rate;9146 u8 index;9147 size_t len_nss1 = ARRAY_SIZE(supported_ht_mcs_rate_nss1);9148 size_t len_nss2 = ARRAY_SIZE(supported_ht_mcs_rate_nss2);9149 9150 if (mcs >= (len_nss1 + len_nss2)) {9151 ath10k_warn(ar, "not supported mcs %d in current rate table", mcs);9152 return;9153 }9154 9155 mcs_rate = (struct ath10k_index_ht_data_rate_type *)9156 ((nss == 1) ? &supported_ht_mcs_rate_nss1 :9157 &supported_ht_mcs_rate_nss2);9158 9159 if (mcs >= len_nss1)9160 index = mcs - len_nss1;9161 else9162 index = mcs;9163 9164 if (rate == mcs_rate[index].supported_rate[0]) {9165 *bw = RATE_INFO_BW_20;9166 } else if (rate == mcs_rate[index].supported_rate[1]) {9167 *bw |= RATE_INFO_BW_40;9168 } else if (rate == mcs_rate[index].supported_rate[2]) {9169 *bw |= RATE_INFO_BW_20;9170 *flags |= RATE_INFO_FLAGS_SHORT_GI;9171 } else if (rate == mcs_rate[index].supported_rate[3]) {9172 *bw |= RATE_INFO_BW_40;9173 *flags |= RATE_INFO_FLAGS_SHORT_GI;9174 } else {9175 ath10k_warn(ar, "invalid ht params rate %d 100kbps nss %d mcs %d",9176 rate, nss, mcs);9177 }9178}9179 9180static void ath10k_mac_get_rate_flags_vht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs,9181 u8 *flags, u8 *bw)9182{9183 struct ath10k_index_vht_data_rate_type *mcs_rate;9184 9185 mcs_rate = (struct ath10k_index_vht_data_rate_type *)9186 ((nss == 1) ? &supported_vht_mcs_rate_nss1 :9187 &supported_vht_mcs_rate_nss2);9188 9189 if (rate == mcs_rate[mcs].supported_VHT80_rate[0]) {9190 *bw = RATE_INFO_BW_80;9191 } else if (rate == mcs_rate[mcs].supported_VHT80_rate[1]) {9192 *bw = RATE_INFO_BW_80;9193 *flags |= RATE_INFO_FLAGS_SHORT_GI;9194 } else if (rate == mcs_rate[mcs].supported_VHT40_rate[0]) {9195 *bw = RATE_INFO_BW_40;9196 } else if (rate == mcs_rate[mcs].supported_VHT40_rate[1]) {9197 *bw = RATE_INFO_BW_40;9198 *flags |= RATE_INFO_FLAGS_SHORT_GI;9199 } else if (rate == mcs_rate[mcs].supported_VHT20_rate[0]) {9200 *bw = RATE_INFO_BW_20;9201 } else if (rate == mcs_rate[mcs].supported_VHT20_rate[1]) {9202 *bw = RATE_INFO_BW_20;9203 *flags |= RATE_INFO_FLAGS_SHORT_GI;9204 } else {9205 ath10k_warn(ar, "invalid vht params rate %d 100kbps nss %d mcs %d",9206 rate, nss, mcs);9207 }9208}9209 9210static void ath10k_mac_get_rate_flags(struct ath10k *ar, u32 rate,9211 enum ath10k_phy_mode mode, u8 nss, u8 mcs,9212 u8 *flags, u8 *bw)9213{9214 if (mode == ATH10K_PHY_MODE_HT) {9215 *flags = RATE_INFO_FLAGS_MCS;9216 ath10k_mac_get_rate_flags_ht(ar, rate, nss, mcs, flags, bw);9217 } else if (mode == ATH10K_PHY_MODE_VHT) {9218 *flags = RATE_INFO_FLAGS_VHT_MCS;9219 ath10k_mac_get_rate_flags_vht(ar, rate, nss, mcs, flags, bw);9220 }9221}9222 9223static void ath10k_mac_parse_bitrate(struct ath10k *ar, u32 rate_code,9224 u32 bitrate_kbps, struct rate_info *rate)9225{9226 enum ath10k_phy_mode mode = ATH10K_PHY_MODE_LEGACY;9227 enum wmi_rate_preamble preamble = WMI_TLV_GET_HW_RC_PREAM_V1(rate_code);9228 u8 nss = WMI_TLV_GET_HW_RC_NSS_V1(rate_code) + 1;9229 u8 mcs = WMI_TLV_GET_HW_RC_RATE_V1(rate_code);9230 u8 flags = 0, bw = 0;9231 9232 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac parse rate code 0x%x bitrate %d kbps\n",9233 rate_code, bitrate_kbps);9234 9235 if (preamble == WMI_RATE_PREAMBLE_HT)9236 mode = ATH10K_PHY_MODE_HT;9237 else if (preamble == WMI_RATE_PREAMBLE_VHT)9238 mode = ATH10K_PHY_MODE_VHT;9239 9240 ath10k_mac_get_rate_flags(ar, bitrate_kbps / 100, mode, nss, mcs, &flags, &bw);9241 9242 ath10k_dbg(ar, ATH10K_DBG_MAC,9243 "mac parse bitrate preamble %d mode %d nss %d mcs %d flags %x bw %d\n",9244 preamble, mode, nss, mcs, flags, bw);9245 9246 rate->flags = flags;9247 rate->bw = bw;9248 rate->legacy = bitrate_kbps / 100;9249 rate->nss = nss;9250 rate->mcs = mcs;9251}9252 9253static void ath10k_mac_sta_get_peer_stats_info(struct ath10k *ar,9254 struct ieee80211_sta *sta,9255 struct station_info *sinfo)9256{9257 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;9258 struct ath10k_peer *peer;9259 unsigned long time_left;9260 int ret;9261 9262 if (!(ar->hw_params.supports_peer_stats_info &&9263 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA))9264 return;9265 9266 spin_lock_bh(&ar->data_lock);9267 peer = ath10k_peer_find(ar, arsta->arvif->vdev_id, sta->addr);9268 spin_unlock_bh(&ar->data_lock);9269 if (!peer)9270 return;9271 9272 reinit_completion(&ar->peer_stats_info_complete);9273 9274 ret = ath10k_wmi_request_peer_stats_info(ar,9275 arsta->arvif->vdev_id,9276 WMI_REQUEST_ONE_PEER_STATS_INFO,9277 arsta->arvif->bssid,9278 0);9279 if (ret && ret != -EOPNOTSUPP) {9280 ath10k_warn(ar, "could not request peer stats info: %d\n", ret);9281 return;9282 }9283 9284 time_left = wait_for_completion_timeout(&ar->peer_stats_info_complete, 3 * HZ);9285 if (time_left == 0) {9286 ath10k_warn(ar, "timed out waiting peer stats info\n");9287 return;9288 }9289 9290 if (arsta->rx_rate_code != 0 && arsta->rx_bitrate_kbps != 0) {9291 ath10k_mac_parse_bitrate(ar, arsta->rx_rate_code,9292 arsta->rx_bitrate_kbps,9293 &sinfo->rxrate);9294 9295 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE);9296 arsta->rx_rate_code = 0;9297 arsta->rx_bitrate_kbps = 0;9298 }9299 9300 if (arsta->tx_rate_code != 0 && arsta->tx_bitrate_kbps != 0) {9301 ath10k_mac_parse_bitrate(ar, arsta->tx_rate_code,9302 arsta->tx_bitrate_kbps,9303 &sinfo->txrate);9304 9305 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);9306 arsta->tx_rate_code = 0;9307 arsta->tx_bitrate_kbps = 0;9308 }9309}9310 9311static void ath10k_sta_statistics(struct ieee80211_hw *hw,9312 struct ieee80211_vif *vif,9313 struct ieee80211_sta *sta,9314 struct station_info *sinfo)9315{9316 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;9317 struct ath10k *ar = arsta->arvif->ar;9318 9319 if (!ath10k_peer_stats_enabled(ar))9320 return;9321 9322 mutex_lock(&ar->conf_mutex);9323 ath10k_debug_fw_stats_request(ar);9324 mutex_unlock(&ar->conf_mutex);9325 9326 sinfo->rx_duration = arsta->rx_duration;9327 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);9328 9329 if (arsta->txrate.legacy || arsta->txrate.nss) {9330 if (arsta->txrate.legacy) {9331 sinfo->txrate.legacy = arsta->txrate.legacy;9332 } else {9333 sinfo->txrate.mcs = arsta->txrate.mcs;9334 sinfo->txrate.nss = arsta->txrate.nss;9335 sinfo->txrate.bw = arsta->txrate.bw;9336 }9337 sinfo->txrate.flags = arsta->txrate.flags;9338 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);9339 }9340 9341 if (ar->htt.disable_tx_comp) {9342 sinfo->tx_failed = arsta->tx_failed;9343 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);9344 }9345 9346 sinfo->tx_retries = arsta->tx_retries;9347 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES);9348 9349 ath10k_mac_sta_get_peer_stats_info(ar, sta, sinfo);9350}9351 9352static int ath10k_mac_op_set_tid_config(struct ieee80211_hw *hw,9353 struct ieee80211_vif *vif,9354 struct ieee80211_sta *sta,9355 struct cfg80211_tid_config *tid_config)9356{9357 struct ath10k *ar = hw->priv;9358 struct ath10k_vif *arvif = (void *)vif->drv_priv;9359 struct ath10k_mac_iter_tid_conf_data data = {};9360 struct wmi_per_peer_per_tid_cfg_arg arg = {};9361 int ret, i;9362 9363 mutex_lock(&ar->conf_mutex);9364 arg.vdev_id = arvif->vdev_id;9365 9366 arvif->tids_rst = 0;9367 memset(arvif->tid_conf_changed, 0, sizeof(arvif->tid_conf_changed));9368 9369 for (i = 0; i < tid_config->n_tid_conf; i++) {9370 ret = ath10k_mac_parse_tid_config(ar, sta, vif,9371 &tid_config->tid_conf[i],9372 &arg);9373 if (ret)9374 goto exit;9375 }9376 9377 ret = 0;9378 9379 if (sta)9380 goto exit;9381 9382 arvif->tids_rst = 0;9383 data.curr_vif = vif;9384 data.ar = ar;9385 9386 ieee80211_iterate_stations_atomic(hw, ath10k_mac_vif_stations_tid_conf,9387 &data);9388 9389exit:9390 mutex_unlock(&ar->conf_mutex);9391 return ret;9392}9393 9394static int ath10k_mac_op_reset_tid_config(struct ieee80211_hw *hw,9395 struct ieee80211_vif *vif,9396 struct ieee80211_sta *sta,9397 u8 tids)9398{9399 struct ath10k_vif *arvif = (void *)vif->drv_priv;9400 struct ath10k_mac_iter_tid_conf_data data = {};9401 struct ath10k *ar = hw->priv;9402 int ret = 0;9403 9404 mutex_lock(&ar->conf_mutex);9405 9406 if (sta) {9407 arvif->tids_rst = 0;9408 ret = ath10k_mac_reset_tid_config(ar, sta, arvif, tids);9409 goto exit;9410 }9411 9412 arvif->tids_rst = tids;9413 data.curr_vif = vif;9414 data.ar = ar;9415 ieee80211_iterate_stations_atomic(hw, ath10k_mac_vif_stations_tid_conf,9416 &data);9417 9418exit:9419 mutex_unlock(&ar->conf_mutex);9420 return ret;9421}9422 9423static const struct ieee80211_ops ath10k_ops = {9424 .tx = ath10k_mac_op_tx,9425 .wake_tx_queue = ath10k_mac_op_wake_tx_queue,9426 .start = ath10k_start,9427 .stop = ath10k_stop,9428 .config = ath10k_config,9429 .add_interface = ath10k_add_interface,9430 .update_vif_offload = ath10k_update_vif_offload,9431 .remove_interface = ath10k_remove_interface,9432 .configure_filter = ath10k_configure_filter,9433 .bss_info_changed = ath10k_bss_info_changed,9434 .set_coverage_class = ath10k_mac_op_set_coverage_class,9435 .hw_scan = ath10k_hw_scan,9436 .cancel_hw_scan = ath10k_cancel_hw_scan,9437 .set_key = ath10k_set_key,9438 .set_default_unicast_key = ath10k_set_default_unicast_key,9439 .sta_state = ath10k_sta_state,9440 .sta_set_txpwr = ath10k_sta_set_txpwr,9441 .conf_tx = ath10k_conf_tx,9442 .remain_on_channel = ath10k_remain_on_channel,9443 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,9444 .set_rts_threshold = ath10k_set_rts_threshold,9445 .set_frag_threshold = ath10k_mac_op_set_frag_threshold,9446 .flush = ath10k_flush,9447 .tx_last_beacon = ath10k_tx_last_beacon,9448 .set_antenna = ath10k_set_antenna,9449 .get_antenna = ath10k_get_antenna,9450 .reconfig_complete = ath10k_reconfig_complete,9451 .get_survey = ath10k_get_survey,9452 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask,9453 .sta_rc_update = ath10k_sta_rc_update,9454 .offset_tsf = ath10k_offset_tsf,9455 .ampdu_action = ath10k_ampdu_action,9456 .get_et_sset_count = ath10k_debug_get_et_sset_count,9457 .get_et_stats = ath10k_debug_get_et_stats,9458 .get_et_strings = ath10k_debug_get_et_strings,9459 .add_chanctx = ath10k_mac_op_add_chanctx,9460 .remove_chanctx = ath10k_mac_op_remove_chanctx,9461 .change_chanctx = ath10k_mac_op_change_chanctx,9462 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx,9463 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx,9464 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx,9465 .sta_pre_rcu_remove = ath10k_mac_op_sta_pre_rcu_remove,9466 .sta_statistics = ath10k_sta_statistics,9467 .set_tid_config = ath10k_mac_op_set_tid_config,9468 .reset_tid_config = ath10k_mac_op_reset_tid_config,9469 9470 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)9471 9472#ifdef CONFIG_PM9473 .suspend = ath10k_wow_op_suspend,9474 .resume = ath10k_wow_op_resume,9475 .set_wakeup = ath10k_wow_op_set_wakeup,9476#endif9477#ifdef CONFIG_MAC80211_DEBUGFS9478 .sta_add_debugfs = ath10k_sta_add_debugfs,9479#endif9480 .set_sar_specs = ath10k_mac_set_sar_specs,9481};9482 9483#define CHAN2G(_channel, _freq, _flags) { \9484 .band = NL80211_BAND_2GHZ, \9485 .hw_value = (_channel), \9486 .center_freq = (_freq), \9487 .flags = (_flags), \9488 .max_antenna_gain = 0, \9489 .max_power = 30, \9490}9491 9492#define CHAN5G(_channel, _freq, _flags) { \9493 .band = NL80211_BAND_5GHZ, \9494 .hw_value = (_channel), \9495 .center_freq = (_freq), \9496 .flags = (_flags), \9497 .max_antenna_gain = 0, \9498 .max_power = 30, \9499}9500 9501static const struct ieee80211_channel ath10k_2ghz_channels[] = {9502 CHAN2G(1, 2412, 0),9503 CHAN2G(2, 2417, 0),9504 CHAN2G(3, 2422, 0),9505 CHAN2G(4, 2427, 0),9506 CHAN2G(5, 2432, 0),9507 CHAN2G(6, 2437, 0),9508 CHAN2G(7, 2442, 0),9509 CHAN2G(8, 2447, 0),9510 CHAN2G(9, 2452, 0),9511 CHAN2G(10, 2457, 0),9512 CHAN2G(11, 2462, 0),9513 CHAN2G(12, 2467, 0),9514 CHAN2G(13, 2472, 0),9515 CHAN2G(14, 2484, 0),9516};9517 9518static const struct ieee80211_channel ath10k_5ghz_channels[] = {9519 CHAN5G(36, 5180, 0),9520 CHAN5G(40, 5200, 0),9521 CHAN5G(44, 5220, 0),9522 CHAN5G(48, 5240, 0),9523 CHAN5G(52, 5260, 0),9524 CHAN5G(56, 5280, 0),9525 CHAN5G(60, 5300, 0),9526 CHAN5G(64, 5320, 0),9527 CHAN5G(100, 5500, 0),9528 CHAN5G(104, 5520, 0),9529 CHAN5G(108, 5540, 0),9530 CHAN5G(112, 5560, 0),9531 CHAN5G(116, 5580, 0),9532 CHAN5G(120, 5600, 0),9533 CHAN5G(124, 5620, 0),9534 CHAN5G(128, 5640, 0),9535 CHAN5G(132, 5660, 0),9536 CHAN5G(136, 5680, 0),9537 CHAN5G(140, 5700, 0),9538 CHAN5G(144, 5720, 0),9539 CHAN5G(149, 5745, 0),9540 CHAN5G(153, 5765, 0),9541 CHAN5G(157, 5785, 0),9542 CHAN5G(161, 5805, 0),9543 CHAN5G(165, 5825, 0),9544 CHAN5G(169, 5845, 0),9545 CHAN5G(173, 5865, 0),9546 /* If you add more, you may need to change ATH10K_MAX_5G_CHAN */9547 /* And you will definitely need to change ATH10K_NUM_CHANS in core.h */9548};9549 9550struct ath10k *ath10k_mac_create(size_t priv_size)9551{9552 struct ieee80211_hw *hw;9553 struct ieee80211_ops *ops;9554 struct ath10k *ar;9555 9556 ops = kmemdup(&ath10k_ops, sizeof(ath10k_ops), GFP_KERNEL);9557 if (!ops)9558 return NULL;9559 9560 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, ops);9561 if (!hw) {9562 kfree(ops);9563 return NULL;9564 }9565 9566 ar = hw->priv;9567 ar->hw = hw;9568 ar->ops = ops;9569 9570 return ar;9571}9572 9573void ath10k_mac_destroy(struct ath10k *ar)9574{9575 struct ieee80211_ops *ops = ar->ops;9576 9577 ieee80211_free_hw(ar->hw);9578 kfree(ops);9579}9580 9581static const struct ieee80211_iface_limit ath10k_if_limits[] = {9582 {9583 .max = 8,9584 .types = BIT(NL80211_IFTYPE_STATION)9585 | BIT(NL80211_IFTYPE_P2P_CLIENT)9586 },9587 {9588 .max = 3,9589 .types = BIT(NL80211_IFTYPE_P2P_GO)9590 },9591 {9592 .max = 1,9593 .types = BIT(NL80211_IFTYPE_P2P_DEVICE)9594 },9595 {9596 .max = 7,9597 .types = BIT(NL80211_IFTYPE_AP)9598#ifdef CONFIG_MAC80211_MESH9599 | BIT(NL80211_IFTYPE_MESH_POINT)9600#endif9601 },9602};9603 9604static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {9605 {9606 .max = 8,9607 .types = BIT(NL80211_IFTYPE_AP)9608#ifdef CONFIG_MAC80211_MESH9609 | BIT(NL80211_IFTYPE_MESH_POINT)9610#endif9611 },9612 {9613 .max = 1,9614 .types = BIT(NL80211_IFTYPE_STATION)9615 },9616};9617 9618static const struct ieee80211_iface_combination ath10k_if_comb[] = {9619 {9620 .limits = ath10k_if_limits,9621 .n_limits = ARRAY_SIZE(ath10k_if_limits),9622 .max_interfaces = 8,9623 .num_different_channels = 1,9624 .beacon_int_infra_match = true,9625 },9626};9627 9628static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {9629 {9630 .limits = ath10k_10x_if_limits,9631 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),9632 .max_interfaces = 8,9633 .num_different_channels = 1,9634 .beacon_int_infra_match = true,9635 .beacon_int_min_gcd = 1,9636#ifdef CONFIG_ATH10K_DFS_CERTIFIED9637 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |9638 BIT(NL80211_CHAN_WIDTH_20) |9639 BIT(NL80211_CHAN_WIDTH_40) |9640 BIT(NL80211_CHAN_WIDTH_80),9641#endif9642 },9643};9644 9645static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {9646 {9647 .max = 2,9648 .types = BIT(NL80211_IFTYPE_STATION),9649 },9650 {9651 .max = 2,9652 .types = BIT(NL80211_IFTYPE_AP) |9653#ifdef CONFIG_MAC80211_MESH9654 BIT(NL80211_IFTYPE_MESH_POINT) |9655#endif9656 BIT(NL80211_IFTYPE_P2P_CLIENT) |9657 BIT(NL80211_IFTYPE_P2P_GO),9658 },9659 {9660 .max = 1,9661 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),9662 },9663};9664 9665static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {9666 {9667 .max = 2,9668 .types = BIT(NL80211_IFTYPE_STATION),9669 },9670 {9671 .max = 2,9672 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),9673 },9674 {9675 .max = 1,9676 .types = BIT(NL80211_IFTYPE_AP) |9677#ifdef CONFIG_MAC80211_MESH9678 BIT(NL80211_IFTYPE_MESH_POINT) |9679#endif9680 BIT(NL80211_IFTYPE_P2P_GO),9681 },9682 {9683 .max = 1,9684 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),9685 },9686};9687 9688static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {9689 {9690 .max = 1,9691 .types = BIT(NL80211_IFTYPE_STATION),9692 },9693 {9694 .max = 1,9695 .types = BIT(NL80211_IFTYPE_ADHOC),9696 },9697};9698 9699/* FIXME: This is not thoroughly tested. These combinations may over- or9700 * underestimate hw/fw capabilities.9701 */9702static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {9703 {9704 .limits = ath10k_tlv_if_limit,9705 .num_different_channels = 1,9706 .max_interfaces = 4,9707 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),9708 },9709 {9710 .limits = ath10k_tlv_if_limit_ibss,9711 .num_different_channels = 1,9712 .max_interfaces = 2,9713 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),9714 },9715};9716 9717static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {9718 {9719 .limits = ath10k_tlv_if_limit,9720 .num_different_channels = 1,9721 .max_interfaces = 4,9722 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),9723 },9724 {9725 .limits = ath10k_tlv_qcs_if_limit,9726 .num_different_channels = 2,9727 .max_interfaces = 4,9728 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),9729 },9730 {9731 .limits = ath10k_tlv_if_limit_ibss,9732 .num_different_channels = 1,9733 .max_interfaces = 2,9734 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),9735 },9736};9737 9738static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {9739 {9740 .max = 1,9741 .types = BIT(NL80211_IFTYPE_STATION),9742 },9743 {9744 .max = 16,9745 .types = BIT(NL80211_IFTYPE_AP)9746#ifdef CONFIG_MAC80211_MESH9747 | BIT(NL80211_IFTYPE_MESH_POINT)9748#endif9749 },9750};9751 9752static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {9753 {9754 .limits = ath10k_10_4_if_limits,9755 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),9756 .max_interfaces = 16,9757 .num_different_channels = 1,9758 .beacon_int_infra_match = true,9759 .beacon_int_min_gcd = 1,9760#ifdef CONFIG_ATH10K_DFS_CERTIFIED9761 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |9762 BIT(NL80211_CHAN_WIDTH_20) |9763 BIT(NL80211_CHAN_WIDTH_40) |9764 BIT(NL80211_CHAN_WIDTH_80) |9765 BIT(NL80211_CHAN_WIDTH_80P80) |9766 BIT(NL80211_CHAN_WIDTH_160),9767#endif9768 },9769};9770 9771static const struct9772ieee80211_iface_combination ath10k_10_4_bcn_int_if_comb[] = {9773 {9774 .limits = ath10k_10_4_if_limits,9775 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),9776 .max_interfaces = 16,9777 .num_different_channels = 1,9778 .beacon_int_infra_match = true,9779 .beacon_int_min_gcd = 100,9780#ifdef CONFIG_ATH10K_DFS_CERTIFIED9781 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |9782 BIT(NL80211_CHAN_WIDTH_20) |9783 BIT(NL80211_CHAN_WIDTH_40) |9784 BIT(NL80211_CHAN_WIDTH_80) |9785 BIT(NL80211_CHAN_WIDTH_80P80) |9786 BIT(NL80211_CHAN_WIDTH_160),9787#endif9788 },9789};9790 9791static void ath10k_get_arvif_iter(void *data, u8 *mac,9792 struct ieee80211_vif *vif)9793{9794 struct ath10k_vif_iter *arvif_iter = data;9795 struct ath10k_vif *arvif = (void *)vif->drv_priv;9796 9797 if (arvif->vdev_id == arvif_iter->vdev_id)9798 arvif_iter->arvif = arvif;9799}9800 9801struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)9802{9803 struct ath10k_vif_iter arvif_iter;9804 9805 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));9806 arvif_iter.vdev_id = vdev_id;9807 9808 ieee80211_iterate_active_interfaces_atomic(ar->hw,9809 ATH10K_ITER_RESUME_FLAGS,9810 ath10k_get_arvif_iter,9811 &arvif_iter);9812 if (!arvif_iter.arvif) {9813 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);9814 return NULL;9815 }9816 9817 return arvif_iter.arvif;9818}9819 9820#define WRD_METHOD "WRDD"9821#define WRDD_WIFI (0x07)9822 9823static u32 ath10k_mac_wrdd_get_mcc(struct ath10k *ar, union acpi_object *wrdd)9824{9825 union acpi_object *mcc_pkg;9826 union acpi_object *domain_type;9827 union acpi_object *mcc_value;9828 u32 i;9829 9830 if (wrdd->type != ACPI_TYPE_PACKAGE ||9831 wrdd->package.count < 2 ||9832 wrdd->package.elements[0].type != ACPI_TYPE_INTEGER ||9833 wrdd->package.elements[0].integer.value != 0) {9834 ath10k_warn(ar, "ignoring malformed/unsupported wrdd structure\n");9835 return 0;9836 }9837 9838 for (i = 1; i < wrdd->package.count; ++i) {9839 mcc_pkg = &wrdd->package.elements[i];9840 9841 if (mcc_pkg->type != ACPI_TYPE_PACKAGE)9842 continue;9843 if (mcc_pkg->package.count < 2)9844 continue;9845 if (mcc_pkg->package.elements[0].type != ACPI_TYPE_INTEGER ||9846 mcc_pkg->package.elements[1].type != ACPI_TYPE_INTEGER)9847 continue;9848 9849 domain_type = &mcc_pkg->package.elements[0];9850 if (domain_type->integer.value != WRDD_WIFI)9851 continue;9852 9853 mcc_value = &mcc_pkg->package.elements[1];9854 return mcc_value->integer.value;9855 }9856 return 0;9857}9858 9859static int ath10k_mac_get_wrdd_regulatory(struct ath10k *ar, u16 *rd)9860{9861 acpi_handle root_handle;9862 acpi_handle handle;9863 struct acpi_buffer wrdd = {ACPI_ALLOCATE_BUFFER, NULL};9864 acpi_status status;9865 u32 alpha2_code;9866 char alpha2[3];9867 9868 root_handle = ACPI_HANDLE(ar->dev);9869 if (!root_handle)9870 return -EOPNOTSUPP;9871 9872 status = acpi_get_handle(root_handle, (acpi_string)WRD_METHOD, &handle);9873 if (ACPI_FAILURE(status)) {9874 ath10k_dbg(ar, ATH10K_DBG_BOOT,9875 "failed to get wrd method %d\n", status);9876 return -EIO;9877 }9878 9879 status = acpi_evaluate_object(handle, NULL, NULL, &wrdd);9880 if (ACPI_FAILURE(status)) {9881 ath10k_dbg(ar, ATH10K_DBG_BOOT,9882 "failed to call wrdc %d\n", status);9883 return -EIO;9884 }9885 9886 alpha2_code = ath10k_mac_wrdd_get_mcc(ar, wrdd.pointer);9887 kfree(wrdd.pointer);9888 if (!alpha2_code)9889 return -EIO;9890 9891 alpha2[0] = (alpha2_code >> 8) & 0xff;9892 alpha2[1] = (alpha2_code >> 0) & 0xff;9893 alpha2[2] = '\0';9894 9895 ath10k_dbg(ar, ATH10K_DBG_BOOT,9896 "regulatory hint from WRDD (alpha2-code): %s\n", alpha2);9897 9898 *rd = ath_regd_find_country_by_name(alpha2);9899 if (*rd == 0xffff)9900 return -EIO;9901 9902 *rd |= COUNTRY_ERD_FLAG;9903 return 0;9904}9905 9906static int ath10k_mac_init_rd(struct ath10k *ar)9907{9908 int ret;9909 u16 rd;9910 9911 ret = ath10k_mac_get_wrdd_regulatory(ar, &rd);9912 if (ret) {9913 ath10k_dbg(ar, ATH10K_DBG_BOOT,9914 "fallback to eeprom programmed regulatory settings\n");9915 rd = ar->hw_eeprom_rd;9916 }9917 9918 ar->ath_common.regulatory.current_rd = rd;9919 return 0;9920}9921 9922int ath10k_mac_register(struct ath10k *ar)9923{9924 static const u32 cipher_suites[] = {9925 WLAN_CIPHER_SUITE_WEP40,9926 WLAN_CIPHER_SUITE_WEP104,9927 WLAN_CIPHER_SUITE_TKIP,9928 WLAN_CIPHER_SUITE_CCMP,9929 9930 /* Do not add hardware supported ciphers before this line.9931 * Allow software encryption for all chips. Don't forget to9932 * update n_cipher_suites below.9933 */9934 WLAN_CIPHER_SUITE_AES_CMAC,9935 WLAN_CIPHER_SUITE_BIP_CMAC_256,9936 WLAN_CIPHER_SUITE_BIP_GMAC_128,9937 WLAN_CIPHER_SUITE_BIP_GMAC_256,9938 9939 /* Only QCA99x0 and QCA4019 variants support GCMP-128, GCMP-2569940 * and CCMP-256 in hardware.9941 */9942 WLAN_CIPHER_SUITE_GCMP,9943 WLAN_CIPHER_SUITE_GCMP_256,9944 WLAN_CIPHER_SUITE_CCMP_256,9945 };9946 struct ieee80211_supported_band *band;9947 void *channels;9948 int ret;9949 9950 if (!is_valid_ether_addr(ar->mac_addr)) {9951 ath10k_warn(ar, "invalid MAC address; choosing random\n");9952 eth_random_addr(ar->mac_addr);9953 }9954 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);9955 9956 SET_IEEE80211_DEV(ar->hw, ar->dev);9957 9958 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +9959 ARRAY_SIZE(ath10k_5ghz_channels)) !=9960 ATH10K_NUM_CHANS);9961 9962 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {9963 channels = kmemdup(ath10k_2ghz_channels,9964 sizeof(ath10k_2ghz_channels),9965 GFP_KERNEL);9966 if (!channels) {9967 ret = -ENOMEM;9968 goto err_free;9969 }9970 9971 band = &ar->mac.sbands[NL80211_BAND_2GHZ];9972 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);9973 band->channels = channels;9974 9975 if (ar->hw_params.cck_rate_map_rev2) {9976 band->n_bitrates = ath10k_g_rates_rev2_size;9977 band->bitrates = ath10k_g_rates_rev2;9978 } else {9979 band->n_bitrates = ath10k_g_rates_size;9980 band->bitrates = ath10k_g_rates;9981 }9982 9983 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;9984 }9985 9986 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {9987 channels = kmemdup(ath10k_5ghz_channels,9988 sizeof(ath10k_5ghz_channels),9989 GFP_KERNEL);9990 if (!channels) {9991 ret = -ENOMEM;9992 goto err_free;9993 }9994 9995 band = &ar->mac.sbands[NL80211_BAND_5GHZ];9996 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);9997 band->channels = channels;9998 band->n_bitrates = ath10k_a_rates_size;9999 band->bitrates = ath10k_a_rates;10000 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;10001 }10002 10003 wiphy_read_of_freq_limits(ar->hw->wiphy);10004 ath10k_mac_setup_ht_vht_cap(ar);10005 10006 ar->hw->wiphy->interface_modes =10007 BIT(NL80211_IFTYPE_STATION) |10008 BIT(NL80211_IFTYPE_AP) |10009 BIT(NL80211_IFTYPE_MESH_POINT);10010 10011 ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask;10012 ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask;10013 10014 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->normal_mode_fw.fw_file.fw_features))10015 ar->hw->wiphy->interface_modes |=10016 BIT(NL80211_IFTYPE_P2P_DEVICE) |10017 BIT(NL80211_IFTYPE_P2P_CLIENT) |10018 BIT(NL80211_IFTYPE_P2P_GO);10019 10020 ieee80211_hw_set(ar->hw, SIGNAL_DBM);10021 10022 if (!test_bit(ATH10K_FW_FEATURE_NO_PS,10023 ar->running_fw->fw_file.fw_features)) {10024 ieee80211_hw_set(ar->hw, SUPPORTS_PS);10025 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);10026 }10027 10028 ieee80211_hw_set(ar->hw, MFP_CAPABLE);10029 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);10030 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);10031 ieee80211_hw_set(ar->hw, AP_LINK_PS);10032 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);10033 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);10034 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);10035 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);10036 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);10037 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);10038 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);10039 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);10040 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);10041 10042 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))10043 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);10044 10045 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;10046 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;10047 10048 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)10049 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;10050 10051 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {10052 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);10053 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);10054 }10055 10056 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;10057 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;10058 10059 if (test_bit(WMI_SERVICE_NLO, ar->wmi.svc_map)) {10060 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;10061 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;10062 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;10063 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;10064 ar->hw->wiphy->max_sched_scan_plan_interval =10065 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;10066 ar->hw->wiphy->max_sched_scan_plan_iterations =10067 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;10068 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;10069 }10070 10071 ar->hw->vif_data_size = sizeof(struct ath10k_vif);10072 ar->hw->sta_data_size = sizeof(struct ath10k_sta);10073 ar->hw->txq_data_size = sizeof(struct ath10k_txq);10074 10075 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;10076 10077 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {10078 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;10079 10080 /* Firmware delivers WPS/P2P Probe Requests frames to driver so10081 * that userspace (e.g. wpa_supplicant/hostapd) can generate10082 * correct Probe Responses. This is more of a hack advert..10083 */10084 ar->hw->wiphy->probe_resp_offload |=10085 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |10086 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |10087 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;10088 }10089 10090 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map) ||10091 test_bit(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY, ar->wmi.svc_map)) {10092 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;10093 if (test_bit(WMI_SERVICE_TDLS_WIDER_BANDWIDTH, ar->wmi.svc_map))10094 ieee80211_hw_set(ar->hw, TDLS_WIDER_BW);10095 }10096 10097 if (test_bit(WMI_SERVICE_TDLS_UAPSD_BUFFER_STA, ar->wmi.svc_map))10098 ieee80211_hw_set(ar->hw, SUPPORTS_TDLS_BUFFER_STA);10099 10100 if (ath10k_frame_mode == ATH10K_HW_TXRX_ETHERNET) {10101 if (ar->wmi.vdev_param->tx_encap_type !=10102 WMI_VDEV_PARAM_UNSUPPORTED)10103 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD);10104 }10105 10106 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;10107 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;10108 ar->hw->wiphy->max_remain_on_channel_duration = 5000;10109 10110 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;10111 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |10112 NL80211_FEATURE_AP_SCAN;10113 10114 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;10115 10116 ret = ath10k_wow_init(ar);10117 if (ret) {10118 ath10k_warn(ar, "failed to init wow: %d\n", ret);10119 goto err_free;10120 }10121 10122 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);10123 wiphy_ext_feature_set(ar->hw->wiphy,10124 NL80211_EXT_FEATURE_SET_SCAN_DWELL);10125 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_AQL);10126 10127 if (ar->hw_params.mcast_frame_registration)10128 wiphy_ext_feature_set(ar->hw->wiphy,10129 NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS);10130 10131 if (test_bit(WMI_SERVICE_TX_DATA_ACK_RSSI, ar->wmi.svc_map) ||10132 test_bit(WMI_SERVICE_HTT_MGMT_TX_COMP_VALID_FLAGS, ar->wmi.svc_map))10133 wiphy_ext_feature_set(ar->hw->wiphy,10134 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT);10135 10136 if (ath10k_peer_stats_enabled(ar) ||10137 test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map))10138 wiphy_ext_feature_set(ar->hw->wiphy,10139 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS);10140 10141 if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map))10142 wiphy_ext_feature_set(ar->hw->wiphy,10143 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER);10144 10145 if (test_bit(WMI_SERVICE_TX_PWR_PER_PEER, ar->wmi.svc_map))10146 wiphy_ext_feature_set(ar->hw->wiphy,10147 NL80211_EXT_FEATURE_STA_TX_PWR);10148 10149 if (test_bit(WMI_SERVICE_PEER_TID_CONFIGS_SUPPORT, ar->wmi.svc_map)) {10150 ar->hw->wiphy->tid_config_support.vif |=10151 BIT(NL80211_TID_CONFIG_ATTR_NOACK) |10152 BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT) |10153 BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG) |10154 BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL) |10155 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |10156 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE);10157 10158 if (test_bit(WMI_SERVICE_EXT_PEER_TID_CONFIGS_SUPPORT,10159 ar->wmi.svc_map)) {10160 ar->hw->wiphy->tid_config_support.vif |=10161 BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL);10162 }10163 10164 ar->hw->wiphy->tid_config_support.peer =10165 ar->hw->wiphy->tid_config_support.vif;10166 ar->hw->wiphy->max_data_retry_count = ATH10K_MAX_RETRY_COUNT;10167 } else {10168 ar->ops->set_tid_config = NULL;10169 }10170 /*10171 * on LL hardware queues are managed entirely by the FW10172 * so we only advertise to mac we can do the queues thing10173 */10174 ar->hw->queues = IEEE80211_MAX_QUEUES;10175 10176 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is10177 * something that vdev_ids can't reach so that we don't stop the queue10178 * accidentally.10179 */10180 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;10181 10182 switch (ar->running_fw->fw_file.wmi_op_version) {10183 case ATH10K_FW_WMI_OP_VERSION_MAIN:10184 ar->hw->wiphy->iface_combinations = ath10k_if_comb;10185 ar->hw->wiphy->n_iface_combinations =10186 ARRAY_SIZE(ath10k_if_comb);10187 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);10188 break;10189 case ATH10K_FW_WMI_OP_VERSION_TLV:10190 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {10191 ar->hw->wiphy->iface_combinations =10192 ath10k_tlv_qcs_if_comb;10193 ar->hw->wiphy->n_iface_combinations =10194 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);10195 } else {10196 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;10197 ar->hw->wiphy->n_iface_combinations =10198 ARRAY_SIZE(ath10k_tlv_if_comb);10199 }10200 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);10201 break;10202 case ATH10K_FW_WMI_OP_VERSION_10_1:10203 case ATH10K_FW_WMI_OP_VERSION_10_2:10204 case ATH10K_FW_WMI_OP_VERSION_10_2_4:10205 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;10206 ar->hw->wiphy->n_iface_combinations =10207 ARRAY_SIZE(ath10k_10x_if_comb);10208 break;10209 case ATH10K_FW_WMI_OP_VERSION_10_4:10210 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;10211 ar->hw->wiphy->n_iface_combinations =10212 ARRAY_SIZE(ath10k_10_4_if_comb);10213 if (test_bit(WMI_SERVICE_VDEV_DIFFERENT_BEACON_INTERVAL_SUPPORT,10214 ar->wmi.svc_map)) {10215 ar->hw->wiphy->iface_combinations =10216 ath10k_10_4_bcn_int_if_comb;10217 ar->hw->wiphy->n_iface_combinations =10218 ARRAY_SIZE(ath10k_10_4_bcn_int_if_comb);10219 }10220 break;10221 case ATH10K_FW_WMI_OP_VERSION_UNSET:10222 case ATH10K_FW_WMI_OP_VERSION_MAX:10223 WARN_ON(1);10224 ret = -EINVAL;10225 goto err_free;10226 }10227 10228 if (ar->hw_params.dynamic_sar_support)10229 ar->hw->wiphy->sar_capa = &ath10k_sar_capa;10230 10231 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))10232 ar->hw->netdev_features = NETIF_F_HW_CSUM;10233 10234 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) {10235 /* Init ath dfs pattern detector */10236 ar->ath_common.debug_mask = ATH_DBG_DFS;10237 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,10238 NL80211_DFS_UNSET);10239 10240 if (!ar->dfs_detector)10241 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");10242 }10243 10244 ret = ath10k_mac_init_rd(ar);10245 if (ret) {10246 ath10k_err(ar, "failed to derive regdom: %d\n", ret);10247 goto err_dfs_detector_exit;10248 }10249 10250 /* Disable set_coverage_class for chipsets that do not support it. */10251 if (!ar->hw_params.hw_ops->set_coverage_class)10252 ar->ops->set_coverage_class = NULL;10253 10254 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,10255 ath10k_reg_notifier);10256 if (ret) {10257 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);10258 goto err_dfs_detector_exit;10259 }10260 10261 if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) {10262 ar->hw->wiphy->features |=10263 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;10264 }10265 10266 ar->hw->wiphy->cipher_suites = cipher_suites;10267 10268 /* QCA988x and QCA6174 family chips do not support CCMP-256, GCMP-12810269 * and GCMP-256 ciphers in hardware. Fetch number of ciphers supported10270 * from chip specific hw_param table.10271 */10272 if (!ar->hw_params.n_cipher_suites ||10273 ar->hw_params.n_cipher_suites > ARRAY_SIZE(cipher_suites)) {10274 ath10k_err(ar, "invalid hw_params.n_cipher_suites %d\n",10275 ar->hw_params.n_cipher_suites);10276 ar->hw_params.n_cipher_suites = 8;10277 }10278 ar->hw->wiphy->n_cipher_suites = ar->hw_params.n_cipher_suites;10279 10280 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);10281 10282 ar->hw->weight_multiplier = ATH10K_AIRTIME_WEIGHT_MULTIPLIER;10283 10284 ret = ieee80211_register_hw(ar->hw);10285 if (ret) {10286 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);10287 goto err_dfs_detector_exit;10288 }10289 10290 if (test_bit(WMI_SERVICE_PER_PACKET_SW_ENCRYPT, ar->wmi.svc_map)) {10291 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);10292 ar->hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN);10293 }10294 10295 if (!ath_is_world_regd(&ar->ath_common.reg_world_copy) &&10296 !ath_is_world_regd(&ar->ath_common.regulatory)) {10297 ret = regulatory_hint(ar->hw->wiphy,10298 ar->ath_common.regulatory.alpha2);10299 if (ret)10300 goto err_unregister;10301 }10302 10303 return 0;10304 10305err_unregister:10306 ieee80211_unregister_hw(ar->hw);10307 10308err_dfs_detector_exit:10309 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)10310 ar->dfs_detector->exit(ar->dfs_detector);10311 10312err_free:10313 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);10314 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);10315 10316 SET_IEEE80211_DEV(ar->hw, NULL);10317 return ret;10318}10319 10320void ath10k_mac_unregister(struct ath10k *ar)10321{10322 ieee80211_unregister_hw(ar->hw);10323 10324 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)10325 ar->dfs_detector->exit(ar->dfs_detector);10326 10327 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);10328 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);10329 10330 SET_IEEE80211_DEV(ar->hw, NULL);10331}10332