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