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

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