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

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