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

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