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