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