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

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