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

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