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

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