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