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