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

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