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
 204         if (cmd == DISABLE_KEY) {
 205                 arg.key_cipher = WMI_CIPHER_NONE;
 206                 arg.key_data = NULL;
 207         }
 208
 209         return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
 210 }
 211
 212 static int ath10k_install_key(struct ath10k_vif *arvif,
 213                               struct ieee80211_key_conf *key,
 214                               enum set_key_cmd cmd,
 215                               const u8 *macaddr, u32 flags)
 216 {
 217         struct ath10k *ar = arvif->ar;
 218         int ret;
 219         unsigned long time_left;
 220
 221         lockdep_assert_held(&ar->conf_mutex);
 222
 223         reinit_completion(&ar->install_key_done);
 224
 225         if (arvif->nohwcrypt)
 226                 return 1;
 227
 228         ret = ath10k_send_key(arvif, key, cmd, macaddr, flags);
 229         if (ret)
 230                 return ret;
 231
 232         time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ);
 233         if (time_left == 0)
 234                 return -ETIMEDOUT;
 235
 236         return 0;
 237 }
 238
 239 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
 240                                         const u8 *addr)
 241 {
 242         struct ath10k *ar = arvif->ar;
 243         struct ath10k_peer *peer;
 244         int ret;
 245         int i;
 246         u32 flags;
 247
 248         lockdep_assert_held(&ar->conf_mutex);
 249
 250         if (WARN_ON(arvif->vif->type != NL80211_IFTYPE_AP &&
 251                     arvif->vif->type != NL80211_IFTYPE_ADHOC))
 252                 return -EINVAL;
 253
 254         spin_lock_bh(&ar->data_lock);
 255         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
 256         spin_unlock_bh(&ar->data_lock);
 257
 258         if (!peer)
 259                 return -ENOENT;
 260
 261         for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
 262                 if (arvif->wep_keys[i] == NULL)
 263                         continue;
 264
 265                 switch (arvif->vif->type) {
 266                 case NL80211_IFTYPE_AP:
 267                         flags = WMI_KEY_PAIRWISE;
 268
 269                         if (arvif->def_wep_key_idx == i)
 270                                 flags |= WMI_KEY_TX_USAGE;
 271
 272                         ret = ath10k_install_key(arvif, arvif->wep_keys[i],
 273                                                  SET_KEY, addr, flags);
 274                         if (ret < 0)
 275                                 return ret;
 276                         break;
 277                 case NL80211_IFTYPE_ADHOC:
 278                         ret = ath10k_install_key(arvif, arvif->wep_keys[i],
 279                                                  SET_KEY, addr,
 280                                                  WMI_KEY_PAIRWISE);
 281                         if (ret < 0)
 282                                 return ret;
 283
 284                         ret = ath10k_install_key(arvif, arvif->wep_keys[i],
 285                                                  SET_KEY, addr, WMI_KEY_GROUP);
 286                         if (ret < 0)
 287                                 return ret;
 288                         break;
 289                 default:
 290                         WARN_ON(1);
 291                         return -EINVAL;
 292                 }
 293
 294                 spin_lock_bh(&ar->data_lock);
 295                 peer->keys[i] = arvif->wep_keys[i];
 296                 spin_unlock_bh(&ar->data_lock);
 297         }
 298
 299         /* In some cases (notably with static WEP IBSS with multiple keys)
 300          * multicast Tx becomes broken. Both pairwise and groupwise keys are
 301          * installed already. Using WMI_KEY_TX_USAGE in different combinations
 302          * didn't seem help. Using def_keyid vdev parameter seems to be
 303          * effective so use that.
 304          *
 305          * FIXME: Revisit. Perhaps this can be done in a less hacky way.
 306          */
 307         if (arvif->vif->type != NL80211_IFTYPE_ADHOC)
 308                 return 0;
 309
 310         if (arvif->def_wep_key_idx == -1)
 311                 return 0;
 312
 313         ret = ath10k_wmi_vdev_set_param(arvif->ar,
 314                                         arvif->vdev_id,
 315                                         arvif->ar->wmi.vdev_param->def_keyid,
 316                                         arvif->def_wep_key_idx);
 317         if (ret) {
 318                 ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n",
 319                             arvif->vdev_id, ret);
 320                 return ret;
 321         }
 322
 323         return 0;
 324 }
 325
 326 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
 327                                   const u8 *addr)
 328 {
 329         struct ath10k *ar = arvif->ar;
 330         struct ath10k_peer *peer;
 331         int first_errno = 0;
 332         int ret;
 333         int i;
 334         u32 flags = 0;
 335
 336         lockdep_assert_held(&ar->conf_mutex);
 337
 338         spin_lock_bh(&ar->data_lock);
 339         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
 340         spin_unlock_bh(&ar->data_lock);
 341
 342         if (!peer)
 343                 return -ENOENT;
 344
 345         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
 346                 if (peer->keys[i] == NULL)
 347                         continue;
 348
 349                 /* key flags are not required to delete the key */
 350                 ret = ath10k_install_key(arvif, peer->keys[i],
 351                                          DISABLE_KEY, addr, flags);
 352                 if (ret < 0 && first_errno == 0)
 353                         first_errno = ret;
 354
 355                 if (ret < 0)
 356                         ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
 357                                     i, ret);
 358
 359                 spin_lock_bh(&ar->data_lock);
 360                 peer->keys[i] = NULL;
 361                 spin_unlock_bh(&ar->data_lock);
 362         }
 363
 364         return first_errno;
 365 }
 366
 367 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,
 368                                     u8 keyidx)
 369 {
 370         struct ath10k_peer *peer;
 371         int i;
 372
 373         lockdep_assert_held(&ar->data_lock);
 374
 375         /* We don't know which vdev this peer belongs to,
 376          * since WMI doesn't give us that information.
 377          *
 378          * FIXME: multi-bss needs to be handled.
 379          */
 380         peer = ath10k_peer_find(ar, 0, addr);
 381         if (!peer)
 382                 return false;
 383
 384         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
 385                 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)
 386                         return true;
 387         }
 388
 389         return false;
 390 }
 391
 392 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
 393                                  struct ieee80211_key_conf *key)
 394 {
 395         struct ath10k *ar = arvif->ar;
 396         struct ath10k_peer *peer;
 397         u8 addr[ETH_ALEN];
 398         int first_errno = 0;
 399         int ret;
 400         int i;
 401         u32 flags = 0;
 402
 403         lockdep_assert_held(&ar->conf_mutex);
 404
 405         for (;;) {
 406                 /* since ath10k_install_key we can't hold data_lock all the
 407                  * time, so we try to remove the keys incrementally */
 408                 spin_lock_bh(&ar->data_lock);
 409                 i = 0;
 410                 list_for_each_entry(peer, &ar->peers, list) {
 411                         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
 412                                 if (peer->keys[i] == key) {
 413                                         ether_addr_copy(addr, peer->addr);
 414                                         peer->keys[i] = NULL;
 415                                         break;
 416                                 }
 417                         }
 418
 419                         if (i < ARRAY_SIZE(peer->keys))
 420                                 break;
 421                 }
 422                 spin_unlock_bh(&ar->data_lock);
 423
 424                 if (i == ARRAY_SIZE(peer->keys))
 425                         break;
 426                 /* key flags are not required to delete the key */
 427                 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags);
 428                 if (ret < 0 && first_errno == 0)
 429                         first_errno = ret;
 430
 431                 if (ret)
 432                         ath10k_warn(ar, "failed to remove key for %pM: %d\n",
 433                                     addr, ret);
 434         }
 435
 436         return first_errno;
 437 }
 438
 439 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif,
 440                                          struct ieee80211_key_conf *key)
 441 {
 442         struct ath10k *ar = arvif->ar;
 443         struct ath10k_peer *peer;
 444         int ret;
 445
 446         lockdep_assert_held(&ar->conf_mutex);
 447
 448         list_for_each_entry(peer, &ar->peers, list) {
 449                 if (!memcmp(peer->addr, arvif->vif->addr, ETH_ALEN))
 450                         continue;
 451
 452                 if (!memcmp(peer->addr, arvif->bssid, ETH_ALEN))
 453                         continue;
 454
 455                 if (peer->keys[key->keyidx] == key)
 456                         continue;
 457
 458                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n",
 459                            arvif->vdev_id, key->keyidx);
 460
 461                 ret = ath10k_install_peer_wep_keys(arvif, peer->addr);
 462                 if (ret) {
 463                         ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n",
 464                                     arvif->vdev_id, peer->addr, ret);
 465                         return ret;
 466                 }
 467         }
 468
 469         return 0;
 470 }
 471
 472 /*********************/
 473 /* General utilities */
 474 /*********************/
 475
 476 static inline enum wmi_phy_mode
 477 chan_to_phymode(const struct cfg80211_chan_def *chandef)
 478 {
 479         enum wmi_phy_mode phymode = MODE_UNKNOWN;
 480
 481         switch (chandef->chan->band) {
 482         case IEEE80211_BAND_2GHZ:
 483                 switch (chandef->width) {
 484                 case NL80211_CHAN_WIDTH_20_NOHT:
 485                         if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)
 486                                 phymode = MODE_11B;
 487                         else
 488                                 phymode = MODE_11G;
 489                         break;
 490                 case NL80211_CHAN_WIDTH_20:
 491                         phymode = MODE_11NG_HT20;
 492                         break;
 493                 case NL80211_CHAN_WIDTH_40:
 494                         phymode = MODE_11NG_HT40;
 495                         break;
 496                 case NL80211_CHAN_WIDTH_5:
 497                 case NL80211_CHAN_WIDTH_10:
 498                 case NL80211_CHAN_WIDTH_80:
 499                 case NL80211_CHAN_WIDTH_80P80:
 500                 case NL80211_CHAN_WIDTH_160:
 501                         phymode = MODE_UNKNOWN;
 502                         break;
 503                 }
 504                 break;
 505         case IEEE80211_BAND_5GHZ:
 506                 switch (chandef->width) {
 507                 case NL80211_CHAN_WIDTH_20_NOHT:
 508                         phymode = MODE_11A;
 509                         break;
 510                 case NL80211_CHAN_WIDTH_20:
 511                         phymode = MODE_11NA_HT20;
 512                         break;
 513                 case NL80211_CHAN_WIDTH_40:
 514                         phymode = MODE_11NA_HT40;
 515                         break;
 516                 case NL80211_CHAN_WIDTH_80:
 517                         phymode = MODE_11AC_VHT80;
 518                         break;
 519                 case NL80211_CHAN_WIDTH_5:
 520                 case NL80211_CHAN_WIDTH_10:
 521                 case NL80211_CHAN_WIDTH_80P80:
 522                 case NL80211_CHAN_WIDTH_160:
 523                         phymode = MODE_UNKNOWN;
 524                         break;
 525                 }
 526                 break;
 527         default:
 528                 break;
 529         }
 530
 531         WARN_ON(phymode == MODE_UNKNOWN);
 532         return phymode;
 533 }
 534
 535 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
 536 {
 537 /*
 538  * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
 539  *   0 for no restriction
 540  *   1 for 1/4 us
 541  *   2 for 1/2 us
 542  *   3 for 1 us
 543  *   4 for 2 us
 544  *   5 for 4 us
 545  *   6 for 8 us
 546  *   7 for 16 us
 547  */
 548         switch (mpdudensity) {
 549         case 0:
 550                 return 0;
 551         case 1:
 552         case 2:
 553         case 3:
 554         /* Our lower layer calculations limit our precision to
 555            1 microsecond */
 556                 return 1;
 557         case 4:
 558                 return 2;
 559         case 5:
 560                 return 4;
 561         case 6:
 562                 return 8;
 563         case 7:
 564                 return 16;
 565         default:
 566                 return 0;
 567         }
 568 }
 569
 570 int ath10k_mac_vif_chan(struct ieee80211_vif *vif,
 571                         struct cfg80211_chan_def *def)
 572 {
 573         struct ieee80211_chanctx_conf *conf;
 574
 575         rcu_read_lock();
 576         conf = rcu_dereference(vif->chanctx_conf);
 577         if (!conf) {
 578                 rcu_read_unlock();
 579                 return -ENOENT;
 580         }
 581
 582         *def = conf->def;
 583         rcu_read_unlock();
 584
 585         return 0;
 586 }
 587
 588 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw,
 589                                          struct ieee80211_chanctx_conf *conf,
 590                                          void *data)
 591 {
 592         int *num = data;
 593
 594         (*num)++;
 595 }
 596
 597 static int ath10k_mac_num_chanctxs(struct ath10k *ar)
 598 {
 599         int num = 0;
 600
 601         ieee80211_iter_chan_contexts_atomic(ar->hw,
 602                                             ath10k_mac_num_chanctxs_iter,
 603                                             &num);
 604
 605         return num;
 606 }
 607
 608 static void
 609 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
 610                                 struct ieee80211_chanctx_conf *conf,
 611                                 void *data)
 612 {
 613         struct cfg80211_chan_def **def = data;
 614
 615         *def = &conf->def;
 616 }
 617
 618 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr,
 619                               enum wmi_peer_type peer_type)
 620 {
 621         struct ath10k_vif *arvif;
 622         int num_peers = 0;
 623         int ret;
 624
 625         lockdep_assert_held(&ar->conf_mutex);
 626
 627         num_peers = ar->num_peers;
 628
 629         /* Each vdev consumes a peer entry as well */
 630         list_for_each_entry(arvif, &ar->arvifs, list)
 631                 num_peers++;
 632
 633         if (num_peers >= ar->max_num_peers)
 634                 return -ENOBUFS;
 635
 636         ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type);
 637         if (ret) {
 638                 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
 639                             addr, vdev_id, ret);
 640                 return ret;
 641         }
 642
 643         ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
 644         if (ret) {
 645                 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
 646                             addr, vdev_id, ret);
 647                 return ret;
 648         }
 649
 650         ar->num_peers++;
 651
 652         return 0;
 653 }
 654
 655 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
 656 {
 657         struct ath10k *ar = arvif->ar;
 658         u32 param;
 659         int ret;
 660
 661         param = ar->wmi.pdev_param->sta_kickout_th;
 662         ret = ath10k_wmi_pdev_set_param(ar, param,
 663                                         ATH10K_KICKOUT_THRESHOLD);
 664         if (ret) {
 665                 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
 666                             arvif->vdev_id, ret);
 667                 return ret;
 668         }
 669
 670         param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
 671         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
 672                                         ATH10K_KEEPALIVE_MIN_IDLE);
 673         if (ret) {
 674                 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
 675                             arvif->vdev_id, ret);
 676                 return ret;
 677         }
 678
 679         param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
 680         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
 681                                         ATH10K_KEEPALIVE_MAX_IDLE);
 682         if (ret) {
 683                 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
 684                             arvif->vdev_id, ret);
 685                 return ret;
 686         }
 687
 688         param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
 689         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
 690                                         ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
 691         if (ret) {
 692                 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
 693                             arvif->vdev_id, ret);
 694                 return ret;
 695         }
 696
 697         return 0;
 698 }
 699
 700 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
 701 {
 702         struct ath10k *ar = arvif->ar;
 703         u32 vdev_param;
 704
 705         vdev_param = ar->wmi.vdev_param->rts_threshold;
 706         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
 707 }
 708
 709 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
 710 {
 711         int ret;
 712
 713         lockdep_assert_held(&ar->conf_mutex);
 714
 715         ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
 716         if (ret)
 717                 return ret;
 718
 719         ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
 720         if (ret)
 721                 return ret;
 722
 723         ar->num_peers--;
 724
 725         return 0;
 726 }
 727
 728 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
 729 {
 730         struct ath10k_peer *peer, *tmp;
 731
 732         lockdep_assert_held(&ar->conf_mutex);
 733
 734         spin_lock_bh(&ar->data_lock);
 735         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
 736                 if (peer->vdev_id != vdev_id)
 737                         continue;
 738
 739                 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
 740                             peer->addr, vdev_id);
 741
 742                 list_del(&peer->list);
 743                 kfree(peer);
 744                 ar->num_peers--;
 745         }
 746         spin_unlock_bh(&ar->data_lock);
 747 }
 748
 749 static void ath10k_peer_cleanup_all(struct ath10k *ar)
 750 {
 751         struct ath10k_peer *peer, *tmp;
 752
 753         lockdep_assert_held(&ar->conf_mutex);
 754
 755         spin_lock_bh(&ar->data_lock);
 756         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
 757                 list_del(&peer->list);
 758                 kfree(peer);
 759         }
 760         spin_unlock_bh(&ar->data_lock);
 761
 762         ar->num_peers = 0;
 763         ar->num_stations = 0;
 764 }
 765
 766 static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id,
 767                                        struct ieee80211_sta *sta,
 768                                        enum wmi_tdls_peer_state state)
 769 {
 770         int ret;
 771         struct wmi_tdls_peer_update_cmd_arg arg = {};
 772         struct wmi_tdls_peer_capab_arg cap = {};
 773         struct wmi_channel_arg chan_arg = {};
 774
 775         lockdep_assert_held(&ar->conf_mutex);
 776
 777         arg.vdev_id = vdev_id;
 778         arg.peer_state = state;
 779         ether_addr_copy(arg.addr, sta->addr);
 780
 781         cap.peer_max_sp = sta->max_sp;
 782         cap.peer_uapsd_queues = sta->uapsd_queues;
 783
 784         if (state == WMI_TDLS_PEER_STATE_CONNECTED &&
 785             !sta->tdls_initiator)
 786                 cap.is_peer_responder = 1;
 787
 788         ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg);
 789         if (ret) {
 790                 ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n",
 791                             arg.addr, vdev_id, ret);
 792                 return ret;
 793         }
 794
 795         return 0;
 796 }
 797
 798 /************************/
 799 /* Interface management */
 800 /************************/
 801
 802 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
 803 {
 804         struct ath10k *ar = arvif->ar;
 805
 806         lockdep_assert_held(&ar->data_lock);
 807
 808         if (!arvif->beacon)
 809                 return;
 810
 811         if (!arvif->beacon_buf)
 812                 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
 813                                  arvif->beacon->len, DMA_TO_DEVICE);
 814
 815         if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED &&
 816                     arvif->beacon_state != ATH10K_BEACON_SENT))
 817                 return;
 818
 819         dev_kfree_skb_any(arvif->beacon);
 820
 821         arvif->beacon = NULL;
 822         arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
 823 }
 824
 825 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
 826 {
 827         struct ath10k *ar = arvif->ar;
 828
 829         lockdep_assert_held(&ar->data_lock);
 830
 831         ath10k_mac_vif_beacon_free(arvif);
 832
 833         if (arvif->beacon_buf) {
 834                 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
 835                                   arvif->beacon_buf, arvif->beacon_paddr);
 836                 arvif->beacon_buf = NULL;
 837         }
 838 }
 839
 840 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
 841 {
 842         unsigned long time_left;
 843
 844         lockdep_assert_held(&ar->conf_mutex);
 845
 846         if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
 847                 return -ESHUTDOWN;
 848
 849         time_left = wait_for_completion_timeout(&ar->vdev_setup_done,
 850                                                 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
 851         if (time_left == 0)
 852                 return -ETIMEDOUT;
 853
 854         return 0;
 855 }
 856
 857 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
 858 {
 859         struct cfg80211_chan_def *chandef = NULL;
 860         struct ieee80211_channel *channel = NULL;
 861         struct wmi_vdev_start_request_arg arg = {};
 862         int ret = 0;
 863
 864         lockdep_assert_held(&ar->conf_mutex);
 865
 866         ieee80211_iter_chan_contexts_atomic(ar->hw,
 867                                             ath10k_mac_get_any_chandef_iter,
 868                                             &chandef);
 869         if (WARN_ON_ONCE(!chandef))
 870                 return -ENOENT;
 871
 872         channel = chandef->chan;
 873
 874         arg.vdev_id = vdev_id;
 875         arg.channel.freq = channel->center_freq;
 876         arg.channel.band_center_freq1 = chandef->center_freq1;
 877
 878         /* TODO setup this dynamically, what in case we
 879            don't have any vifs? */
 880         arg.channel.mode = chan_to_phymode(chandef);
 881         arg.channel.chan_radar =
 882                         !!(channel->flags & IEEE80211_CHAN_RADAR);
 883
 884         arg.channel.min_power = 0;
 885         arg.channel.max_power = channel->max_power * 2;
 886         arg.channel.max_reg_power = channel->max_reg_power * 2;
 887         arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
 888
 889         reinit_completion(&ar->vdev_setup_done);
 890
 891         ret = ath10k_wmi_vdev_start(ar, &arg);
 892         if (ret) {
 893                 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
 894                             vdev_id, ret);
 895                 return ret;
 896         }
 897
 898         ret = ath10k_vdev_setup_sync(ar);
 899         if (ret) {
 900                 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n",
 901                             vdev_id, ret);
 902                 return ret;
 903         }
 904
 905         ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
 906         if (ret) {
 907                 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
 908                             vdev_id, ret);
 909                 goto vdev_stop;
 910         }
 911
 912         ar->monitor_vdev_id = vdev_id;
 913
 914         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
 915                    ar->monitor_vdev_id);
 916         return 0;
 917
 918 vdev_stop:
 919         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
 920         if (ret)
 921                 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
 922                             ar->monitor_vdev_id, ret);
 923
 924         return ret;
 925 }
 926
 927 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
 928 {
 929         int ret = 0;
 930
 931         lockdep_assert_held(&ar->conf_mutex);
 932
 933         ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
 934         if (ret)
 935                 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
 936                             ar->monitor_vdev_id, ret);
 937
 938         reinit_completion(&ar->vdev_setup_done);
 939
 940         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
 941         if (ret)
 942                 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
 943                             ar->monitor_vdev_id, ret);
 944
 945         ret = ath10k_vdev_setup_sync(ar);
 946         if (ret)
 947                 ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n",
 948                             ar->monitor_vdev_id, ret);
 949
 950         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
 951                    ar->monitor_vdev_id);
 952         return ret;
 953 }
 954
 955 static int ath10k_monitor_vdev_create(struct ath10k *ar)
 956 {
 957         int bit, ret = 0;
 958
 959         lockdep_assert_held(&ar->conf_mutex);
 960
 961         if (ar->free_vdev_map == 0) {
 962                 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
 963                 return -ENOMEM;
 964         }
 965
 966         bit = __ffs64(ar->free_vdev_map);
 967
 968         ar->monitor_vdev_id = bit;
 969
 970         ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
 971                                      WMI_VDEV_TYPE_MONITOR,
 972                                      0, ar->mac_addr);
 973         if (ret) {
 974                 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
 975                             ar->monitor_vdev_id, ret);
 976                 return ret;
 977         }
 978
 979         ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
 980         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
 981                    ar->monitor_vdev_id);
 982
 983         return 0;
 984 }
 985
 986 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
 987 {
 988         int ret = 0;
 989
 990         lockdep_assert_held(&ar->conf_mutex);
 991
 992         ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
 993         if (ret) {
 994                 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
 995                             ar->monitor_vdev_id, ret);
 996                 return ret;
 997         }
 998
 999         ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
1000
1001         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
1002                    ar->monitor_vdev_id);
1003         return ret;
1004 }
1005
1006 static int ath10k_monitor_start(struct ath10k *ar)
1007 {
1008         int ret;
1009
1010         lockdep_assert_held(&ar->conf_mutex);
1011
1012         ret = ath10k_monitor_vdev_create(ar);
1013         if (ret) {
1014                 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
1015                 return ret;
1016         }
1017
1018         ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
1019         if (ret) {
1020                 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
1021                 ath10k_monitor_vdev_delete(ar);
1022                 return ret;
1023         }
1024
1025         ar->monitor_started = true;
1026         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
1027
1028         return 0;
1029 }
1030
1031 static int ath10k_monitor_stop(struct ath10k *ar)
1032 {
1033         int ret;
1034
1035         lockdep_assert_held(&ar->conf_mutex);
1036
1037         ret = ath10k_monitor_vdev_stop(ar);
1038         if (ret) {
1039                 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
1040                 return ret;
1041         }
1042
1043         ret = ath10k_monitor_vdev_delete(ar);
1044         if (ret) {
1045                 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
1046                 return ret;
1047         }
1048
1049         ar->monitor_started = false;
1050         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
1051
1052         return 0;
1053 }
1054
1055 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar)
1056 {
1057         int num_ctx;
1058
1059         /* At least one chanctx is required to derive a channel to start
1060          * monitor vdev on.
1061          */
1062         num_ctx = ath10k_mac_num_chanctxs(ar);
1063         if (num_ctx == 0)
1064                 return false;
1065
1066         /* If there's already an existing special monitor interface then don't
1067          * bother creating another monitor vdev.
1068          */
1069         if (ar->monitor_arvif)
1070                 return false;
1071
1072         return ar->monitor ||
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         /* Add a 200ms margin to account for event/command processing */
3621         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
3622                                      msecs_to_jiffies(arg->max_scan_time+200));
3623         return 0;
3624 }
3625
3626 /**********************/
3627 /* mac80211 callbacks */
3628 /**********************/
3629
3630 static void ath10k_tx(struct ieee80211_hw *hw,
3631                       struct ieee80211_tx_control *control,
3632                       struct sk_buff *skb)
3633 {
3634         struct ath10k *ar = hw->priv;
3635         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3636         struct ieee80211_vif *vif = info->control.vif;
3637         struct ieee80211_sta *sta = control->sta;
3638         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3639         __le16 fc = hdr->frame_control;
3640
3641         /* We should disable CCK RATE due to P2P */
3642         if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
3643                 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
3644
3645         ATH10K_SKB_CB(skb)->htt.is_offchan = false;
3646         ATH10K_SKB_CB(skb)->htt.freq = 0;
3647         ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
3648         ATH10K_SKB_CB(skb)->htt.nohwcrypt = !ath10k_tx_h_use_hwcrypto(vif, skb);
3649         ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, vif);
3650         ATH10K_SKB_CB(skb)->txmode = ath10k_tx_h_get_txmode(ar, vif, sta, skb);
3651         ATH10K_SKB_CB(skb)->is_protected = ieee80211_has_protected(fc);
3652
3653         switch (ATH10K_SKB_CB(skb)->txmode) {
3654         case ATH10K_HW_TXRX_MGMT:
3655         case ATH10K_HW_TXRX_NATIVE_WIFI:
3656                 ath10k_tx_h_nwifi(hw, skb);
3657                 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
3658                 ath10k_tx_h_seq_no(vif, skb);
3659                 break;
3660         case ATH10K_HW_TXRX_ETHERNET:
3661                 ath10k_tx_h_8023(skb);
3662                 break;
3663         case ATH10K_HW_TXRX_RAW:
3664                 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
3665                         WARN_ON_ONCE(1);
3666                         ieee80211_free_txskb(hw, skb);
3667                         return;
3668                 }
3669         }
3670
3671         if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
3672                 spin_lock_bh(&ar->data_lock);
3673                 ATH10K_SKB_CB(skb)->htt.freq = ar->scan.roc_freq;
3674                 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
3675                 spin_unlock_bh(&ar->data_lock);
3676
3677                 if (ath10k_mac_need_offchan_tx_work(ar)) {
3678                         ATH10K_SKB_CB(skb)->htt.freq = 0;
3679                         ATH10K_SKB_CB(skb)->htt.is_offchan = true;
3680
3681                         ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
3682                                    skb);
3683
3684                         skb_queue_tail(&ar->offchan_tx_queue, skb);
3685                         ieee80211_queue_work(hw, &ar->offchan_tx_work);
3686                         return;
3687                 }
3688         }
3689
3690         ath10k_mac_tx(ar, skb);
3691 }
3692
3693 /* Must not be called with conf_mutex held as workers can use that also. */
3694 void ath10k_drain_tx(struct ath10k *ar)
3695 {
3696         /* make sure rcu-protected mac80211 tx path itself is drained */
3697         synchronize_net();
3698
3699         ath10k_offchan_tx_purge(ar);
3700         ath10k_mgmt_over_wmi_tx_purge(ar);
3701
3702         cancel_work_sync(&ar->offchan_tx_work);
3703         cancel_work_sync(&ar->wmi_mgmt_tx_work);
3704 }
3705
3706 void ath10k_halt(struct ath10k *ar)
3707 {
3708         struct ath10k_vif *arvif;
3709
3710         lockdep_assert_held(&ar->conf_mutex);
3711
3712         clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
3713         ar->filter_flags = 0;
3714         ar->monitor = false;
3715         ar->monitor_arvif = NULL;
3716
3717         if (ar->monitor_started)
3718                 ath10k_monitor_stop(ar);
3719
3720         ar->monitor_started = false;
3721         ar->tx_paused = 0;
3722
3723         ath10k_scan_finish(ar);
3724         ath10k_peer_cleanup_all(ar);
3725         ath10k_core_stop(ar);
3726         ath10k_hif_power_down(ar);
3727
3728         spin_lock_bh(&ar->data_lock);
3729         list_for_each_entry(arvif, &ar->arvifs, list)
3730                 ath10k_mac_vif_beacon_cleanup(arvif);
3731         spin_unlock_bh(&ar->data_lock);
3732 }
3733
3734 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
3735 {
3736         struct ath10k *ar = hw->priv;
3737
3738         mutex_lock(&ar->conf_mutex);
3739
3740         if (ar->cfg_tx_chainmask) {
3741                 *tx_ant = ar->cfg_tx_chainmask;
3742                 *rx_ant = ar->cfg_rx_chainmask;
3743         } else {
3744                 *tx_ant = ar->supp_tx_chainmask;
3745                 *rx_ant = ar->supp_rx_chainmask;
3746         }
3747
3748         mutex_unlock(&ar->conf_mutex);
3749
3750         return 0;
3751 }
3752
3753 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
3754 {
3755         /* It is not clear that allowing gaps in chainmask
3756          * is helpful.  Probably it will not do what user
3757          * is hoping for, so warn in that case.
3758          */
3759         if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
3760                 return;
3761
3762         ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x.  Suggested values: 15, 7, 3, 1 or 0.\n",
3763                     dbg, cm);
3764 }
3765
3766 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
3767 {
3768         int ret;
3769
3770         lockdep_assert_held(&ar->conf_mutex);
3771
3772         ath10k_check_chain_mask(ar, tx_ant, "tx");
3773         ath10k_check_chain_mask(ar, rx_ant, "rx");
3774
3775         ar->cfg_tx_chainmask = tx_ant;
3776         ar->cfg_rx_chainmask = rx_ant;
3777
3778         if ((ar->state != ATH10K_STATE_ON) &&
3779             (ar->state != ATH10K_STATE_RESTARTED))
3780                 return 0;
3781
3782         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
3783                                         tx_ant);
3784         if (ret) {
3785                 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
3786                             ret, tx_ant);
3787                 return ret;
3788         }
3789
3790         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
3791                                         rx_ant);
3792         if (ret) {
3793                 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
3794                             ret, rx_ant);
3795                 return ret;
3796         }
3797
3798         return 0;
3799 }
3800
3801 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
3802 {
3803         struct ath10k *ar = hw->priv;
3804         int ret;
3805
3806         mutex_lock(&ar->conf_mutex);
3807         ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
3808         mutex_unlock(&ar->conf_mutex);
3809         return ret;
3810 }
3811
3812 static int ath10k_start(struct ieee80211_hw *hw)
3813 {
3814         struct ath10k *ar = hw->priv;
3815         u32 burst_enable;
3816         int ret = 0;
3817
3818         /*
3819          * This makes sense only when restarting hw. It is harmless to call
3820          * uncoditionally. This is necessary to make sure no HTT/WMI tx
3821          * commands will be submitted while restarting.
3822          */
3823         ath10k_drain_tx(ar);
3824
3825         mutex_lock(&ar->conf_mutex);
3826
3827         switch (ar->state) {
3828         case ATH10K_STATE_OFF:
3829                 ar->state = ATH10K_STATE_ON;
3830                 break;
3831         case ATH10K_STATE_RESTARTING:
3832                 ath10k_halt(ar);
3833                 ar->state = ATH10K_STATE_RESTARTED;
3834                 break;
3835         case ATH10K_STATE_ON:
3836         case ATH10K_STATE_RESTARTED:
3837         case ATH10K_STATE_WEDGED:
3838                 WARN_ON(1);
3839                 ret = -EINVAL;
3840                 goto err;
3841         case ATH10K_STATE_UTF:
3842                 ret = -EBUSY;
3843                 goto err;
3844         }
3845
3846         ret = ath10k_hif_power_up(ar);
3847         if (ret) {
3848                 ath10k_err(ar, "Could not init hif: %d\n", ret);
3849                 goto err_off;
3850         }
3851
3852         ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
3853         if (ret) {
3854                 ath10k_err(ar, "Could not init core: %d\n", ret);
3855                 goto err_power_down;
3856         }
3857
3858         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
3859         if (ret) {
3860                 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
3861                 goto err_core_stop;
3862         }
3863
3864         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
3865         if (ret) {
3866                 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
3867                 goto err_core_stop;
3868         }
3869
3870         if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
3871                 ret = ath10k_wmi_adaptive_qcs(ar, true);
3872                 if (ret) {
3873                         ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
3874                                     ret);
3875                         goto err_core_stop;
3876                 }
3877         }
3878
3879         if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
3880                 burst_enable = ar->wmi.pdev_param->burst_enable;
3881                 ret = ath10k_wmi_pdev_set_param(ar, burst_enable, 0);
3882                 if (ret) {
3883                         ath10k_warn(ar, "failed to disable burst: %d\n", ret);
3884                         goto err_core_stop;
3885                 }
3886         }
3887
3888         if (ar->cfg_tx_chainmask)
3889                 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
3890                                      ar->cfg_rx_chainmask);
3891
3892         /*
3893          * By default FW set ARP frames ac to voice (6). In that case ARP
3894          * exchange is not working properly for UAPSD enabled AP. ARP requests
3895          * which arrives with access category 0 are processed by network stack
3896          * and send back with access category 0, but FW changes access category
3897          * to 6. Set ARP frames access category to best effort (0) solves
3898          * this problem.
3899          */
3900
3901         ret = ath10k_wmi_pdev_set_param(ar,
3902                                         ar->wmi.pdev_param->arp_ac_override, 0);
3903         if (ret) {
3904                 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
3905                             ret);
3906                 goto err_core_stop;
3907         }
3908
3909         ret = ath10k_wmi_pdev_set_param(ar,
3910                                         ar->wmi.pdev_param->ani_enable, 1);
3911         if (ret) {
3912                 ath10k_warn(ar, "failed to enable ani by default: %d\n",
3913                             ret);
3914                 goto err_core_stop;
3915         }
3916
3917         ar->ani_enabled = true;
3918
3919         ar->num_started_vdevs = 0;
3920         ath10k_regd_update(ar);
3921
3922         ath10k_spectral_start(ar);
3923         ath10k_thermal_set_throttling(ar);
3924
3925         mutex_unlock(&ar->conf_mutex);
3926         return 0;
3927
3928 err_core_stop:
3929         ath10k_core_stop(ar);
3930
3931 err_power_down:
3932         ath10k_hif_power_down(ar);
3933
3934 err_off:
3935         ar->state = ATH10K_STATE_OFF;
3936
3937 err:
3938         mutex_unlock(&ar->conf_mutex);
3939         return ret;
3940 }
3941
3942 static void ath10k_stop(struct ieee80211_hw *hw)
3943 {
3944         struct ath10k *ar = hw->priv;
3945
3946         ath10k_drain_tx(ar);
3947
3948         mutex_lock(&ar->conf_mutex);
3949         if (ar->state != ATH10K_STATE_OFF) {
3950                 ath10k_halt(ar);
3951                 ar->state = ATH10K_STATE_OFF;
3952         }
3953         mutex_unlock(&ar->conf_mutex);
3954
3955         cancel_delayed_work_sync(&ar->scan.timeout);
3956         cancel_work_sync(&ar->restart_work);
3957 }
3958
3959 static int ath10k_config_ps(struct ath10k *ar)
3960 {
3961         struct ath10k_vif *arvif;
3962         int ret = 0;
3963
3964         lockdep_assert_held(&ar->conf_mutex);
3965
3966         list_for_each_entry(arvif, &ar->arvifs, list) {
3967                 ret = ath10k_mac_vif_setup_ps(arvif);
3968                 if (ret) {
3969                         ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
3970                         break;
3971                 }
3972         }
3973
3974         return ret;
3975 }
3976
3977 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
3978 {
3979         int ret;
3980         u32 param;
3981
3982         lockdep_assert_held(&ar->conf_mutex);
3983
3984         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
3985
3986         param = ar->wmi.pdev_param->txpower_limit2g;
3987         ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
3988         if (ret) {
3989                 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
3990                             txpower, ret);
3991                 return ret;
3992         }
3993
3994         param = ar->wmi.pdev_param->txpower_limit5g;
3995         ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
3996         if (ret) {
3997                 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
3998                             txpower, ret);
3999                 return ret;
4000         }
4001
4002         return 0;
4003 }
4004
4005 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
4006 {
4007         struct ath10k_vif *arvif;
4008         int ret, txpower = -1;
4009
4010         lockdep_assert_held(&ar->conf_mutex);
4011
4012         list_for_each_entry(arvif, &ar->arvifs, list) {
4013                 WARN_ON(arvif->txpower < 0);
4014
4015                 if (txpower == -1)
4016                         txpower = arvif->txpower;
4017                 else
4018                         txpower = min(txpower, arvif->txpower);
4019         }
4020
4021         if (WARN_ON(txpower == -1))
4022                 return -EINVAL;
4023
4024         ret = ath10k_mac_txpower_setup(ar, txpower);
4025         if (ret) {
4026                 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
4027                             txpower, ret);
4028                 return ret;
4029         }
4030
4031         return 0;
4032 }
4033
4034 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
4035 {
4036         struct ath10k *ar = hw->priv;
4037         struct ieee80211_conf *conf = &hw->conf;
4038         int ret = 0;
4039
4040         mutex_lock(&ar->conf_mutex);
4041
4042         if (changed & IEEE80211_CONF_CHANGE_PS)
4043                 ath10k_config_ps(ar);
4044
4045         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
4046                 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
4047                 ret = ath10k_monitor_recalc(ar);
4048                 if (ret)
4049                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4050         }
4051
4052         mutex_unlock(&ar->conf_mutex);
4053         return ret;
4054 }
4055
4056 static u32 get_nss_from_chainmask(u16 chain_mask)
4057 {
4058         if ((chain_mask & 0x15) == 0x15)
4059                 return 4;
4060         else if ((chain_mask & 0x7) == 0x7)
4061                 return 3;
4062         else if ((chain_mask & 0x3) == 0x3)
4063                 return 2;
4064         return 1;
4065 }
4066
4067 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar)
4068 {
4069         int nsts = ar->vht_cap_info;
4070         nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4071         nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4072
4073         /* If firmware does not deliver to host number of space-time
4074          * streams supported, assume it support up to 4 BF STS and return
4075          * the value for VHT CAP: nsts-1)
4076          * */
4077         if (nsts == 0)
4078                 return 3;
4079
4080         return nsts;
4081 }
4082
4083 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)
4084 {
4085         u32 value = 0;
4086         struct ath10k *ar = arvif->ar;
4087         int nsts;
4088
4089         if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)
4090                 return 0;
4091
4092         nsts = ath10k_mac_get_vht_cap_bf_sts(ar);
4093         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4094                                 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))
4095                 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4096
4097         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4098                                 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))
4099                 value |= SM((ar->num_rf_chains - 1), WMI_BF_SOUND_DIM_OFFSET);
4100
4101         if (!value)
4102                 return 0;
4103
4104         if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
4105                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4106
4107         if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
4108                 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |
4109                           WMI_VDEV_PARAM_TXBF_SU_TX_BFER);
4110
4111         if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
4112                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4113
4114         if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
4115                 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |
4116                           WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);
4117
4118         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4119                                          ar->wmi.vdev_param->txbf, value);
4120 }
4121
4122 /*
4123  * TODO:
4124  * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
4125  * because we will send mgmt frames without CCK. This requirement
4126  * for P2P_FIND/GO_NEG should be handled by checking CCK flag
4127  * in the TX packet.
4128  */
4129 static int ath10k_add_interface(struct ieee80211_hw *hw,
4130                                 struct ieee80211_vif *vif)
4131 {
4132         struct ath10k *ar = hw->priv;
4133         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4134         enum wmi_sta_powersave_param param;
4135         int ret = 0;
4136         u32 value;
4137         int bit;
4138         int i;
4139         u32 vdev_param;
4140
4141         vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
4142
4143         mutex_lock(&ar->conf_mutex);
4144
4145         memset(arvif, 0, sizeof(*arvif));
4146
4147         arvif->ar = ar;
4148         arvif->vif = vif;
4149
4150         INIT_LIST_HEAD(&arvif->list);
4151         INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
4152         INIT_DELAYED_WORK(&arvif->connection_loss_work,
4153                           ath10k_mac_vif_sta_connection_loss_work);
4154
4155         for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
4156                 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
4157                 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
4158                        sizeof(arvif->bitrate_mask.control[i].ht_mcs));
4159                 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
4160                        sizeof(arvif->bitrate_mask.control[i].vht_mcs));
4161         }
4162
4163         if (ar->num_peers >= ar->max_num_peers) {
4164                 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
4165                 ret = -ENOBUFS;
4166                 goto err;
4167         }
4168
4169         if (ar->free_vdev_map == 0) {
4170                 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
4171                 ret = -EBUSY;
4172                 goto err;
4173         }
4174         bit = __ffs64(ar->free_vdev_map);
4175
4176         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
4177                    bit, ar->free_vdev_map);
4178
4179         arvif->vdev_id = bit;
4180         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
4181
4182         switch (vif->type) {
4183         case NL80211_IFTYPE_P2P_DEVICE:
4184                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4185                 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
4186                 break;
4187         case NL80211_IFTYPE_UNSPECIFIED:
4188         case NL80211_IFTYPE_STATION:
4189                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4190                 if (vif->p2p)
4191                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
4192                 break;
4193         case NL80211_IFTYPE_ADHOC:
4194                 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
4195                 break;
4196         case NL80211_IFTYPE_AP:
4197                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4198
4199                 if (vif->p2p)
4200                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
4201                 break;
4202         case NL80211_IFTYPE_MONITOR:
4203                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
4204                 break;
4205         default:
4206                 WARN_ON(1);
4207                 break;
4208         }
4209
4210         /* Using vdev_id as queue number will make it very easy to do per-vif
4211          * tx queue locking. This shouldn't wrap due to interface combinations
4212          * but do a modulo for correctness sake and prevent using offchannel tx
4213          * queues for regular vif tx.
4214          */
4215         vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4216         for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
4217                 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4218
4219         /* Some firmware revisions don't wait for beacon tx completion before
4220          * sending another SWBA event. This could lead to hardware using old
4221          * (freed) beacon data in some cases, e.g. tx credit starvation
4222          * combined with missed TBTT. This is very very rare.
4223          *
4224          * On non-IOMMU-enabled hosts this could be a possible security issue
4225          * because hw could beacon some random data on the air.  On
4226          * IOMMU-enabled hosts DMAR faults would occur in most cases and target
4227          * device would crash.
4228          *
4229          * Since there are no beacon tx completions (implicit nor explicit)
4230          * propagated to host the only workaround for this is to allocate a
4231          * DMA-coherent buffer for a lifetime of a vif and use it for all
4232          * beacon tx commands. Worst case for this approach is some beacons may
4233          * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
4234          */
4235         if (vif->type == NL80211_IFTYPE_ADHOC ||
4236             vif->type == NL80211_IFTYPE_AP) {
4237                 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
4238                                                         IEEE80211_MAX_FRAME_LEN,
4239                                                         &arvif->beacon_paddr,
4240                                                         GFP_ATOMIC);
4241                 if (!arvif->beacon_buf) {
4242                         ret = -ENOMEM;
4243                         ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
4244                                     ret);
4245                         goto err;
4246                 }
4247         }
4248         if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))
4249                 arvif->nohwcrypt = true;
4250
4251         if (arvif->nohwcrypt &&
4252             !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4253                 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");
4254                 goto err;
4255         }
4256
4257         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
4258                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
4259                    arvif->beacon_buf ? "single-buf" : "per-skb");
4260
4261         ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
4262                                      arvif->vdev_subtype, vif->addr);
4263         if (ret) {
4264                 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
4265                             arvif->vdev_id, ret);
4266                 goto err;
4267         }
4268
4269         ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
4270         list_add(&arvif->list, &ar->arvifs);
4271
4272         /* It makes no sense to have firmware do keepalives. mac80211 already
4273          * takes care of this with idle connection polling.
4274          */
4275         ret = ath10k_mac_vif_disable_keepalive(arvif);
4276         if (ret) {
4277                 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
4278                             arvif->vdev_id, ret);
4279                 goto err_vdev_delete;
4280         }
4281
4282         arvif->def_wep_key_idx = -1;
4283
4284         vdev_param = ar->wmi.vdev_param->tx_encap_type;
4285         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4286                                         ATH10K_HW_TXRX_NATIVE_WIFI);
4287         /* 10.X firmware does not support this VDEV parameter. Do not warn */
4288         if (ret && ret != -EOPNOTSUPP) {
4289                 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
4290                             arvif->vdev_id, ret);
4291                 goto err_vdev_delete;
4292         }
4293
4294         if (ar->cfg_tx_chainmask) {
4295                 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4296
4297                 vdev_param = ar->wmi.vdev_param->nss;
4298                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4299                                                 nss);
4300                 if (ret) {
4301                         ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4302                                     arvif->vdev_id, ar->cfg_tx_chainmask, nss,
4303                                     ret);
4304                         goto err_vdev_delete;
4305                 }
4306         }
4307
4308         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4309             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4310                 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr,
4311                                          WMI_PEER_TYPE_DEFAULT);
4312                 if (ret) {
4313                         ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
4314                                     arvif->vdev_id, ret);
4315                         goto err_vdev_delete;
4316                 }
4317         }
4318
4319         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
4320                 ret = ath10k_mac_set_kickout(arvif);
4321                 if (ret) {
4322                         ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
4323                                     arvif->vdev_id, ret);
4324                         goto err_peer_delete;
4325                 }
4326         }
4327
4328         if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
4329                 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
4330                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4331                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4332                                                   param, value);
4333                 if (ret) {
4334                         ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
4335                                     arvif->vdev_id, ret);
4336                         goto err_peer_delete;
4337                 }
4338
4339                 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4340                 if (ret) {
4341                         ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4342                                     arvif->vdev_id, ret);
4343                         goto err_peer_delete;
4344                 }
4345
4346                 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4347                 if (ret) {
4348                         ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4349                                     arvif->vdev_id, ret);
4350                         goto err_peer_delete;
4351                 }
4352         }
4353
4354         ret = ath10k_mac_set_txbf_conf(arvif);
4355         if (ret) {
4356                 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
4357                             arvif->vdev_id, ret);
4358                 goto err_peer_delete;
4359         }
4360
4361         ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
4362         if (ret) {
4363                 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4364                             arvif->vdev_id, ret);
4365                 goto err_peer_delete;
4366         }
4367
4368         arvif->txpower = vif->bss_conf.txpower;
4369         ret = ath10k_mac_txpower_recalc(ar);
4370         if (ret) {
4371                 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4372                 goto err_peer_delete;
4373         }
4374
4375         if (vif->type == NL80211_IFTYPE_MONITOR) {
4376                 ar->monitor_arvif = arvif;
4377                 ret = ath10k_monitor_recalc(ar);
4378                 if (ret) {
4379                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4380                         goto err_peer_delete;
4381                 }
4382         }
4383
4384         spin_lock_bh(&ar->htt.tx_lock);
4385         if (!ar->tx_paused)
4386                 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
4387         spin_unlock_bh(&ar->htt.tx_lock);
4388
4389         mutex_unlock(&ar->conf_mutex);
4390         return 0;
4391
4392 err_peer_delete:
4393         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4394             arvif->vdev_type == WMI_VDEV_TYPE_IBSS)
4395                 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
4396
4397 err_vdev_delete:
4398         ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4399         ar->free_vdev_map |= 1LL << arvif->vdev_id;
4400         list_del(&arvif->list);
4401
4402 err:
4403         if (arvif->beacon_buf) {
4404                 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
4405                                   arvif->beacon_buf, arvif->beacon_paddr);
4406                 arvif->beacon_buf = NULL;
4407         }
4408
4409         mutex_unlock(&ar->conf_mutex);
4410
4411         return ret;
4412 }
4413
4414 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
4415 {
4416         int i;
4417
4418         for (i = 0; i < BITS_PER_LONG; i++)
4419                 ath10k_mac_vif_tx_unlock(arvif, i);
4420 }
4421
4422 static void ath10k_remove_interface(struct ieee80211_hw *hw,
4423                                     struct ieee80211_vif *vif)
4424 {
4425         struct ath10k *ar = hw->priv;
4426         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4427         int ret;
4428
4429         cancel_work_sync(&arvif->ap_csa_work);
4430         cancel_delayed_work_sync(&arvif->connection_loss_work);
4431
4432         mutex_lock(&ar->conf_mutex);
4433
4434         spin_lock_bh(&ar->data_lock);
4435         ath10k_mac_vif_beacon_cleanup(arvif);
4436         spin_unlock_bh(&ar->data_lock);
4437
4438         ret = ath10k_spectral_vif_stop(arvif);
4439         if (ret)
4440                 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
4441                             arvif->vdev_id, ret);
4442
4443         ar->free_vdev_map |= 1LL << arvif->vdev_id;
4444         list_del(&arvif->list);
4445
4446         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4447             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4448                 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
4449                                              vif->addr);
4450                 if (ret)
4451                         ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4452                                     arvif->vdev_id, ret);
4453
4454                 kfree(arvif->u.ap.noa_data);
4455         }
4456
4457         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
4458                    arvif->vdev_id);
4459
4460         ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4461         if (ret)
4462                 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
4463                             arvif->vdev_id, ret);
4464
4465         /* Some firmware revisions don't notify host about self-peer removal
4466          * until after associated vdev is deleted.
4467          */
4468         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4469             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4470                 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
4471                                                    vif->addr);
4472                 if (ret)
4473                         ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
4474                                     arvif->vdev_id, ret);
4475
4476                 spin_lock_bh(&ar->data_lock);
4477                 ar->num_peers--;
4478                 spin_unlock_bh(&ar->data_lock);
4479         }
4480
4481         ath10k_peer_cleanup(ar, arvif->vdev_id);
4482
4483         if (vif->type == NL80211_IFTYPE_MONITOR) {
4484                 ar->monitor_arvif = NULL;
4485                 ret = ath10k_monitor_recalc(ar);
4486                 if (ret)
4487                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4488         }
4489
4490         spin_lock_bh(&ar->htt.tx_lock);
4491         ath10k_mac_vif_tx_unlock_all(arvif);
4492         spin_unlock_bh(&ar->htt.tx_lock);
4493
4494         mutex_unlock(&ar->conf_mutex);
4495 }
4496
4497 /*
4498  * FIXME: Has to be verified.
4499  */
4500 #define SUPPORTED_FILTERS                       \
4501         (FIF_ALLMULTI |                         \
4502         FIF_CONTROL |                           \
4503         FIF_PSPOLL |                            \
4504         FIF_OTHER_BSS |                         \
4505         FIF_BCN_PRBRESP_PROMISC |               \
4506         FIF_PROBE_REQ |                         \
4507         FIF_FCSFAIL)
4508
4509 static void ath10k_configure_filter(struct ieee80211_hw *hw,
4510                                     unsigned int changed_flags,
4511                                     unsigned int *total_flags,
4512                                     u64 multicast)
4513 {
4514         struct ath10k *ar = hw->priv;
4515         int ret;
4516
4517         mutex_lock(&ar->conf_mutex);
4518
4519         changed_flags &= SUPPORTED_FILTERS;
4520         *total_flags &= SUPPORTED_FILTERS;
4521         ar->filter_flags = *total_flags;
4522
4523         ret = ath10k_monitor_recalc(ar);
4524         if (ret)
4525                 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
4526
4527         mutex_unlock(&ar->conf_mutex);
4528 }
4529
4530 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
4531                                     struct ieee80211_vif *vif,
4532                                     struct ieee80211_bss_conf *info,
4533                                     u32 changed)
4534 {
4535         struct ath10k *ar = hw->priv;
4536         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4537         int ret = 0;
4538         u32 vdev_param, pdev_param, slottime, preamble;
4539
4540         mutex_lock(&ar->conf_mutex);
4541
4542         if (changed & BSS_CHANGED_IBSS)
4543                 ath10k_control_ibss(arvif, info, vif->addr);
4544
4545         if (changed & BSS_CHANGED_BEACON_INT) {
4546                 arvif->beacon_interval = info->beacon_int;
4547                 vdev_param = ar->wmi.vdev_param->beacon_interval;
4548                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4549                                                 arvif->beacon_interval);
4550                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4551                            "mac vdev %d beacon_interval %d\n",
4552                            arvif->vdev_id, arvif->beacon_interval);
4553
4554                 if (ret)
4555                         ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
4556                                     arvif->vdev_id, ret);
4557         }
4558
4559         if (changed & BSS_CHANGED_BEACON) {
4560                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4561                            "vdev %d set beacon tx mode to staggered\n",
4562                            arvif->vdev_id);
4563
4564                 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
4565                 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
4566                                                 WMI_BEACON_STAGGERED_MODE);
4567                 if (ret)
4568                         ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
4569                                     arvif->vdev_id, ret);
4570
4571                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
4572                 if (ret)
4573                         ath10k_warn(ar, "failed to update beacon template: %d\n",
4574                                     ret);
4575         }
4576
4577         if (changed & BSS_CHANGED_AP_PROBE_RESP) {
4578                 ret = ath10k_mac_setup_prb_tmpl(arvif);
4579                 if (ret)
4580                         ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
4581                                     arvif->vdev_id, ret);
4582         }
4583
4584         if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
4585                 arvif->dtim_period = info->dtim_period;
4586
4587                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4588                            "mac vdev %d dtim_period %d\n",
4589                            arvif->vdev_id, arvif->dtim_period);
4590
4591                 vdev_param = ar->wmi.vdev_param->dtim_period;
4592                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4593                                                 arvif->dtim_period);
4594                 if (ret)
4595                         ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
4596                                     arvif->vdev_id, ret);
4597         }
4598
4599         if (changed & BSS_CHANGED_SSID &&
4600             vif->type == NL80211_IFTYPE_AP) {
4601                 arvif->u.ap.ssid_len = info->ssid_len;
4602                 if (info->ssid_len)
4603                         memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
4604                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
4605         }
4606
4607         if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
4608                 ether_addr_copy(arvif->bssid, info->bssid);
4609
4610         if (changed & BSS_CHANGED_BEACON_ENABLED)
4611                 ath10k_control_beaconing(arvif, info);
4612
4613         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
4614                 arvif->use_cts_prot = info->use_cts_prot;
4615                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
4616                            arvif->vdev_id, info->use_cts_prot);
4617
4618                 ret = ath10k_recalc_rtscts_prot(arvif);
4619                 if (ret)
4620                         ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
4621                                     arvif->vdev_id, ret);
4622
4623                 vdev_param = ar->wmi.vdev_param->protection_mode;
4624                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4625                                                 info->use_cts_prot ? 1 : 0);
4626                 if (ret)
4627                         ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n",
4628                                         info->use_cts_prot, arvif->vdev_id, ret);
4629         }
4630
4631         if (changed & BSS_CHANGED_ERP_SLOT) {
4632                 if (info->use_short_slot)
4633                         slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
4634
4635                 else
4636                         slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
4637
4638                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
4639                            arvif->vdev_id, slottime);
4640
4641                 vdev_param = ar->wmi.vdev_param->slot_time;
4642                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4643                                                 slottime);
4644                 if (ret)
4645                         ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
4646                                     arvif->vdev_id, ret);
4647         }
4648
4649         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4650                 if (info->use_short_preamble)
4651                         preamble = WMI_VDEV_PREAMBLE_SHORT;
4652                 else
4653                         preamble = WMI_VDEV_PREAMBLE_LONG;
4654
4655                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4656                            "mac vdev %d preamble %dn",
4657                            arvif->vdev_id, preamble);
4658
4659                 vdev_param = ar->wmi.vdev_param->preamble;
4660                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4661                                                 preamble);
4662                 if (ret)
4663                         ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
4664                                     arvif->vdev_id, ret);
4665         }
4666
4667         if (changed & BSS_CHANGED_ASSOC) {
4668                 if (info->assoc) {
4669                         /* Workaround: Make sure monitor vdev is not running
4670                          * when associating to prevent some firmware revisions
4671                          * (e.g. 10.1 and 10.2) from crashing.
4672                          */
4673                         if (ar->monitor_started)
4674                                 ath10k_monitor_stop(ar);
4675                         ath10k_bss_assoc(hw, vif, info);
4676                         ath10k_monitor_recalc(ar);
4677                 } else {
4678                         ath10k_bss_disassoc(hw, vif);
4679                 }
4680         }
4681
4682         if (changed & BSS_CHANGED_TXPOWER) {
4683                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
4684                            arvif->vdev_id, info->txpower);
4685
4686                 arvif->txpower = info->txpower;
4687                 ret = ath10k_mac_txpower_recalc(ar);
4688                 if (ret)
4689                         ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4690         }
4691
4692         if (changed & BSS_CHANGED_PS) {
4693                 arvif->ps = vif->bss_conf.ps;
4694
4695                 ret = ath10k_config_ps(ar);
4696                 if (ret)
4697                         ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
4698                                     arvif->vdev_id, ret);
4699         }
4700
4701         mutex_unlock(&ar->conf_mutex);
4702 }
4703
4704 static int ath10k_hw_scan(struct ieee80211_hw *hw,
4705                           struct ieee80211_vif *vif,
4706                           struct ieee80211_scan_request *hw_req)
4707 {
4708         struct ath10k *ar = hw->priv;
4709         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4710         struct cfg80211_scan_request *req = &hw_req->req;
4711         struct wmi_start_scan_arg arg;
4712         int ret = 0;
4713         int i;
4714
4715         mutex_lock(&ar->conf_mutex);
4716
4717         spin_lock_bh(&ar->data_lock);
4718         switch (ar->scan.state) {
4719         case ATH10K_SCAN_IDLE:
4720                 reinit_completion(&ar->scan.started);
4721                 reinit_completion(&ar->scan.completed);
4722                 ar->scan.state = ATH10K_SCAN_STARTING;
4723                 ar->scan.is_roc = false;
4724                 ar->scan.vdev_id = arvif->vdev_id;
4725                 ret = 0;
4726                 break;
4727         case ATH10K_SCAN_STARTING:
4728         case ATH10K_SCAN_RUNNING:
4729         case ATH10K_SCAN_ABORTING:
4730                 ret = -EBUSY;
4731                 break;
4732         }
4733         spin_unlock_bh(&ar->data_lock);
4734
4735         if (ret)
4736                 goto exit;
4737
4738         memset(&arg, 0, sizeof(arg));
4739         ath10k_wmi_start_scan_init(ar, &arg);
4740         arg.vdev_id = arvif->vdev_id;
4741         arg.scan_id = ATH10K_SCAN_ID;
4742
4743         if (req->ie_len) {
4744                 arg.ie_len = req->ie_len;
4745                 memcpy(arg.ie, req->ie, arg.ie_len);
4746         }
4747
4748         if (req->n_ssids) {
4749                 arg.n_ssids = req->n_ssids;
4750                 for (i = 0; i < arg.n_ssids; i++) {
4751                         arg.ssids[i].len  = req->ssids[i].ssid_len;
4752                         arg.ssids[i].ssid = req->ssids[i].ssid;
4753                 }
4754         } else {
4755                 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4756         }
4757
4758         if (req->n_channels) {
4759                 arg.n_channels = req->n_channels;
4760                 for (i = 0; i < arg.n_channels; i++)
4761                         arg.channels[i] = req->channels[i]->center_freq;
4762         }
4763
4764         ret = ath10k_start_scan(ar, &arg);
4765         if (ret) {
4766                 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
4767                 spin_lock_bh(&ar->data_lock);
4768                 ar->scan.state = ATH10K_SCAN_IDLE;
4769                 spin_unlock_bh(&ar->data_lock);
4770         }
4771
4772 exit:
4773         mutex_unlock(&ar->conf_mutex);
4774         return ret;
4775 }
4776
4777 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
4778                                   struct ieee80211_vif *vif)
4779 {
4780         struct ath10k *ar = hw->priv;
4781
4782         mutex_lock(&ar->conf_mutex);
4783         ath10k_scan_abort(ar);
4784         mutex_unlock(&ar->conf_mutex);
4785
4786         cancel_delayed_work_sync(&ar->scan.timeout);
4787 }
4788
4789 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
4790                                         struct ath10k_vif *arvif,
4791                                         enum set_key_cmd cmd,
4792                                         struct ieee80211_key_conf *key)
4793 {
4794         u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
4795         int ret;
4796
4797         /* 10.1 firmware branch requires default key index to be set to group
4798          * key index after installing it. Otherwise FW/HW Txes corrupted
4799          * frames with multi-vif APs. This is not required for main firmware
4800          * branch (e.g. 636).
4801          *
4802          * This is also needed for 636 fw for IBSS-RSN to work more reliably.
4803          *
4804          * FIXME: It remains unknown if this is required for multi-vif STA
4805          * interfaces on 10.1.
4806          */
4807
4808         if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
4809             arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
4810                 return;
4811
4812         if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
4813                 return;
4814
4815         if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
4816                 return;
4817
4818         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4819                 return;
4820
4821         if (cmd != SET_KEY)
4822                 return;
4823
4824         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4825                                         key->keyidx);
4826         if (ret)
4827                 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
4828                             arvif->vdev_id, ret);
4829 }
4830
4831 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
4832                           struct ieee80211_vif *vif, struct ieee80211_sta *sta,
4833                           struct ieee80211_key_conf *key)
4834 {
4835         struct ath10k *ar = hw->priv;
4836         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4837         struct ath10k_peer *peer;
4838         const u8 *peer_addr;
4839         bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
4840                       key->cipher == WLAN_CIPHER_SUITE_WEP104;
4841         int ret = 0;
4842         int ret2;
4843         u32 flags = 0;
4844         u32 flags2;
4845
4846         /* this one needs to be done in software */
4847         if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
4848                 return 1;
4849
4850         if (arvif->nohwcrypt)
4851                 return 1;
4852
4853         if (key->keyidx > WMI_MAX_KEY_INDEX)
4854                 return -ENOSPC;
4855
4856         mutex_lock(&ar->conf_mutex);
4857
4858         if (sta)
4859                 peer_addr = sta->addr;
4860         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
4861                 peer_addr = vif->bss_conf.bssid;
4862         else
4863                 peer_addr = vif->addr;
4864
4865         key->hw_key_idx = key->keyidx;
4866
4867         if (is_wep) {
4868                 if (cmd == SET_KEY)
4869                         arvif->wep_keys[key->keyidx] = key;
4870                 else
4871                         arvif->wep_keys[key->keyidx] = NULL;
4872         }
4873
4874         /* the peer should not disappear in mid-way (unless FW goes awry) since
4875          * we already hold conf_mutex. we just make sure its there now. */
4876         spin_lock_bh(&ar->data_lock);
4877         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
4878         spin_unlock_bh(&ar->data_lock);
4879
4880         if (!peer) {
4881                 if (cmd == SET_KEY) {
4882                         ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
4883                                     peer_addr);
4884                         ret = -EOPNOTSUPP;
4885                         goto exit;
4886                 } else {
4887                         /* if the peer doesn't exist there is no key to disable
4888                          * anymore */
4889                         goto exit;
4890                 }
4891         }
4892
4893         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4894                 flags |= WMI_KEY_PAIRWISE;
4895         else
4896                 flags |= WMI_KEY_GROUP;
4897
4898         if (is_wep) {
4899                 if (cmd == DISABLE_KEY)
4900                         ath10k_clear_vdev_key(arvif, key);
4901
4902                 /* When WEP keys are uploaded it's possible that there are
4903                  * stations associated already (e.g. when merging) without any
4904                  * keys. Static WEP needs an explicit per-peer key upload.
4905                  */
4906                 if (vif->type == NL80211_IFTYPE_ADHOC &&
4907                     cmd == SET_KEY)
4908                         ath10k_mac_vif_update_wep_key(arvif, key);
4909
4910                 /* 802.1x never sets the def_wep_key_idx so each set_key()
4911                  * call changes default tx key.
4912                  *
4913                  * Static WEP sets def_wep_key_idx via .set_default_unicast_key
4914                  * after first set_key().
4915                  */
4916                 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
4917                         flags |= WMI_KEY_TX_USAGE;
4918         }
4919
4920         ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
4921         if (ret) {
4922                 WARN_ON(ret > 0);
4923                 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
4924                             arvif->vdev_id, peer_addr, ret);
4925                 goto exit;
4926         }
4927
4928         /* mac80211 sets static WEP keys as groupwise while firmware requires
4929          * them to be installed twice as both pairwise and groupwise.
4930          */
4931         if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
4932                 flags2 = flags;
4933                 flags2 &= ~WMI_KEY_GROUP;
4934                 flags2 |= WMI_KEY_PAIRWISE;
4935
4936                 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
4937                 if (ret) {
4938                         WARN_ON(ret > 0);
4939                         ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
4940                                     arvif->vdev_id, peer_addr, ret);
4941                         ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
4942                                                   peer_addr, flags);
4943                         if (ret2) {
4944                                 WARN_ON(ret2 > 0);
4945                                 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
4946                                             arvif->vdev_id, peer_addr, ret2);
4947                         }
4948                         goto exit;
4949                 }
4950         }
4951
4952         ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
4953
4954         spin_lock_bh(&ar->data_lock);
4955         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
4956         if (peer && cmd == SET_KEY)
4957                 peer->keys[key->keyidx] = key;
4958         else if (peer && cmd == DISABLE_KEY)
4959                 peer->keys[key->keyidx] = NULL;
4960         else if (peer == NULL)
4961                 /* impossible unless FW goes crazy */
4962                 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
4963         spin_unlock_bh(&ar->data_lock);
4964
4965 exit:
4966         mutex_unlock(&ar->conf_mutex);
4967         return ret;
4968 }
4969
4970 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
4971                                            struct ieee80211_vif *vif,
4972                                            int keyidx)
4973 {
4974         struct ath10k *ar = hw->priv;
4975         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4976         int ret;
4977
4978         mutex_lock(&arvif->ar->conf_mutex);
4979
4980         if (arvif->ar->state != ATH10K_STATE_ON)
4981                 goto unlock;
4982
4983         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
4984                    arvif->vdev_id, keyidx);
4985
4986         ret = ath10k_wmi_vdev_set_param(arvif->ar,
4987                                         arvif->vdev_id,
4988                                         arvif->ar->wmi.vdev_param->def_keyid,
4989                                         keyidx);
4990
4991         if (ret) {
4992                 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
4993                             arvif->vdev_id,
4994                             ret);
4995                 goto unlock;
4996         }
4997
4998         arvif->def_wep_key_idx = keyidx;
4999
5000 unlock:
5001         mutex_unlock(&arvif->ar->conf_mutex);
5002 }
5003
5004 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
5005 {
5006         struct ath10k *ar;
5007         struct ath10k_vif *arvif;
5008         struct ath10k_sta *arsta;
5009         struct ieee80211_sta *sta;
5010         struct cfg80211_chan_def def;
5011         enum ieee80211_band band;
5012         const u8 *ht_mcs_mask;
5013         const u16 *vht_mcs_mask;
5014         u32 changed, bw, nss, smps;
5015         int err;
5016
5017         arsta = container_of(wk, struct ath10k_sta, update_wk);
5018         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
5019         arvif = arsta->arvif;
5020         ar = arvif->ar;
5021
5022         if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
5023                 return;
5024
5025         band = def.chan->band;
5026         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
5027         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
5028
5029         spin_lock_bh(&ar->data_lock);
5030
5031         changed = arsta->changed;
5032         arsta->changed = 0;
5033
5034         bw = arsta->bw;
5035         nss = arsta->nss;
5036         smps = arsta->smps;
5037
5038         spin_unlock_bh(&ar->data_lock);
5039
5040         mutex_lock(&ar->conf_mutex);
5041
5042         nss = max_t(u32, 1, nss);
5043         nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
5044                            ath10k_mac_max_vht_nss(vht_mcs_mask)));
5045
5046         if (changed & IEEE80211_RC_BW_CHANGED) {
5047                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
5048                            sta->addr, bw);
5049
5050                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5051                                                 WMI_PEER_CHAN_WIDTH, bw);
5052                 if (err)
5053                         ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
5054                                     sta->addr, bw, err);
5055         }
5056
5057         if (changed & IEEE80211_RC_NSS_CHANGED) {
5058                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
5059                            sta->addr, nss);
5060
5061                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5062                                                 WMI_PEER_NSS, nss);
5063                 if (err)
5064                         ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
5065                                     sta->addr, nss, err);
5066         }
5067
5068         if (changed & IEEE80211_RC_SMPS_CHANGED) {
5069                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
5070                            sta->addr, smps);
5071
5072                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5073                                                 WMI_PEER_SMPS_STATE, smps);
5074                 if (err)
5075                         ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
5076                                     sta->addr, smps, err);
5077         }
5078
5079         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
5080             changed & IEEE80211_RC_NSS_CHANGED) {
5081                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
5082                            sta->addr);
5083
5084                 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
5085                 if (err)
5086                         ath10k_warn(ar, "failed to reassociate station: %pM\n",
5087                                     sta->addr);
5088         }
5089
5090         mutex_unlock(&ar->conf_mutex);
5091 }
5092
5093 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
5094                                        struct ieee80211_sta *sta)
5095 {
5096         struct ath10k *ar = arvif->ar;
5097
5098         lockdep_assert_held(&ar->conf_mutex);
5099
5100         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5101                 return 0;
5102
5103         if (ar->num_stations >= ar->max_num_stations)
5104                 return -ENOBUFS;
5105
5106         ar->num_stations++;
5107
5108         return 0;
5109 }
5110
5111 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
5112                                         struct ieee80211_sta *sta)
5113 {
5114         struct ath10k *ar = arvif->ar;
5115
5116         lockdep_assert_held(&ar->conf_mutex);
5117
5118         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5119                 return;
5120
5121         ar->num_stations--;
5122 }
5123
5124 struct ath10k_mac_tdls_iter_data {
5125         u32 num_tdls_stations;
5126         struct ieee80211_vif *curr_vif;
5127 };
5128
5129 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
5130                                                     struct ieee80211_sta *sta)
5131 {
5132         struct ath10k_mac_tdls_iter_data *iter_data = data;
5133         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5134         struct ieee80211_vif *sta_vif = arsta->arvif->vif;
5135
5136         if (sta->tdls && sta_vif == iter_data->curr_vif)
5137                 iter_data->num_tdls_stations++;
5138 }
5139
5140 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
5141                                               struct ieee80211_vif *vif)
5142 {
5143         struct ath10k_mac_tdls_iter_data data = {};
5144
5145         data.curr_vif = vif;
5146
5147         ieee80211_iterate_stations_atomic(hw,
5148                                           ath10k_mac_tdls_vif_stations_count_iter,
5149                                           &data);
5150         return data.num_tdls_stations;
5151 }
5152
5153 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac,
5154                                             struct ieee80211_vif *vif)
5155 {
5156         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5157         int *num_tdls_vifs = data;
5158
5159         if (vif->type != NL80211_IFTYPE_STATION)
5160                 return;
5161
5162         if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0)
5163                 (*num_tdls_vifs)++;
5164 }
5165
5166 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw)
5167 {
5168         int num_tdls_vifs = 0;
5169
5170         ieee80211_iterate_active_interfaces_atomic(hw,
5171                                                    IEEE80211_IFACE_ITER_NORMAL,
5172                                                    ath10k_mac_tdls_vifs_count_iter,
5173                                                    &num_tdls_vifs);
5174         return num_tdls_vifs;
5175 }
5176
5177 static int ath10k_sta_state(struct ieee80211_hw *hw,
5178                             struct ieee80211_vif *vif,
5179                             struct ieee80211_sta *sta,
5180                             enum ieee80211_sta_state old_state,
5181                             enum ieee80211_sta_state new_state)
5182 {
5183         struct ath10k *ar = hw->priv;
5184         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5185         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5186         int ret = 0;
5187
5188         if (old_state == IEEE80211_STA_NOTEXIST &&
5189             new_state == IEEE80211_STA_NONE) {
5190                 memset(arsta, 0, sizeof(*arsta));
5191                 arsta->arvif = arvif;
5192                 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
5193         }
5194
5195         /* cancel must be done outside the mutex to avoid deadlock */
5196         if ((old_state == IEEE80211_STA_NONE &&
5197              new_state == IEEE80211_STA_NOTEXIST))
5198                 cancel_work_sync(&arsta->update_wk);
5199
5200         mutex_lock(&ar->conf_mutex);
5201
5202         if (old_state == IEEE80211_STA_NOTEXIST &&
5203             new_state == IEEE80211_STA_NONE) {
5204                 /*
5205                  * New station addition.
5206                  */
5207                 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
5208                 u32 num_tdls_stations;
5209                 u32 num_tdls_vifs;
5210
5211                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5212                            "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5213                            arvif->vdev_id, sta->addr,
5214                            ar->num_stations + 1, ar->max_num_stations,
5215                            ar->num_peers + 1, ar->max_num_peers);
5216
5217                 ret = ath10k_mac_inc_num_stations(arvif, sta);
5218                 if (ret) {
5219                         ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
5220                                     ar->max_num_stations);
5221                         goto exit;
5222                 }
5223
5224                 if (sta->tdls)
5225                         peer_type = WMI_PEER_TYPE_TDLS;
5226
5227                 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr,
5228                                          peer_type);
5229                 if (ret) {
5230                         ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5231                                     sta->addr, arvif->vdev_id, ret);
5232                         ath10k_mac_dec_num_stations(arvif, sta);
5233                         goto exit;
5234                 }
5235
5236                 if (!sta->tdls)
5237                         goto exit;
5238
5239                 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
5240                 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw);
5241
5242                 if (num_tdls_vifs >= ar->max_num_tdls_vdevs &&
5243                     num_tdls_stations == 0) {
5244                         ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5245                                     arvif->vdev_id, ar->max_num_tdls_vdevs);
5246                         ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5247                         ath10k_mac_dec_num_stations(arvif, sta);
5248                         ret = -ENOBUFS;
5249                         goto exit;
5250                 }
5251
5252                 if (num_tdls_stations == 0) {
5253                         /* This is the first tdls peer in current vif */
5254                         enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE;
5255
5256                         ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5257                                                               state);
5258                         if (ret) {
5259                                 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5260                                             arvif->vdev_id, ret);
5261                                 ath10k_peer_delete(ar, arvif->vdev_id,
5262                                                    sta->addr);
5263                                 ath10k_mac_dec_num_stations(arvif, sta);
5264                                 goto exit;
5265                         }
5266                 }
5267
5268                 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5269                                                   WMI_TDLS_PEER_STATE_PEERING);
5270                 if (ret) {
5271                         ath10k_warn(ar,
5272                                     "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5273                                     sta->addr, arvif->vdev_id, ret);
5274                         ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5275                         ath10k_mac_dec_num_stations(arvif, sta);
5276
5277                         if (num_tdls_stations != 0)
5278                                 goto exit;
5279                         ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5280                                                         WMI_TDLS_DISABLE);
5281                 }
5282         } else if ((old_state == IEEE80211_STA_NONE &&
5283                     new_state == IEEE80211_STA_NOTEXIST)) {
5284                 /*
5285                  * Existing station deletion.
5286                  */
5287                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5288                            "mac vdev %d peer delete %pM (sta gone)\n",
5289                            arvif->vdev_id, sta->addr);
5290
5291                 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5292                 if (ret)
5293                         ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
5294                                     sta->addr, arvif->vdev_id, ret);
5295
5296                 ath10k_mac_dec_num_stations(arvif, sta);
5297
5298                 if (!sta->tdls)
5299                         goto exit;
5300
5301                 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
5302                         goto exit;
5303
5304                 /* This was the last tdls peer in current vif */
5305                 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5306                                                       WMI_TDLS_DISABLE);
5307                 if (ret) {
5308                         ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5309                                     arvif->vdev_id, ret);
5310                 }
5311         } else if (old_state == IEEE80211_STA_AUTH &&
5312                    new_state == IEEE80211_STA_ASSOC &&
5313                    (vif->type == NL80211_IFTYPE_AP ||
5314                     vif->type == NL80211_IFTYPE_ADHOC)) {
5315                 /*
5316                  * New association.
5317                  */
5318                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
5319                            sta->addr);
5320
5321                 ret = ath10k_station_assoc(ar, vif, sta, false);
5322                 if (ret)
5323                         ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
5324                                     sta->addr, arvif->vdev_id, ret);
5325         } else if (old_state == IEEE80211_STA_ASSOC &&
5326                    new_state == IEEE80211_STA_AUTHORIZED &&
5327                    sta->tdls) {
5328                 /*
5329                  * Tdls station authorized.
5330                  */
5331                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n",
5332                            sta->addr);
5333
5334                 ret = ath10k_station_assoc(ar, vif, sta, false);
5335                 if (ret) {
5336                         ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
5337                                     sta->addr, arvif->vdev_id, ret);
5338                         goto exit;
5339                 }
5340
5341                 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5342                                                   WMI_TDLS_PEER_STATE_CONNECTED);
5343                 if (ret)
5344                         ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
5345                                     sta->addr, arvif->vdev_id, ret);
5346         } else if (old_state == IEEE80211_STA_ASSOC &&
5347                     new_state == IEEE80211_STA_AUTH &&
5348                     (vif->type == NL80211_IFTYPE_AP ||
5349                      vif->type == NL80211_IFTYPE_ADHOC)) {
5350                 /*
5351                  * Disassociation.
5352                  */
5353                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
5354                            sta->addr);
5355
5356                 ret = ath10k_station_disassoc(ar, vif, sta);
5357                 if (ret)
5358                         ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
5359                                     sta->addr, arvif->vdev_id, ret);
5360         }
5361 exit:
5362         mutex_unlock(&ar->conf_mutex);
5363         return ret;
5364 }
5365
5366 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5367                                 u16 ac, bool enable)
5368 {
5369         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5370         struct wmi_sta_uapsd_auto_trig_arg arg = {};
5371         u32 prio = 0, acc = 0;
5372         u32 value = 0;
5373         int ret = 0;
5374
5375         lockdep_assert_held(&ar->conf_mutex);
5376
5377         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5378                 return 0;
5379
5380         switch (ac) {
5381         case IEEE80211_AC_VO:
5382                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5383                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5384                 prio = 7;
5385                 acc = 3;
5386                 break;
5387         case IEEE80211_AC_VI:
5388                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5389                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5390                 prio = 5;
5391                 acc = 2;
5392                 break;
5393         case IEEE80211_AC_BE:
5394                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5395                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5396                 prio = 2;
5397                 acc = 1;
5398                 break;
5399         case IEEE80211_AC_BK:
5400                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5401                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5402                 prio = 0;
5403                 acc = 0;
5404                 break;
5405         }
5406
5407         if (enable)
5408                 arvif->u.sta.uapsd |= value;
5409         else
5410                 arvif->u.sta.uapsd &= ~value;
5411
5412         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5413                                           WMI_STA_PS_PARAM_UAPSD,
5414                                           arvif->u.sta.uapsd);
5415         if (ret) {
5416                 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
5417                 goto exit;
5418         }
5419
5420         if (arvif->u.sta.uapsd)
5421                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5422         else
5423                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5424
5425         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5426                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5427                                           value);
5428         if (ret)
5429                 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
5430
5431         ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5432         if (ret) {
5433                 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5434                             arvif->vdev_id, ret);
5435                 return ret;
5436         }
5437
5438         ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5439         if (ret) {
5440                 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5441                             arvif->vdev_id, ret);
5442                 return ret;
5443         }
5444
5445         if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
5446             test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
5447                 /* Only userspace can make an educated decision when to send
5448                  * trigger frame. The following effectively disables u-UAPSD
5449                  * autotrigger in firmware (which is enabled by default
5450                  * provided the autotrigger service is available).
5451                  */
5452
5453                 arg.wmm_ac = acc;
5454                 arg.user_priority = prio;
5455                 arg.service_interval = 0;
5456                 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5457                 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5458
5459                 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
5460                                                 arvif->bssid, &arg, 1);
5461                 if (ret) {
5462                         ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
5463                                     ret);
5464                         return ret;
5465                 }
5466         }
5467
5468 exit:
5469         return ret;
5470 }
5471
5472 static int ath10k_conf_tx(struct ieee80211_hw *hw,
5473                           struct ieee80211_vif *vif, u16 ac,
5474                           const struct ieee80211_tx_queue_params *params)
5475 {
5476         struct ath10k *ar = hw->priv;
5477         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5478         struct wmi_wmm_params_arg *p = NULL;
5479         int ret;
5480
5481         mutex_lock(&ar->conf_mutex);
5482
5483         switch (ac) {
5484         case IEEE80211_AC_VO:
5485                 p = &arvif->wmm_params.ac_vo;
5486                 break;
5487         case IEEE80211_AC_VI:
5488                 p = &arvif->wmm_params.ac_vi;
5489                 break;
5490         case IEEE80211_AC_BE:
5491                 p = &arvif->wmm_params.ac_be;
5492                 break;
5493         case IEEE80211_AC_BK:
5494                 p = &arvif->wmm_params.ac_bk;
5495                 break;
5496         }
5497
5498         if (WARN_ON(!p)) {
5499                 ret = -EINVAL;
5500                 goto exit;
5501         }
5502
5503         p->cwmin = params->cw_min;
5504         p->cwmax = params->cw_max;
5505         p->aifs = params->aifs;
5506
5507         /*
5508          * The channel time duration programmed in the HW is in absolute
5509          * microseconds, while mac80211 gives the txop in units of
5510          * 32 microseconds.
5511          */
5512         p->txop = params->txop * 32;
5513
5514         if (ar->wmi.ops->gen_vdev_wmm_conf) {
5515                 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
5516                                                &arvif->wmm_params);
5517                 if (ret) {
5518                         ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
5519                                     arvif->vdev_id, ret);
5520                         goto exit;
5521                 }
5522         } else {
5523                 /* This won't work well with multi-interface cases but it's
5524                  * better than nothing.
5525                  */
5526                 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
5527                 if (ret) {
5528                         ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
5529                         goto exit;
5530                 }
5531         }
5532
5533         ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5534         if (ret)
5535                 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
5536
5537 exit:
5538         mutex_unlock(&ar->conf_mutex);
5539         return ret;
5540 }
5541
5542 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
5543
5544 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
5545                                     struct ieee80211_vif *vif,
5546                                     struct ieee80211_channel *chan,
5547                                     int duration,
5548                                     enum ieee80211_roc_type type)
5549 {
5550         struct ath10k *ar = hw->priv;
5551         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5552         struct wmi_start_scan_arg arg;
5553         int ret = 0;
5554         u32 scan_time_msec;
5555
5556         mutex_lock(&ar->conf_mutex);
5557
5558         spin_lock_bh(&ar->data_lock);
5559         switch (ar->scan.state) {
5560         case ATH10K_SCAN_IDLE:
5561                 reinit_completion(&ar->scan.started);
5562                 reinit_completion(&ar->scan.completed);
5563                 reinit_completion(&ar->scan.on_channel);
5564                 ar->scan.state = ATH10K_SCAN_STARTING;
5565                 ar->scan.is_roc = true;
5566                 ar->scan.vdev_id = arvif->vdev_id;
5567                 ar->scan.roc_freq = chan->center_freq;
5568                 ar->scan.roc_notify = true;
5569                 ret = 0;
5570                 break;
5571         case ATH10K_SCAN_STARTING:
5572         case ATH10K_SCAN_RUNNING:
5573         case ATH10K_SCAN_ABORTING:
5574                 ret = -EBUSY;
5575                 break;
5576         }
5577         spin_unlock_bh(&ar->data_lock);
5578
5579         if (ret)
5580                 goto exit;
5581
5582         scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
5583
5584         memset(&arg, 0, sizeof(arg));
5585         ath10k_wmi_start_scan_init(ar, &arg);
5586         arg.vdev_id = arvif->vdev_id;
5587         arg.scan_id = ATH10K_SCAN_ID;
5588         arg.n_channels = 1;
5589         arg.channels[0] = chan->center_freq;
5590         arg.dwell_time_active = scan_time_msec;
5591         arg.dwell_time_passive = scan_time_msec;
5592         arg.max_scan_time = scan_time_msec;
5593         arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5594         arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
5595         arg.burst_duration_ms = duration;
5596
5597         ret = ath10k_start_scan(ar, &arg);
5598         if (ret) {
5599                 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
5600                 spin_lock_bh(&ar->data_lock);
5601                 ar->scan.state = ATH10K_SCAN_IDLE;
5602                 spin_unlock_bh(&ar->data_lock);
5603                 goto exit;
5604         }
5605
5606         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
5607         if (ret == 0) {
5608                 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
5609
5610                 ret = ath10k_scan_stop(ar);
5611                 if (ret)
5612                         ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5613
5614                 ret = -ETIMEDOUT;
5615                 goto exit;
5616         }
5617
5618         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
5619                                      msecs_to_jiffies(duration));
5620
5621         ret = 0;
5622 exit:
5623         mutex_unlock(&ar->conf_mutex);
5624         return ret;
5625 }
5626
5627 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
5628 {
5629         struct ath10k *ar = hw->priv;
5630
5631         mutex_lock(&ar->conf_mutex);
5632
5633         spin_lock_bh(&ar->data_lock);
5634         ar->scan.roc_notify = false;
5635         spin_unlock_bh(&ar->data_lock);
5636
5637         ath10k_scan_abort(ar);
5638
5639         mutex_unlock(&ar->conf_mutex);
5640
5641         cancel_delayed_work_sync(&ar->scan.timeout);
5642
5643         return 0;
5644 }
5645
5646 /*
5647  * Both RTS and Fragmentation threshold are interface-specific
5648  * in ath10k, but device-specific in mac80211.
5649  */
5650
5651 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
5652 {
5653         struct ath10k *ar = hw->priv;
5654         struct ath10k_vif *arvif;
5655         int ret = 0;
5656
5657         mutex_lock(&ar->conf_mutex);
5658         list_for_each_entry(arvif, &ar->arvifs, list) {
5659                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
5660                            arvif->vdev_id, value);
5661
5662                 ret = ath10k_mac_set_rts(arvif, value);
5663                 if (ret) {
5664                         ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5665                                     arvif->vdev_id, ret);
5666                         break;
5667                 }
5668         }
5669         mutex_unlock(&ar->conf_mutex);
5670
5671         return ret;
5672 }
5673
5674 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5675 {
5676         /* Even though there's a WMI enum for fragmentation threshold no known
5677          * firmware actually implements it. Moreover it is not possible to rely
5678          * frame fragmentation to mac80211 because firmware clears the "more
5679          * fragments" bit in frame control making it impossible for remote
5680          * devices to reassemble frames.
5681          *
5682          * Hence implement a dummy callback just to say fragmentation isn't
5683          * supported. This effectively prevents mac80211 from doing frame
5684          * fragmentation in software.
5685          */
5686         return -EOPNOTSUPP;
5687 }
5688
5689 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
5690                          u32 queues, bool drop)
5691 {
5692         struct ath10k *ar = hw->priv;
5693         bool skip;
5694         long time_left;
5695
5696         /* mac80211 doesn't care if we really xmit queued frames or not
5697          * we'll collect those frames either way if we stop/delete vdevs */
5698         if (drop)
5699                 return;
5700
5701         mutex_lock(&ar->conf_mutex);
5702
5703         if (ar->state == ATH10K_STATE_WEDGED)
5704                 goto skip;
5705
5706         time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
5707                         bool empty;
5708
5709                         spin_lock_bh(&ar->htt.tx_lock);
5710                         empty = (ar->htt.num_pending_tx == 0);
5711                         spin_unlock_bh(&ar->htt.tx_lock);
5712
5713                         skip = (ar->state == ATH10K_STATE_WEDGED) ||
5714                                test_bit(ATH10K_FLAG_CRASH_FLUSH,
5715                                         &ar->dev_flags);
5716
5717                         (empty || skip);
5718                 }), ATH10K_FLUSH_TIMEOUT_HZ);
5719
5720         if (time_left == 0 || skip)
5721                 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
5722                             skip, ar->state, time_left);
5723
5724 skip:
5725         mutex_unlock(&ar->conf_mutex);
5726 }
5727
5728 /* TODO: Implement this function properly
5729  * For now it is needed to reply to Probe Requests in IBSS mode.
5730  * Propably we need this information from FW.
5731  */
5732 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
5733 {
5734         return 1;
5735 }
5736
5737 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
5738                                      enum ieee80211_reconfig_type reconfig_type)
5739 {
5740         struct ath10k *ar = hw->priv;
5741
5742         if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
5743                 return;
5744
5745         mutex_lock(&ar->conf_mutex);
5746
5747         /* If device failed to restart it will be in a different state, e.g.
5748          * ATH10K_STATE_WEDGED */
5749         if (ar->state == ATH10K_STATE_RESTARTED) {
5750                 ath10k_info(ar, "device successfully recovered\n");
5751                 ar->state = ATH10K_STATE_ON;
5752                 ieee80211_wake_queues(ar->hw);
5753         }
5754
5755         mutex_unlock(&ar->conf_mutex);
5756 }
5757
5758 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
5759                              struct survey_info *survey)
5760 {
5761         struct ath10k *ar = hw->priv;
5762         struct ieee80211_supported_band *sband;
5763         struct survey_info *ar_survey = &ar->survey[idx];
5764         int ret = 0;
5765
5766         mutex_lock(&ar->conf_mutex);
5767
5768         sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
5769         if (sband && idx >= sband->n_channels) {
5770                 idx -= sband->n_channels;
5771                 sband = NULL;
5772         }
5773
5774         if (!sband)
5775                 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
5776
5777         if (!sband || idx >= sband->n_channels) {
5778                 ret = -ENOENT;
5779                 goto exit;
5780         }
5781
5782         spin_lock_bh(&ar->data_lock);
5783         memcpy(survey, ar_survey, sizeof(*survey));
5784         spin_unlock_bh(&ar->data_lock);
5785
5786         survey->channel = &sband->channels[idx];
5787
5788         if (ar->rx_channel == survey->channel)
5789                 survey->filled |= SURVEY_INFO_IN_USE;
5790
5791 exit:
5792         mutex_unlock(&ar->conf_mutex);
5793         return ret;
5794 }
5795
5796 static bool
5797 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
5798                                         enum ieee80211_band band,
5799                                         const struct cfg80211_bitrate_mask *mask)
5800 {
5801         int num_rates = 0;
5802         int i;
5803
5804         num_rates += hweight32(mask->control[band].legacy);
5805
5806         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
5807                 num_rates += hweight8(mask->control[band].ht_mcs[i]);
5808
5809         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
5810                 num_rates += hweight16(mask->control[band].vht_mcs[i]);
5811
5812         return num_rates == 1;
5813 }
5814
5815 static bool
5816 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
5817                                        enum ieee80211_band band,
5818                                        const struct cfg80211_bitrate_mask *mask,
5819                                        int *nss)
5820 {
5821         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
5822         u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
5823         u8 ht_nss_mask = 0;
5824         u8 vht_nss_mask = 0;
5825         int i;
5826
5827         if (mask->control[band].legacy)
5828                 return false;
5829
5830         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
5831                 if (mask->control[band].ht_mcs[i] == 0)
5832                         continue;
5833                 else if (mask->control[band].ht_mcs[i] ==
5834                          sband->ht_cap.mcs.rx_mask[i])
5835                         ht_nss_mask |= BIT(i);
5836                 else
5837                         return false;
5838         }
5839
5840         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
5841                 if (mask->control[band].vht_mcs[i] == 0)
5842                         continue;
5843                 else if (mask->control[band].vht_mcs[i] ==
5844                          ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
5845                         vht_nss_mask |= BIT(i);
5846                 else
5847                         return false;
5848         }
5849
5850         if (ht_nss_mask != vht_nss_mask)
5851                 return false;
5852
5853         if (ht_nss_mask == 0)
5854                 return false;
5855
5856         if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
5857                 return false;
5858
5859         *nss = fls(ht_nss_mask);
5860
5861         return true;
5862 }
5863
5864 static int
5865 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
5866                                         enum ieee80211_band band,
5867                                         const struct cfg80211_bitrate_mask *mask,
5868                                         u8 *rate, u8 *nss)
5869 {
5870         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
5871         int rate_idx;
5872         int i;
5873         u16 bitrate;
5874         u8 preamble;
5875         u8 hw_rate;
5876
5877         if (hweight32(mask->control[band].legacy) == 1) {
5878                 rate_idx = ffs(mask->control[band].legacy) - 1;
5879
5880                 hw_rate = sband->bitrates[rate_idx].hw_value;
5881                 bitrate = sband->bitrates[rate_idx].bitrate;
5882
5883                 if (ath10k_mac_bitrate_is_cck(bitrate))
5884                         preamble = WMI_RATE_PREAMBLE_CCK;
5885                 else
5886                         preamble = WMI_RATE_PREAMBLE_OFDM;
5887
5888                 *nss = 1;
5889                 *rate = preamble << 6 |
5890                         (*nss - 1) << 4 |
5891                         hw_rate << 0;
5892
5893                 return 0;
5894         }
5895
5896         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
5897                 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
5898                         *nss = i + 1;
5899                         *rate = WMI_RATE_PREAMBLE_HT << 6 |
5900                                 (*nss - 1) << 4 |
5901                                 (ffs(mask->control[band].ht_mcs[i]) - 1);
5902
5903                         return 0;
5904                 }
5905         }
5906
5907         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
5908                 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
5909                         *nss = i + 1;
5910                         *rate = WMI_RATE_PREAMBLE_VHT << 6 |
5911                                 (*nss - 1) << 4 |
5912                                 (ffs(mask->control[band].vht_mcs[i]) - 1);
5913
5914                         return 0;
5915                 }
5916         }
5917
5918         return -EINVAL;
5919 }
5920
5921 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
5922                                             u8 rate, u8 nss, u8 sgi)
5923 {
5924         struct ath10k *ar = arvif->ar;
5925         u32 vdev_param;
5926         int ret;
5927
5928         lockdep_assert_held(&ar->conf_mutex);
5929
5930         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
5931                    arvif->vdev_id, rate, nss, sgi);
5932
5933         vdev_param = ar->wmi.vdev_param->fixed_rate;
5934         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
5935         if (ret) {
5936                 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
5937                             rate, ret);
5938                 return ret;
5939         }
5940
5941         vdev_param = ar->wmi.vdev_param->nss;
5942         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
5943         if (ret) {
5944                 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
5945                 return ret;
5946         }
5947
5948         vdev_param = ar->wmi.vdev_param->sgi;
5949         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
5950         if (ret) {
5951                 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
5952                 return ret;
5953         }
5954
5955         return 0;
5956 }
5957
5958 static bool
5959 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
5960                                 enum ieee80211_band band,
5961                                 const struct cfg80211_bitrate_mask *mask)
5962 {
5963         int i;
5964         u16 vht_mcs;
5965
5966         /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
5967          * to express all VHT MCS rate masks. Effectively only the following
5968          * ranges can be used: none, 0-7, 0-8 and 0-9.
5969          */
5970         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
5971                 vht_mcs = mask->control[band].vht_mcs[i];
5972
5973                 switch (vht_mcs) {
5974                 case 0:
5975                 case BIT(8) - 1:
5976                 case BIT(9) - 1:
5977                 case BIT(10) - 1:
5978                         break;
5979                 default:
5980                         ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
5981                         return false;
5982                 }
5983         }
5984
5985         return true;
5986 }
5987
5988 static void ath10k_mac_set_bitrate_mask_iter(void *data,
5989                                              struct ieee80211_sta *sta)
5990 {
5991         struct ath10k_vif *arvif = data;
5992         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5993         struct ath10k *ar = arvif->ar;
5994
5995         if (arsta->arvif != arvif)
5996                 return;
5997
5998         spin_lock_bh(&ar->data_lock);
5999         arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
6000         spin_unlock_bh(&ar->data_lock);
6001
6002         ieee80211_queue_work(ar->hw, &arsta->update_wk);
6003 }
6004
6005 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
6006                                           struct ieee80211_vif *vif,
6007                                           const struct cfg80211_bitrate_mask *mask)
6008 {
6009         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6010         struct cfg80211_chan_def def;
6011         struct ath10k *ar = arvif->ar;
6012         enum ieee80211_band band;
6013         const u8 *ht_mcs_mask;
6014         const u16 *vht_mcs_mask;
6015         u8 rate;
6016         u8 nss;
6017         u8 sgi;
6018         int single_nss;
6019         int ret;
6020
6021         if (ath10k_mac_vif_chan(vif, &def))
6022                 return -EPERM;
6023
6024         band = def.chan->band;
6025         ht_mcs_mask = mask->control[band].ht_mcs;
6026         vht_mcs_mask = mask->control[band].vht_mcs;
6027
6028         sgi = mask->control[band].gi;
6029         if (sgi == NL80211_TXRATE_FORCE_LGI)
6030                 return -EINVAL;
6031
6032         if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) {
6033                 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
6034                                                               &rate, &nss);
6035                 if (ret) {
6036                         ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
6037                                     arvif->vdev_id, ret);
6038                         return ret;
6039                 }
6040         } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
6041                                                           &single_nss)) {
6042                 rate = WMI_FIXED_RATE_NONE;
6043                 nss = single_nss;
6044         } else {
6045                 rate = WMI_FIXED_RATE_NONE;
6046                 nss = min(ar->num_rf_chains,
6047                           max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6048                               ath10k_mac_max_vht_nss(vht_mcs_mask)));
6049
6050                 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask))
6051                         return -EINVAL;
6052
6053                 mutex_lock(&ar->conf_mutex);
6054
6055                 arvif->bitrate_mask = *mask;
6056                 ieee80211_iterate_stations_atomic(ar->hw,
6057                                                   ath10k_mac_set_bitrate_mask_iter,
6058                                                   arvif);
6059
6060                 mutex_unlock(&ar->conf_mutex);
6061         }
6062
6063         mutex_lock(&ar->conf_mutex);
6064
6065         ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi);
6066         if (ret) {
6067                 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
6068                             arvif->vdev_id, ret);
6069                 goto exit;
6070         }
6071
6072 exit:
6073         mutex_unlock(&ar->conf_mutex);
6074
6075         return ret;
6076 }
6077
6078 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
6079                                  struct ieee80211_vif *vif,
6080                                  struct ieee80211_sta *sta,
6081                                  u32 changed)
6082 {
6083         struct ath10k *ar = hw->priv;
6084         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6085         u32 bw, smps;
6086
6087         spin_lock_bh(&ar->data_lock);
6088
6089         ath10k_dbg(ar, ATH10K_DBG_MAC,
6090                    "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
6091                    sta->addr, changed, sta->bandwidth, sta->rx_nss,
6092                    sta->smps_mode);
6093
6094         if (changed & IEEE80211_RC_BW_CHANGED) {
6095                 bw = WMI_PEER_CHWIDTH_20MHZ;
6096
6097                 switch (sta->bandwidth) {
6098                 case IEEE80211_STA_RX_BW_20:
6099                         bw = WMI_PEER_CHWIDTH_20MHZ;
6100                         break;
6101                 case IEEE80211_STA_RX_BW_40:
6102                         bw = WMI_PEER_CHWIDTH_40MHZ;
6103                         break;
6104                 case IEEE80211_STA_RX_BW_80:
6105                         bw = WMI_PEER_CHWIDTH_80MHZ;
6106                         break;
6107                 case IEEE80211_STA_RX_BW_160:
6108                         ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
6109                                     sta->bandwidth, sta->addr);
6110                         bw = WMI_PEER_CHWIDTH_20MHZ;
6111                         break;
6112                 }
6113
6114                 arsta->bw = bw;
6115         }
6116
6117         if (changed & IEEE80211_RC_NSS_CHANGED)
6118                 arsta->nss = sta->rx_nss;
6119
6120         if (changed & IEEE80211_RC_SMPS_CHANGED) {
6121                 smps = WMI_PEER_SMPS_PS_NONE;
6122
6123                 switch (sta->smps_mode) {
6124                 case IEEE80211_SMPS_AUTOMATIC:
6125                 case IEEE80211_SMPS_OFF:
6126                         smps = WMI_PEER_SMPS_PS_NONE;
6127                         break;
6128                 case IEEE80211_SMPS_STATIC:
6129                         smps = WMI_PEER_SMPS_STATIC;
6130                         break;
6131                 case IEEE80211_SMPS_DYNAMIC:
6132                         smps = WMI_PEER_SMPS_DYNAMIC;
6133                         break;
6134                 case IEEE80211_SMPS_NUM_MODES:
6135                         ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
6136                                     sta->smps_mode, sta->addr);
6137                         smps = WMI_PEER_SMPS_PS_NONE;
6138                         break;
6139                 }
6140
6141                 arsta->smps = smps;
6142         }
6143
6144         arsta->changed |= changed;
6145
6146         spin_unlock_bh(&ar->data_lock);
6147
6148         ieee80211_queue_work(hw, &arsta->update_wk);
6149 }
6150
6151 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
6152 {
6153         /*
6154          * FIXME: Return 0 for time being. Need to figure out whether FW
6155          * has the API to fetch 64-bit local TSF
6156          */
6157
6158         return 0;
6159 }
6160
6161 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
6162                                struct ieee80211_vif *vif,
6163                                enum ieee80211_ampdu_mlme_action action,
6164                                struct ieee80211_sta *sta, u16 tid, u16 *ssn,
6165                                u8 buf_size)
6166 {
6167         struct ath10k *ar = hw->priv;
6168         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6169
6170         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6171                    arvif->vdev_id, sta->addr, tid, action);
6172
6173         switch (action) {
6174         case IEEE80211_AMPDU_RX_START:
6175         case IEEE80211_AMPDU_RX_STOP:
6176                 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6177                  * creation/removal. Do we need to verify this?
6178                  */
6179                 return 0;
6180         case IEEE80211_AMPDU_TX_START:
6181         case IEEE80211_AMPDU_TX_STOP_CONT:
6182         case IEEE80211_AMPDU_TX_STOP_FLUSH:
6183         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6184         case IEEE80211_AMPDU_TX_OPERATIONAL:
6185                 /* Firmware offloads Tx aggregation entirely so deny mac80211
6186                  * Tx aggregation requests.
6187                  */
6188                 return -EOPNOTSUPP;
6189         }
6190
6191         return -EINVAL;
6192 }
6193
6194 static void
6195 ath10k_mac_update_rx_channel(struct ath10k *ar,
6196                              struct ieee80211_chanctx_conf *ctx,
6197                              struct ieee80211_vif_chanctx_switch *vifs,
6198                              int n_vifs)
6199 {
6200         struct cfg80211_chan_def *def = NULL;
6201
6202         /* Both locks are required because ar->rx_channel is modified. This
6203          * allows readers to hold either lock.
6204          */
6205         lockdep_assert_held(&ar->conf_mutex);
6206         lockdep_assert_held(&ar->data_lock);
6207
6208         WARN_ON(ctx && vifs);
6209         WARN_ON(vifs && n_vifs != 1);
6210
6211         /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6212          * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6213          * ppdu on Rx may reduce performance on low-end systems. It should be
6214          * possible to make tables/hashmaps to speed the lookup up (be vary of
6215          * cpu data cache lines though regarding sizes) but to keep the initial
6216          * implementation simple and less intrusive fallback to the slow lookup
6217          * only for multi-channel cases. Single-channel cases will remain to
6218          * use the old channel derival and thus performance should not be
6219          * affected much.
6220          */
6221         rcu_read_lock();
6222         if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
6223                 ieee80211_iter_chan_contexts_atomic(ar->hw,
6224                                         ath10k_mac_get_any_chandef_iter,
6225                                         &def);
6226
6227                 if (vifs)
6228                         def = &vifs[0].new_ctx->def;
6229
6230                 ar->rx_channel = def->chan;
6231         } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) {
6232                 ar->rx_channel = ctx->def.chan;
6233         } else {
6234                 ar->rx_channel = NULL;
6235         }
6236         rcu_read_unlock();
6237 }
6238
6239 static int
6240 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6241                           struct ieee80211_chanctx_conf *ctx)
6242 {
6243         struct ath10k *ar = hw->priv;
6244
6245         ath10k_dbg(ar, ATH10K_DBG_MAC,
6246                    "mac chanctx add freq %hu width %d ptr %p\n",
6247                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6248
6249         mutex_lock(&ar->conf_mutex);
6250
6251         spin_lock_bh(&ar->data_lock);
6252         ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
6253         spin_unlock_bh(&ar->data_lock);
6254
6255         ath10k_recalc_radar_detection(ar);
6256         ath10k_monitor_recalc(ar);
6257
6258         mutex_unlock(&ar->conf_mutex);
6259
6260         return 0;
6261 }
6262
6263 static void
6264 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6265                              struct ieee80211_chanctx_conf *ctx)
6266 {
6267         struct ath10k *ar = hw->priv;
6268
6269         ath10k_dbg(ar, ATH10K_DBG_MAC,
6270                    "mac chanctx remove freq %hu width %d ptr %p\n",
6271                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6272
6273         mutex_lock(&ar->conf_mutex);
6274
6275         spin_lock_bh(&ar->data_lock);
6276         ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
6277         spin_unlock_bh(&ar->data_lock);
6278
6279         ath10k_recalc_radar_detection(ar);
6280         ath10k_monitor_recalc(ar);
6281
6282         mutex_unlock(&ar->conf_mutex);
6283 }
6284
6285 static void
6286 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6287                              struct ieee80211_chanctx_conf *ctx,
6288                              u32 changed)
6289 {
6290         struct ath10k *ar = hw->priv;
6291
6292         mutex_lock(&ar->conf_mutex);
6293
6294         ath10k_dbg(ar, ATH10K_DBG_MAC,
6295                    "mac chanctx change freq %hu width %d ptr %p changed %x\n",
6296                    ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6297
6298         /* This shouldn't really happen because channel switching should use
6299          * switch_vif_chanctx().
6300          */
6301         if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6302                 goto unlock;
6303
6304         ath10k_recalc_radar_detection(ar);
6305
6306         /* FIXME: How to configure Rx chains properly? */
6307
6308         /* No other actions are actually necessary. Firmware maintains channel
6309          * definitions per vdev internally and there's no host-side channel
6310          * context abstraction to configure, e.g. channel width.
6311          */
6312
6313 unlock:
6314         mutex_unlock(&ar->conf_mutex);
6315 }
6316
6317 static int
6318 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
6319                                  struct ieee80211_vif *vif,
6320                                  struct ieee80211_chanctx_conf *ctx)
6321 {
6322         struct ath10k *ar = hw->priv;
6323         struct ath10k_vif *arvif = (void *)vif->drv_priv;
6324         int ret;
6325
6326         mutex_lock(&ar->conf_mutex);
6327
6328         ath10k_dbg(ar, ATH10K_DBG_MAC,
6329                    "mac chanctx assign ptr %p vdev_id %i\n",
6330                    ctx, arvif->vdev_id);
6331
6332         if (WARN_ON(arvif->is_started)) {
6333                 mutex_unlock(&ar->conf_mutex);
6334                 return -EBUSY;
6335         }
6336
6337         ret = ath10k_vdev_start(arvif, &ctx->def);
6338         if (ret) {
6339                 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
6340                             arvif->vdev_id, vif->addr,
6341                             ctx->def.chan->center_freq, ret);
6342                 goto err;
6343         }
6344
6345         arvif->is_started = true;
6346
6347         ret = ath10k_mac_vif_setup_ps(arvif);
6348         if (ret) {
6349                 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
6350                             arvif->vdev_id, ret);
6351                 goto err_stop;
6352         }
6353
6354         if (vif->type == NL80211_IFTYPE_MONITOR) {
6355                 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
6356                 if (ret) {
6357                         ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
6358                                     arvif->vdev_id, ret);
6359                         goto err_stop;
6360                 }
6361
6362                 arvif->is_up = true;
6363         }
6364
6365         mutex_unlock(&ar->conf_mutex);
6366         return 0;
6367
6368 err_stop:
6369         ath10k_vdev_stop(arvif);
6370         arvif->is_started = false;
6371         ath10k_mac_vif_setup_ps(arvif);
6372
6373 err:
6374         mutex_unlock(&ar->conf_mutex);
6375         return ret;
6376 }
6377
6378 static void
6379 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
6380                                    struct ieee80211_vif *vif,
6381                                    struct ieee80211_chanctx_conf *ctx)
6382 {
6383         struct ath10k *ar = hw->priv;
6384         struct ath10k_vif *arvif = (void *)vif->drv_priv;
6385         int ret;
6386
6387         mutex_lock(&ar->conf_mutex);
6388
6389         ath10k_dbg(ar, ATH10K_DBG_MAC,
6390                    "mac chanctx unassign ptr %p vdev_id %i\n",
6391                    ctx, arvif->vdev_id);
6392
6393         WARN_ON(!arvif->is_started);
6394
6395         if (vif->type == NL80211_IFTYPE_MONITOR) {
6396                 WARN_ON(!arvif->is_up);
6397
6398                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6399                 if (ret)
6400                         ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
6401                                     arvif->vdev_id, ret);
6402
6403                 arvif->is_up = false;
6404         }
6405
6406         ret = ath10k_vdev_stop(arvif);
6407         if (ret)
6408                 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
6409                             arvif->vdev_id, ret);
6410
6411         arvif->is_started = false;
6412
6413         mutex_unlock(&ar->conf_mutex);
6414 }
6415
6416 static int
6417 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
6418                                  struct ieee80211_vif_chanctx_switch *vifs,
6419                                  int n_vifs,
6420                                  enum ieee80211_chanctx_switch_mode mode)
6421 {
6422         struct ath10k *ar = hw->priv;
6423         struct ath10k_vif *arvif;
6424         int ret;
6425         int i;
6426
6427         mutex_lock(&ar->conf_mutex);
6428
6429         ath10k_dbg(ar, ATH10K_DBG_MAC,
6430                    "mac chanctx switch n_vifs %d mode %d\n",
6431                    n_vifs, mode);
6432
6433         /* First stop monitor interface. Some FW versions crash if there's a
6434          * lone monitor interface.
6435          */
6436         if (ar->monitor_started)
6437                 ath10k_monitor_stop(ar);
6438
6439         for (i = 0; i < n_vifs; i++) {
6440                 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6441
6442                 ath10k_dbg(ar, ATH10K_DBG_MAC,
6443                            "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6444                            arvif->vdev_id,
6445                            vifs[i].old_ctx->def.chan->center_freq,
6446                            vifs[i].new_ctx->def.chan->center_freq,
6447                            vifs[i].old_ctx->def.width,
6448                            vifs[i].new_ctx->def.width);
6449
6450                 if (WARN_ON(!arvif->is_started))
6451                         continue;
6452
6453                 if (WARN_ON(!arvif->is_up))
6454                         continue;
6455
6456                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6457                 if (ret) {
6458                         ath10k_warn(ar, "failed to down vdev %d: %d\n",
6459                                     arvif->vdev_id, ret);
6460                         continue;
6461                 }
6462         }
6463
6464         /* All relevant vdevs are downed and associated channel resources
6465          * should be available for the channel switch now.
6466          */
6467
6468         spin_lock_bh(&ar->data_lock);
6469         ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
6470         spin_unlock_bh(&ar->data_lock);
6471
6472         for (i = 0; i < n_vifs; i++) {
6473                 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6474
6475                 if (WARN_ON(!arvif->is_started))
6476                         continue;
6477
6478                 if (WARN_ON(!arvif->is_up))
6479                         continue;
6480
6481                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6482                 if (ret)
6483                         ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
6484                                     ret);
6485
6486                 ret = ath10k_mac_setup_prb_tmpl(arvif);
6487                 if (ret)
6488                         ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
6489                                     ret);
6490
6491                 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
6492                 if (ret) {
6493                         ath10k_warn(ar, "failed to restart vdev %d: %d\n",
6494                                     arvif->vdev_id, ret);
6495                         continue;
6496                 }
6497
6498                 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6499                                          arvif->bssid);
6500                 if (ret) {
6501                         ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
6502                                     arvif->vdev_id, ret);
6503                         continue;
6504                 }
6505         }
6506
6507         ath10k_monitor_recalc(ar);
6508
6509         mutex_unlock(&ar->conf_mutex);
6510         return 0;
6511 }
6512
6513 static const struct ieee80211_ops ath10k_ops = {
6514         .tx                             = ath10k_tx,
6515         .start                          = ath10k_start,
6516         .stop                           = ath10k_stop,
6517         .config                         = ath10k_config,
6518         .add_interface                  = ath10k_add_interface,
6519         .remove_interface               = ath10k_remove_interface,
6520         .configure_filter               = ath10k_configure_filter,
6521         .bss_info_changed               = ath10k_bss_info_changed,
6522         .hw_scan                        = ath10k_hw_scan,
6523         .cancel_hw_scan                 = ath10k_cancel_hw_scan,
6524         .set_key                        = ath10k_set_key,
6525         .set_default_unicast_key        = ath10k_set_default_unicast_key,
6526         .sta_state                      = ath10k_sta_state,
6527         .conf_tx                        = ath10k_conf_tx,
6528         .remain_on_channel              = ath10k_remain_on_channel,
6529         .cancel_remain_on_channel       = ath10k_cancel_remain_on_channel,
6530         .set_rts_threshold              = ath10k_set_rts_threshold,
6531         .set_frag_threshold             = ath10k_mac_op_set_frag_threshold,
6532         .flush                          = ath10k_flush,
6533         .tx_last_beacon                 = ath10k_tx_last_beacon,
6534         .set_antenna                    = ath10k_set_antenna,
6535         .get_antenna                    = ath10k_get_antenna,
6536         .reconfig_complete              = ath10k_reconfig_complete,
6537         .get_survey                     = ath10k_get_survey,
6538         .set_bitrate_mask               = ath10k_mac_op_set_bitrate_mask,
6539         .sta_rc_update                  = ath10k_sta_rc_update,
6540         .get_tsf                        = ath10k_get_tsf,
6541         .ampdu_action                   = ath10k_ampdu_action,
6542         .get_et_sset_count              = ath10k_debug_get_et_sset_count,
6543         .get_et_stats                   = ath10k_debug_get_et_stats,
6544         .get_et_strings                 = ath10k_debug_get_et_strings,
6545         .add_chanctx                    = ath10k_mac_op_add_chanctx,
6546         .remove_chanctx                 = ath10k_mac_op_remove_chanctx,
6547         .change_chanctx                 = ath10k_mac_op_change_chanctx,
6548         .assign_vif_chanctx             = ath10k_mac_op_assign_vif_chanctx,
6549         .unassign_vif_chanctx           = ath10k_mac_op_unassign_vif_chanctx,
6550         .switch_vif_chanctx             = ath10k_mac_op_switch_vif_chanctx,
6551
6552         CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
6553
6554 #ifdef CONFIG_PM
6555         .suspend                        = ath10k_wow_op_suspend,
6556         .resume                         = ath10k_wow_op_resume,
6557 #endif
6558 #ifdef CONFIG_MAC80211_DEBUGFS
6559         .sta_add_debugfs                = ath10k_sta_add_debugfs,
6560 #endif
6561 };
6562
6563 #define CHAN2G(_channel, _freq, _flags) { \
6564         .band                   = IEEE80211_BAND_2GHZ, \
6565         .hw_value               = (_channel), \
6566         .center_freq            = (_freq), \
6567         .flags                  = (_flags), \
6568         .max_antenna_gain       = 0, \
6569         .max_power              = 30, \
6570 }
6571
6572 #define CHAN5G(_channel, _freq, _flags) { \
6573         .band                   = IEEE80211_BAND_5GHZ, \
6574         .hw_value               = (_channel), \
6575         .center_freq            = (_freq), \
6576         .flags                  = (_flags), \
6577         .max_antenna_gain       = 0, \
6578         .max_power              = 30, \
6579 }
6580
6581 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
6582         CHAN2G(1, 2412, 0),
6583         CHAN2G(2, 2417, 0),
6584         CHAN2G(3, 2422, 0),
6585         CHAN2G(4, 2427, 0),
6586         CHAN2G(5, 2432, 0),
6587         CHAN2G(6, 2437, 0),
6588         CHAN2G(7, 2442, 0),
6589         CHAN2G(8, 2447, 0),
6590         CHAN2G(9, 2452, 0),
6591         CHAN2G(10, 2457, 0),
6592         CHAN2G(11, 2462, 0),
6593         CHAN2G(12, 2467, 0),
6594         CHAN2G(13, 2472, 0),
6595         CHAN2G(14, 2484, 0),
6596 };
6597
6598 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
6599         CHAN5G(36, 5180, 0),
6600         CHAN5G(40, 5200, 0),
6601         CHAN5G(44, 5220, 0),
6602         CHAN5G(48, 5240, 0),
6603         CHAN5G(52, 5260, 0),
6604         CHAN5G(56, 5280, 0),
6605         CHAN5G(60, 5300, 0),
6606         CHAN5G(64, 5320, 0),
6607         CHAN5G(100, 5500, 0),
6608         CHAN5G(104, 5520, 0),
6609         CHAN5G(108, 5540, 0),
6610         CHAN5G(112, 5560, 0),
6611         CHAN5G(116, 5580, 0),
6612         CHAN5G(120, 5600, 0),
6613         CHAN5G(124, 5620, 0),
6614         CHAN5G(128, 5640, 0),
6615         CHAN5G(132, 5660, 0),
6616         CHAN5G(136, 5680, 0),
6617         CHAN5G(140, 5700, 0),
6618         CHAN5G(144, 5720, 0),
6619         CHAN5G(149, 5745, 0),
6620         CHAN5G(153, 5765, 0),
6621         CHAN5G(157, 5785, 0),
6622         CHAN5G(161, 5805, 0),
6623         CHAN5G(165, 5825, 0),
6624 };
6625
6626 struct ath10k *ath10k_mac_create(size_t priv_size)
6627 {
6628         struct ieee80211_hw *hw;
6629         struct ath10k *ar;
6630
6631         hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
6632         if (!hw)
6633                 return NULL;
6634
6635         ar = hw->priv;
6636         ar->hw = hw;
6637
6638         return ar;
6639 }
6640
6641 void ath10k_mac_destroy(struct ath10k *ar)
6642 {
6643         ieee80211_free_hw(ar->hw);
6644 }
6645
6646 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
6647         {
6648         .max    = 8,
6649         .types  = BIT(NL80211_IFTYPE_STATION)
6650                 | BIT(NL80211_IFTYPE_P2P_CLIENT)
6651         },
6652         {
6653         .max    = 3,
6654         .types  = BIT(NL80211_IFTYPE_P2P_GO)
6655         },
6656         {
6657         .max    = 1,
6658         .types  = BIT(NL80211_IFTYPE_P2P_DEVICE)
6659         },
6660         {
6661         .max    = 7,
6662         .types  = BIT(NL80211_IFTYPE_AP)
6663         },
6664 };
6665
6666 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
6667         {
6668         .max    = 8,
6669         .types  = BIT(NL80211_IFTYPE_AP)
6670         },
6671 };
6672
6673 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
6674         {
6675                 .limits = ath10k_if_limits,
6676                 .n_limits = ARRAY_SIZE(ath10k_if_limits),
6677                 .max_interfaces = 8,
6678                 .num_different_channels = 1,
6679                 .beacon_int_infra_match = true,
6680         },
6681 };
6682
6683 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
6684         {
6685                 .limits = ath10k_10x_if_limits,
6686                 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
6687                 .max_interfaces = 8,
6688                 .num_different_channels = 1,
6689                 .beacon_int_infra_match = true,
6690 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6691                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6692                                         BIT(NL80211_CHAN_WIDTH_20) |
6693                                         BIT(NL80211_CHAN_WIDTH_40) |
6694                                         BIT(NL80211_CHAN_WIDTH_80),
6695 #endif
6696         },
6697 };
6698
6699 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
6700         {
6701                 .max = 2,
6702                 .types = BIT(NL80211_IFTYPE_STATION),
6703         },
6704         {
6705                 .max = 2,
6706                 .types = BIT(NL80211_IFTYPE_AP) |
6707                          BIT(NL80211_IFTYPE_P2P_CLIENT) |
6708                          BIT(NL80211_IFTYPE_P2P_GO),
6709         },
6710         {
6711                 .max = 1,
6712                 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
6713         },
6714 };
6715
6716 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
6717         {
6718                 .max = 2,
6719                 .types = BIT(NL80211_IFTYPE_STATION),
6720         },
6721         {
6722                 .max = 2,
6723                 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
6724         },
6725         {
6726                 .max = 1,
6727                 .types = BIT(NL80211_IFTYPE_AP) |
6728                          BIT(NL80211_IFTYPE_P2P_GO),
6729         },
6730         {
6731                 .max = 1,
6732                 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
6733         },
6734 };
6735
6736 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
6737         {
6738                 .max = 1,
6739                 .types = BIT(NL80211_IFTYPE_STATION),
6740         },
6741         {
6742                 .max = 1,
6743                 .types = BIT(NL80211_IFTYPE_ADHOC),
6744         },
6745 };
6746
6747 /* FIXME: This is not thouroughly tested. These combinations may over- or
6748  * underestimate hw/fw capabilities.
6749  */
6750 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
6751         {
6752                 .limits = ath10k_tlv_if_limit,
6753                 .num_different_channels = 1,
6754                 .max_interfaces = 4,
6755                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
6756         },
6757         {
6758                 .limits = ath10k_tlv_if_limit_ibss,
6759                 .num_different_channels = 1,
6760                 .max_interfaces = 2,
6761                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
6762         },
6763 };
6764
6765 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
6766         {
6767                 .limits = ath10k_tlv_if_limit,
6768                 .num_different_channels = 1,
6769                 .max_interfaces = 4,
6770                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
6771         },
6772         {
6773                 .limits = ath10k_tlv_qcs_if_limit,
6774                 .num_different_channels = 2,
6775                 .max_interfaces = 4,
6776                 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
6777         },
6778         {
6779                 .limits = ath10k_tlv_if_limit_ibss,
6780                 .num_different_channels = 1,
6781                 .max_interfaces = 2,
6782                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
6783         },
6784 };
6785
6786 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
6787         {
6788                 .max = 1,
6789                 .types = BIT(NL80211_IFTYPE_STATION),
6790         },
6791         {
6792                 .max    = 16,
6793                 .types  = BIT(NL80211_IFTYPE_AP)
6794         },
6795 };
6796
6797 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
6798         {
6799                 .limits = ath10k_10_4_if_limits,
6800                 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
6801                 .max_interfaces = 16,
6802                 .num_different_channels = 1,
6803                 .beacon_int_infra_match = true,
6804 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6805                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6806                                         BIT(NL80211_CHAN_WIDTH_20) |
6807                                         BIT(NL80211_CHAN_WIDTH_40) |
6808                                         BIT(NL80211_CHAN_WIDTH_80),
6809 #endif
6810         },
6811 };
6812
6813 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
6814 {
6815         struct ieee80211_sta_vht_cap vht_cap = {0};
6816         u16 mcs_map;
6817         u32 val;
6818         int i;
6819
6820         vht_cap.vht_supported = 1;
6821         vht_cap.cap = ar->vht_cap_info;
6822
6823         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
6824                                 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
6825                 val = ath10k_mac_get_vht_cap_bf_sts(ar);
6826                 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
6827                 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
6828
6829                 vht_cap.cap |= val;
6830         }
6831
6832         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
6833                                 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
6834                 val = ar->num_rf_chains - 1;
6835                 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
6836                 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
6837
6838                 vht_cap.cap |= val;
6839         }
6840
6841         mcs_map = 0;
6842         for (i = 0; i < 8; i++) {
6843                 if (i < ar->num_rf_chains)
6844                         mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
6845                 else
6846                         mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
6847         }
6848
6849         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
6850         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
6851
6852         return vht_cap;
6853 }
6854
6855 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
6856 {
6857         int i;
6858         struct ieee80211_sta_ht_cap ht_cap = {0};
6859
6860         if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
6861                 return ht_cap;
6862
6863         ht_cap.ht_supported = 1;
6864         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
6865         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
6866         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
6867         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
6868         ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
6869
6870         if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
6871                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
6872
6873         if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
6874                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
6875
6876         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
6877                 u32 smps;
6878
6879                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
6880                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
6881
6882                 ht_cap.cap |= smps;
6883         }
6884
6885         if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
6886                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
6887
6888         if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
6889                 u32 stbc;
6890
6891                 stbc   = ar->ht_cap_info;
6892                 stbc  &= WMI_HT_CAP_RX_STBC;
6893                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
6894                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
6895                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
6896
6897                 ht_cap.cap |= stbc;
6898         }
6899
6900         if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
6901                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
6902
6903         if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
6904                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
6905
6906         /* max AMSDU is implicitly taken from vht_cap_info */
6907         if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
6908                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
6909
6910         for (i = 0; i < ar->num_rf_chains; i++)
6911                 ht_cap.mcs.rx_mask[i] = 0xFF;
6912
6913         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
6914
6915         return ht_cap;
6916 }
6917
6918 static void ath10k_get_arvif_iter(void *data, u8 *mac,
6919                                   struct ieee80211_vif *vif)
6920 {
6921         struct ath10k_vif_iter *arvif_iter = data;
6922         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6923
6924         if (arvif->vdev_id == arvif_iter->vdev_id)
6925                 arvif_iter->arvif = arvif;
6926 }
6927
6928 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
6929 {
6930         struct ath10k_vif_iter arvif_iter;
6931         u32 flags;
6932
6933         memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
6934         arvif_iter.vdev_id = vdev_id;
6935
6936         flags = IEEE80211_IFACE_ITER_RESUME_ALL;
6937         ieee80211_iterate_active_interfaces_atomic(ar->hw,
6938                                                    flags,
6939                                                    ath10k_get_arvif_iter,
6940                                                    &arvif_iter);
6941         if (!arvif_iter.arvif) {
6942                 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
6943                 return NULL;
6944         }
6945
6946         return arvif_iter.arvif;
6947 }
6948
6949 int ath10k_mac_register(struct ath10k *ar)
6950 {
6951         static const u32 cipher_suites[] = {
6952                 WLAN_CIPHER_SUITE_WEP40,
6953                 WLAN_CIPHER_SUITE_WEP104,
6954                 WLAN_CIPHER_SUITE_TKIP,
6955                 WLAN_CIPHER_SUITE_CCMP,
6956                 WLAN_CIPHER_SUITE_AES_CMAC,
6957         };
6958         struct ieee80211_supported_band *band;
6959         struct ieee80211_sta_vht_cap vht_cap;
6960         struct ieee80211_sta_ht_cap ht_cap;
6961         void *channels;
6962         int ret;
6963
6964         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
6965
6966         SET_IEEE80211_DEV(ar->hw, ar->dev);
6967
6968         ht_cap = ath10k_get_ht_cap(ar);
6969         vht_cap = ath10k_create_vht_cap(ar);
6970
6971         BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
6972                       ARRAY_SIZE(ath10k_5ghz_channels)) !=
6973                      ATH10K_NUM_CHANS);
6974
6975         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
6976                 channels = kmemdup(ath10k_2ghz_channels,
6977                                    sizeof(ath10k_2ghz_channels),
6978                                    GFP_KERNEL);
6979                 if (!channels) {
6980                         ret = -ENOMEM;
6981                         goto err_free;
6982                 }
6983
6984                 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
6985                 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
6986                 band->channels = channels;
6987                 band->n_bitrates = ath10k_g_rates_size;
6988                 band->bitrates = ath10k_g_rates;
6989                 band->ht_cap = ht_cap;
6990
6991                 /* Enable the VHT support at 2.4 GHz */
6992                 band->vht_cap = vht_cap;
6993
6994                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
6995         }
6996
6997         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
6998                 channels = kmemdup(ath10k_5ghz_channels,
6999                                    sizeof(ath10k_5ghz_channels),
7000                                    GFP_KERNEL);
7001                 if (!channels) {
7002                         ret = -ENOMEM;
7003                         goto err_free;
7004                 }
7005
7006                 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
7007                 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
7008                 band->channels = channels;
7009                 band->n_bitrates = ath10k_a_rates_size;
7010                 band->bitrates = ath10k_a_rates;
7011                 band->ht_cap = ht_cap;
7012                 band->vht_cap = vht_cap;
7013                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
7014         }
7015
7016         ar->hw->wiphy->interface_modes =
7017                 BIT(NL80211_IFTYPE_STATION) |
7018                 BIT(NL80211_IFTYPE_AP);
7019
7020         ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
7021         ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
7022
7023         if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
7024                 ar->hw->wiphy->interface_modes |=
7025                         BIT(NL80211_IFTYPE_P2P_DEVICE) |
7026                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
7027                         BIT(NL80211_IFTYPE_P2P_GO);
7028
7029         ieee80211_hw_set(ar->hw, SIGNAL_DBM);
7030         ieee80211_hw_set(ar->hw, SUPPORTS_PS);
7031         ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
7032         ieee80211_hw_set(ar->hw, MFP_CAPABLE);
7033         ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
7034         ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
7035         ieee80211_hw_set(ar->hw, AP_LINK_PS);
7036         ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
7037         ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
7038         ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
7039         ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
7040         ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
7041         ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
7042         ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
7043
7044         if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7045                 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
7046
7047         ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
7048         ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
7049
7050         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
7051                 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
7052
7053         if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
7054                 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
7055                 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
7056         }
7057
7058         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
7059         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
7060
7061         ar->hw->vif_data_size = sizeof(struct ath10k_vif);
7062         ar->hw->sta_data_size = sizeof(struct ath10k_sta);
7063
7064         ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
7065
7066         if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
7067                 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
7068
7069                 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
7070                  * that userspace (e.g. wpa_supplicant/hostapd) can generate
7071                  * correct Probe Responses. This is more of a hack advert..
7072                  */
7073                 ar->hw->wiphy->probe_resp_offload |=
7074                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
7075                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
7076                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
7077         }
7078
7079         if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))
7080                 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7081
7082         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
7083         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
7084         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
7085
7086         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
7087         ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
7088
7089         ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
7090
7091         ret = ath10k_wow_init(ar);
7092         if (ret) {
7093                 ath10k_warn(ar, "failed to init wow: %d\n", ret);
7094                 goto err_free;
7095         }
7096
7097         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
7098
7099         /*
7100          * on LL hardware queues are managed entirely by the FW
7101          * so we only advertise to mac we can do the queues thing
7102          */
7103         ar->hw->queues = IEEE80211_MAX_QUEUES;
7104
7105         /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
7106          * something that vdev_ids can't reach so that we don't stop the queue
7107          * accidentally.
7108          */
7109         ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
7110
7111         switch (ar->wmi.op_version) {
7112         case ATH10K_FW_WMI_OP_VERSION_MAIN:
7113                 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
7114                 ar->hw->wiphy->n_iface_combinations =
7115                         ARRAY_SIZE(ath10k_if_comb);
7116                 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7117                 break;
7118         case ATH10K_FW_WMI_OP_VERSION_TLV:
7119                 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
7120                         ar->hw->wiphy->iface_combinations =
7121                                 ath10k_tlv_qcs_if_comb;
7122                         ar->hw->wiphy->n_iface_combinations =
7123                                 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
7124                 } else {
7125                         ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
7126                         ar->hw->wiphy->n_iface_combinations =
7127                                 ARRAY_SIZE(ath10k_tlv_if_comb);
7128                 }
7129                 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7130                 break;
7131         case ATH10K_FW_WMI_OP_VERSION_10_1:
7132         case ATH10K_FW_WMI_OP_VERSION_10_2:
7133         case ATH10K_FW_WMI_OP_VERSION_10_2_4:
7134                 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
7135                 ar->hw->wiphy->n_iface_combinations =
7136                         ARRAY_SIZE(ath10k_10x_if_comb);
7137                 break;
7138         case ATH10K_FW_WMI_OP_VERSION_10_4:
7139                 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
7140                 ar->hw->wiphy->n_iface_combinations =
7141                         ARRAY_SIZE(ath10k_10_4_if_comb);
7142                 break;
7143         case ATH10K_FW_WMI_OP_VERSION_UNSET:
7144         case ATH10K_FW_WMI_OP_VERSION_MAX:
7145                 WARN_ON(1);
7146                 ret = -EINVAL;
7147                 goto err_free;
7148         }
7149
7150         if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7151                 ar->hw->netdev_features = NETIF_F_HW_CSUM;
7152
7153         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
7154                 /* Init ath dfs pattern detector */
7155                 ar->ath_common.debug_mask = ATH_DBG_DFS;
7156                 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
7157                                                              NL80211_DFS_UNSET);
7158
7159                 if (!ar->dfs_detector)
7160                         ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
7161         }
7162
7163         ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
7164                             ath10k_reg_notifier);
7165         if (ret) {
7166                 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
7167                 goto err_free;
7168         }
7169
7170         ar->hw->wiphy->cipher_suites = cipher_suites;
7171         ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7172
7173         ret = ieee80211_register_hw(ar->hw);
7174         if (ret) {
7175                 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
7176                 goto err_free;
7177         }
7178
7179         if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
7180                 ret = regulatory_hint(ar->hw->wiphy,
7181                                       ar->ath_common.regulatory.alpha2);
7182                 if (ret)
7183                         goto err_unregister;
7184         }
7185
7186         return 0;
7187
7188 err_unregister:
7189         ieee80211_unregister_hw(ar->hw);
7190 err_free:
7191         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7192         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7193
7194         return ret;
7195 }
7196
7197 void ath10k_mac_unregister(struct ath10k *ar)
7198 {
7199         ieee80211_unregister_hw(ar->hw);
7200
7201         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7202                 ar->dfs_detector->exit(ar->dfs_detector);
7203
7204         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7205         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7206
7207         SET_IEEE80211_DEV(ar->hw, NULL);
7208 }