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

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