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