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