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 & 0x15) == 0x15)
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         if (ar->cfg_tx_chainmask) {
4460                 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4461
4462                 vdev_param = ar->wmi.vdev_param->nss;
4463                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4464                                                 nss);
4465                 if (ret) {
4466                         ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4467                                     arvif->vdev_id, ar->cfg_tx_chainmask, nss,
4468                                     ret);
4469                         goto err_vdev_delete;
4470                 }
4471         }
4472
4473         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4474             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4475                 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr,
4476                                          WMI_PEER_TYPE_DEFAULT);
4477                 if (ret) {
4478                         ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
4479                                     arvif->vdev_id, ret);
4480                         goto err_vdev_delete;
4481                 }
4482         }
4483
4484         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
4485                 ret = ath10k_mac_set_kickout(arvif);
4486                 if (ret) {
4487                         ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
4488                                     arvif->vdev_id, ret);
4489                         goto err_peer_delete;
4490                 }
4491         }
4492
4493         if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
4494                 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
4495                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4496                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4497                                                   param, value);
4498                 if (ret) {
4499                         ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
4500                                     arvif->vdev_id, ret);
4501                         goto err_peer_delete;
4502                 }
4503
4504                 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4505                 if (ret) {
4506                         ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4507                                     arvif->vdev_id, ret);
4508                         goto err_peer_delete;
4509                 }
4510
4511                 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4512                 if (ret) {
4513                         ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4514                                     arvif->vdev_id, ret);
4515                         goto err_peer_delete;
4516                 }
4517         }
4518
4519         ret = ath10k_mac_set_txbf_conf(arvif);
4520         if (ret) {
4521                 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
4522                             arvif->vdev_id, ret);
4523                 goto err_peer_delete;
4524         }
4525
4526         ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
4527         if (ret) {
4528                 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4529                             arvif->vdev_id, ret);
4530                 goto err_peer_delete;
4531         }
4532
4533         arvif->txpower = vif->bss_conf.txpower;
4534         ret = ath10k_mac_txpower_recalc(ar);
4535         if (ret) {
4536                 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4537                 goto err_peer_delete;
4538         }
4539
4540         if (vif->type == NL80211_IFTYPE_MONITOR) {
4541                 ar->monitor_arvif = arvif;
4542                 ret = ath10k_monitor_recalc(ar);
4543                 if (ret) {
4544                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4545                         goto err_peer_delete;
4546                 }
4547         }
4548
4549         spin_lock_bh(&ar->htt.tx_lock);
4550         if (!ar->tx_paused)
4551                 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
4552         spin_unlock_bh(&ar->htt.tx_lock);
4553
4554         mutex_unlock(&ar->conf_mutex);
4555         return 0;
4556
4557 err_peer_delete:
4558         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4559             arvif->vdev_type == WMI_VDEV_TYPE_IBSS)
4560                 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
4561
4562 err_vdev_delete:
4563         ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4564         ar->free_vdev_map |= 1LL << arvif->vdev_id;
4565         list_del(&arvif->list);
4566
4567 err:
4568         if (arvif->beacon_buf) {
4569                 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
4570                                   arvif->beacon_buf, arvif->beacon_paddr);
4571                 arvif->beacon_buf = NULL;
4572         }
4573
4574         mutex_unlock(&ar->conf_mutex);
4575
4576         return ret;
4577 }
4578
4579 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
4580 {
4581         int i;
4582
4583         for (i = 0; i < BITS_PER_LONG; i++)
4584                 ath10k_mac_vif_tx_unlock(arvif, i);
4585 }
4586
4587 static void ath10k_remove_interface(struct ieee80211_hw *hw,
4588                                     struct ieee80211_vif *vif)
4589 {
4590         struct ath10k *ar = hw->priv;
4591         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4592         int ret;
4593
4594         cancel_work_sync(&arvif->ap_csa_work);
4595         cancel_delayed_work_sync(&arvif->connection_loss_work);
4596
4597         mutex_lock(&ar->conf_mutex);
4598
4599         spin_lock_bh(&ar->data_lock);
4600         ath10k_mac_vif_beacon_cleanup(arvif);
4601         spin_unlock_bh(&ar->data_lock);
4602
4603         ret = ath10k_spectral_vif_stop(arvif);
4604         if (ret)
4605                 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
4606                             arvif->vdev_id, ret);
4607
4608         ar->free_vdev_map |= 1LL << arvif->vdev_id;
4609         list_del(&arvif->list);
4610
4611         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4612             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4613                 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
4614                                              vif->addr);
4615                 if (ret)
4616                         ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4617                                     arvif->vdev_id, ret);
4618
4619                 kfree(arvif->u.ap.noa_data);
4620         }
4621
4622         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
4623                    arvif->vdev_id);
4624
4625         ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4626         if (ret)
4627                 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
4628                             arvif->vdev_id, ret);
4629
4630         /* Some firmware revisions don't notify host about self-peer removal
4631          * until after associated vdev is deleted.
4632          */
4633         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4634             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4635                 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
4636                                                    vif->addr);
4637                 if (ret)
4638                         ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
4639                                     arvif->vdev_id, ret);
4640
4641                 spin_lock_bh(&ar->data_lock);
4642                 ar->num_peers--;
4643                 spin_unlock_bh(&ar->data_lock);
4644         }
4645
4646         ath10k_peer_cleanup(ar, arvif->vdev_id);
4647
4648         if (vif->type == NL80211_IFTYPE_MONITOR) {
4649                 ar->monitor_arvif = NULL;
4650                 ret = ath10k_monitor_recalc(ar);
4651                 if (ret)
4652                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4653         }
4654
4655         spin_lock_bh(&ar->htt.tx_lock);
4656         ath10k_mac_vif_tx_unlock_all(arvif);
4657         spin_unlock_bh(&ar->htt.tx_lock);
4658
4659         mutex_unlock(&ar->conf_mutex);
4660 }
4661
4662 /*
4663  * FIXME: Has to be verified.
4664  */
4665 #define SUPPORTED_FILTERS                       \
4666         (FIF_ALLMULTI |                         \
4667         FIF_CONTROL |                           \
4668         FIF_PSPOLL |                            \
4669         FIF_OTHER_BSS |                         \
4670         FIF_BCN_PRBRESP_PROMISC |               \
4671         FIF_PROBE_REQ |                         \
4672         FIF_FCSFAIL)
4673
4674 static void ath10k_configure_filter(struct ieee80211_hw *hw,
4675                                     unsigned int changed_flags,
4676                                     unsigned int *total_flags,
4677                                     u64 multicast)
4678 {
4679         struct ath10k *ar = hw->priv;
4680         int ret;
4681
4682         mutex_lock(&ar->conf_mutex);
4683
4684         changed_flags &= SUPPORTED_FILTERS;
4685         *total_flags &= SUPPORTED_FILTERS;
4686         ar->filter_flags = *total_flags;
4687
4688         ret = ath10k_monitor_recalc(ar);
4689         if (ret)
4690                 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
4691
4692         mutex_unlock(&ar->conf_mutex);
4693 }
4694
4695 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
4696                                     struct ieee80211_vif *vif,
4697                                     struct ieee80211_bss_conf *info,
4698                                     u32 changed)
4699 {
4700         struct ath10k *ar = hw->priv;
4701         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4702         int ret = 0;
4703         u32 vdev_param, pdev_param, slottime, preamble;
4704
4705         mutex_lock(&ar->conf_mutex);
4706
4707         if (changed & BSS_CHANGED_IBSS)
4708                 ath10k_control_ibss(arvif, info, vif->addr);
4709
4710         if (changed & BSS_CHANGED_BEACON_INT) {
4711                 arvif->beacon_interval = info->beacon_int;
4712                 vdev_param = ar->wmi.vdev_param->beacon_interval;
4713                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4714                                                 arvif->beacon_interval);
4715                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4716                            "mac vdev %d beacon_interval %d\n",
4717                            arvif->vdev_id, arvif->beacon_interval);
4718
4719                 if (ret)
4720                         ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
4721                                     arvif->vdev_id, ret);
4722         }
4723
4724         if (changed & BSS_CHANGED_BEACON) {
4725                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4726                            "vdev %d set beacon tx mode to staggered\n",
4727                            arvif->vdev_id);
4728
4729                 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
4730                 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
4731                                                 WMI_BEACON_STAGGERED_MODE);
4732                 if (ret)
4733                         ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
4734                                     arvif->vdev_id, ret);
4735
4736                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
4737                 if (ret)
4738                         ath10k_warn(ar, "failed to update beacon template: %d\n",
4739                                     ret);
4740
4741                 if (ieee80211_vif_is_mesh(vif)) {
4742                         /* mesh doesn't use SSID but firmware needs it */
4743                         strncpy(arvif->u.ap.ssid, "mesh",
4744                                 sizeof(arvif->u.ap.ssid));
4745                         arvif->u.ap.ssid_len = 4;
4746                 }
4747         }
4748
4749         if (changed & BSS_CHANGED_AP_PROBE_RESP) {
4750                 ret = ath10k_mac_setup_prb_tmpl(arvif);
4751                 if (ret)
4752                         ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
4753                                     arvif->vdev_id, ret);
4754         }
4755
4756         if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
4757                 arvif->dtim_period = info->dtim_period;
4758
4759                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4760                            "mac vdev %d dtim_period %d\n",
4761                            arvif->vdev_id, arvif->dtim_period);
4762
4763                 vdev_param = ar->wmi.vdev_param->dtim_period;
4764                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4765                                                 arvif->dtim_period);
4766                 if (ret)
4767                         ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
4768                                     arvif->vdev_id, ret);
4769         }
4770
4771         if (changed & BSS_CHANGED_SSID &&
4772             vif->type == NL80211_IFTYPE_AP) {
4773                 arvif->u.ap.ssid_len = info->ssid_len;
4774                 if (info->ssid_len)
4775                         memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
4776                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
4777         }
4778
4779         if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
4780                 ether_addr_copy(arvif->bssid, info->bssid);
4781
4782         if (changed & BSS_CHANGED_BEACON_ENABLED)
4783                 ath10k_control_beaconing(arvif, info);
4784
4785         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
4786                 arvif->use_cts_prot = info->use_cts_prot;
4787                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
4788                            arvif->vdev_id, info->use_cts_prot);
4789
4790                 ret = ath10k_recalc_rtscts_prot(arvif);
4791                 if (ret)
4792                         ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
4793                                     arvif->vdev_id, ret);
4794
4795                 vdev_param = ar->wmi.vdev_param->protection_mode;
4796                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4797                                                 info->use_cts_prot ? 1 : 0);
4798                 if (ret)
4799                         ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n",
4800                                     info->use_cts_prot, arvif->vdev_id, ret);
4801         }
4802
4803         if (changed & BSS_CHANGED_ERP_SLOT) {
4804                 if (info->use_short_slot)
4805                         slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
4806
4807                 else
4808                         slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
4809
4810                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
4811                            arvif->vdev_id, slottime);
4812
4813                 vdev_param = ar->wmi.vdev_param->slot_time;
4814                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4815                                                 slottime);
4816                 if (ret)
4817                         ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
4818                                     arvif->vdev_id, ret);
4819         }
4820
4821         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4822                 if (info->use_short_preamble)
4823                         preamble = WMI_VDEV_PREAMBLE_SHORT;
4824                 else
4825                         preamble = WMI_VDEV_PREAMBLE_LONG;
4826
4827                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4828                            "mac vdev %d preamble %dn",
4829                            arvif->vdev_id, preamble);
4830
4831                 vdev_param = ar->wmi.vdev_param->preamble;
4832                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4833                                                 preamble);
4834                 if (ret)
4835                         ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
4836                                     arvif->vdev_id, ret);
4837         }
4838
4839         if (changed & BSS_CHANGED_ASSOC) {
4840                 if (info->assoc) {
4841                         /* Workaround: Make sure monitor vdev is not running
4842                          * when associating to prevent some firmware revisions
4843                          * (e.g. 10.1 and 10.2) from crashing.
4844                          */
4845                         if (ar->monitor_started)
4846                                 ath10k_monitor_stop(ar);
4847                         ath10k_bss_assoc(hw, vif, info);
4848                         ath10k_monitor_recalc(ar);
4849                 } else {
4850                         ath10k_bss_disassoc(hw, vif);
4851                 }
4852         }
4853
4854         if (changed & BSS_CHANGED_TXPOWER) {
4855                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
4856                            arvif->vdev_id, info->txpower);
4857
4858                 arvif->txpower = info->txpower;
4859                 ret = ath10k_mac_txpower_recalc(ar);
4860                 if (ret)
4861                         ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4862         }
4863
4864         if (changed & BSS_CHANGED_PS) {
4865                 arvif->ps = vif->bss_conf.ps;
4866
4867                 ret = ath10k_config_ps(ar);
4868                 if (ret)
4869                         ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
4870                                     arvif->vdev_id, ret);
4871         }
4872
4873         mutex_unlock(&ar->conf_mutex);
4874 }
4875
4876 static int ath10k_hw_scan(struct ieee80211_hw *hw,
4877                           struct ieee80211_vif *vif,
4878                           struct ieee80211_scan_request *hw_req)
4879 {
4880         struct ath10k *ar = hw->priv;
4881         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4882         struct cfg80211_scan_request *req = &hw_req->req;
4883         struct wmi_start_scan_arg arg;
4884         int ret = 0;
4885         int i;
4886
4887         mutex_lock(&ar->conf_mutex);
4888
4889         spin_lock_bh(&ar->data_lock);
4890         switch (ar->scan.state) {
4891         case ATH10K_SCAN_IDLE:
4892                 reinit_completion(&ar->scan.started);
4893                 reinit_completion(&ar->scan.completed);
4894                 ar->scan.state = ATH10K_SCAN_STARTING;
4895                 ar->scan.is_roc = false;
4896                 ar->scan.vdev_id = arvif->vdev_id;
4897                 ret = 0;
4898                 break;
4899         case ATH10K_SCAN_STARTING:
4900         case ATH10K_SCAN_RUNNING:
4901         case ATH10K_SCAN_ABORTING:
4902                 ret = -EBUSY;
4903                 break;
4904         }
4905         spin_unlock_bh(&ar->data_lock);
4906
4907         if (ret)
4908                 goto exit;
4909
4910         memset(&arg, 0, sizeof(arg));
4911         ath10k_wmi_start_scan_init(ar, &arg);
4912         arg.vdev_id = arvif->vdev_id;
4913         arg.scan_id = ATH10K_SCAN_ID;
4914
4915         if (req->ie_len) {
4916                 arg.ie_len = req->ie_len;
4917                 memcpy(arg.ie, req->ie, arg.ie_len);
4918         }
4919
4920         if (req->n_ssids) {
4921                 arg.n_ssids = req->n_ssids;
4922                 for (i = 0; i < arg.n_ssids; i++) {
4923                         arg.ssids[i].len  = req->ssids[i].ssid_len;
4924                         arg.ssids[i].ssid = req->ssids[i].ssid;
4925                 }
4926         } else {
4927                 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4928         }
4929
4930         if (req->n_channels) {
4931                 arg.n_channels = req->n_channels;
4932                 for (i = 0; i < arg.n_channels; i++)
4933                         arg.channels[i] = req->channels[i]->center_freq;
4934         }
4935
4936         ret = ath10k_start_scan(ar, &arg);
4937         if (ret) {
4938                 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
4939                 spin_lock_bh(&ar->data_lock);
4940                 ar->scan.state = ATH10K_SCAN_IDLE;
4941                 spin_unlock_bh(&ar->data_lock);
4942         }
4943
4944         /* Add a 200ms margin to account for event/command processing */
4945         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
4946                                      msecs_to_jiffies(arg.max_scan_time +
4947                                                       200));
4948
4949 exit:
4950         mutex_unlock(&ar->conf_mutex);
4951         return ret;
4952 }
4953
4954 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
4955                                   struct ieee80211_vif *vif)
4956 {
4957         struct ath10k *ar = hw->priv;
4958
4959         mutex_lock(&ar->conf_mutex);
4960         ath10k_scan_abort(ar);
4961         mutex_unlock(&ar->conf_mutex);
4962
4963         cancel_delayed_work_sync(&ar->scan.timeout);
4964 }
4965
4966 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
4967                                         struct ath10k_vif *arvif,
4968                                         enum set_key_cmd cmd,
4969                                         struct ieee80211_key_conf *key)
4970 {
4971         u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
4972         int ret;
4973
4974         /* 10.1 firmware branch requires default key index to be set to group
4975          * key index after installing it. Otherwise FW/HW Txes corrupted
4976          * frames with multi-vif APs. This is not required for main firmware
4977          * branch (e.g. 636).
4978          *
4979          * This is also needed for 636 fw for IBSS-RSN to work more reliably.
4980          *
4981          * FIXME: It remains unknown if this is required for multi-vif STA
4982          * interfaces on 10.1.
4983          */
4984
4985         if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
4986             arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
4987                 return;
4988
4989         if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
4990                 return;
4991
4992         if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
4993                 return;
4994
4995         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4996                 return;
4997
4998         if (cmd != SET_KEY)
4999                 return;
5000
5001         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5002                                         key->keyidx);
5003         if (ret)
5004                 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
5005                             arvif->vdev_id, ret);
5006 }
5007
5008 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
5009                           struct ieee80211_vif *vif, struct ieee80211_sta *sta,
5010                           struct ieee80211_key_conf *key)
5011 {
5012         struct ath10k *ar = hw->priv;
5013         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5014         struct ath10k_peer *peer;
5015         const u8 *peer_addr;
5016         bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
5017                       key->cipher == WLAN_CIPHER_SUITE_WEP104;
5018         int ret = 0;
5019         int ret2;
5020         u32 flags = 0;
5021         u32 flags2;
5022
5023         /* this one needs to be done in software */
5024         if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
5025                 return 1;
5026
5027         if (arvif->nohwcrypt)
5028                 return 1;
5029
5030         if (key->keyidx > WMI_MAX_KEY_INDEX)
5031                 return -ENOSPC;
5032
5033         mutex_lock(&ar->conf_mutex);
5034
5035         if (sta)
5036                 peer_addr = sta->addr;
5037         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
5038                 peer_addr = vif->bss_conf.bssid;
5039         else
5040                 peer_addr = vif->addr;
5041
5042         key->hw_key_idx = key->keyidx;
5043
5044         if (is_wep) {
5045                 if (cmd == SET_KEY)
5046                         arvif->wep_keys[key->keyidx] = key;
5047                 else
5048                         arvif->wep_keys[key->keyidx] = NULL;
5049         }
5050
5051         /* the peer should not disappear in mid-way (unless FW goes awry) since
5052          * we already hold conf_mutex. we just make sure its there now. */
5053         spin_lock_bh(&ar->data_lock);
5054         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5055         spin_unlock_bh(&ar->data_lock);
5056
5057         if (!peer) {
5058                 if (cmd == SET_KEY) {
5059                         ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
5060                                     peer_addr);
5061                         ret = -EOPNOTSUPP;
5062                         goto exit;
5063                 } else {
5064                         /* if the peer doesn't exist there is no key to disable
5065                          * anymore */
5066                         goto exit;
5067                 }
5068         }
5069
5070         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5071                 flags |= WMI_KEY_PAIRWISE;
5072         else
5073                 flags |= WMI_KEY_GROUP;
5074
5075         if (is_wep) {
5076                 if (cmd == DISABLE_KEY)
5077                         ath10k_clear_vdev_key(arvif, key);
5078
5079                 /* When WEP keys are uploaded it's possible that there are
5080                  * stations associated already (e.g. when merging) without any
5081                  * keys. Static WEP needs an explicit per-peer key upload.
5082                  */
5083                 if (vif->type == NL80211_IFTYPE_ADHOC &&
5084                     cmd == SET_KEY)
5085                         ath10k_mac_vif_update_wep_key(arvif, key);
5086
5087                 /* 802.1x never sets the def_wep_key_idx so each set_key()
5088                  * call changes default tx key.
5089                  *
5090                  * Static WEP sets def_wep_key_idx via .set_default_unicast_key
5091                  * after first set_key().
5092                  */
5093                 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
5094                         flags |= WMI_KEY_TX_USAGE;
5095         }
5096
5097         ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
5098         if (ret) {
5099                 WARN_ON(ret > 0);
5100                 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
5101                             arvif->vdev_id, peer_addr, ret);
5102                 goto exit;
5103         }
5104
5105         /* mac80211 sets static WEP keys as groupwise while firmware requires
5106          * them to be installed twice as both pairwise and groupwise.
5107          */
5108         if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
5109                 flags2 = flags;
5110                 flags2 &= ~WMI_KEY_GROUP;
5111                 flags2 |= WMI_KEY_PAIRWISE;
5112
5113                 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
5114                 if (ret) {
5115                         WARN_ON(ret > 0);
5116                         ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
5117                                     arvif->vdev_id, peer_addr, ret);
5118                         ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
5119                                                   peer_addr, flags);
5120                         if (ret2) {
5121                                 WARN_ON(ret2 > 0);
5122                                 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
5123                                             arvif->vdev_id, peer_addr, ret2);
5124                         }
5125                         goto exit;
5126                 }
5127         }
5128
5129         ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
5130
5131         spin_lock_bh(&ar->data_lock);
5132         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5133         if (peer && cmd == SET_KEY)
5134                 peer->keys[key->keyidx] = key;
5135         else if (peer && cmd == DISABLE_KEY)
5136                 peer->keys[key->keyidx] = NULL;
5137         else if (peer == NULL)
5138                 /* impossible unless FW goes crazy */
5139                 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
5140         spin_unlock_bh(&ar->data_lock);
5141
5142 exit:
5143         mutex_unlock(&ar->conf_mutex);
5144         return ret;
5145 }
5146
5147 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
5148                                            struct ieee80211_vif *vif,
5149                                            int keyidx)
5150 {
5151         struct ath10k *ar = hw->priv;
5152         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5153         int ret;
5154
5155         mutex_lock(&arvif->ar->conf_mutex);
5156
5157         if (arvif->ar->state != ATH10K_STATE_ON)
5158                 goto unlock;
5159
5160         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
5161                    arvif->vdev_id, keyidx);
5162
5163         ret = ath10k_wmi_vdev_set_param(arvif->ar,
5164                                         arvif->vdev_id,
5165                                         arvif->ar->wmi.vdev_param->def_keyid,
5166                                         keyidx);
5167
5168         if (ret) {
5169                 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
5170                             arvif->vdev_id,
5171                             ret);
5172                 goto unlock;
5173         }
5174
5175         arvif->def_wep_key_idx = keyidx;
5176
5177 unlock:
5178         mutex_unlock(&arvif->ar->conf_mutex);
5179 }
5180
5181 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
5182 {
5183         struct ath10k *ar;
5184         struct ath10k_vif *arvif;
5185         struct ath10k_sta *arsta;
5186         struct ieee80211_sta *sta;
5187         struct cfg80211_chan_def def;
5188         enum ieee80211_band band;
5189         const u8 *ht_mcs_mask;
5190         const u16 *vht_mcs_mask;
5191         u32 changed, bw, nss, smps;
5192         int err;
5193
5194         arsta = container_of(wk, struct ath10k_sta, update_wk);
5195         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
5196         arvif = arsta->arvif;
5197         ar = arvif->ar;
5198
5199         if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
5200                 return;
5201
5202         band = def.chan->band;
5203         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
5204         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
5205
5206         spin_lock_bh(&ar->data_lock);
5207
5208         changed = arsta->changed;
5209         arsta->changed = 0;
5210
5211         bw = arsta->bw;
5212         nss = arsta->nss;
5213         smps = arsta->smps;
5214
5215         spin_unlock_bh(&ar->data_lock);
5216
5217         mutex_lock(&ar->conf_mutex);
5218
5219         nss = max_t(u32, 1, nss);
5220         nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
5221                            ath10k_mac_max_vht_nss(vht_mcs_mask)));
5222
5223         if (changed & IEEE80211_RC_BW_CHANGED) {
5224                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
5225                            sta->addr, bw);
5226
5227                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5228                                                 WMI_PEER_CHAN_WIDTH, bw);
5229                 if (err)
5230                         ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
5231                                     sta->addr, bw, err);
5232         }
5233
5234         if (changed & IEEE80211_RC_NSS_CHANGED) {
5235                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
5236                            sta->addr, nss);
5237
5238                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5239                                                 WMI_PEER_NSS, nss);
5240                 if (err)
5241                         ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
5242                                     sta->addr, nss, err);
5243         }
5244
5245         if (changed & IEEE80211_RC_SMPS_CHANGED) {
5246                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
5247                            sta->addr, smps);
5248
5249                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5250                                                 WMI_PEER_SMPS_STATE, smps);
5251                 if (err)
5252                         ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
5253                                     sta->addr, smps, err);
5254         }
5255
5256         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
5257             changed & IEEE80211_RC_NSS_CHANGED) {
5258                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
5259                            sta->addr);
5260
5261                 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
5262                 if (err)
5263                         ath10k_warn(ar, "failed to reassociate station: %pM\n",
5264                                     sta->addr);
5265         }
5266
5267         mutex_unlock(&ar->conf_mutex);
5268 }
5269
5270 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
5271                                        struct ieee80211_sta *sta)
5272 {
5273         struct ath10k *ar = arvif->ar;
5274
5275         lockdep_assert_held(&ar->conf_mutex);
5276
5277         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5278                 return 0;
5279
5280         if (ar->num_stations >= ar->max_num_stations)
5281                 return -ENOBUFS;
5282
5283         ar->num_stations++;
5284
5285         return 0;
5286 }
5287
5288 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
5289                                         struct ieee80211_sta *sta)
5290 {
5291         struct ath10k *ar = arvif->ar;
5292
5293         lockdep_assert_held(&ar->conf_mutex);
5294
5295         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5296                 return;
5297
5298         ar->num_stations--;
5299 }
5300
5301 struct ath10k_mac_tdls_iter_data {
5302         u32 num_tdls_stations;
5303         struct ieee80211_vif *curr_vif;
5304 };
5305
5306 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
5307                                                     struct ieee80211_sta *sta)
5308 {
5309         struct ath10k_mac_tdls_iter_data *iter_data = data;
5310         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5311         struct ieee80211_vif *sta_vif = arsta->arvif->vif;
5312
5313         if (sta->tdls && sta_vif == iter_data->curr_vif)
5314                 iter_data->num_tdls_stations++;
5315 }
5316
5317 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
5318                                               struct ieee80211_vif *vif)
5319 {
5320         struct ath10k_mac_tdls_iter_data data = {};
5321
5322         data.curr_vif = vif;
5323
5324         ieee80211_iterate_stations_atomic(hw,
5325                                           ath10k_mac_tdls_vif_stations_count_iter,
5326                                           &data);
5327         return data.num_tdls_stations;
5328 }
5329
5330 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac,
5331                                             struct ieee80211_vif *vif)
5332 {
5333         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5334         int *num_tdls_vifs = data;
5335
5336         if (vif->type != NL80211_IFTYPE_STATION)
5337                 return;
5338
5339         if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0)
5340                 (*num_tdls_vifs)++;
5341 }
5342
5343 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw)
5344 {
5345         int num_tdls_vifs = 0;
5346
5347         ieee80211_iterate_active_interfaces_atomic(hw,
5348                                                    IEEE80211_IFACE_ITER_NORMAL,
5349                                                    ath10k_mac_tdls_vifs_count_iter,
5350                                                    &num_tdls_vifs);
5351         return num_tdls_vifs;
5352 }
5353
5354 static int ath10k_sta_state(struct ieee80211_hw *hw,
5355                             struct ieee80211_vif *vif,
5356                             struct ieee80211_sta *sta,
5357                             enum ieee80211_sta_state old_state,
5358                             enum ieee80211_sta_state new_state)
5359 {
5360         struct ath10k *ar = hw->priv;
5361         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5362         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5363         int ret = 0;
5364
5365         if (old_state == IEEE80211_STA_NOTEXIST &&
5366             new_state == IEEE80211_STA_NONE) {
5367                 memset(arsta, 0, sizeof(*arsta));
5368                 arsta->arvif = arvif;
5369                 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
5370         }
5371
5372         /* cancel must be done outside the mutex to avoid deadlock */
5373         if ((old_state == IEEE80211_STA_NONE &&
5374              new_state == IEEE80211_STA_NOTEXIST))
5375                 cancel_work_sync(&arsta->update_wk);
5376
5377         mutex_lock(&ar->conf_mutex);
5378
5379         if (old_state == IEEE80211_STA_NOTEXIST &&
5380             new_state == IEEE80211_STA_NONE) {
5381                 /*
5382                  * New station addition.
5383                  */
5384                 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
5385                 u32 num_tdls_stations;
5386                 u32 num_tdls_vifs;
5387
5388                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5389                            "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5390                            arvif->vdev_id, sta->addr,
5391                            ar->num_stations + 1, ar->max_num_stations,
5392                            ar->num_peers + 1, ar->max_num_peers);
5393
5394                 ret = ath10k_mac_inc_num_stations(arvif, sta);
5395                 if (ret) {
5396                         ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
5397                                     ar->max_num_stations);
5398                         goto exit;
5399                 }
5400
5401                 if (sta->tdls)
5402                         peer_type = WMI_PEER_TYPE_TDLS;
5403
5404                 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr,
5405                                          peer_type);
5406                 if (ret) {
5407                         ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5408                                     sta->addr, arvif->vdev_id, ret);
5409                         ath10k_mac_dec_num_stations(arvif, sta);
5410                         goto exit;
5411                 }
5412
5413                 if (!sta->tdls)
5414                         goto exit;
5415
5416                 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
5417                 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw);
5418
5419                 if (num_tdls_vifs >= ar->max_num_tdls_vdevs &&
5420                     num_tdls_stations == 0) {
5421                         ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5422                                     arvif->vdev_id, ar->max_num_tdls_vdevs);
5423                         ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5424                         ath10k_mac_dec_num_stations(arvif, sta);
5425                         ret = -ENOBUFS;
5426                         goto exit;
5427                 }
5428
5429                 if (num_tdls_stations == 0) {
5430                         /* This is the first tdls peer in current vif */
5431                         enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE;
5432
5433                         ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5434                                                               state);
5435                         if (ret) {
5436                                 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5437                                             arvif->vdev_id, ret);
5438                                 ath10k_peer_delete(ar, arvif->vdev_id,
5439                                                    sta->addr);
5440                                 ath10k_mac_dec_num_stations(arvif, sta);
5441                                 goto exit;
5442                         }
5443                 }
5444
5445                 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5446                                                   WMI_TDLS_PEER_STATE_PEERING);
5447                 if (ret) {
5448                         ath10k_warn(ar,
5449                                     "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5450                                     sta->addr, arvif->vdev_id, ret);
5451                         ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5452                         ath10k_mac_dec_num_stations(arvif, sta);
5453
5454                         if (num_tdls_stations != 0)
5455                                 goto exit;
5456                         ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5457                                                         WMI_TDLS_DISABLE);
5458                 }
5459         } else if ((old_state == IEEE80211_STA_NONE &&
5460                     new_state == IEEE80211_STA_NOTEXIST)) {
5461                 /*
5462                  * Existing station deletion.
5463                  */
5464                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5465                            "mac vdev %d peer delete %pM (sta gone)\n",
5466                            arvif->vdev_id, sta->addr);
5467
5468                 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5469                 if (ret)
5470                         ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
5471                                     sta->addr, arvif->vdev_id, ret);
5472
5473                 ath10k_mac_dec_num_stations(arvif, sta);
5474
5475                 if (!sta->tdls)
5476                         goto exit;
5477
5478                 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
5479                         goto exit;
5480
5481                 /* This was the last tdls peer in current vif */
5482                 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5483                                                       WMI_TDLS_DISABLE);
5484                 if (ret) {
5485                         ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5486                                     arvif->vdev_id, ret);
5487                 }
5488         } else if (old_state == IEEE80211_STA_AUTH &&
5489                    new_state == IEEE80211_STA_ASSOC &&
5490                    (vif->type == NL80211_IFTYPE_AP ||
5491                     vif->type == NL80211_IFTYPE_MESH_POINT ||
5492                     vif->type == NL80211_IFTYPE_ADHOC)) {
5493                 /*
5494                  * New association.
5495                  */
5496                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
5497                            sta->addr);
5498
5499                 ret = ath10k_station_assoc(ar, vif, sta, false);
5500                 if (ret)
5501                         ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
5502                                     sta->addr, arvif->vdev_id, ret);
5503         } else if (old_state == IEEE80211_STA_ASSOC &&
5504                    new_state == IEEE80211_STA_AUTHORIZED &&
5505                    sta->tdls) {
5506                 /*
5507                  * Tdls station authorized.
5508                  */
5509                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n",
5510                            sta->addr);
5511
5512                 ret = ath10k_station_assoc(ar, vif, sta, false);
5513                 if (ret) {
5514                         ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
5515                                     sta->addr, arvif->vdev_id, ret);
5516                         goto exit;
5517                 }
5518
5519                 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5520                                                   WMI_TDLS_PEER_STATE_CONNECTED);
5521                 if (ret)
5522                         ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
5523                                     sta->addr, arvif->vdev_id, ret);
5524         } else if (old_state == IEEE80211_STA_ASSOC &&
5525                     new_state == IEEE80211_STA_AUTH &&
5526                     (vif->type == NL80211_IFTYPE_AP ||
5527                      vif->type == NL80211_IFTYPE_MESH_POINT ||
5528                      vif->type == NL80211_IFTYPE_ADHOC)) {
5529                 /*
5530                  * Disassociation.
5531                  */
5532                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
5533                            sta->addr);
5534
5535                 ret = ath10k_station_disassoc(ar, vif, sta);
5536                 if (ret)
5537                         ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
5538                                     sta->addr, arvif->vdev_id, ret);
5539         }
5540 exit:
5541         mutex_unlock(&ar->conf_mutex);
5542         return ret;
5543 }
5544
5545 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5546                                 u16 ac, bool enable)
5547 {
5548         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5549         struct wmi_sta_uapsd_auto_trig_arg arg = {};
5550         u32 prio = 0, acc = 0;
5551         u32 value = 0;
5552         int ret = 0;
5553
5554         lockdep_assert_held(&ar->conf_mutex);
5555
5556         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5557                 return 0;
5558
5559         switch (ac) {
5560         case IEEE80211_AC_VO:
5561                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5562                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5563                 prio = 7;
5564                 acc = 3;
5565                 break;
5566         case IEEE80211_AC_VI:
5567                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5568                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5569                 prio = 5;
5570                 acc = 2;
5571                 break;
5572         case IEEE80211_AC_BE:
5573                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5574                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5575                 prio = 2;
5576                 acc = 1;
5577                 break;
5578         case IEEE80211_AC_BK:
5579                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5580                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5581                 prio = 0;
5582                 acc = 0;
5583                 break;
5584         }
5585
5586         if (enable)
5587                 arvif->u.sta.uapsd |= value;
5588         else
5589                 arvif->u.sta.uapsd &= ~value;
5590
5591         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5592                                           WMI_STA_PS_PARAM_UAPSD,
5593                                           arvif->u.sta.uapsd);
5594         if (ret) {
5595                 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
5596                 goto exit;
5597         }
5598
5599         if (arvif->u.sta.uapsd)
5600                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5601         else
5602                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5603
5604         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5605                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5606                                           value);
5607         if (ret)
5608                 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
5609
5610         ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5611         if (ret) {
5612                 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5613                             arvif->vdev_id, ret);
5614                 return ret;
5615         }
5616
5617         ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5618         if (ret) {
5619                 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5620                             arvif->vdev_id, ret);
5621                 return ret;
5622         }
5623
5624         if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
5625             test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
5626                 /* Only userspace can make an educated decision when to send
5627                  * trigger frame. The following effectively disables u-UAPSD
5628                  * autotrigger in firmware (which is enabled by default
5629                  * provided the autotrigger service is available).
5630                  */
5631
5632                 arg.wmm_ac = acc;
5633                 arg.user_priority = prio;
5634                 arg.service_interval = 0;
5635                 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5636                 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5637
5638                 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
5639                                                 arvif->bssid, &arg, 1);
5640                 if (ret) {
5641                         ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
5642                                     ret);
5643                         return ret;
5644                 }
5645         }
5646
5647 exit:
5648         return ret;
5649 }
5650
5651 static int ath10k_conf_tx(struct ieee80211_hw *hw,
5652                           struct ieee80211_vif *vif, u16 ac,
5653                           const struct ieee80211_tx_queue_params *params)
5654 {
5655         struct ath10k *ar = hw->priv;
5656         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5657         struct wmi_wmm_params_arg *p = NULL;
5658         int ret;
5659
5660         mutex_lock(&ar->conf_mutex);
5661
5662         switch (ac) {
5663         case IEEE80211_AC_VO:
5664                 p = &arvif->wmm_params.ac_vo;
5665                 break;
5666         case IEEE80211_AC_VI:
5667                 p = &arvif->wmm_params.ac_vi;
5668                 break;
5669         case IEEE80211_AC_BE:
5670                 p = &arvif->wmm_params.ac_be;
5671                 break;
5672         case IEEE80211_AC_BK:
5673                 p = &arvif->wmm_params.ac_bk;
5674                 break;
5675         }
5676
5677         if (WARN_ON(!p)) {
5678                 ret = -EINVAL;
5679                 goto exit;
5680         }
5681
5682         p->cwmin = params->cw_min;
5683         p->cwmax = params->cw_max;
5684         p->aifs = params->aifs;
5685
5686         /*
5687          * The channel time duration programmed in the HW is in absolute
5688          * microseconds, while mac80211 gives the txop in units of
5689          * 32 microseconds.
5690          */
5691         p->txop = params->txop * 32;
5692
5693         if (ar->wmi.ops->gen_vdev_wmm_conf) {
5694                 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
5695                                                &arvif->wmm_params);
5696                 if (ret) {
5697                         ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
5698                                     arvif->vdev_id, ret);
5699                         goto exit;
5700                 }
5701         } else {
5702                 /* This won't work well with multi-interface cases but it's
5703                  * better than nothing.
5704                  */
5705                 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
5706                 if (ret) {
5707                         ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
5708                         goto exit;
5709                 }
5710         }
5711
5712         ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5713         if (ret)
5714                 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
5715
5716 exit:
5717         mutex_unlock(&ar->conf_mutex);
5718         return ret;
5719 }
5720
5721 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
5722
5723 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
5724                                     struct ieee80211_vif *vif,
5725                                     struct ieee80211_channel *chan,
5726                                     int duration,
5727                                     enum ieee80211_roc_type type)
5728 {
5729         struct ath10k *ar = hw->priv;
5730         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5731         struct wmi_start_scan_arg arg;
5732         int ret = 0;
5733         u32 scan_time_msec;
5734
5735         mutex_lock(&ar->conf_mutex);
5736
5737         spin_lock_bh(&ar->data_lock);
5738         switch (ar->scan.state) {
5739         case ATH10K_SCAN_IDLE:
5740                 reinit_completion(&ar->scan.started);
5741                 reinit_completion(&ar->scan.completed);
5742                 reinit_completion(&ar->scan.on_channel);
5743                 ar->scan.state = ATH10K_SCAN_STARTING;
5744                 ar->scan.is_roc = true;
5745                 ar->scan.vdev_id = arvif->vdev_id;
5746                 ar->scan.roc_freq = chan->center_freq;
5747                 ar->scan.roc_notify = true;
5748                 ret = 0;
5749                 break;
5750         case ATH10K_SCAN_STARTING:
5751         case ATH10K_SCAN_RUNNING:
5752         case ATH10K_SCAN_ABORTING:
5753                 ret = -EBUSY;
5754                 break;
5755         }
5756         spin_unlock_bh(&ar->data_lock);
5757
5758         if (ret)
5759                 goto exit;
5760
5761         scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
5762
5763         memset(&arg, 0, sizeof(arg));
5764         ath10k_wmi_start_scan_init(ar, &arg);
5765         arg.vdev_id = arvif->vdev_id;
5766         arg.scan_id = ATH10K_SCAN_ID;
5767         arg.n_channels = 1;
5768         arg.channels[0] = chan->center_freq;
5769         arg.dwell_time_active = scan_time_msec;
5770         arg.dwell_time_passive = scan_time_msec;
5771         arg.max_scan_time = scan_time_msec;
5772         arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5773         arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
5774         arg.burst_duration_ms = duration;
5775
5776         ret = ath10k_start_scan(ar, &arg);
5777         if (ret) {
5778                 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
5779                 spin_lock_bh(&ar->data_lock);
5780                 ar->scan.state = ATH10K_SCAN_IDLE;
5781                 spin_unlock_bh(&ar->data_lock);
5782                 goto exit;
5783         }
5784
5785         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
5786         if (ret == 0) {
5787                 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
5788
5789                 ret = ath10k_scan_stop(ar);
5790                 if (ret)
5791                         ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5792
5793                 ret = -ETIMEDOUT;
5794                 goto exit;
5795         }
5796
5797         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
5798                                      msecs_to_jiffies(duration));
5799
5800         ret = 0;
5801 exit:
5802         mutex_unlock(&ar->conf_mutex);
5803         return ret;
5804 }
5805
5806 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
5807 {
5808         struct ath10k *ar = hw->priv;
5809
5810         mutex_lock(&ar->conf_mutex);
5811
5812         spin_lock_bh(&ar->data_lock);
5813         ar->scan.roc_notify = false;
5814         spin_unlock_bh(&ar->data_lock);
5815
5816         ath10k_scan_abort(ar);
5817
5818         mutex_unlock(&ar->conf_mutex);
5819
5820         cancel_delayed_work_sync(&ar->scan.timeout);
5821
5822         return 0;
5823 }
5824
5825 /*
5826  * Both RTS and Fragmentation threshold are interface-specific
5827  * in ath10k, but device-specific in mac80211.
5828  */
5829
5830 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
5831 {
5832         struct ath10k *ar = hw->priv;
5833         struct ath10k_vif *arvif;
5834         int ret = 0;
5835
5836         mutex_lock(&ar->conf_mutex);
5837         list_for_each_entry(arvif, &ar->arvifs, list) {
5838                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
5839                            arvif->vdev_id, value);
5840
5841                 ret = ath10k_mac_set_rts(arvif, value);
5842                 if (ret) {
5843                         ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5844                                     arvif->vdev_id, ret);
5845                         break;
5846                 }
5847         }
5848         mutex_unlock(&ar->conf_mutex);
5849
5850         return ret;
5851 }
5852
5853 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5854 {
5855         /* Even though there's a WMI enum for fragmentation threshold no known
5856          * firmware actually implements it. Moreover it is not possible to rely
5857          * frame fragmentation to mac80211 because firmware clears the "more
5858          * fragments" bit in frame control making it impossible for remote
5859          * devices to reassemble frames.
5860          *
5861          * Hence implement a dummy callback just to say fragmentation isn't
5862          * supported. This effectively prevents mac80211 from doing frame
5863          * fragmentation in software.
5864          */
5865         return -EOPNOTSUPP;
5866 }
5867
5868 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
5869                          u32 queues, bool drop)
5870 {
5871         struct ath10k *ar = hw->priv;
5872         bool skip;
5873         long time_left;
5874
5875         /* mac80211 doesn't care if we really xmit queued frames or not
5876          * we'll collect those frames either way if we stop/delete vdevs */
5877         if (drop)
5878                 return;
5879
5880         mutex_lock(&ar->conf_mutex);
5881
5882         if (ar->state == ATH10K_STATE_WEDGED)
5883                 goto skip;
5884
5885         time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
5886                         bool empty;
5887
5888                         spin_lock_bh(&ar->htt.tx_lock);
5889                         empty = (ar->htt.num_pending_tx == 0);
5890                         spin_unlock_bh(&ar->htt.tx_lock);
5891
5892                         skip = (ar->state == ATH10K_STATE_WEDGED) ||
5893                                test_bit(ATH10K_FLAG_CRASH_FLUSH,
5894                                         &ar->dev_flags);
5895
5896                         (empty || skip);
5897                 }), ATH10K_FLUSH_TIMEOUT_HZ);
5898
5899         if (time_left == 0 || skip)
5900                 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
5901                             skip, ar->state, time_left);
5902
5903 skip:
5904         mutex_unlock(&ar->conf_mutex);
5905 }
5906
5907 /* TODO: Implement this function properly
5908  * For now it is needed to reply to Probe Requests in IBSS mode.
5909  * Propably we need this information from FW.
5910  */
5911 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
5912 {
5913         return 1;
5914 }
5915
5916 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
5917                                      enum ieee80211_reconfig_type reconfig_type)
5918 {
5919         struct ath10k *ar = hw->priv;
5920
5921         if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
5922                 return;
5923
5924         mutex_lock(&ar->conf_mutex);
5925
5926         /* If device failed to restart it will be in a different state, e.g.
5927          * ATH10K_STATE_WEDGED */
5928         if (ar->state == ATH10K_STATE_RESTARTED) {
5929                 ath10k_info(ar, "device successfully recovered\n");
5930                 ar->state = ATH10K_STATE_ON;
5931                 ieee80211_wake_queues(ar->hw);
5932         }
5933
5934         mutex_unlock(&ar->conf_mutex);
5935 }
5936
5937 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
5938                              struct survey_info *survey)
5939 {
5940         struct ath10k *ar = hw->priv;
5941         struct ieee80211_supported_band *sband;
5942         struct survey_info *ar_survey = &ar->survey[idx];
5943         int ret = 0;
5944
5945         mutex_lock(&ar->conf_mutex);
5946
5947         sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
5948         if (sband && idx >= sband->n_channels) {
5949                 idx -= sband->n_channels;
5950                 sband = NULL;
5951         }
5952
5953         if (!sband)
5954                 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
5955
5956         if (!sband || idx >= sband->n_channels) {
5957                 ret = -ENOENT;
5958                 goto exit;
5959         }
5960
5961         spin_lock_bh(&ar->data_lock);
5962         memcpy(survey, ar_survey, sizeof(*survey));
5963         spin_unlock_bh(&ar->data_lock);
5964
5965         survey->channel = &sband->channels[idx];
5966
5967         if (ar->rx_channel == survey->channel)
5968                 survey->filled |= SURVEY_INFO_IN_USE;
5969
5970 exit:
5971         mutex_unlock(&ar->conf_mutex);
5972         return ret;
5973 }
5974
5975 static bool
5976 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
5977                                         enum ieee80211_band band,
5978                                         const struct cfg80211_bitrate_mask *mask)
5979 {
5980         int num_rates = 0;
5981         int i;
5982
5983         num_rates += hweight32(mask->control[band].legacy);
5984
5985         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
5986                 num_rates += hweight8(mask->control[band].ht_mcs[i]);
5987
5988         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
5989                 num_rates += hweight16(mask->control[band].vht_mcs[i]);
5990
5991         return num_rates == 1;
5992 }
5993
5994 static bool
5995 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
5996                                        enum ieee80211_band band,
5997                                        const struct cfg80211_bitrate_mask *mask,
5998                                        int *nss)
5999 {
6000         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6001         u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
6002         u8 ht_nss_mask = 0;
6003         u8 vht_nss_mask = 0;
6004         int i;
6005
6006         if (mask->control[band].legacy)
6007                 return false;
6008
6009         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6010                 if (mask->control[band].ht_mcs[i] == 0)
6011                         continue;
6012                 else if (mask->control[band].ht_mcs[i] ==
6013                          sband->ht_cap.mcs.rx_mask[i])
6014                         ht_nss_mask |= BIT(i);
6015                 else
6016                         return false;
6017         }
6018
6019         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6020                 if (mask->control[band].vht_mcs[i] == 0)
6021                         continue;
6022                 else if (mask->control[band].vht_mcs[i] ==
6023                          ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
6024                         vht_nss_mask |= BIT(i);
6025                 else
6026                         return false;
6027         }
6028
6029         if (ht_nss_mask != vht_nss_mask)
6030                 return false;
6031
6032         if (ht_nss_mask == 0)
6033                 return false;
6034
6035         if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
6036                 return false;
6037
6038         *nss = fls(ht_nss_mask);
6039
6040         return true;
6041 }
6042
6043 static int
6044 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
6045                                         enum ieee80211_band band,
6046                                         const struct cfg80211_bitrate_mask *mask,
6047                                         u8 *rate, u8 *nss)
6048 {
6049         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6050         int rate_idx;
6051         int i;
6052         u16 bitrate;
6053         u8 preamble;
6054         u8 hw_rate;
6055
6056         if (hweight32(mask->control[band].legacy) == 1) {
6057                 rate_idx = ffs(mask->control[band].legacy) - 1;
6058
6059                 hw_rate = sband->bitrates[rate_idx].hw_value;
6060                 bitrate = sband->bitrates[rate_idx].bitrate;
6061
6062                 if (ath10k_mac_bitrate_is_cck(bitrate))
6063                         preamble = WMI_RATE_PREAMBLE_CCK;
6064                 else
6065                         preamble = WMI_RATE_PREAMBLE_OFDM;
6066
6067                 *nss = 1;
6068                 *rate = preamble << 6 |
6069                         (*nss - 1) << 4 |
6070                         hw_rate << 0;
6071
6072                 return 0;
6073         }
6074
6075         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6076                 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
6077                         *nss = i + 1;
6078                         *rate = WMI_RATE_PREAMBLE_HT << 6 |
6079                                 (*nss - 1) << 4 |
6080                                 (ffs(mask->control[band].ht_mcs[i]) - 1);
6081
6082                         return 0;
6083                 }
6084         }
6085
6086         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6087                 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
6088                         *nss = i + 1;
6089                         *rate = WMI_RATE_PREAMBLE_VHT << 6 |
6090                                 (*nss - 1) << 4 |
6091                                 (ffs(mask->control[band].vht_mcs[i]) - 1);
6092
6093                         return 0;
6094                 }
6095         }
6096
6097         return -EINVAL;
6098 }
6099
6100 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
6101                                             u8 rate, u8 nss, u8 sgi, u8 ldpc)
6102 {
6103         struct ath10k *ar = arvif->ar;
6104         u32 vdev_param;
6105         int ret;
6106
6107         lockdep_assert_held(&ar->conf_mutex);
6108
6109         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
6110                    arvif->vdev_id, rate, nss, sgi);
6111
6112         vdev_param = ar->wmi.vdev_param->fixed_rate;
6113         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
6114         if (ret) {
6115                 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
6116                             rate, ret);
6117                 return ret;
6118         }
6119
6120         vdev_param = ar->wmi.vdev_param->nss;
6121         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
6122         if (ret) {
6123                 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
6124                 return ret;
6125         }
6126
6127         vdev_param = ar->wmi.vdev_param->sgi;
6128         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
6129         if (ret) {
6130                 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
6131                 return ret;
6132         }
6133
6134         vdev_param = ar->wmi.vdev_param->ldpc;
6135         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);
6136         if (ret) {
6137                 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);
6138                 return ret;
6139         }
6140
6141         return 0;
6142 }
6143
6144 static bool
6145 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
6146                                 enum ieee80211_band band,
6147                                 const struct cfg80211_bitrate_mask *mask)
6148 {
6149         int i;
6150         u16 vht_mcs;
6151
6152         /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
6153          * to express all VHT MCS rate masks. Effectively only the following
6154          * ranges can be used: none, 0-7, 0-8 and 0-9.
6155          */
6156         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
6157                 vht_mcs = mask->control[band].vht_mcs[i];
6158
6159                 switch (vht_mcs) {
6160                 case 0:
6161                 case BIT(8) - 1:
6162                 case BIT(9) - 1:
6163                 case BIT(10) - 1:
6164                         break;
6165                 default:
6166                         ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
6167                         return false;
6168                 }
6169         }
6170
6171         return true;
6172 }
6173
6174 static void ath10k_mac_set_bitrate_mask_iter(void *data,
6175                                              struct ieee80211_sta *sta)
6176 {
6177         struct ath10k_vif *arvif = data;
6178         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6179         struct ath10k *ar = arvif->ar;
6180
6181         if (arsta->arvif != arvif)
6182                 return;
6183
6184         spin_lock_bh(&ar->data_lock);
6185         arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
6186         spin_unlock_bh(&ar->data_lock);
6187
6188         ieee80211_queue_work(ar->hw, &arsta->update_wk);
6189 }
6190
6191 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
6192                                           struct ieee80211_vif *vif,
6193                                           const struct cfg80211_bitrate_mask *mask)
6194 {
6195         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6196         struct cfg80211_chan_def def;
6197         struct ath10k *ar = arvif->ar;
6198         enum ieee80211_band band;
6199         const u8 *ht_mcs_mask;
6200         const u16 *vht_mcs_mask;
6201         u8 rate;
6202         u8 nss;
6203         u8 sgi;
6204         u8 ldpc;
6205         int single_nss;
6206         int ret;
6207
6208         if (ath10k_mac_vif_chan(vif, &def))
6209                 return -EPERM;
6210
6211         band = def.chan->band;
6212         ht_mcs_mask = mask->control[band].ht_mcs;
6213         vht_mcs_mask = mask->control[band].vht_mcs;
6214         ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
6215
6216         sgi = mask->control[band].gi;
6217         if (sgi == NL80211_TXRATE_FORCE_LGI)
6218                 return -EINVAL;
6219
6220         if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) {
6221                 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
6222                                                               &rate, &nss);
6223                 if (ret) {
6224                         ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
6225                                     arvif->vdev_id, ret);
6226                         return ret;
6227                 }
6228         } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
6229                                                           &single_nss)) {
6230                 rate = WMI_FIXED_RATE_NONE;
6231                 nss = single_nss;
6232         } else {
6233                 rate = WMI_FIXED_RATE_NONE;
6234                 nss = min(ar->num_rf_chains,
6235                           max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6236                               ath10k_mac_max_vht_nss(vht_mcs_mask)));
6237
6238                 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask))
6239                         return -EINVAL;
6240
6241                 mutex_lock(&ar->conf_mutex);
6242
6243                 arvif->bitrate_mask = *mask;
6244                 ieee80211_iterate_stations_atomic(ar->hw,
6245                                                   ath10k_mac_set_bitrate_mask_iter,
6246                                                   arvif);
6247
6248                 mutex_unlock(&ar->conf_mutex);
6249         }
6250
6251         mutex_lock(&ar->conf_mutex);
6252
6253         ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
6254         if (ret) {
6255                 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
6256                             arvif->vdev_id, ret);
6257                 goto exit;
6258         }
6259
6260 exit:
6261         mutex_unlock(&ar->conf_mutex);
6262
6263         return ret;
6264 }
6265
6266 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
6267                                  struct ieee80211_vif *vif,
6268                                  struct ieee80211_sta *sta,
6269                                  u32 changed)
6270 {
6271         struct ath10k *ar = hw->priv;
6272         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6273         u32 bw, smps;
6274
6275         spin_lock_bh(&ar->data_lock);
6276
6277         ath10k_dbg(ar, ATH10K_DBG_MAC,
6278                    "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
6279                    sta->addr, changed, sta->bandwidth, sta->rx_nss,
6280                    sta->smps_mode);
6281
6282         if (changed & IEEE80211_RC_BW_CHANGED) {
6283                 bw = WMI_PEER_CHWIDTH_20MHZ;
6284
6285                 switch (sta->bandwidth) {
6286                 case IEEE80211_STA_RX_BW_20:
6287                         bw = WMI_PEER_CHWIDTH_20MHZ;
6288                         break;
6289                 case IEEE80211_STA_RX_BW_40:
6290                         bw = WMI_PEER_CHWIDTH_40MHZ;
6291                         break;
6292                 case IEEE80211_STA_RX_BW_80:
6293                         bw = WMI_PEER_CHWIDTH_80MHZ;
6294                         break;
6295                 case IEEE80211_STA_RX_BW_160:
6296                         ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
6297                                     sta->bandwidth, sta->addr);
6298                         bw = WMI_PEER_CHWIDTH_20MHZ;
6299                         break;
6300                 }
6301
6302                 arsta->bw = bw;
6303         }
6304
6305         if (changed & IEEE80211_RC_NSS_CHANGED)
6306                 arsta->nss = sta->rx_nss;
6307
6308         if (changed & IEEE80211_RC_SMPS_CHANGED) {
6309                 smps = WMI_PEER_SMPS_PS_NONE;
6310
6311                 switch (sta->smps_mode) {
6312                 case IEEE80211_SMPS_AUTOMATIC:
6313                 case IEEE80211_SMPS_OFF:
6314                         smps = WMI_PEER_SMPS_PS_NONE;
6315                         break;
6316                 case IEEE80211_SMPS_STATIC:
6317                         smps = WMI_PEER_SMPS_STATIC;
6318                         break;
6319                 case IEEE80211_SMPS_DYNAMIC:
6320                         smps = WMI_PEER_SMPS_DYNAMIC;
6321                         break;
6322                 case IEEE80211_SMPS_NUM_MODES:
6323                         ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
6324                                     sta->smps_mode, sta->addr);
6325                         smps = WMI_PEER_SMPS_PS_NONE;
6326                         break;
6327                 }
6328
6329                 arsta->smps = smps;
6330         }
6331
6332         arsta->changed |= changed;
6333
6334         spin_unlock_bh(&ar->data_lock);
6335
6336         ieee80211_queue_work(hw, &arsta->update_wk);
6337 }
6338
6339 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
6340 {
6341         /*
6342          * FIXME: Return 0 for time being. Need to figure out whether FW
6343          * has the API to fetch 64-bit local TSF
6344          */
6345
6346         return 0;
6347 }
6348
6349 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
6350                                struct ieee80211_vif *vif,
6351                                enum ieee80211_ampdu_mlme_action action,
6352                                struct ieee80211_sta *sta, u16 tid, u16 *ssn,
6353                                u8 buf_size, bool amsdu)
6354 {
6355         struct ath10k *ar = hw->priv;
6356         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6357
6358         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6359                    arvif->vdev_id, sta->addr, tid, action);
6360
6361         switch (action) {
6362         case IEEE80211_AMPDU_RX_START:
6363         case IEEE80211_AMPDU_RX_STOP:
6364                 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6365                  * creation/removal. Do we need to verify this?
6366                  */
6367                 return 0;
6368         case IEEE80211_AMPDU_TX_START:
6369         case IEEE80211_AMPDU_TX_STOP_CONT:
6370         case IEEE80211_AMPDU_TX_STOP_FLUSH:
6371         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6372         case IEEE80211_AMPDU_TX_OPERATIONAL:
6373                 /* Firmware offloads Tx aggregation entirely so deny mac80211
6374                  * Tx aggregation requests.
6375                  */
6376                 return -EOPNOTSUPP;
6377         }
6378
6379         return -EINVAL;
6380 }
6381
6382 static void
6383 ath10k_mac_update_rx_channel(struct ath10k *ar,
6384                              struct ieee80211_chanctx_conf *ctx,
6385                              struct ieee80211_vif_chanctx_switch *vifs,
6386                              int n_vifs)
6387 {
6388         struct cfg80211_chan_def *def = NULL;
6389
6390         /* Both locks are required because ar->rx_channel is modified. This
6391          * allows readers to hold either lock.
6392          */
6393         lockdep_assert_held(&ar->conf_mutex);
6394         lockdep_assert_held(&ar->data_lock);
6395
6396         WARN_ON(ctx && vifs);
6397         WARN_ON(vifs && n_vifs != 1);
6398
6399         /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6400          * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6401          * ppdu on Rx may reduce performance on low-end systems. It should be
6402          * possible to make tables/hashmaps to speed the lookup up (be vary of
6403          * cpu data cache lines though regarding sizes) but to keep the initial
6404          * implementation simple and less intrusive fallback to the slow lookup
6405          * only for multi-channel cases. Single-channel cases will remain to
6406          * use the old channel derival and thus performance should not be
6407          * affected much.
6408          */
6409         rcu_read_lock();
6410         if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
6411                 ieee80211_iter_chan_contexts_atomic(ar->hw,
6412                                                     ath10k_mac_get_any_chandef_iter,
6413                                                     &def);
6414
6415                 if (vifs)
6416                         def = &vifs[0].new_ctx->def;
6417
6418                 ar->rx_channel = def->chan;
6419         } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) {
6420                 ar->rx_channel = ctx->def.chan;
6421         } else {
6422                 ar->rx_channel = NULL;
6423         }
6424         rcu_read_unlock();
6425 }
6426
6427 static void
6428 ath10k_mac_update_vif_chan(struct ath10k *ar,
6429                            struct ieee80211_vif_chanctx_switch *vifs,
6430                            int n_vifs)
6431 {
6432         struct ath10k_vif *arvif;
6433         int ret;
6434         int i;
6435
6436         lockdep_assert_held(&ar->conf_mutex);
6437
6438         /* First stop monitor interface. Some FW versions crash if there's a
6439          * lone monitor interface.
6440          */
6441         if (ar->monitor_started)
6442                 ath10k_monitor_stop(ar);
6443
6444         for (i = 0; i < n_vifs; i++) {
6445                 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6446
6447                 ath10k_dbg(ar, ATH10K_DBG_MAC,
6448                            "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6449                            arvif->vdev_id,
6450                            vifs[i].old_ctx->def.chan->center_freq,
6451                            vifs[i].new_ctx->def.chan->center_freq,
6452                            vifs[i].old_ctx->def.width,
6453                            vifs[i].new_ctx->def.width);
6454
6455                 if (WARN_ON(!arvif->is_started))
6456                         continue;
6457
6458                 if (WARN_ON(!arvif->is_up))
6459                         continue;
6460
6461                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6462                 if (ret) {
6463                         ath10k_warn(ar, "failed to down vdev %d: %d\n",
6464                                     arvif->vdev_id, ret);
6465                         continue;
6466                 }
6467         }
6468
6469         /* All relevant vdevs are downed and associated channel resources
6470          * should be available for the channel switch now.
6471          */
6472
6473         spin_lock_bh(&ar->data_lock);
6474         ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
6475         spin_unlock_bh(&ar->data_lock);
6476
6477         for (i = 0; i < n_vifs; i++) {
6478                 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6479
6480                 if (WARN_ON(!arvif->is_started))
6481                         continue;
6482
6483                 if (WARN_ON(!arvif->is_up))
6484                         continue;
6485
6486                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6487                 if (ret)
6488                         ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
6489                                     ret);
6490
6491                 ret = ath10k_mac_setup_prb_tmpl(arvif);
6492                 if (ret)
6493                         ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
6494                                     ret);
6495
6496                 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
6497                 if (ret) {
6498                         ath10k_warn(ar, "failed to restart vdev %d: %d\n",
6499                                     arvif->vdev_id, ret);
6500                         continue;
6501                 }
6502
6503                 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6504                                          arvif->bssid);
6505                 if (ret) {
6506                         ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
6507                                     arvif->vdev_id, ret);
6508                         continue;
6509                 }
6510         }
6511
6512         ath10k_monitor_recalc(ar);
6513 }
6514
6515 static int
6516 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6517                           struct ieee80211_chanctx_conf *ctx)
6518 {
6519         struct ath10k *ar = hw->priv;
6520
6521         ath10k_dbg(ar, ATH10K_DBG_MAC,
6522                    "mac chanctx add freq %hu width %d ptr %p\n",
6523                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6524
6525         mutex_lock(&ar->conf_mutex);
6526
6527         spin_lock_bh(&ar->data_lock);
6528         ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
6529         spin_unlock_bh(&ar->data_lock);
6530
6531         ath10k_recalc_radar_detection(ar);
6532         ath10k_monitor_recalc(ar);
6533
6534         mutex_unlock(&ar->conf_mutex);
6535
6536         return 0;
6537 }
6538
6539 static void
6540 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6541                              struct ieee80211_chanctx_conf *ctx)
6542 {
6543         struct ath10k *ar = hw->priv;
6544
6545         ath10k_dbg(ar, ATH10K_DBG_MAC,
6546                    "mac chanctx remove freq %hu width %d ptr %p\n",
6547                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6548
6549         mutex_lock(&ar->conf_mutex);
6550
6551         spin_lock_bh(&ar->data_lock);
6552         ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
6553         spin_unlock_bh(&ar->data_lock);
6554
6555         ath10k_recalc_radar_detection(ar);
6556         ath10k_monitor_recalc(ar);
6557
6558         mutex_unlock(&ar->conf_mutex);
6559 }
6560
6561 struct ath10k_mac_change_chanctx_arg {
6562         struct ieee80211_chanctx_conf *ctx;
6563         struct ieee80211_vif_chanctx_switch *vifs;
6564         int n_vifs;
6565         int next_vif;
6566 };
6567
6568 static void
6569 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6570                                    struct ieee80211_vif *vif)
6571 {
6572         struct ath10k_mac_change_chanctx_arg *arg = data;
6573
6574         if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx)
6575                 return;
6576
6577         arg->n_vifs++;
6578 }
6579
6580 static void
6581 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6582                                     struct ieee80211_vif *vif)
6583 {
6584         struct ath10k_mac_change_chanctx_arg *arg = data;
6585         struct ieee80211_chanctx_conf *ctx;
6586
6587         ctx = rcu_access_pointer(vif->chanctx_conf);
6588         if (ctx != arg->ctx)
6589                 return;
6590
6591         if (WARN_ON(arg->next_vif == arg->n_vifs))
6592                 return;
6593
6594         arg->vifs[arg->next_vif].vif = vif;
6595         arg->vifs[arg->next_vif].old_ctx = ctx;
6596         arg->vifs[arg->next_vif].new_ctx = ctx;
6597         arg->next_vif++;
6598 }
6599
6600 static void
6601 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6602                              struct ieee80211_chanctx_conf *ctx,
6603                              u32 changed)
6604 {
6605         struct ath10k *ar = hw->priv;
6606         struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };
6607
6608         mutex_lock(&ar->conf_mutex);
6609
6610         ath10k_dbg(ar, ATH10K_DBG_MAC,
6611                    "mac chanctx change freq %hu width %d ptr %p changed %x\n",
6612                    ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6613
6614         /* This shouldn't really happen because channel switching should use
6615          * switch_vif_chanctx().
6616          */
6617         if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6618                 goto unlock;
6619
6620         if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {
6621                 ieee80211_iterate_active_interfaces_atomic(
6622                                         hw,
6623                                         IEEE80211_IFACE_ITER_NORMAL,
6624                                         ath10k_mac_change_chanctx_cnt_iter,
6625                                         &arg);
6626                 if (arg.n_vifs == 0)
6627                         goto radar;
6628
6629                 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),
6630                                    GFP_KERNEL);
6631                 if (!arg.vifs)
6632                         goto radar;
6633
6634                 ieee80211_iterate_active_interfaces_atomic(
6635                                         hw,
6636                                         IEEE80211_IFACE_ITER_NORMAL,
6637                                         ath10k_mac_change_chanctx_fill_iter,
6638                                         &arg);
6639                 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6640                 kfree(arg.vifs);
6641         }
6642
6643 radar:
6644         ath10k_recalc_radar_detection(ar);
6645
6646         /* FIXME: How to configure Rx chains properly? */
6647
6648         /* No other actions are actually necessary. Firmware maintains channel
6649          * definitions per vdev internally and there's no host-side channel
6650          * context abstraction to configure, e.g. channel width.
6651          */
6652
6653 unlock:
6654         mutex_unlock(&ar->conf_mutex);
6655 }
6656
6657 static int
6658 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
6659                                  struct ieee80211_vif *vif,
6660                                  struct ieee80211_chanctx_conf *ctx)
6661 {
6662         struct ath10k *ar = hw->priv;
6663         struct ath10k_vif *arvif = (void *)vif->drv_priv;
6664         int ret;
6665
6666         mutex_lock(&ar->conf_mutex);
6667
6668         ath10k_dbg(ar, ATH10K_DBG_MAC,
6669                    "mac chanctx assign ptr %p vdev_id %i\n",
6670                    ctx, arvif->vdev_id);
6671
6672         if (WARN_ON(arvif->is_started)) {
6673                 mutex_unlock(&ar->conf_mutex);
6674                 return -EBUSY;
6675         }
6676
6677         ret = ath10k_vdev_start(arvif, &ctx->def);
6678         if (ret) {
6679                 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
6680                             arvif->vdev_id, vif->addr,
6681                             ctx->def.chan->center_freq, ret);
6682                 goto err;
6683         }
6684
6685         arvif->is_started = true;
6686
6687         ret = ath10k_mac_vif_setup_ps(arvif);
6688         if (ret) {
6689                 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
6690                             arvif->vdev_id, ret);
6691                 goto err_stop;
6692         }
6693
6694         if (vif->type == NL80211_IFTYPE_MONITOR) {
6695                 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
6696                 if (ret) {
6697                         ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
6698                                     arvif->vdev_id, ret);
6699                         goto err_stop;
6700                 }
6701
6702                 arvif->is_up = true;
6703         }
6704
6705         mutex_unlock(&ar->conf_mutex);
6706         return 0;
6707
6708 err_stop:
6709         ath10k_vdev_stop(arvif);
6710         arvif->is_started = false;
6711         ath10k_mac_vif_setup_ps(arvif);
6712
6713 err:
6714         mutex_unlock(&ar->conf_mutex);
6715         return ret;
6716 }
6717
6718 static void
6719 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
6720                                    struct ieee80211_vif *vif,
6721                                    struct ieee80211_chanctx_conf *ctx)
6722 {
6723         struct ath10k *ar = hw->priv;
6724         struct ath10k_vif *arvif = (void *)vif->drv_priv;
6725         int ret;
6726
6727         mutex_lock(&ar->conf_mutex);
6728
6729         ath10k_dbg(ar, ATH10K_DBG_MAC,
6730                    "mac chanctx unassign ptr %p vdev_id %i\n",
6731                    ctx, arvif->vdev_id);
6732
6733         WARN_ON(!arvif->is_started);
6734
6735         if (vif->type == NL80211_IFTYPE_MONITOR) {
6736                 WARN_ON(!arvif->is_up);
6737
6738                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6739                 if (ret)
6740                         ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
6741                                     arvif->vdev_id, ret);
6742
6743                 arvif->is_up = false;
6744         }
6745
6746         ret = ath10k_vdev_stop(arvif);
6747         if (ret)
6748                 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
6749                             arvif->vdev_id, ret);
6750
6751         arvif->is_started = false;
6752
6753         mutex_unlock(&ar->conf_mutex);
6754 }
6755
6756 static int
6757 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
6758                                  struct ieee80211_vif_chanctx_switch *vifs,
6759                                  int n_vifs,
6760                                  enum ieee80211_chanctx_switch_mode mode)
6761 {
6762         struct ath10k *ar = hw->priv;
6763
6764         mutex_lock(&ar->conf_mutex);
6765
6766         ath10k_dbg(ar, ATH10K_DBG_MAC,
6767                    "mac chanctx switch n_vifs %d mode %d\n",
6768                    n_vifs, mode);
6769         ath10k_mac_update_vif_chan(ar, vifs, n_vifs);
6770
6771         mutex_unlock(&ar->conf_mutex);
6772         return 0;
6773 }
6774
6775 static const struct ieee80211_ops ath10k_ops = {
6776         .tx                             = ath10k_tx,
6777         .start                          = ath10k_start,
6778         .stop                           = ath10k_stop,
6779         .config                         = ath10k_config,
6780         .add_interface                  = ath10k_add_interface,
6781         .remove_interface               = ath10k_remove_interface,
6782         .configure_filter               = ath10k_configure_filter,
6783         .bss_info_changed               = ath10k_bss_info_changed,
6784         .hw_scan                        = ath10k_hw_scan,
6785         .cancel_hw_scan                 = ath10k_cancel_hw_scan,
6786         .set_key                        = ath10k_set_key,
6787         .set_default_unicast_key        = ath10k_set_default_unicast_key,
6788         .sta_state                      = ath10k_sta_state,
6789         .conf_tx                        = ath10k_conf_tx,
6790         .remain_on_channel              = ath10k_remain_on_channel,
6791         .cancel_remain_on_channel       = ath10k_cancel_remain_on_channel,
6792         .set_rts_threshold              = ath10k_set_rts_threshold,
6793         .set_frag_threshold             = ath10k_mac_op_set_frag_threshold,
6794         .flush                          = ath10k_flush,
6795         .tx_last_beacon                 = ath10k_tx_last_beacon,
6796         .set_antenna                    = ath10k_set_antenna,
6797         .get_antenna                    = ath10k_get_antenna,
6798         .reconfig_complete              = ath10k_reconfig_complete,
6799         .get_survey                     = ath10k_get_survey,
6800         .set_bitrate_mask               = ath10k_mac_op_set_bitrate_mask,
6801         .sta_rc_update                  = ath10k_sta_rc_update,
6802         .get_tsf                        = ath10k_get_tsf,
6803         .ampdu_action                   = ath10k_ampdu_action,
6804         .get_et_sset_count              = ath10k_debug_get_et_sset_count,
6805         .get_et_stats                   = ath10k_debug_get_et_stats,
6806         .get_et_strings                 = ath10k_debug_get_et_strings,
6807         .add_chanctx                    = ath10k_mac_op_add_chanctx,
6808         .remove_chanctx                 = ath10k_mac_op_remove_chanctx,
6809         .change_chanctx                 = ath10k_mac_op_change_chanctx,
6810         .assign_vif_chanctx             = ath10k_mac_op_assign_vif_chanctx,
6811         .unassign_vif_chanctx           = ath10k_mac_op_unassign_vif_chanctx,
6812         .switch_vif_chanctx             = ath10k_mac_op_switch_vif_chanctx,
6813
6814         CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
6815
6816 #ifdef CONFIG_PM
6817         .suspend                        = ath10k_wow_op_suspend,
6818         .resume                         = ath10k_wow_op_resume,
6819 #endif
6820 #ifdef CONFIG_MAC80211_DEBUGFS
6821         .sta_add_debugfs                = ath10k_sta_add_debugfs,
6822 #endif
6823 };
6824
6825 #define CHAN2G(_channel, _freq, _flags) { \
6826         .band                   = IEEE80211_BAND_2GHZ, \
6827         .hw_value               = (_channel), \
6828         .center_freq            = (_freq), \
6829         .flags                  = (_flags), \
6830         .max_antenna_gain       = 0, \
6831         .max_power              = 30, \
6832 }
6833
6834 #define CHAN5G(_channel, _freq, _flags) { \
6835         .band                   = IEEE80211_BAND_5GHZ, \
6836         .hw_value               = (_channel), \
6837         .center_freq            = (_freq), \
6838         .flags                  = (_flags), \
6839         .max_antenna_gain       = 0, \
6840         .max_power              = 30, \
6841 }
6842
6843 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
6844         CHAN2G(1, 2412, 0),
6845         CHAN2G(2, 2417, 0),
6846         CHAN2G(3, 2422, 0),
6847         CHAN2G(4, 2427, 0),
6848         CHAN2G(5, 2432, 0),
6849         CHAN2G(6, 2437, 0),
6850         CHAN2G(7, 2442, 0),
6851         CHAN2G(8, 2447, 0),
6852         CHAN2G(9, 2452, 0),
6853         CHAN2G(10, 2457, 0),
6854         CHAN2G(11, 2462, 0),
6855         CHAN2G(12, 2467, 0),
6856         CHAN2G(13, 2472, 0),
6857         CHAN2G(14, 2484, 0),
6858 };
6859
6860 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
6861         CHAN5G(36, 5180, 0),
6862         CHAN5G(40, 5200, 0),
6863         CHAN5G(44, 5220, 0),
6864         CHAN5G(48, 5240, 0),
6865         CHAN5G(52, 5260, 0),
6866         CHAN5G(56, 5280, 0),
6867         CHAN5G(60, 5300, 0),
6868         CHAN5G(64, 5320, 0),
6869         CHAN5G(100, 5500, 0),
6870         CHAN5G(104, 5520, 0),
6871         CHAN5G(108, 5540, 0),
6872         CHAN5G(112, 5560, 0),
6873         CHAN5G(116, 5580, 0),
6874         CHAN5G(120, 5600, 0),
6875         CHAN5G(124, 5620, 0),
6876         CHAN5G(128, 5640, 0),
6877         CHAN5G(132, 5660, 0),
6878         CHAN5G(136, 5680, 0),
6879         CHAN5G(140, 5700, 0),
6880         CHAN5G(144, 5720, 0),
6881         CHAN5G(149, 5745, 0),
6882         CHAN5G(153, 5765, 0),
6883         CHAN5G(157, 5785, 0),
6884         CHAN5G(161, 5805, 0),
6885         CHAN5G(165, 5825, 0),
6886 };
6887
6888 struct ath10k *ath10k_mac_create(size_t priv_size)
6889 {
6890         struct ieee80211_hw *hw;
6891         struct ath10k *ar;
6892
6893         hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
6894         if (!hw)
6895                 return NULL;
6896
6897         ar = hw->priv;
6898         ar->hw = hw;
6899
6900         return ar;
6901 }
6902
6903 void ath10k_mac_destroy(struct ath10k *ar)
6904 {
6905         ieee80211_free_hw(ar->hw);
6906 }
6907
6908 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
6909         {
6910         .max    = 8,
6911         .types  = BIT(NL80211_IFTYPE_STATION)
6912                 | BIT(NL80211_IFTYPE_P2P_CLIENT)
6913         },
6914         {
6915         .max    = 3,
6916         .types  = BIT(NL80211_IFTYPE_P2P_GO)
6917         },
6918         {
6919         .max    = 1,
6920         .types  = BIT(NL80211_IFTYPE_P2P_DEVICE)
6921         },
6922         {
6923         .max    = 7,
6924         .types  = BIT(NL80211_IFTYPE_AP)
6925 #ifdef CONFIG_MAC80211_MESH
6926                 | BIT(NL80211_IFTYPE_MESH_POINT)
6927 #endif
6928         },
6929 };
6930
6931 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
6932         {
6933         .max    = 8,
6934         .types  = BIT(NL80211_IFTYPE_AP)
6935 #ifdef CONFIG_MAC80211_MESH
6936                 | BIT(NL80211_IFTYPE_MESH_POINT)
6937 #endif
6938         },
6939 };
6940
6941 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
6942         {
6943                 .limits = ath10k_if_limits,
6944                 .n_limits = ARRAY_SIZE(ath10k_if_limits),
6945                 .max_interfaces = 8,
6946                 .num_different_channels = 1,
6947                 .beacon_int_infra_match = true,
6948         },
6949 };
6950
6951 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
6952         {
6953                 .limits = ath10k_10x_if_limits,
6954                 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
6955                 .max_interfaces = 8,
6956                 .num_different_channels = 1,
6957                 .beacon_int_infra_match = true,
6958 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6959                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6960                                         BIT(NL80211_CHAN_WIDTH_20) |
6961                                         BIT(NL80211_CHAN_WIDTH_40) |
6962                                         BIT(NL80211_CHAN_WIDTH_80),
6963 #endif
6964         },
6965 };
6966
6967 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
6968         {
6969                 .max = 2,
6970                 .types = BIT(NL80211_IFTYPE_STATION),
6971         },
6972         {
6973                 .max = 2,
6974                 .types = BIT(NL80211_IFTYPE_AP) |
6975 #ifdef CONFIG_MAC80211_MESH
6976                          BIT(NL80211_IFTYPE_MESH_POINT) |
6977 #endif
6978                          BIT(NL80211_IFTYPE_P2P_CLIENT) |
6979                          BIT(NL80211_IFTYPE_P2P_GO),
6980         },
6981         {
6982                 .max = 1,
6983                 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
6984         },
6985 };
6986
6987 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
6988         {
6989                 .max = 2,
6990                 .types = BIT(NL80211_IFTYPE_STATION),
6991         },
6992         {
6993                 .max = 2,
6994                 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
6995         },
6996         {
6997                 .max = 1,
6998                 .types = BIT(NL80211_IFTYPE_AP) |
6999 #ifdef CONFIG_MAC80211_MESH
7000                          BIT(NL80211_IFTYPE_MESH_POINT) |
7001 #endif
7002                          BIT(NL80211_IFTYPE_P2P_GO),
7003         },
7004         {
7005                 .max = 1,
7006                 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7007         },
7008 };
7009
7010 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
7011         {
7012                 .max = 1,
7013                 .types = BIT(NL80211_IFTYPE_STATION),
7014         },
7015         {
7016                 .max = 1,
7017                 .types = BIT(NL80211_IFTYPE_ADHOC),
7018         },
7019 };
7020
7021 /* FIXME: This is not thouroughly tested. These combinations may over- or
7022  * underestimate hw/fw capabilities.
7023  */
7024 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
7025         {
7026                 .limits = ath10k_tlv_if_limit,
7027                 .num_different_channels = 1,
7028                 .max_interfaces = 4,
7029                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7030         },
7031         {
7032                 .limits = ath10k_tlv_if_limit_ibss,
7033                 .num_different_channels = 1,
7034                 .max_interfaces = 2,
7035                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7036         },
7037 };
7038
7039 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
7040         {
7041                 .limits = ath10k_tlv_if_limit,
7042                 .num_different_channels = 1,
7043                 .max_interfaces = 4,
7044                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7045         },
7046         {
7047                 .limits = ath10k_tlv_qcs_if_limit,
7048                 .num_different_channels = 2,
7049                 .max_interfaces = 4,
7050                 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
7051         },
7052         {
7053                 .limits = ath10k_tlv_if_limit_ibss,
7054                 .num_different_channels = 1,
7055                 .max_interfaces = 2,
7056                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7057         },
7058 };
7059
7060 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
7061         {
7062                 .max = 1,
7063                 .types = BIT(NL80211_IFTYPE_STATION),
7064         },
7065         {
7066                 .max    = 16,
7067                 .types  = BIT(NL80211_IFTYPE_AP)
7068 #ifdef CONFIG_MAC80211_MESH
7069                         | BIT(NL80211_IFTYPE_MESH_POINT)
7070 #endif
7071         },
7072 };
7073
7074 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
7075         {
7076                 .limits = ath10k_10_4_if_limits,
7077                 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
7078                 .max_interfaces = 16,
7079                 .num_different_channels = 1,
7080                 .beacon_int_infra_match = true,
7081 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
7082                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
7083                                         BIT(NL80211_CHAN_WIDTH_20) |
7084                                         BIT(NL80211_CHAN_WIDTH_40) |
7085                                         BIT(NL80211_CHAN_WIDTH_80),
7086 #endif
7087         },
7088 };
7089
7090 static void ath10k_get_arvif_iter(void *data, u8 *mac,
7091                                   struct ieee80211_vif *vif)
7092 {
7093         struct ath10k_vif_iter *arvif_iter = data;
7094         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
7095
7096         if (arvif->vdev_id == arvif_iter->vdev_id)
7097                 arvif_iter->arvif = arvif;
7098 }
7099
7100 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
7101 {
7102         struct ath10k_vif_iter arvif_iter;
7103         u32 flags;
7104
7105         memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
7106         arvif_iter.vdev_id = vdev_id;
7107
7108         flags = IEEE80211_IFACE_ITER_RESUME_ALL;
7109         ieee80211_iterate_active_interfaces_atomic(ar->hw,
7110                                                    flags,
7111                                                    ath10k_get_arvif_iter,
7112                                                    &arvif_iter);
7113         if (!arvif_iter.arvif) {
7114                 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
7115                 return NULL;
7116         }
7117
7118         return arvif_iter.arvif;
7119 }
7120
7121 int ath10k_mac_register(struct ath10k *ar)
7122 {
7123         static const u32 cipher_suites[] = {
7124                 WLAN_CIPHER_SUITE_WEP40,
7125                 WLAN_CIPHER_SUITE_WEP104,
7126                 WLAN_CIPHER_SUITE_TKIP,
7127                 WLAN_CIPHER_SUITE_CCMP,
7128                 WLAN_CIPHER_SUITE_AES_CMAC,
7129         };
7130         struct ieee80211_supported_band *band;
7131         void *channels;
7132         int ret;
7133
7134         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
7135
7136         SET_IEEE80211_DEV(ar->hw, ar->dev);
7137
7138         BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
7139                       ARRAY_SIZE(ath10k_5ghz_channels)) !=
7140                      ATH10K_NUM_CHANS);
7141
7142         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
7143                 channels = kmemdup(ath10k_2ghz_channels,
7144                                    sizeof(ath10k_2ghz_channels),
7145                                    GFP_KERNEL);
7146                 if (!channels) {
7147                         ret = -ENOMEM;
7148                         goto err_free;
7149                 }
7150
7151                 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
7152                 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
7153                 band->channels = channels;
7154                 band->n_bitrates = ath10k_g_rates_size;
7155                 band->bitrates = ath10k_g_rates;
7156
7157                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
7158         }
7159
7160         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
7161                 channels = kmemdup(ath10k_5ghz_channels,
7162                                    sizeof(ath10k_5ghz_channels),
7163                                    GFP_KERNEL);
7164                 if (!channels) {
7165                         ret = -ENOMEM;
7166                         goto err_free;
7167                 }
7168
7169                 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
7170                 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
7171                 band->channels = channels;
7172                 band->n_bitrates = ath10k_a_rates_size;
7173                 band->bitrates = ath10k_a_rates;
7174                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
7175         }
7176
7177         ath10k_mac_setup_ht_vht_cap(ar);
7178
7179         ar->hw->wiphy->interface_modes =
7180                 BIT(NL80211_IFTYPE_STATION) |
7181                 BIT(NL80211_IFTYPE_AP) |
7182                 BIT(NL80211_IFTYPE_MESH_POINT);
7183
7184         ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask;
7185         ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask;
7186
7187         if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
7188                 ar->hw->wiphy->interface_modes |=
7189                         BIT(NL80211_IFTYPE_P2P_DEVICE) |
7190                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
7191                         BIT(NL80211_IFTYPE_P2P_GO);
7192
7193         ieee80211_hw_set(ar->hw, SIGNAL_DBM);
7194         ieee80211_hw_set(ar->hw, SUPPORTS_PS);
7195         ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
7196         ieee80211_hw_set(ar->hw, MFP_CAPABLE);
7197         ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
7198         ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
7199         ieee80211_hw_set(ar->hw, AP_LINK_PS);
7200         ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
7201         ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
7202         ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
7203         ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
7204         ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
7205         ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
7206         ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
7207
7208         if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7209                 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
7210
7211         ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
7212         ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
7213
7214         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
7215                 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
7216
7217         if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
7218                 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
7219                 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
7220         }
7221
7222         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
7223         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
7224
7225         ar->hw->vif_data_size = sizeof(struct ath10k_vif);
7226         ar->hw->sta_data_size = sizeof(struct ath10k_sta);
7227
7228         ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
7229
7230         if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
7231                 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
7232
7233                 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
7234                  * that userspace (e.g. wpa_supplicant/hostapd) can generate
7235                  * correct Probe Responses. This is more of a hack advert..
7236                  */
7237                 ar->hw->wiphy->probe_resp_offload |=
7238                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
7239                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
7240                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
7241         }
7242
7243         if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))
7244                 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7245
7246         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
7247         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
7248         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
7249
7250         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
7251         ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
7252
7253         ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
7254
7255         ret = ath10k_wow_init(ar);
7256         if (ret) {
7257                 ath10k_warn(ar, "failed to init wow: %d\n", ret);
7258                 goto err_free;
7259         }
7260
7261         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
7262
7263         /*
7264          * on LL hardware queues are managed entirely by the FW
7265          * so we only advertise to mac we can do the queues thing
7266          */
7267         ar->hw->queues = IEEE80211_MAX_QUEUES;
7268
7269         /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
7270          * something that vdev_ids can't reach so that we don't stop the queue
7271          * accidentally.
7272          */
7273         ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
7274
7275         switch (ar->wmi.op_version) {
7276         case ATH10K_FW_WMI_OP_VERSION_MAIN:
7277                 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
7278                 ar->hw->wiphy->n_iface_combinations =
7279                         ARRAY_SIZE(ath10k_if_comb);
7280                 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7281                 break;
7282         case ATH10K_FW_WMI_OP_VERSION_TLV:
7283                 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
7284                         ar->hw->wiphy->iface_combinations =
7285                                 ath10k_tlv_qcs_if_comb;
7286                         ar->hw->wiphy->n_iface_combinations =
7287                                 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
7288                 } else {
7289                         ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
7290                         ar->hw->wiphy->n_iface_combinations =
7291                                 ARRAY_SIZE(ath10k_tlv_if_comb);
7292                 }
7293                 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7294                 break;
7295         case ATH10K_FW_WMI_OP_VERSION_10_1:
7296         case ATH10K_FW_WMI_OP_VERSION_10_2:
7297         case ATH10K_FW_WMI_OP_VERSION_10_2_4:
7298                 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
7299                 ar->hw->wiphy->n_iface_combinations =
7300                         ARRAY_SIZE(ath10k_10x_if_comb);
7301                 break;
7302         case ATH10K_FW_WMI_OP_VERSION_10_4:
7303                 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
7304                 ar->hw->wiphy->n_iface_combinations =
7305                         ARRAY_SIZE(ath10k_10_4_if_comb);
7306                 break;
7307         case ATH10K_FW_WMI_OP_VERSION_UNSET:
7308         case ATH10K_FW_WMI_OP_VERSION_MAX:
7309                 WARN_ON(1);
7310                 ret = -EINVAL;
7311                 goto err_free;
7312         }
7313
7314         if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7315                 ar->hw->netdev_features = NETIF_F_HW_CSUM;
7316
7317         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
7318                 /* Init ath dfs pattern detector */
7319                 ar->ath_common.debug_mask = ATH_DBG_DFS;
7320                 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
7321                                                              NL80211_DFS_UNSET);
7322
7323                 if (!ar->dfs_detector)
7324                         ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
7325         }
7326
7327         ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
7328                             ath10k_reg_notifier);
7329         if (ret) {
7330                 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
7331                 goto err_dfs_detector_exit;
7332         }
7333
7334         ar->hw->wiphy->cipher_suites = cipher_suites;
7335         ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7336
7337         ret = ieee80211_register_hw(ar->hw);
7338         if (ret) {
7339                 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
7340                 goto err_dfs_detector_exit;
7341         }
7342
7343         if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
7344                 ret = regulatory_hint(ar->hw->wiphy,
7345                                       ar->ath_common.regulatory.alpha2);
7346                 if (ret)
7347                         goto err_unregister;
7348         }
7349
7350         return 0;
7351
7352 err_unregister:
7353         ieee80211_unregister_hw(ar->hw);
7354
7355 err_dfs_detector_exit:
7356         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7357                 ar->dfs_detector->exit(ar->dfs_detector);
7358
7359 err_free:
7360         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7361         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7362
7363         SET_IEEE80211_DEV(ar->hw, NULL);
7364         return ret;
7365 }
7366
7367 void ath10k_mac_unregister(struct ath10k *ar)
7368 {
7369         ieee80211_unregister_hw(ar->hw);
7370
7371         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7372                 ar->dfs_detector->exit(ar->dfs_detector);
7373
7374         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7375         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7376
7377         SET_IEEE80211_DEV(ar->hw, NULL);
7378 }