drivers/net/wireless/ath/ath10k/mac.c

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