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 IEEE80211_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 IEEE80211_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 ieee80211_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 ieee80211_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 ieee80211_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 == IEEE80211_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[IEEE80211_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 ieee80211_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 IEEE80211_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 IEEE80211_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 ieee80211_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 < IEEE80211_NUM_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 < IEEE80211_NUM_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 == IEEE80211_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         const bool is_mgmt = false;
3703         const bool is_presp = false;
3704         struct ath10k *ar = hw->priv;
3705         struct ath10k_htt *htt = &ar->htt;
3706         struct ath10k_txq *artxq = (void *)txq->drv_priv;
3707         struct ieee80211_vif *vif = txq->vif;
3708         struct ieee80211_sta *sta = txq->sta;
3709         enum ath10k_hw_txrx_mode txmode;
3710         enum ath10k_mac_tx_path txpath;
3711         struct sk_buff *skb;
3712         size_t skb_len;
3713         int ret;
3714
3715         spin_lock_bh(&ar->htt.tx_lock);
3716         ret = ath10k_htt_tx_inc_pending(htt, is_mgmt, is_presp);
3717         spin_unlock_bh(&ar->htt.tx_lock);
3718
3719         if (ret)
3720                 return ret;
3721
3722         skb = ieee80211_tx_dequeue(hw, txq);
3723         if (!skb) {
3724                 spin_lock_bh(&ar->htt.tx_lock);
3725                 ath10k_htt_tx_dec_pending(htt, is_mgmt);
3726                 spin_unlock_bh(&ar->htt.tx_lock);
3727
3728                 return -ENOENT;
3729         }
3730
3731         ath10k_mac_tx_h_fill_cb(ar, vif, txq, skb);
3732
3733         skb_len = skb->len;
3734         txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
3735         txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
3736
3737         ret = ath10k_mac_tx(ar, vif, sta, txmode, txpath, skb);
3738         if (unlikely(ret)) {
3739                 ath10k_warn(ar, "failed to push frame: %d\n", ret);
3740
3741                 spin_lock_bh(&ar->htt.tx_lock);
3742                 ath10k_htt_tx_dec_pending(htt, is_mgmt);
3743                 spin_unlock_bh(&ar->htt.tx_lock);
3744
3745                 return ret;
3746         }
3747
3748         spin_lock_bh(&ar->htt.tx_lock);
3749         artxq->num_fw_queued++;
3750         spin_unlock_bh(&ar->htt.tx_lock);
3751
3752         return skb_len;
3753 }
3754
3755 void ath10k_mac_tx_push_pending(struct ath10k *ar)
3756 {
3757         struct ieee80211_hw *hw = ar->hw;
3758         struct ieee80211_txq *txq;
3759         struct ath10k_txq *artxq;
3760         struct ath10k_txq *last;
3761         int ret;
3762         int max;
3763
3764         spin_lock_bh(&ar->txqs_lock);
3765         rcu_read_lock();
3766
3767         last = list_last_entry(&ar->txqs, struct ath10k_txq, list);
3768         while (!list_empty(&ar->txqs)) {
3769                 artxq = list_first_entry(&ar->txqs, struct ath10k_txq, list);
3770                 txq = container_of((void *)artxq, struct ieee80211_txq,
3771                                    drv_priv);
3772
3773                 /* Prevent aggressive sta/tid taking over tx queue */
3774                 max = 16;
3775                 while (max--) {
3776                         ret = ath10k_mac_tx_push_txq(hw, txq);
3777                         if (ret < 0)
3778                                 break;
3779                 }
3780
3781                 list_del_init(&artxq->list);
3782                 ath10k_htt_tx_txq_update(hw, txq);
3783
3784                 if (artxq == last || (ret < 0 && ret != -ENOENT)) {
3785                         if (ret != -ENOENT)
3786                                 list_add_tail(&artxq->list, &ar->txqs);
3787                         break;
3788                 }
3789         }
3790
3791         rcu_read_unlock();
3792         spin_unlock_bh(&ar->txqs_lock);
3793 }
3794
3795 /************/
3796 /* Scanning */
3797 /************/
3798
3799 void __ath10k_scan_finish(struct ath10k *ar)
3800 {
3801         lockdep_assert_held(&ar->data_lock);
3802
3803         switch (ar->scan.state) {
3804         case ATH10K_SCAN_IDLE:
3805                 break;
3806         case ATH10K_SCAN_RUNNING:
3807         case ATH10K_SCAN_ABORTING:
3808                 if (!ar->scan.is_roc)
3809                         ieee80211_scan_completed(ar->hw,
3810                                                  (ar->scan.state ==
3811                                                   ATH10K_SCAN_ABORTING));
3812                 else if (ar->scan.roc_notify)
3813                         ieee80211_remain_on_channel_expired(ar->hw);
3814                 /* fall through */
3815         case ATH10K_SCAN_STARTING:
3816                 ar->scan.state = ATH10K_SCAN_IDLE;
3817                 ar->scan_channel = NULL;
3818                 ar->scan.roc_freq = 0;
3819                 ath10k_offchan_tx_purge(ar);
3820                 cancel_delayed_work(&ar->scan.timeout);
3821                 complete_all(&ar->scan.completed);
3822                 break;
3823         }
3824 }
3825
3826 void ath10k_scan_finish(struct ath10k *ar)
3827 {
3828         spin_lock_bh(&ar->data_lock);
3829         __ath10k_scan_finish(ar);
3830         spin_unlock_bh(&ar->data_lock);
3831 }
3832
3833 static int ath10k_scan_stop(struct ath10k *ar)
3834 {
3835         struct wmi_stop_scan_arg arg = {
3836                 .req_id = 1, /* FIXME */
3837                 .req_type = WMI_SCAN_STOP_ONE,
3838                 .u.scan_id = ATH10K_SCAN_ID,
3839         };
3840         int ret;
3841
3842         lockdep_assert_held(&ar->conf_mutex);
3843
3844         ret = ath10k_wmi_stop_scan(ar, &arg);
3845         if (ret) {
3846                 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
3847                 goto out;
3848         }
3849
3850         ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
3851         if (ret == 0) {
3852                 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
3853                 ret = -ETIMEDOUT;
3854         } else if (ret > 0) {
3855                 ret = 0;
3856         }
3857
3858 out:
3859         /* Scan state should be updated upon scan completion but in case
3860          * firmware fails to deliver the event (for whatever reason) it is
3861          * desired to clean up scan state anyway. Firmware may have just
3862          * dropped the scan completion event delivery due to transport pipe
3863          * being overflown with data and/or it can recover on its own before
3864          * next scan request is submitted.
3865          */
3866         spin_lock_bh(&ar->data_lock);
3867         if (ar->scan.state != ATH10K_SCAN_IDLE)
3868                 __ath10k_scan_finish(ar);
3869         spin_unlock_bh(&ar->data_lock);
3870
3871         return ret;
3872 }
3873
3874 static void ath10k_scan_abort(struct ath10k *ar)
3875 {
3876         int ret;
3877
3878         lockdep_assert_held(&ar->conf_mutex);
3879
3880         spin_lock_bh(&ar->data_lock);
3881
3882         switch (ar->scan.state) {
3883         case ATH10K_SCAN_IDLE:
3884                 /* This can happen if timeout worker kicked in and called
3885                  * abortion while scan completion was being processed.
3886                  */
3887                 break;
3888         case ATH10K_SCAN_STARTING:
3889         case ATH10K_SCAN_ABORTING:
3890                 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
3891                             ath10k_scan_state_str(ar->scan.state),
3892                             ar->scan.state);
3893                 break;
3894         case ATH10K_SCAN_RUNNING:
3895                 ar->scan.state = ATH10K_SCAN_ABORTING;
3896                 spin_unlock_bh(&ar->data_lock);
3897
3898                 ret = ath10k_scan_stop(ar);
3899                 if (ret)
3900                         ath10k_warn(ar, "failed to abort scan: %d\n", ret);
3901
3902                 spin_lock_bh(&ar->data_lock);
3903                 break;
3904         }
3905
3906         spin_unlock_bh(&ar->data_lock);
3907 }
3908
3909 void ath10k_scan_timeout_work(struct work_struct *work)
3910 {
3911         struct ath10k *ar = container_of(work, struct ath10k,
3912                                          scan.timeout.work);
3913
3914         mutex_lock(&ar->conf_mutex);
3915         ath10k_scan_abort(ar);
3916         mutex_unlock(&ar->conf_mutex);
3917 }
3918
3919 static int ath10k_start_scan(struct ath10k *ar,
3920                              const struct wmi_start_scan_arg *arg)
3921 {
3922         int ret;
3923
3924         lockdep_assert_held(&ar->conf_mutex);
3925
3926         ret = ath10k_wmi_start_scan(ar, arg);
3927         if (ret)
3928                 return ret;
3929
3930         ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
3931         if (ret == 0) {
3932                 ret = ath10k_scan_stop(ar);
3933                 if (ret)
3934                         ath10k_warn(ar, "failed to stop scan: %d\n", ret);
3935
3936                 return -ETIMEDOUT;
3937         }
3938
3939         /* If we failed to start the scan, return error code at
3940          * this point.  This is probably due to some issue in the
3941          * firmware, but no need to wedge the driver due to that...
3942          */
3943         spin_lock_bh(&ar->data_lock);
3944         if (ar->scan.state == ATH10K_SCAN_IDLE) {
3945                 spin_unlock_bh(&ar->data_lock);
3946                 return -EINVAL;
3947         }
3948         spin_unlock_bh(&ar->data_lock);
3949
3950         return 0;
3951 }
3952
3953 /**********************/
3954 /* mac80211 callbacks */
3955 /**********************/
3956
3957 static void ath10k_mac_op_tx(struct ieee80211_hw *hw,
3958                              struct ieee80211_tx_control *control,
3959                              struct sk_buff *skb)
3960 {
3961         struct ath10k *ar = hw->priv;
3962         struct ath10k_htt *htt = &ar->htt;
3963         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3964         struct ieee80211_vif *vif = info->control.vif;
3965         struct ieee80211_sta *sta = control->sta;
3966         struct ieee80211_txq *txq = NULL;
3967         struct ieee80211_hdr *hdr = (void *)skb->data;
3968         enum ath10k_hw_txrx_mode txmode;
3969         enum ath10k_mac_tx_path txpath;
3970         bool is_htt;
3971         bool is_mgmt;
3972         bool is_presp;
3973         int ret;
3974
3975         ath10k_mac_tx_h_fill_cb(ar, vif, txq, skb);
3976
3977         txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
3978         txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
3979         is_htt = (txpath == ATH10K_MAC_TX_HTT ||
3980                   txpath == ATH10K_MAC_TX_HTT_MGMT);
3981
3982         if (is_htt) {
3983                 spin_lock_bh(&ar->htt.tx_lock);
3984
3985                 is_mgmt = ieee80211_is_mgmt(hdr->frame_control);
3986                 is_presp = ieee80211_is_probe_resp(hdr->frame_control);
3987
3988                 ret = ath10k_htt_tx_inc_pending(htt, is_mgmt, is_presp);
3989                 if (ret) {
3990                         ath10k_warn(ar, "failed to increase tx pending count: %d, dropping\n",
3991                                     ret);
3992                         spin_unlock_bh(&ar->htt.tx_lock);
3993                         ieee80211_free_txskb(ar->hw, skb);
3994                         return;
3995                 }
3996
3997                 spin_unlock_bh(&ar->htt.tx_lock);
3998         }
3999
4000         ret = ath10k_mac_tx(ar, vif, sta, txmode, txpath, skb);
4001         if (ret) {
4002                 ath10k_warn(ar, "failed to transmit frame: %d\n", ret);
4003                 if (is_htt) {
4004                         spin_lock_bh(&ar->htt.tx_lock);
4005                         ath10k_htt_tx_dec_pending(htt, is_mgmt);
4006                         spin_unlock_bh(&ar->htt.tx_lock);
4007                 }
4008                 return;
4009         }
4010 }
4011
4012 static void ath10k_mac_op_wake_tx_queue(struct ieee80211_hw *hw,
4013                                         struct ieee80211_txq *txq)
4014 {
4015         struct ath10k *ar = hw->priv;
4016         struct ath10k_txq *artxq = (void *)txq->drv_priv;
4017
4018         if (ath10k_mac_tx_can_push(hw, txq)) {
4019                 spin_lock_bh(&ar->txqs_lock);
4020                 if (list_empty(&artxq->list))
4021                         list_add_tail(&artxq->list, &ar->txqs);
4022                 spin_unlock_bh(&ar->txqs_lock);
4023
4024                 tasklet_schedule(&ar->htt.txrx_compl_task);
4025         }
4026
4027         ath10k_htt_tx_txq_update(hw, txq);
4028 }
4029
4030 /* Must not be called with conf_mutex held as workers can use that also. */
4031 void ath10k_drain_tx(struct ath10k *ar)
4032 {
4033         /* make sure rcu-protected mac80211 tx path itself is drained */
4034         synchronize_net();
4035
4036         ath10k_offchan_tx_purge(ar);
4037         ath10k_mgmt_over_wmi_tx_purge(ar);
4038
4039         cancel_work_sync(&ar->offchan_tx_work);
4040         cancel_work_sync(&ar->wmi_mgmt_tx_work);
4041 }
4042
4043 void ath10k_halt(struct ath10k *ar)
4044 {
4045         struct ath10k_vif *arvif;
4046
4047         lockdep_assert_held(&ar->conf_mutex);
4048
4049         clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
4050         ar->filter_flags = 0;
4051         ar->monitor = false;
4052         ar->monitor_arvif = NULL;
4053
4054         if (ar->monitor_started)
4055                 ath10k_monitor_stop(ar);
4056
4057         ar->monitor_started = false;
4058         ar->tx_paused = 0;
4059
4060         ath10k_scan_finish(ar);
4061         ath10k_peer_cleanup_all(ar);
4062         ath10k_core_stop(ar);
4063         ath10k_hif_power_down(ar);
4064
4065         spin_lock_bh(&ar->data_lock);
4066         list_for_each_entry(arvif, &ar->arvifs, list)
4067                 ath10k_mac_vif_beacon_cleanup(arvif);
4068         spin_unlock_bh(&ar->data_lock);
4069 }
4070
4071 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
4072 {
4073         struct ath10k *ar = hw->priv;
4074
4075         mutex_lock(&ar->conf_mutex);
4076
4077         *tx_ant = ar->cfg_tx_chainmask;
4078         *rx_ant = ar->cfg_rx_chainmask;
4079
4080         mutex_unlock(&ar->conf_mutex);
4081
4082         return 0;
4083 }
4084
4085 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
4086 {
4087         /* It is not clear that allowing gaps in chainmask
4088          * is helpful.  Probably it will not do what user
4089          * is hoping for, so warn in that case.
4090          */
4091         if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
4092                 return;
4093
4094         ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x.  Suggested values: 15, 7, 3, 1 or 0.\n",
4095                     dbg, cm);
4096 }
4097
4098 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar)
4099 {
4100         int nsts = ar->vht_cap_info;
4101
4102         nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4103         nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4104
4105         /* If firmware does not deliver to host number of space-time
4106          * streams supported, assume it support up to 4 BF STS and return
4107          * the value for VHT CAP: nsts-1)
4108          */
4109         if (nsts == 0)
4110                 return 3;
4111
4112         return nsts;
4113 }
4114
4115 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar)
4116 {
4117         int sound_dim = ar->vht_cap_info;
4118
4119         sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4120         sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4121
4122         /* If the sounding dimension is not advertised by the firmware,
4123          * let's use a default value of 1
4124          */
4125         if (sound_dim == 0)
4126                 return 1;
4127
4128         return sound_dim;
4129 }
4130
4131 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4132 {
4133         struct ieee80211_sta_vht_cap vht_cap = {0};
4134         u16 mcs_map;
4135         u32 val;
4136         int i;
4137
4138         vht_cap.vht_supported = 1;
4139         vht_cap.cap = ar->vht_cap_info;
4140
4141         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4142                                 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
4143                 val = ath10k_mac_get_vht_cap_bf_sts(ar);
4144                 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4145                 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4146
4147                 vht_cap.cap |= val;
4148         }
4149
4150         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4151                                 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
4152                 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
4153                 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4154                 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4155
4156                 vht_cap.cap |= val;
4157         }
4158
4159         mcs_map = 0;
4160         for (i = 0; i < 8; i++) {
4161                 if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i)))
4162                         mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
4163                 else
4164                         mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
4165         }
4166
4167         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4168         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4169
4170         return vht_cap;
4171 }
4172
4173 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4174 {
4175         int i;
4176         struct ieee80211_sta_ht_cap ht_cap = {0};
4177
4178         if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4179                 return ht_cap;
4180
4181         ht_cap.ht_supported = 1;
4182         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4183         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4184         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4185         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4186         ht_cap.cap |=
4187                 WLAN_HT_CAP_SM_PS_DISABLED << IEEE80211_HT_CAP_SM_PS_SHIFT;
4188
4189         if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4190                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4191
4192         if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4193                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4194
4195         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4196                 u32 smps;
4197
4198                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
4199                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4200
4201                 ht_cap.cap |= smps;
4202         }
4203
4204         if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4205                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4206
4207         if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4208                 u32 stbc;
4209
4210                 stbc   = ar->ht_cap_info;
4211                 stbc  &= WMI_HT_CAP_RX_STBC;
4212                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4213                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4214                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
4215
4216                 ht_cap.cap |= stbc;
4217         }
4218
4219         if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4220                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4221
4222         if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4223                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4224
4225         /* max AMSDU is implicitly taken from vht_cap_info */
4226         if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4227                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4228
4229         for (i = 0; i < ar->num_rf_chains; i++) {
4230                 if (ar->cfg_rx_chainmask & BIT(i))
4231                         ht_cap.mcs.rx_mask[i] = 0xFF;
4232         }
4233
4234         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4235
4236         return ht_cap;
4237 }
4238
4239 static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar)
4240 {
4241         struct ieee80211_supported_band *band;
4242         struct ieee80211_sta_vht_cap vht_cap;
4243         struct ieee80211_sta_ht_cap ht_cap;
4244
4245         ht_cap = ath10k_get_ht_cap(ar);
4246         vht_cap = ath10k_create_vht_cap(ar);
4247
4248         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4249                 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
4250                 band->ht_cap = ht_cap;
4251
4252                 /* Enable the VHT support at 2.4 GHz */
4253                 band->vht_cap = vht_cap;
4254         }
4255         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4256                 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
4257                 band->ht_cap = ht_cap;
4258                 band->vht_cap = vht_cap;
4259         }
4260 }
4261
4262 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
4263 {
4264         int ret;
4265
4266         lockdep_assert_held(&ar->conf_mutex);
4267
4268         ath10k_check_chain_mask(ar, tx_ant, "tx");
4269         ath10k_check_chain_mask(ar, rx_ant, "rx");
4270
4271         ar->cfg_tx_chainmask = tx_ant;
4272         ar->cfg_rx_chainmask = rx_ant;
4273
4274         if ((ar->state != ATH10K_STATE_ON) &&
4275             (ar->state != ATH10K_STATE_RESTARTED))
4276                 return 0;
4277
4278         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
4279                                         tx_ant);
4280         if (ret) {
4281                 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
4282                             ret, tx_ant);
4283                 return ret;
4284         }
4285
4286         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
4287                                         rx_ant);
4288         if (ret) {
4289                 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
4290                             ret, rx_ant);
4291                 return ret;
4292         }
4293
4294         /* Reload HT/VHT capability */
4295         ath10k_mac_setup_ht_vht_cap(ar);
4296
4297         return 0;
4298 }
4299
4300 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
4301 {
4302         struct ath10k *ar = hw->priv;
4303         int ret;
4304
4305         mutex_lock(&ar->conf_mutex);
4306         ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
4307         mutex_unlock(&ar->conf_mutex);
4308         return ret;
4309 }
4310
4311 static int ath10k_start(struct ieee80211_hw *hw)
4312 {
4313         struct ath10k *ar = hw->priv;
4314         u32 param;
4315         int ret = 0;
4316
4317         /*
4318          * This makes sense only when restarting hw. It is harmless to call
4319          * uncoditionally. This is necessary to make sure no HTT/WMI tx
4320          * commands will be submitted while restarting.
4321          */
4322         ath10k_drain_tx(ar);
4323
4324         mutex_lock(&ar->conf_mutex);
4325
4326         switch (ar->state) {
4327         case ATH10K_STATE_OFF:
4328                 ar->state = ATH10K_STATE_ON;
4329                 break;
4330         case ATH10K_STATE_RESTARTING:
4331                 ath10k_halt(ar);
4332                 ar->state = ATH10K_STATE_RESTARTED;
4333                 break;
4334         case ATH10K_STATE_ON:
4335         case ATH10K_STATE_RESTARTED:
4336         case ATH10K_STATE_WEDGED:
4337                 WARN_ON(1);
4338                 ret = -EINVAL;
4339                 goto err;
4340         case ATH10K_STATE_UTF:
4341                 ret = -EBUSY;
4342                 goto err;
4343         }
4344
4345         ret = ath10k_hif_power_up(ar);
4346         if (ret) {
4347                 ath10k_err(ar, "Could not init hif: %d\n", ret);
4348                 goto err_off;
4349         }
4350
4351         ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
4352         if (ret) {
4353                 ath10k_err(ar, "Could not init core: %d\n", ret);
4354                 goto err_power_down;
4355         }
4356
4357         param = ar->wmi.pdev_param->pmf_qos;
4358         ret = ath10k_wmi_pdev_set_param(ar, param, 1);
4359         if (ret) {
4360                 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
4361                 goto err_core_stop;
4362         }
4363
4364         param = ar->wmi.pdev_param->dynamic_bw;
4365         ret = ath10k_wmi_pdev_set_param(ar, param, 1);
4366         if (ret) {
4367                 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
4368                 goto err_core_stop;
4369         }
4370
4371         if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
4372                 ret = ath10k_wmi_adaptive_qcs(ar, true);
4373                 if (ret) {
4374                         ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
4375                                     ret);
4376                         goto err_core_stop;
4377                 }
4378         }
4379
4380         if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
4381                 param = ar->wmi.pdev_param->burst_enable;
4382                 ret = ath10k_wmi_pdev_set_param(ar, param, 0);
4383                 if (ret) {
4384                         ath10k_warn(ar, "failed to disable burst: %d\n", ret);
4385                         goto err_core_stop;
4386                 }
4387         }
4388
4389         __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
4390
4391         /*
4392          * By default FW set ARP frames ac to voice (6). In that case ARP
4393          * exchange is not working properly for UAPSD enabled AP. ARP requests
4394          * which arrives with access category 0 are processed by network stack
4395          * and send back with access category 0, but FW changes access category
4396          * to 6. Set ARP frames access category to best effort (0) solves
4397          * this problem.
4398          */
4399
4400         param = ar->wmi.pdev_param->arp_ac_override;
4401         ret = ath10k_wmi_pdev_set_param(ar, param, 0);
4402         if (ret) {
4403                 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
4404                             ret);
4405                 goto err_core_stop;
4406         }
4407
4408         if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA,
4409                      ar->fw_features)) {
4410                 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1,
4411                                                           WMI_CCA_DETECT_LEVEL_AUTO,
4412                                                           WMI_CCA_DETECT_MARGIN_AUTO);
4413                 if (ret) {
4414                         ath10k_warn(ar, "failed to enable adaptive cca: %d\n",
4415                                     ret);
4416                         goto err_core_stop;
4417                 }
4418         }
4419
4420         param = ar->wmi.pdev_param->ani_enable;
4421         ret = ath10k_wmi_pdev_set_param(ar, param, 1);
4422         if (ret) {
4423                 ath10k_warn(ar, "failed to enable ani by default: %d\n",
4424                             ret);
4425                 goto err_core_stop;
4426         }
4427
4428         ar->ani_enabled = true;
4429
4430         if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map)) {
4431                 param = ar->wmi.pdev_param->peer_stats_update_period;
4432                 ret = ath10k_wmi_pdev_set_param(ar, param,
4433                                                 PEER_DEFAULT_STATS_UPDATE_PERIOD);
4434                 if (ret) {
4435                         ath10k_warn(ar,
4436                                     "failed to set peer stats period : %d\n",
4437                                     ret);
4438                         goto err_core_stop;
4439                 }
4440         }
4441
4442         ar->num_started_vdevs = 0;
4443         ath10k_regd_update(ar);
4444
4445         ath10k_spectral_start(ar);
4446         ath10k_thermal_set_throttling(ar);
4447
4448         mutex_unlock(&ar->conf_mutex);
4449         return 0;
4450
4451 err_core_stop:
4452         ath10k_core_stop(ar);
4453
4454 err_power_down:
4455         ath10k_hif_power_down(ar);
4456
4457 err_off:
4458         ar->state = ATH10K_STATE_OFF;
4459
4460 err:
4461         mutex_unlock(&ar->conf_mutex);
4462         return ret;
4463 }
4464
4465 static void ath10k_stop(struct ieee80211_hw *hw)
4466 {
4467         struct ath10k *ar = hw->priv;
4468
4469         ath10k_drain_tx(ar);
4470
4471         mutex_lock(&ar->conf_mutex);
4472         if (ar->state != ATH10K_STATE_OFF) {
4473                 ath10k_halt(ar);
4474                 ar->state = ATH10K_STATE_OFF;
4475         }
4476         mutex_unlock(&ar->conf_mutex);
4477
4478         cancel_delayed_work_sync(&ar->scan.timeout);
4479         cancel_work_sync(&ar->restart_work);
4480 }
4481
4482 static int ath10k_config_ps(struct ath10k *ar)
4483 {
4484         struct ath10k_vif *arvif;
4485         int ret = 0;
4486
4487         lockdep_assert_held(&ar->conf_mutex);
4488
4489         list_for_each_entry(arvif, &ar->arvifs, list) {
4490                 ret = ath10k_mac_vif_setup_ps(arvif);
4491                 if (ret) {
4492                         ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
4493                         break;
4494                 }
4495         }
4496
4497         return ret;
4498 }
4499
4500 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
4501 {
4502         int ret;
4503         u32 param;
4504
4505         lockdep_assert_held(&ar->conf_mutex);
4506
4507         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
4508
4509         param = ar->wmi.pdev_param->txpower_limit2g;
4510         ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4511         if (ret) {
4512                 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
4513                             txpower, ret);
4514                 return ret;
4515         }
4516
4517         param = ar->wmi.pdev_param->txpower_limit5g;
4518         ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4519         if (ret) {
4520                 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
4521                             txpower, ret);
4522                 return ret;
4523         }
4524
4525         return 0;
4526 }
4527
4528 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
4529 {
4530         struct ath10k_vif *arvif;
4531         int ret, txpower = -1;
4532
4533         lockdep_assert_held(&ar->conf_mutex);
4534
4535         list_for_each_entry(arvif, &ar->arvifs, list) {
4536                 WARN_ON(arvif->txpower < 0);
4537
4538                 if (txpower == -1)
4539                         txpower = arvif->txpower;
4540                 else
4541                         txpower = min(txpower, arvif->txpower);
4542         }
4543
4544         if (WARN_ON(txpower == -1))
4545                 return -EINVAL;
4546
4547         ret = ath10k_mac_txpower_setup(ar, txpower);
4548         if (ret) {
4549                 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
4550                             txpower, ret);
4551                 return ret;
4552         }
4553
4554         return 0;
4555 }
4556
4557 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
4558 {
4559         struct ath10k *ar = hw->priv;
4560         struct ieee80211_conf *conf = &hw->conf;
4561         int ret = 0;
4562
4563         mutex_lock(&ar->conf_mutex);
4564
4565         if (changed & IEEE80211_CONF_CHANGE_PS)
4566                 ath10k_config_ps(ar);
4567
4568         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
4569                 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
4570                 ret = ath10k_monitor_recalc(ar);
4571                 if (ret)
4572                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4573         }
4574
4575         mutex_unlock(&ar->conf_mutex);
4576         return ret;
4577 }
4578
4579 static u32 get_nss_from_chainmask(u16 chain_mask)
4580 {
4581         if ((chain_mask & 0xf) == 0xf)
4582                 return 4;
4583         else if ((chain_mask & 0x7) == 0x7)
4584                 return 3;
4585         else if ((chain_mask & 0x3) == 0x3)
4586                 return 2;
4587         return 1;
4588 }
4589
4590 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)
4591 {
4592         u32 value = 0;
4593         struct ath10k *ar = arvif->ar;
4594         int nsts;
4595         int sound_dim;
4596
4597         if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)
4598                 return 0;
4599
4600         nsts = ath10k_mac_get_vht_cap_bf_sts(ar);
4601         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4602                                 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))
4603                 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4604
4605         sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
4606         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4607                                 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))
4608                 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4609
4610         if (!value)
4611                 return 0;
4612
4613         if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
4614                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4615
4616         if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
4617                 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |
4618                           WMI_VDEV_PARAM_TXBF_SU_TX_BFER);
4619
4620         if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
4621                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4622
4623         if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
4624                 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |
4625                           WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);
4626
4627         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4628                                          ar->wmi.vdev_param->txbf, value);
4629 }
4630
4631 /*
4632  * TODO:
4633  * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
4634  * because we will send mgmt frames without CCK. This requirement
4635  * for P2P_FIND/GO_NEG should be handled by checking CCK flag
4636  * in the TX packet.
4637  */
4638 static int ath10k_add_interface(struct ieee80211_hw *hw,
4639                                 struct ieee80211_vif *vif)
4640 {
4641         struct ath10k *ar = hw->priv;
4642         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4643         struct ath10k_peer *peer;
4644         enum wmi_sta_powersave_param param;
4645         int ret = 0;
4646         u32 value;
4647         int bit;
4648         int i;
4649         u32 vdev_param;
4650
4651         vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
4652
4653         mutex_lock(&ar->conf_mutex);
4654
4655         memset(arvif, 0, sizeof(*arvif));
4656         ath10k_mac_txq_init(vif->txq);
4657
4658         arvif->ar = ar;
4659         arvif->vif = vif;
4660
4661         INIT_LIST_HEAD(&arvif->list);
4662         INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
4663         INIT_DELAYED_WORK(&arvif->connection_loss_work,
4664                           ath10k_mac_vif_sta_connection_loss_work);
4665
4666         for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
4667                 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
4668                 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
4669                        sizeof(arvif->bitrate_mask.control[i].ht_mcs));
4670                 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
4671                        sizeof(arvif->bitrate_mask.control[i].vht_mcs));
4672         }
4673
4674         if (ar->num_peers >= ar->max_num_peers) {
4675                 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
4676                 ret = -ENOBUFS;
4677                 goto err;
4678         }
4679
4680         if (ar->free_vdev_map == 0) {
4681                 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
4682                 ret = -EBUSY;
4683                 goto err;
4684         }
4685         bit = __ffs64(ar->free_vdev_map);
4686
4687         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
4688                    bit, ar->free_vdev_map);
4689
4690         arvif->vdev_id = bit;
4691         arvif->vdev_subtype =
4692                 ath10k_wmi_get_vdev_subtype(ar, WMI_VDEV_SUBTYPE_NONE);
4693
4694         switch (vif->type) {
4695         case NL80211_IFTYPE_P2P_DEVICE:
4696                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4697                 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
4698                                         (ar, WMI_VDEV_SUBTYPE_P2P_DEVICE);
4699                 break;
4700         case NL80211_IFTYPE_UNSPECIFIED:
4701         case NL80211_IFTYPE_STATION:
4702                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4703                 if (vif->p2p)
4704                         arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
4705                                         (ar, WMI_VDEV_SUBTYPE_P2P_CLIENT);
4706                 break;
4707         case NL80211_IFTYPE_ADHOC:
4708                 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
4709                 break;
4710         case NL80211_IFTYPE_MESH_POINT:
4711                 if (test_bit(WMI_SERVICE_MESH_11S, ar->wmi.svc_map)) {
4712                         arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
4713                                                 (ar, WMI_VDEV_SUBTYPE_MESH_11S);
4714                 } else if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4715                         ret = -EINVAL;
4716                         ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n");
4717                         goto err;
4718                 }
4719                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4720                 break;
4721         case NL80211_IFTYPE_AP:
4722                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4723
4724                 if (vif->p2p)
4725                         arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
4726                                                 (ar, WMI_VDEV_SUBTYPE_P2P_GO);
4727                 break;
4728         case NL80211_IFTYPE_MONITOR:
4729                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
4730                 break;
4731         default:
4732                 WARN_ON(1);
4733                 break;
4734         }
4735
4736         /* Using vdev_id as queue number will make it very easy to do per-vif
4737          * tx queue locking. This shouldn't wrap due to interface combinations
4738          * but do a modulo for correctness sake and prevent using offchannel tx
4739          * queues for regular vif tx.
4740          */
4741         vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4742         for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
4743                 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4744
4745         /* Some firmware revisions don't wait for beacon tx completion before
4746          * sending another SWBA event. This could lead to hardware using old
4747          * (freed) beacon data in some cases, e.g. tx credit starvation
4748          * combined with missed TBTT. This is very very rare.
4749          *
4750          * On non-IOMMU-enabled hosts this could be a possible security issue
4751          * because hw could beacon some random data on the air.  On
4752          * IOMMU-enabled hosts DMAR faults would occur in most cases and target
4753          * device would crash.
4754          *
4755          * Since there are no beacon tx completions (implicit nor explicit)
4756          * propagated to host the only workaround for this is to allocate a
4757          * DMA-coherent buffer for a lifetime of a vif and use it for all
4758          * beacon tx commands. Worst case for this approach is some beacons may
4759          * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
4760          */
4761         if (vif->type == NL80211_IFTYPE_ADHOC ||
4762             vif->type == NL80211_IFTYPE_MESH_POINT ||
4763             vif->type == NL80211_IFTYPE_AP) {
4764                 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
4765                                                         IEEE80211_MAX_FRAME_LEN,
4766                                                         &arvif->beacon_paddr,
4767                                                         GFP_ATOMIC);
4768                 if (!arvif->beacon_buf) {
4769                         ret = -ENOMEM;
4770                         ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
4771                                     ret);
4772                         goto err;
4773                 }
4774         }
4775         if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))
4776                 arvif->nohwcrypt = true;
4777
4778         if (arvif->nohwcrypt &&
4779             !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4780                 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");
4781                 goto err;
4782         }
4783
4784         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
4785                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
4786                    arvif->beacon_buf ? "single-buf" : "per-skb");
4787
4788         ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
4789                                      arvif->vdev_subtype, vif->addr);
4790         if (ret) {
4791                 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
4792                             arvif->vdev_id, ret);
4793                 goto err;
4794         }
4795
4796         ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
4797         list_add(&arvif->list, &ar->arvifs);
4798
4799         /* It makes no sense to have firmware do keepalives. mac80211 already
4800          * takes care of this with idle connection polling.
4801          */
4802         ret = ath10k_mac_vif_disable_keepalive(arvif);
4803         if (ret) {
4804                 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
4805                             arvif->vdev_id, ret);
4806                 goto err_vdev_delete;
4807         }
4808
4809         arvif->def_wep_key_idx = -1;
4810
4811         vdev_param = ar->wmi.vdev_param->tx_encap_type;
4812         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4813                                         ATH10K_HW_TXRX_NATIVE_WIFI);
4814         /* 10.X firmware does not support this VDEV parameter. Do not warn */
4815         if (ret && ret != -EOPNOTSUPP) {
4816                 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
4817                             arvif->vdev_id, ret);
4818                 goto err_vdev_delete;
4819         }
4820
4821         if (ar->cfg_tx_chainmask) {
4822                 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4823
4824                 vdev_param = ar->wmi.vdev_param->nss;
4825                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4826                                                 nss);
4827                 if (ret) {
4828                         ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4829                                     arvif->vdev_id, ar->cfg_tx_chainmask, nss,
4830                                     ret);
4831                         goto err_vdev_delete;
4832                 }
4833         }
4834
4835         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4836             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4837                 ret = ath10k_peer_create(ar, vif, NULL, arvif->vdev_id,
4838                                          vif->addr, WMI_PEER_TYPE_DEFAULT);
4839                 if (ret) {
4840                         ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
4841                                     arvif->vdev_id, ret);
4842                         goto err_vdev_delete;
4843                 }
4844
4845                 spin_lock_bh(&ar->data_lock);
4846
4847                 peer = ath10k_peer_find(ar, arvif->vdev_id, vif->addr);
4848                 if (!peer) {
4849                         ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",
4850                                     vif->addr, arvif->vdev_id);
4851                         spin_unlock_bh(&ar->data_lock);
4852                         ret = -ENOENT;
4853                         goto err_peer_delete;
4854                 }
4855
4856                 arvif->peer_id = find_first_bit(peer->peer_ids,
4857                                                 ATH10K_MAX_NUM_PEER_IDS);
4858
4859                 spin_unlock_bh(&ar->data_lock);
4860         } else {
4861                 arvif->peer_id = HTT_INVALID_PEERID;
4862         }
4863
4864         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
4865                 ret = ath10k_mac_set_kickout(arvif);
4866                 if (ret) {
4867                         ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
4868                                     arvif->vdev_id, ret);
4869                         goto err_peer_delete;
4870                 }
4871         }
4872
4873         if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
4874                 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
4875                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4876                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4877                                                   param, value);
4878                 if (ret) {
4879                         ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
4880                                     arvif->vdev_id, ret);
4881                         goto err_peer_delete;
4882                 }
4883
4884                 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4885                 if (ret) {
4886                         ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4887                                     arvif->vdev_id, ret);
4888                         goto err_peer_delete;
4889                 }
4890
4891                 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4892                 if (ret) {
4893                         ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4894                                     arvif->vdev_id, ret);
4895                         goto err_peer_delete;
4896                 }
4897         }
4898
4899         ret = ath10k_mac_set_txbf_conf(arvif);
4900         if (ret) {
4901                 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
4902                             arvif->vdev_id, ret);
4903                 goto err_peer_delete;
4904         }
4905
4906         ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
4907         if (ret) {
4908                 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4909                             arvif->vdev_id, ret);
4910                 goto err_peer_delete;
4911         }
4912
4913         arvif->txpower = vif->bss_conf.txpower;
4914         ret = ath10k_mac_txpower_recalc(ar);
4915         if (ret) {
4916                 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4917                 goto err_peer_delete;
4918         }
4919
4920         if (vif->type == NL80211_IFTYPE_MONITOR) {
4921                 ar->monitor_arvif = arvif;
4922                 ret = ath10k_monitor_recalc(ar);
4923                 if (ret) {
4924                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4925                         goto err_peer_delete;
4926                 }
4927         }
4928
4929         spin_lock_bh(&ar->htt.tx_lock);
4930         if (!ar->tx_paused)
4931                 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
4932         spin_unlock_bh(&ar->htt.tx_lock);
4933
4934         mutex_unlock(&ar->conf_mutex);
4935         return 0;
4936
4937 err_peer_delete:
4938         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4939             arvif->vdev_type == WMI_VDEV_TYPE_IBSS)
4940                 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
4941
4942 err_vdev_delete:
4943         ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4944         ar->free_vdev_map |= 1LL << arvif->vdev_id;
4945         list_del(&arvif->list);
4946
4947 err:
4948         if (arvif->beacon_buf) {
4949                 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
4950                                   arvif->beacon_buf, arvif->beacon_paddr);
4951                 arvif->beacon_buf = NULL;
4952         }
4953
4954         mutex_unlock(&ar->conf_mutex);
4955
4956         return ret;
4957 }
4958
4959 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
4960 {
4961         int i;
4962
4963         for (i = 0; i < BITS_PER_LONG; i++)
4964                 ath10k_mac_vif_tx_unlock(arvif, i);
4965 }
4966
4967 static void ath10k_remove_interface(struct ieee80211_hw *hw,
4968                                     struct ieee80211_vif *vif)
4969 {
4970         struct ath10k *ar = hw->priv;
4971         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4972         struct ath10k_peer *peer;
4973         int ret;
4974         int i;
4975
4976         cancel_work_sync(&arvif->ap_csa_work);
4977         cancel_delayed_work_sync(&arvif->connection_loss_work);
4978
4979         mutex_lock(&ar->conf_mutex);
4980
4981         spin_lock_bh(&ar->data_lock);
4982         ath10k_mac_vif_beacon_cleanup(arvif);
4983         spin_unlock_bh(&ar->data_lock);
4984
4985         ret = ath10k_spectral_vif_stop(arvif);
4986         if (ret)
4987                 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
4988                             arvif->vdev_id, ret);
4989
4990         ar->free_vdev_map |= 1LL << arvif->vdev_id;
4991         list_del(&arvif->list);
4992
4993         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4994             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4995                 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
4996                                              vif->addr);
4997                 if (ret)
4998                         ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4999                                     arvif->vdev_id, ret);
5000
5001                 kfree(arvif->u.ap.noa_data);
5002         }
5003
5004         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
5005                    arvif->vdev_id);
5006
5007         ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
5008         if (ret)
5009                 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
5010                             arvif->vdev_id, ret);
5011
5012         /* Some firmware revisions don't notify host about self-peer removal
5013          * until after associated vdev is deleted.
5014          */
5015         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
5016             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
5017                 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
5018                                                    vif->addr);
5019                 if (ret)
5020                         ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
5021                                     arvif->vdev_id, ret);
5022
5023                 spin_lock_bh(&ar->data_lock);
5024                 ar->num_peers--;
5025                 spin_unlock_bh(&ar->data_lock);
5026         }
5027
5028         spin_lock_bh(&ar->data_lock);
5029         for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
5030                 peer = ar->peer_map[i];
5031                 if (!peer)
5032                         continue;
5033
5034                 if (peer->vif == vif) {
5035                         ath10k_warn(ar, "found vif peer %pM entry on vdev %i after it was supposedly removed\n",
5036                                     vif->addr, arvif->vdev_id);
5037                         peer->vif = NULL;
5038                 }
5039         }
5040         spin_unlock_bh(&ar->data_lock);
5041
5042         ath10k_peer_cleanup(ar, arvif->vdev_id);
5043         ath10k_mac_txq_unref(ar, vif->txq);
5044
5045         if (vif->type == NL80211_IFTYPE_MONITOR) {
5046                 ar->monitor_arvif = NULL;
5047                 ret = ath10k_monitor_recalc(ar);
5048                 if (ret)
5049                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
5050         }
5051
5052         spin_lock_bh(&ar->htt.tx_lock);
5053         ath10k_mac_vif_tx_unlock_all(arvif);
5054         spin_unlock_bh(&ar->htt.tx_lock);
5055
5056         ath10k_mac_txq_unref(ar, vif->txq);
5057
5058         mutex_unlock(&ar->conf_mutex);
5059 }
5060
5061 /*
5062  * FIXME: Has to be verified.
5063  */
5064 #define SUPPORTED_FILTERS                       \
5065         (FIF_ALLMULTI |                         \
5066         FIF_CONTROL |                           \
5067         FIF_PSPOLL |                            \
5068         FIF_OTHER_BSS |                         \
5069         FIF_BCN_PRBRESP_PROMISC |               \
5070         FIF_PROBE_REQ |                         \
5071         FIF_FCSFAIL)
5072
5073 static void ath10k_configure_filter(struct ieee80211_hw *hw,
5074                                     unsigned int changed_flags,
5075                                     unsigned int *total_flags,
5076                                     u64 multicast)
5077 {
5078         struct ath10k *ar = hw->priv;
5079         int ret;
5080
5081         mutex_lock(&ar->conf_mutex);
5082
5083         changed_flags &= SUPPORTED_FILTERS;
5084         *total_flags &= SUPPORTED_FILTERS;
5085         ar->filter_flags = *total_flags;
5086
5087         ret = ath10k_monitor_recalc(ar);
5088         if (ret)
5089                 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
5090
5091         mutex_unlock(&ar->conf_mutex);
5092 }
5093
5094 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
5095                                     struct ieee80211_vif *vif,
5096                                     struct ieee80211_bss_conf *info,
5097                                     u32 changed)
5098 {
5099         struct ath10k *ar = hw->priv;
5100         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5101         int ret = 0;
5102         u32 vdev_param, pdev_param, slottime, preamble;
5103
5104         mutex_lock(&ar->conf_mutex);
5105
5106         if (changed & BSS_CHANGED_IBSS)
5107                 ath10k_control_ibss(arvif, info, vif->addr);
5108
5109         if (changed & BSS_CHANGED_BEACON_INT) {
5110                 arvif->beacon_interval = info->beacon_int;
5111                 vdev_param = ar->wmi.vdev_param->beacon_interval;
5112                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5113                                                 arvif->beacon_interval);
5114                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5115                            "mac vdev %d beacon_interval %d\n",
5116                            arvif->vdev_id, arvif->beacon_interval);
5117
5118                 if (ret)
5119                         ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
5120                                     arvif->vdev_id, ret);
5121         }
5122
5123         if (changed & BSS_CHANGED_BEACON) {
5124                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5125                            "vdev %d set beacon tx mode to staggered\n",
5126                            arvif->vdev_id);
5127
5128                 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
5129                 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
5130                                                 WMI_BEACON_STAGGERED_MODE);
5131                 if (ret)
5132                         ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
5133                                     arvif->vdev_id, ret);
5134
5135                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
5136                 if (ret)
5137                         ath10k_warn(ar, "failed to update beacon template: %d\n",
5138                                     ret);
5139
5140                 if (ieee80211_vif_is_mesh(vif)) {
5141                         /* mesh doesn't use SSID but firmware needs it */
5142                         strncpy(arvif->u.ap.ssid, "mesh",
5143                                 sizeof(arvif->u.ap.ssid));
5144                         arvif->u.ap.ssid_len = 4;
5145                 }
5146         }
5147
5148         if (changed & BSS_CHANGED_AP_PROBE_RESP) {
5149                 ret = ath10k_mac_setup_prb_tmpl(arvif);
5150                 if (ret)
5151                         ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
5152                                     arvif->vdev_id, ret);
5153         }
5154
5155         if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
5156                 arvif->dtim_period = info->dtim_period;
5157
5158                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5159                            "mac vdev %d dtim_period %d\n",
5160                            arvif->vdev_id, arvif->dtim_period);
5161
5162                 vdev_param = ar->wmi.vdev_param->dtim_period;
5163                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5164                                                 arvif->dtim_period);
5165                 if (ret)
5166                         ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
5167                                     arvif->vdev_id, ret);
5168         }
5169
5170         if (changed & BSS_CHANGED_SSID &&
5171             vif->type == NL80211_IFTYPE_AP) {
5172                 arvif->u.ap.ssid_len = info->ssid_len;
5173                 if (info->ssid_len)
5174                         memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
5175                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
5176         }
5177
5178         if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
5179                 ether_addr_copy(arvif->bssid, info->bssid);
5180
5181         if (changed & BSS_CHANGED_BEACON_ENABLED)
5182                 ath10k_control_beaconing(arvif, info);
5183
5184         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
5185                 arvif->use_cts_prot = info->use_cts_prot;
5186                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
5187                            arvif->vdev_id, info->use_cts_prot);
5188
5189                 ret = ath10k_recalc_rtscts_prot(arvif);
5190                 if (ret)
5191                         ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
5192                                     arvif->vdev_id, ret);
5193
5194                 vdev_param = ar->wmi.vdev_param->protection_mode;
5195                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5196                                                 info->use_cts_prot ? 1 : 0);
5197                 if (ret)
5198                         ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n",
5199                                     info->use_cts_prot, arvif->vdev_id, ret);
5200         }
5201
5202         if (changed & BSS_CHANGED_ERP_SLOT) {
5203                 if (info->use_short_slot)
5204                         slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
5205
5206                 else
5207                         slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
5208
5209                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
5210                            arvif->vdev_id, slottime);
5211
5212                 vdev_param = ar->wmi.vdev_param->slot_time;
5213                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5214                                                 slottime);
5215                 if (ret)
5216                         ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
5217                                     arvif->vdev_id, ret);
5218         }
5219
5220         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
5221                 if (info->use_short_preamble)
5222                         preamble = WMI_VDEV_PREAMBLE_SHORT;
5223                 else
5224                         preamble = WMI_VDEV_PREAMBLE_LONG;
5225
5226                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5227                            "mac vdev %d preamble %dn",
5228                            arvif->vdev_id, preamble);
5229
5230                 vdev_param = ar->wmi.vdev_param->preamble;
5231                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5232                                                 preamble);
5233                 if (ret)
5234                         ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
5235                                     arvif->vdev_id, ret);
5236         }
5237
5238         if (changed & BSS_CHANGED_ASSOC) {
5239                 if (info->assoc) {
5240                         /* Workaround: Make sure monitor vdev is not running
5241                          * when associating to prevent some firmware revisions
5242                          * (e.g. 10.1 and 10.2) from crashing.
5243                          */
5244                         if (ar->monitor_started)
5245                                 ath10k_monitor_stop(ar);
5246                         ath10k_bss_assoc(hw, vif, info);
5247                         ath10k_monitor_recalc(ar);
5248                 } else {
5249                         ath10k_bss_disassoc(hw, vif);
5250                 }
5251         }
5252
5253         if (changed & BSS_CHANGED_TXPOWER) {
5254                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
5255                            arvif->vdev_id, info->txpower);
5256
5257                 arvif->txpower = info->txpower;
5258                 ret = ath10k_mac_txpower_recalc(ar);
5259                 if (ret)
5260                         ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
5261         }
5262
5263         if (changed & BSS_CHANGED_PS) {
5264                 arvif->ps = vif->bss_conf.ps;
5265
5266                 ret = ath10k_config_ps(ar);
5267                 if (ret)
5268                         ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
5269                                     arvif->vdev_id, ret);
5270         }
5271
5272         mutex_unlock(&ar->conf_mutex);
5273 }
5274
5275 static int ath10k_hw_scan(struct ieee80211_hw *hw,
5276                           struct ieee80211_vif *vif,
5277                           struct ieee80211_scan_request *hw_req)
5278 {
5279         struct ath10k *ar = hw->priv;
5280         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5281         struct cfg80211_scan_request *req = &hw_req->req;
5282         struct wmi_start_scan_arg arg;
5283         int ret = 0;
5284         int i;
5285
5286         mutex_lock(&ar->conf_mutex);
5287
5288         spin_lock_bh(&ar->data_lock);
5289         switch (ar->scan.state) {
5290         case ATH10K_SCAN_IDLE:
5291                 reinit_completion(&ar->scan.started);
5292                 reinit_completion(&ar->scan.completed);
5293                 ar->scan.state = ATH10K_SCAN_STARTING;
5294                 ar->scan.is_roc = false;
5295                 ar->scan.vdev_id = arvif->vdev_id;
5296                 ret = 0;
5297                 break;
5298         case ATH10K_SCAN_STARTING:
5299         case ATH10K_SCAN_RUNNING:
5300         case ATH10K_SCAN_ABORTING:
5301                 ret = -EBUSY;
5302                 break;
5303         }
5304         spin_unlock_bh(&ar->data_lock);
5305
5306         if (ret)
5307                 goto exit;
5308
5309         memset(&arg, 0, sizeof(arg));
5310         ath10k_wmi_start_scan_init(ar, &arg);
5311         arg.vdev_id = arvif->vdev_id;
5312         arg.scan_id = ATH10K_SCAN_ID;
5313
5314         if (req->ie_len) {
5315                 arg.ie_len = req->ie_len;
5316                 memcpy(arg.ie, req->ie, arg.ie_len);
5317         }
5318
5319         if (req->n_ssids) {
5320                 arg.n_ssids = req->n_ssids;
5321                 for (i = 0; i < arg.n_ssids; i++) {
5322                         arg.ssids[i].len  = req->ssids[i].ssid_len;
5323                         arg.ssids[i].ssid = req->ssids[i].ssid;
5324                 }
5325         } else {
5326                 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5327         }
5328
5329         if (req->n_channels) {
5330                 arg.n_channels = req->n_channels;
5331                 for (i = 0; i < arg.n_channels; i++)
5332                         arg.channels[i] = req->channels[i]->center_freq;
5333         }
5334
5335         ret = ath10k_start_scan(ar, &arg);
5336         if (ret) {
5337                 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
5338                 spin_lock_bh(&ar->data_lock);
5339                 ar->scan.state = ATH10K_SCAN_IDLE;
5340                 spin_unlock_bh(&ar->data_lock);
5341         }
5342
5343         /* Add a 200ms margin to account for event/command processing */
5344         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
5345                                      msecs_to_jiffies(arg.max_scan_time +
5346                                                       200));
5347
5348 exit:
5349         mutex_unlock(&ar->conf_mutex);
5350         return ret;
5351 }
5352
5353 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
5354                                   struct ieee80211_vif *vif)
5355 {
5356         struct ath10k *ar = hw->priv;
5357
5358         mutex_lock(&ar->conf_mutex);
5359         ath10k_scan_abort(ar);
5360         mutex_unlock(&ar->conf_mutex);
5361
5362         cancel_delayed_work_sync(&ar->scan.timeout);
5363 }
5364
5365 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
5366                                         struct ath10k_vif *arvif,
5367                                         enum set_key_cmd cmd,
5368                                         struct ieee80211_key_conf *key)
5369 {
5370         u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
5371         int ret;
5372
5373         /* 10.1 firmware branch requires default key index to be set to group
5374          * key index after installing it. Otherwise FW/HW Txes corrupted
5375          * frames with multi-vif APs. This is not required for main firmware
5376          * branch (e.g. 636).
5377          *
5378          * This is also needed for 636 fw for IBSS-RSN to work more reliably.
5379          *
5380          * FIXME: It remains unknown if this is required for multi-vif STA
5381          * interfaces on 10.1.
5382          */
5383
5384         if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
5385             arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
5386                 return;
5387
5388         if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
5389                 return;
5390
5391         if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
5392                 return;
5393
5394         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5395                 return;
5396
5397         if (cmd != SET_KEY)
5398                 return;
5399
5400         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5401                                         key->keyidx);
5402         if (ret)
5403                 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
5404                             arvif->vdev_id, ret);
5405 }
5406
5407 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
5408                           struct ieee80211_vif *vif, struct ieee80211_sta *sta,
5409                           struct ieee80211_key_conf *key)
5410 {
5411         struct ath10k *ar = hw->priv;
5412         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5413         struct ath10k_peer *peer;
5414         const u8 *peer_addr;
5415         bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
5416                       key->cipher == WLAN_CIPHER_SUITE_WEP104;
5417         int ret = 0;
5418         int ret2;
5419         u32 flags = 0;
5420         u32 flags2;
5421
5422         /* this one needs to be done in software */
5423         if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
5424                 return 1;
5425
5426         if (arvif->nohwcrypt)
5427                 return 1;
5428
5429         if (key->keyidx > WMI_MAX_KEY_INDEX)
5430                 return -ENOSPC;
5431
5432         mutex_lock(&ar->conf_mutex);
5433
5434         if (sta)
5435                 peer_addr = sta->addr;
5436         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
5437                 peer_addr = vif->bss_conf.bssid;
5438         else
5439                 peer_addr = vif->addr;
5440
5441         key->hw_key_idx = key->keyidx;
5442
5443         if (is_wep) {
5444                 if (cmd == SET_KEY)
5445                         arvif->wep_keys[key->keyidx] = key;
5446                 else
5447                         arvif->wep_keys[key->keyidx] = NULL;
5448         }
5449
5450         /* the peer should not disappear in mid-way (unless FW goes awry) since
5451          * we already hold conf_mutex. we just make sure its there now. */
5452         spin_lock_bh(&ar->data_lock);
5453         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5454         spin_unlock_bh(&ar->data_lock);
5455
5456         if (!peer) {
5457                 if (cmd == SET_KEY) {
5458                         ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
5459                                     peer_addr);
5460                         ret = -EOPNOTSUPP;
5461                         goto exit;
5462                 } else {
5463                         /* if the peer doesn't exist there is no key to disable
5464                          * anymore */
5465                         goto exit;
5466                 }
5467         }
5468
5469         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5470                 flags |= WMI_KEY_PAIRWISE;
5471         else
5472                 flags |= WMI_KEY_GROUP;
5473
5474         if (is_wep) {
5475                 if (cmd == DISABLE_KEY)
5476                         ath10k_clear_vdev_key(arvif, key);
5477
5478                 /* When WEP keys are uploaded it's possible that there are
5479                  * stations associated already (e.g. when merging) without any
5480                  * keys. Static WEP needs an explicit per-peer key upload.
5481                  */
5482                 if (vif->type == NL80211_IFTYPE_ADHOC &&
5483                     cmd == SET_KEY)
5484                         ath10k_mac_vif_update_wep_key(arvif, key);
5485
5486                 /* 802.1x never sets the def_wep_key_idx so each set_key()
5487                  * call changes default tx key.
5488                  *
5489                  * Static WEP sets def_wep_key_idx via .set_default_unicast_key
5490                  * after first set_key().
5491                  */
5492                 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
5493                         flags |= WMI_KEY_TX_USAGE;
5494         }
5495
5496         ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
5497         if (ret) {
5498                 WARN_ON(ret > 0);
5499                 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
5500                             arvif->vdev_id, peer_addr, ret);
5501                 goto exit;
5502         }
5503
5504         /* mac80211 sets static WEP keys as groupwise while firmware requires
5505          * them to be installed twice as both pairwise and groupwise.
5506          */
5507         if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
5508                 flags2 = flags;
5509                 flags2 &= ~WMI_KEY_GROUP;
5510                 flags2 |= WMI_KEY_PAIRWISE;
5511
5512                 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
5513                 if (ret) {
5514                         WARN_ON(ret > 0);
5515                         ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
5516                                     arvif->vdev_id, peer_addr, ret);
5517                         ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
5518                                                   peer_addr, flags);
5519                         if (ret2) {
5520                                 WARN_ON(ret2 > 0);
5521                                 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
5522                                             arvif->vdev_id, peer_addr, ret2);
5523                         }
5524                         goto exit;
5525                 }
5526         }
5527
5528         ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
5529
5530         spin_lock_bh(&ar->data_lock);
5531         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5532         if (peer && cmd == SET_KEY)
5533                 peer->keys[key->keyidx] = key;
5534         else if (peer && cmd == DISABLE_KEY)
5535                 peer->keys[key->keyidx] = NULL;
5536         else if (peer == NULL)
5537                 /* impossible unless FW goes crazy */
5538                 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
5539         spin_unlock_bh(&ar->data_lock);
5540
5541 exit:
5542         mutex_unlock(&ar->conf_mutex);
5543         return ret;
5544 }
5545
5546 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
5547                                            struct ieee80211_vif *vif,
5548                                            int keyidx)
5549 {
5550         struct ath10k *ar = hw->priv;
5551         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5552         int ret;
5553
5554         mutex_lock(&arvif->ar->conf_mutex);
5555
5556         if (arvif->ar->state != ATH10K_STATE_ON)
5557                 goto unlock;
5558
5559         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
5560                    arvif->vdev_id, keyidx);
5561
5562         ret = ath10k_wmi_vdev_set_param(arvif->ar,
5563                                         arvif->vdev_id,
5564                                         arvif->ar->wmi.vdev_param->def_keyid,
5565                                         keyidx);
5566
5567         if (ret) {
5568                 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
5569                             arvif->vdev_id,
5570                             ret);
5571                 goto unlock;
5572         }
5573
5574         arvif->def_wep_key_idx = keyidx;
5575
5576 unlock:
5577         mutex_unlock(&arvif->ar->conf_mutex);
5578 }
5579
5580 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
5581 {
5582         struct ath10k *ar;
5583         struct ath10k_vif *arvif;
5584         struct ath10k_sta *arsta;
5585         struct ieee80211_sta *sta;
5586         struct cfg80211_chan_def def;
5587         enum ieee80211_band band;
5588         const u8 *ht_mcs_mask;
5589         const u16 *vht_mcs_mask;
5590         u32 changed, bw, nss, smps;
5591         int err;
5592
5593         arsta = container_of(wk, struct ath10k_sta, update_wk);
5594         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
5595         arvif = arsta->arvif;
5596         ar = arvif->ar;
5597
5598         if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
5599                 return;
5600
5601         band = def.chan->band;
5602         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
5603         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
5604
5605         spin_lock_bh(&ar->data_lock);
5606
5607         changed = arsta->changed;
5608         arsta->changed = 0;
5609
5610         bw = arsta->bw;
5611         nss = arsta->nss;
5612         smps = arsta->smps;
5613
5614         spin_unlock_bh(&ar->data_lock);
5615
5616         mutex_lock(&ar->conf_mutex);
5617
5618         nss = max_t(u32, 1, nss);
5619         nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
5620                            ath10k_mac_max_vht_nss(vht_mcs_mask)));
5621
5622         if (changed & IEEE80211_RC_BW_CHANGED) {
5623                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
5624                            sta->addr, bw);
5625
5626                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5627                                                 WMI_PEER_CHAN_WIDTH, bw);
5628                 if (err)
5629                         ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
5630                                     sta->addr, bw, err);
5631         }
5632
5633         if (changed & IEEE80211_RC_NSS_CHANGED) {
5634                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
5635                            sta->addr, nss);
5636
5637                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5638                                                 WMI_PEER_NSS, nss);
5639                 if (err)
5640                         ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
5641                                     sta->addr, nss, err);
5642         }
5643
5644         if (changed & IEEE80211_RC_SMPS_CHANGED) {
5645                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
5646                            sta->addr, smps);
5647
5648                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5649                                                 WMI_PEER_SMPS_STATE, smps);
5650                 if (err)
5651                         ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
5652                                     sta->addr, smps, err);
5653         }
5654
5655         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
5656             changed & IEEE80211_RC_NSS_CHANGED) {
5657                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
5658                            sta->addr);
5659
5660                 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
5661                 if (err)
5662                         ath10k_warn(ar, "failed to reassociate station: %pM\n",
5663                                     sta->addr);
5664         }
5665
5666         mutex_unlock(&ar->conf_mutex);
5667 }
5668
5669 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
5670                                        struct ieee80211_sta *sta)
5671 {
5672         struct ath10k *ar = arvif->ar;
5673
5674         lockdep_assert_held(&ar->conf_mutex);
5675
5676         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5677                 return 0;
5678
5679         if (ar->num_stations >= ar->max_num_stations)
5680                 return -ENOBUFS;
5681
5682         ar->num_stations++;
5683
5684         return 0;
5685 }
5686
5687 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
5688                                         struct ieee80211_sta *sta)
5689 {
5690         struct ath10k *ar = arvif->ar;
5691
5692         lockdep_assert_held(&ar->conf_mutex);
5693
5694         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5695                 return;
5696
5697         ar->num_stations--;
5698 }
5699
5700 struct ath10k_mac_tdls_iter_data {
5701         u32 num_tdls_stations;
5702         struct ieee80211_vif *curr_vif;
5703 };
5704
5705 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
5706                                                     struct ieee80211_sta *sta)
5707 {
5708         struct ath10k_mac_tdls_iter_data *iter_data = data;
5709         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5710         struct ieee80211_vif *sta_vif = arsta->arvif->vif;
5711
5712         if (sta->tdls && sta_vif == iter_data->curr_vif)
5713                 iter_data->num_tdls_stations++;
5714 }
5715
5716 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
5717                                               struct ieee80211_vif *vif)
5718 {
5719         struct ath10k_mac_tdls_iter_data data = {};
5720
5721         data.curr_vif = vif;
5722
5723         ieee80211_iterate_stations_atomic(hw,
5724                                           ath10k_mac_tdls_vif_stations_count_iter,
5725                                           &data);
5726         return data.num_tdls_stations;
5727 }
5728
5729 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac,
5730                                             struct ieee80211_vif *vif)
5731 {
5732         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5733         int *num_tdls_vifs = data;
5734
5735         if (vif->type != NL80211_IFTYPE_STATION)
5736                 return;
5737
5738         if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0)
5739                 (*num_tdls_vifs)++;
5740 }
5741
5742 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw)
5743 {
5744         int num_tdls_vifs = 0;
5745
5746         ieee80211_iterate_active_interfaces_atomic(hw,
5747                                                    IEEE80211_IFACE_ITER_NORMAL,
5748                                                    ath10k_mac_tdls_vifs_count_iter,
5749                                                    &num_tdls_vifs);
5750         return num_tdls_vifs;
5751 }
5752
5753 static int ath10k_sta_state(struct ieee80211_hw *hw,
5754                             struct ieee80211_vif *vif,
5755                             struct ieee80211_sta *sta,
5756                             enum ieee80211_sta_state old_state,
5757                             enum ieee80211_sta_state new_state)
5758 {
5759         struct ath10k *ar = hw->priv;
5760         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5761         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5762         struct ath10k_peer *peer;
5763         int ret = 0;
5764         int i;
5765
5766         if (old_state == IEEE80211_STA_NOTEXIST &&
5767             new_state == IEEE80211_STA_NONE) {
5768                 memset(arsta, 0, sizeof(*arsta));
5769                 arsta->arvif = arvif;
5770                 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
5771
5772                 for (i = 0; i < ARRAY_SIZE(sta->txq); i++)
5773                         ath10k_mac_txq_init(sta->txq[i]);
5774         }
5775
5776         /* cancel must be done outside the mutex to avoid deadlock */
5777         if ((old_state == IEEE80211_STA_NONE &&
5778              new_state == IEEE80211_STA_NOTEXIST))
5779                 cancel_work_sync(&arsta->update_wk);
5780
5781         mutex_lock(&ar->conf_mutex);
5782
5783         if (old_state == IEEE80211_STA_NOTEXIST &&
5784             new_state == IEEE80211_STA_NONE) {
5785                 /*
5786                  * New station addition.
5787                  */
5788                 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
5789                 u32 num_tdls_stations;
5790                 u32 num_tdls_vifs;
5791
5792                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5793                            "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5794                            arvif->vdev_id, sta->addr,
5795                            ar->num_stations + 1, ar->max_num_stations,
5796                            ar->num_peers + 1, ar->max_num_peers);
5797
5798                 ret = ath10k_mac_inc_num_stations(arvif, sta);
5799                 if (ret) {
5800                         ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
5801                                     ar->max_num_stations);
5802                         goto exit;
5803                 }
5804
5805                 if (sta->tdls)
5806                         peer_type = WMI_PEER_TYPE_TDLS;
5807
5808                 ret = ath10k_peer_create(ar, vif, sta, arvif->vdev_id,
5809                                          sta->addr, peer_type);
5810                 if (ret) {
5811                         ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5812                                     sta->addr, arvif->vdev_id, ret);
5813                         ath10k_mac_dec_num_stations(arvif, sta);
5814                         goto exit;
5815                 }
5816
5817                 spin_lock_bh(&ar->data_lock);
5818
5819                 peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr);
5820                 if (!peer) {
5821                         ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",
5822                                     vif->addr, arvif->vdev_id);
5823                         spin_unlock_bh(&ar->data_lock);
5824                         ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5825                         ath10k_mac_dec_num_stations(arvif, sta);
5826                         ret = -ENOENT;
5827                         goto exit;
5828                 }
5829
5830                 arsta->peer_id = find_first_bit(peer->peer_ids,
5831                                                 ATH10K_MAX_NUM_PEER_IDS);
5832
5833                 spin_unlock_bh(&ar->data_lock);
5834
5835                 if (!sta->tdls)
5836                         goto exit;
5837
5838                 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
5839                 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw);
5840
5841                 if (num_tdls_vifs >= ar->max_num_tdls_vdevs &&
5842                     num_tdls_stations == 0) {
5843                         ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5844                                     arvif->vdev_id, ar->max_num_tdls_vdevs);
5845                         ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5846                         ath10k_mac_dec_num_stations(arvif, sta);
5847                         ret = -ENOBUFS;
5848                         goto exit;
5849                 }
5850
5851                 if (num_tdls_stations == 0) {
5852                         /* This is the first tdls peer in current vif */
5853                         enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE;
5854
5855                         ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5856                                                               state);
5857                         if (ret) {
5858                                 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5859                                             arvif->vdev_id, ret);
5860                                 ath10k_peer_delete(ar, arvif->vdev_id,
5861                                                    sta->addr);
5862                                 ath10k_mac_dec_num_stations(arvif, sta);
5863                                 goto exit;
5864                         }
5865                 }
5866
5867                 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5868                                                   WMI_TDLS_PEER_STATE_PEERING);
5869                 if (ret) {
5870                         ath10k_warn(ar,
5871                                     "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5872                                     sta->addr, arvif->vdev_id, ret);
5873                         ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5874                         ath10k_mac_dec_num_stations(arvif, sta);
5875
5876                         if (num_tdls_stations != 0)
5877                                 goto exit;
5878                         ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5879                                                         WMI_TDLS_DISABLE);
5880                 }
5881         } else if ((old_state == IEEE80211_STA_NONE &&
5882                     new_state == IEEE80211_STA_NOTEXIST)) {
5883                 /*
5884                  * Existing station deletion.
5885                  */
5886                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5887                            "mac vdev %d peer delete %pM (sta gone)\n",
5888                            arvif->vdev_id, sta->addr);
5889
5890                 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5891                 if (ret)
5892                         ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
5893                                     sta->addr, arvif->vdev_id, ret);
5894
5895                 ath10k_mac_dec_num_stations(arvif, sta);
5896
5897                 spin_lock_bh(&ar->data_lock);
5898                 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
5899                         peer = ar->peer_map[i];
5900                         if (!peer)
5901                                 continue;
5902
5903                         if (peer->sta == sta) {
5904                                 ath10k_warn(ar, "found sta peer %pM entry on vdev %i after it was supposedly removed\n",
5905                                             sta->addr, arvif->vdev_id);
5906                                 peer->sta = NULL;
5907                         }
5908                 }
5909                 spin_unlock_bh(&ar->data_lock);
5910
5911                 for (i = 0; i < ARRAY_SIZE(sta->txq); i++)
5912                         ath10k_mac_txq_unref(ar, sta->txq[i]);
5913
5914                 if (!sta->tdls)
5915                         goto exit;
5916
5917                 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
5918                         goto exit;
5919
5920                 /* This was the last tdls peer in current vif */
5921                 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5922                                                       WMI_TDLS_DISABLE);
5923                 if (ret) {
5924                         ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5925                                     arvif->vdev_id, ret);
5926                 }
5927         } else if (old_state == IEEE80211_STA_AUTH &&
5928                    new_state == IEEE80211_STA_ASSOC &&
5929                    (vif->type == NL80211_IFTYPE_AP ||
5930                     vif->type == NL80211_IFTYPE_MESH_POINT ||
5931                     vif->type == NL80211_IFTYPE_ADHOC)) {
5932                 /*
5933                  * New association.
5934                  */
5935                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
5936                            sta->addr);
5937
5938                 ret = ath10k_station_assoc(ar, vif, sta, false);
5939                 if (ret)
5940                         ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
5941                                     sta->addr, arvif->vdev_id, ret);
5942         } else if (old_state == IEEE80211_STA_ASSOC &&
5943                    new_state == IEEE80211_STA_AUTHORIZED &&
5944                    sta->tdls) {
5945                 /*
5946                  * Tdls station authorized.
5947                  */
5948                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n",
5949                            sta->addr);
5950
5951                 ret = ath10k_station_assoc(ar, vif, sta, false);
5952                 if (ret) {
5953                         ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
5954                                     sta->addr, arvif->vdev_id, ret);
5955                         goto exit;
5956                 }
5957
5958                 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5959                                                   WMI_TDLS_PEER_STATE_CONNECTED);
5960                 if (ret)
5961                         ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
5962                                     sta->addr, arvif->vdev_id, ret);
5963         } else if (old_state == IEEE80211_STA_ASSOC &&
5964                     new_state == IEEE80211_STA_AUTH &&
5965                     (vif->type == NL80211_IFTYPE_AP ||
5966                      vif->type == NL80211_IFTYPE_MESH_POINT ||
5967                      vif->type == NL80211_IFTYPE_ADHOC)) {
5968                 /*
5969                  * Disassociation.
5970                  */
5971                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
5972                            sta->addr);
5973
5974                 ret = ath10k_station_disassoc(ar, vif, sta);
5975                 if (ret)
5976                         ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
5977                                     sta->addr, arvif->vdev_id, ret);
5978         }
5979 exit:
5980         mutex_unlock(&ar->conf_mutex);
5981         return ret;
5982 }
5983
5984 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5985                                 u16 ac, bool enable)
5986 {
5987         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5988         struct wmi_sta_uapsd_auto_trig_arg arg = {};
5989         u32 prio = 0, acc = 0;
5990         u32 value = 0;
5991         int ret = 0;
5992
5993         lockdep_assert_held(&ar->conf_mutex);
5994
5995         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5996                 return 0;
5997
5998         switch (ac) {
5999         case IEEE80211_AC_VO:
6000                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
6001                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
6002                 prio = 7;
6003                 acc = 3;
6004                 break;
6005         case IEEE80211_AC_VI:
6006                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
6007                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
6008                 prio = 5;
6009                 acc = 2;
6010                 break;
6011         case IEEE80211_AC_BE:
6012                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
6013                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
6014                 prio = 2;
6015                 acc = 1;
6016                 break;
6017         case IEEE80211_AC_BK:
6018                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
6019                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
6020                 prio = 0;
6021                 acc = 0;
6022                 break;
6023         }
6024
6025         if (enable)
6026                 arvif->u.sta.uapsd |= value;
6027         else
6028                 arvif->u.sta.uapsd &= ~value;
6029
6030         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6031                                           WMI_STA_PS_PARAM_UAPSD,
6032                                           arvif->u.sta.uapsd);
6033         if (ret) {
6034                 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
6035                 goto exit;
6036         }
6037
6038         if (arvif->u.sta.uapsd)
6039                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
6040         else
6041                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
6042
6043         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6044                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
6045                                           value);
6046         if (ret)
6047                 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
6048
6049         ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
6050         if (ret) {
6051                 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
6052                             arvif->vdev_id, ret);
6053                 return ret;
6054         }
6055
6056         ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
6057         if (ret) {
6058                 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
6059                             arvif->vdev_id, ret);
6060                 return ret;
6061         }
6062
6063         if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
6064             test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
6065                 /* Only userspace can make an educated decision when to send
6066                  * trigger frame. The following effectively disables u-UAPSD
6067                  * autotrigger in firmware (which is enabled by default
6068                  * provided the autotrigger service is available).
6069                  */
6070
6071                 arg.wmm_ac = acc;
6072                 arg.user_priority = prio;
6073                 arg.service_interval = 0;
6074                 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
6075                 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
6076
6077                 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
6078                                                 arvif->bssid, &arg, 1);
6079                 if (ret) {
6080                         ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
6081                                     ret);
6082                         return ret;
6083                 }
6084         }
6085
6086 exit:
6087         return ret;
6088 }
6089
6090 static int ath10k_conf_tx(struct ieee80211_hw *hw,
6091                           struct ieee80211_vif *vif, u16 ac,
6092                           const struct ieee80211_tx_queue_params *params)
6093 {
6094         struct ath10k *ar = hw->priv;
6095         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6096         struct wmi_wmm_params_arg *p = NULL;
6097         int ret;
6098
6099         mutex_lock(&ar->conf_mutex);
6100
6101         switch (ac) {
6102         case IEEE80211_AC_VO:
6103                 p = &arvif->wmm_params.ac_vo;
6104                 break;
6105         case IEEE80211_AC_VI:
6106                 p = &arvif->wmm_params.ac_vi;
6107                 break;
6108         case IEEE80211_AC_BE:
6109                 p = &arvif->wmm_params.ac_be;
6110                 break;
6111         case IEEE80211_AC_BK:
6112                 p = &arvif->wmm_params.ac_bk;
6113                 break;
6114         }
6115
6116         if (WARN_ON(!p)) {
6117                 ret = -EINVAL;
6118                 goto exit;
6119         }
6120
6121         p->cwmin = params->cw_min;
6122         p->cwmax = params->cw_max;
6123         p->aifs = params->aifs;
6124
6125         /*
6126          * The channel time duration programmed in the HW is in absolute
6127          * microseconds, while mac80211 gives the txop in units of
6128          * 32 microseconds.
6129          */
6130         p->txop = params->txop * 32;
6131
6132         if (ar->wmi.ops->gen_vdev_wmm_conf) {
6133                 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
6134                                                &arvif->wmm_params);
6135                 if (ret) {
6136                         ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
6137                                     arvif->vdev_id, ret);
6138                         goto exit;
6139                 }
6140         } else {
6141                 /* This won't work well with multi-interface cases but it's
6142                  * better than nothing.
6143                  */
6144                 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
6145                 if (ret) {
6146                         ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
6147                         goto exit;
6148                 }
6149         }
6150
6151         ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
6152         if (ret)
6153                 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
6154
6155 exit:
6156         mutex_unlock(&ar->conf_mutex);
6157         return ret;
6158 }
6159
6160 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
6161
6162 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
6163                                     struct ieee80211_vif *vif,
6164                                     struct ieee80211_channel *chan,
6165                                     int duration,
6166                                     enum ieee80211_roc_type type)
6167 {
6168         struct ath10k *ar = hw->priv;
6169         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6170         struct wmi_start_scan_arg arg;
6171         int ret = 0;
6172         u32 scan_time_msec;
6173
6174         mutex_lock(&ar->conf_mutex);
6175
6176         spin_lock_bh(&ar->data_lock);
6177         switch (ar->scan.state) {
6178         case ATH10K_SCAN_IDLE:
6179                 reinit_completion(&ar->scan.started);
6180                 reinit_completion(&ar->scan.completed);
6181                 reinit_completion(&ar->scan.on_channel);
6182                 ar->scan.state = ATH10K_SCAN_STARTING;
6183                 ar->scan.is_roc = true;
6184                 ar->scan.vdev_id = arvif->vdev_id;
6185                 ar->scan.roc_freq = chan->center_freq;
6186                 ar->scan.roc_notify = true;
6187                 ret = 0;
6188                 break;
6189         case ATH10K_SCAN_STARTING:
6190         case ATH10K_SCAN_RUNNING:
6191         case ATH10K_SCAN_ABORTING:
6192                 ret = -EBUSY;
6193                 break;
6194         }
6195         spin_unlock_bh(&ar->data_lock);
6196
6197         if (ret)
6198                 goto exit;
6199
6200         scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
6201
6202         memset(&arg, 0, sizeof(arg));
6203         ath10k_wmi_start_scan_init(ar, &arg);
6204         arg.vdev_id = arvif->vdev_id;
6205         arg.scan_id = ATH10K_SCAN_ID;
6206         arg.n_channels = 1;
6207         arg.channels[0] = chan->center_freq;
6208         arg.dwell_time_active = scan_time_msec;
6209         arg.dwell_time_passive = scan_time_msec;
6210         arg.max_scan_time = scan_time_msec;
6211         arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
6212         arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
6213         arg.burst_duration_ms = duration;
6214
6215         ret = ath10k_start_scan(ar, &arg);
6216         if (ret) {
6217                 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
6218                 spin_lock_bh(&ar->data_lock);
6219                 ar->scan.state = ATH10K_SCAN_IDLE;
6220                 spin_unlock_bh(&ar->data_lock);
6221                 goto exit;
6222         }
6223
6224         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
6225         if (ret == 0) {
6226                 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
6227
6228                 ret = ath10k_scan_stop(ar);
6229                 if (ret)
6230                         ath10k_warn(ar, "failed to stop scan: %d\n", ret);
6231
6232                 ret = -ETIMEDOUT;
6233                 goto exit;
6234         }
6235
6236         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
6237                                      msecs_to_jiffies(duration));
6238
6239         ret = 0;
6240 exit:
6241         mutex_unlock(&ar->conf_mutex);
6242         return ret;
6243 }
6244
6245 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
6246 {
6247         struct ath10k *ar = hw->priv;
6248
6249         mutex_lock(&ar->conf_mutex);
6250
6251         spin_lock_bh(&ar->data_lock);
6252         ar->scan.roc_notify = false;
6253         spin_unlock_bh(&ar->data_lock);
6254
6255         ath10k_scan_abort(ar);
6256
6257         mutex_unlock(&ar->conf_mutex);
6258
6259         cancel_delayed_work_sync(&ar->scan.timeout);
6260
6261         return 0;
6262 }
6263
6264 /*
6265  * Both RTS and Fragmentation threshold are interface-specific
6266  * in ath10k, but device-specific in mac80211.
6267  */
6268
6269 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
6270 {
6271         struct ath10k *ar = hw->priv;
6272         struct ath10k_vif *arvif;
6273         int ret = 0;
6274
6275         mutex_lock(&ar->conf_mutex);
6276         list_for_each_entry(arvif, &ar->arvifs, list) {
6277                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
6278                            arvif->vdev_id, value);
6279
6280                 ret = ath10k_mac_set_rts(arvif, value);
6281                 if (ret) {
6282                         ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
6283                                     arvif->vdev_id, ret);
6284                         break;
6285                 }
6286         }
6287         mutex_unlock(&ar->conf_mutex);
6288
6289         return ret;
6290 }
6291
6292 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
6293 {
6294         /* Even though there's a WMI enum for fragmentation threshold no known
6295          * firmware actually implements it. Moreover it is not possible to rely
6296          * frame fragmentation to mac80211 because firmware clears the "more
6297          * fragments" bit in frame control making it impossible for remote
6298          * devices to reassemble frames.
6299          *
6300          * Hence implement a dummy callback just to say fragmentation isn't
6301          * supported. This effectively prevents mac80211 from doing frame
6302          * fragmentation in software.
6303          */
6304         return -EOPNOTSUPP;
6305 }
6306
6307 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
6308                          u32 queues, bool drop)
6309 {
6310         struct ath10k *ar = hw->priv;
6311         bool skip;
6312         long time_left;
6313
6314         /* mac80211 doesn't care if we really xmit queued frames or not
6315          * we'll collect those frames either way if we stop/delete vdevs */
6316         if (drop)
6317                 return;
6318
6319         mutex_lock(&ar->conf_mutex);
6320
6321         if (ar->state == ATH10K_STATE_WEDGED)
6322                 goto skip;
6323
6324         time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
6325                         bool empty;
6326
6327                         spin_lock_bh(&ar->htt.tx_lock);
6328                         empty = (ar->htt.num_pending_tx == 0);
6329                         spin_unlock_bh(&ar->htt.tx_lock);
6330
6331                         skip = (ar->state == ATH10K_STATE_WEDGED) ||
6332                                test_bit(ATH10K_FLAG_CRASH_FLUSH,
6333                                         &ar->dev_flags);
6334
6335                         (empty || skip);
6336                 }), ATH10K_FLUSH_TIMEOUT_HZ);
6337
6338         if (time_left == 0 || skip)
6339                 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
6340                             skip, ar->state, time_left);
6341
6342 skip:
6343         mutex_unlock(&ar->conf_mutex);
6344 }
6345
6346 /* TODO: Implement this function properly
6347  * For now it is needed to reply to Probe Requests in IBSS mode.
6348  * Propably we need this information from FW.
6349  */
6350 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
6351 {
6352         return 1;
6353 }
6354
6355 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
6356                                      enum ieee80211_reconfig_type reconfig_type)
6357 {
6358         struct ath10k *ar = hw->priv;
6359
6360         if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
6361                 return;
6362
6363         mutex_lock(&ar->conf_mutex);
6364
6365         /* If device failed to restart it will be in a different state, e.g.
6366          * ATH10K_STATE_WEDGED */
6367         if (ar->state == ATH10K_STATE_RESTARTED) {
6368                 ath10k_info(ar, "device successfully recovered\n");
6369                 ar->state = ATH10K_STATE_ON;
6370                 ieee80211_wake_queues(ar->hw);
6371         }
6372
6373         mutex_unlock(&ar->conf_mutex);
6374 }
6375
6376 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
6377                              struct survey_info *survey)
6378 {
6379         struct ath10k *ar = hw->priv;
6380         struct ieee80211_supported_band *sband;
6381         struct survey_info *ar_survey = &ar->survey[idx];
6382         int ret = 0;
6383
6384         mutex_lock(&ar->conf_mutex);
6385
6386         sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
6387         if (sband && idx >= sband->n_channels) {
6388                 idx -= sband->n_channels;
6389                 sband = NULL;
6390         }
6391
6392         if (!sband)
6393                 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
6394
6395         if (!sband || idx >= sband->n_channels) {
6396                 ret = -ENOENT;
6397                 goto exit;
6398         }
6399
6400         spin_lock_bh(&ar->data_lock);
6401         memcpy(survey, ar_survey, sizeof(*survey));
6402         spin_unlock_bh(&ar->data_lock);
6403
6404         survey->channel = &sband->channels[idx];
6405
6406         if (ar->rx_channel == survey->channel)
6407                 survey->filled |= SURVEY_INFO_IN_USE;
6408
6409 exit:
6410         mutex_unlock(&ar->conf_mutex);
6411         return ret;
6412 }
6413
6414 static bool
6415 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
6416                                         enum ieee80211_band band,
6417                                         const struct cfg80211_bitrate_mask *mask)
6418 {
6419         int num_rates = 0;
6420         int i;
6421
6422         num_rates += hweight32(mask->control[band].legacy);
6423
6424         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
6425                 num_rates += hweight8(mask->control[band].ht_mcs[i]);
6426
6427         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
6428                 num_rates += hweight16(mask->control[band].vht_mcs[i]);
6429
6430         return num_rates == 1;
6431 }
6432
6433 static bool
6434 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
6435                                        enum ieee80211_band band,
6436                                        const struct cfg80211_bitrate_mask *mask,
6437                                        int *nss)
6438 {
6439         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6440         u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
6441         u8 ht_nss_mask = 0;
6442         u8 vht_nss_mask = 0;
6443         int i;
6444
6445         if (mask->control[band].legacy)
6446                 return false;
6447
6448         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6449                 if (mask->control[band].ht_mcs[i] == 0)
6450                         continue;
6451                 else if (mask->control[band].ht_mcs[i] ==
6452                          sband->ht_cap.mcs.rx_mask[i])
6453                         ht_nss_mask |= BIT(i);
6454                 else
6455                         return false;
6456         }
6457
6458         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6459                 if (mask->control[band].vht_mcs[i] == 0)
6460                         continue;
6461                 else if (mask->control[band].vht_mcs[i] ==
6462                          ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
6463                         vht_nss_mask |= BIT(i);
6464                 else
6465                         return false;
6466         }
6467
6468         if (ht_nss_mask != vht_nss_mask)
6469                 return false;
6470
6471         if (ht_nss_mask == 0)
6472                 return false;
6473
6474         if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
6475                 return false;
6476
6477         *nss = fls(ht_nss_mask);
6478
6479         return true;
6480 }
6481
6482 static int
6483 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
6484                                         enum ieee80211_band band,
6485                                         const struct cfg80211_bitrate_mask *mask,
6486                                         u8 *rate, u8 *nss)
6487 {
6488         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6489         int rate_idx;
6490         int i;
6491         u16 bitrate;
6492         u8 preamble;
6493         u8 hw_rate;
6494
6495         if (hweight32(mask->control[band].legacy) == 1) {
6496                 rate_idx = ffs(mask->control[band].legacy) - 1;
6497
6498                 hw_rate = sband->bitrates[rate_idx].hw_value;
6499                 bitrate = sband->bitrates[rate_idx].bitrate;
6500
6501                 if (ath10k_mac_bitrate_is_cck(bitrate))
6502                         preamble = WMI_RATE_PREAMBLE_CCK;
6503                 else
6504                         preamble = WMI_RATE_PREAMBLE_OFDM;
6505
6506                 *nss = 1;
6507                 *rate = preamble << 6 |
6508                         (*nss - 1) << 4 |
6509                         hw_rate << 0;
6510
6511                 return 0;
6512         }
6513
6514         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6515                 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
6516                         *nss = i + 1;
6517                         *rate = WMI_RATE_PREAMBLE_HT << 6 |
6518                                 (*nss - 1) << 4 |
6519                                 (ffs(mask->control[band].ht_mcs[i]) - 1);
6520
6521                         return 0;
6522                 }
6523         }
6524
6525         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6526                 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
6527                         *nss = i + 1;
6528                         *rate = WMI_RATE_PREAMBLE_VHT << 6 |
6529                                 (*nss - 1) << 4 |
6530                                 (ffs(mask->control[band].vht_mcs[i]) - 1);
6531
6532                         return 0;
6533                 }
6534         }
6535
6536         return -EINVAL;
6537 }
6538
6539 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
6540                                             u8 rate, u8 nss, u8 sgi, u8 ldpc)
6541 {
6542         struct ath10k *ar = arvif->ar;
6543         u32 vdev_param;
6544         int ret;
6545
6546         lockdep_assert_held(&ar->conf_mutex);
6547
6548         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
6549                    arvif->vdev_id, rate, nss, sgi);
6550
6551         vdev_param = ar->wmi.vdev_param->fixed_rate;
6552         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
6553         if (ret) {
6554                 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
6555                             rate, ret);
6556                 return ret;
6557         }
6558
6559         vdev_param = ar->wmi.vdev_param->nss;
6560         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
6561         if (ret) {
6562                 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
6563                 return ret;
6564         }
6565
6566         vdev_param = ar->wmi.vdev_param->sgi;
6567         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
6568         if (ret) {
6569                 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
6570                 return ret;
6571         }
6572
6573         vdev_param = ar->wmi.vdev_param->ldpc;
6574         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);
6575         if (ret) {
6576                 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);
6577                 return ret;
6578         }
6579
6580         return 0;
6581 }
6582
6583 static bool
6584 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
6585                                 enum ieee80211_band band,
6586                                 const struct cfg80211_bitrate_mask *mask)
6587 {
6588         int i;
6589         u16 vht_mcs;
6590
6591         /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
6592          * to express all VHT MCS rate masks. Effectively only the following
6593          * ranges can be used: none, 0-7, 0-8 and 0-9.
6594          */
6595         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
6596                 vht_mcs = mask->control[band].vht_mcs[i];
6597
6598                 switch (vht_mcs) {
6599                 case 0:
6600                 case BIT(8) - 1:
6601                 case BIT(9) - 1:
6602                 case BIT(10) - 1:
6603                         break;
6604                 default:
6605                         ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
6606                         return false;
6607                 }
6608         }
6609
6610         return true;
6611 }
6612
6613 static void ath10k_mac_set_bitrate_mask_iter(void *data,
6614                                              struct ieee80211_sta *sta)
6615 {
6616         struct ath10k_vif *arvif = data;
6617         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6618         struct ath10k *ar = arvif->ar;
6619
6620         if (arsta->arvif != arvif)
6621                 return;
6622
6623         spin_lock_bh(&ar->data_lock);
6624         arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
6625         spin_unlock_bh(&ar->data_lock);
6626
6627         ieee80211_queue_work(ar->hw, &arsta->update_wk);
6628 }
6629
6630 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
6631                                           struct ieee80211_vif *vif,
6632                                           const struct cfg80211_bitrate_mask *mask)
6633 {
6634         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6635         struct cfg80211_chan_def def;
6636         struct ath10k *ar = arvif->ar;
6637         enum ieee80211_band band;
6638         const u8 *ht_mcs_mask;
6639         const u16 *vht_mcs_mask;
6640         u8 rate;
6641         u8 nss;
6642         u8 sgi;
6643         u8 ldpc;
6644         int single_nss;
6645         int ret;
6646
6647         if (ath10k_mac_vif_chan(vif, &def))
6648                 return -EPERM;
6649
6650         band = def.chan->band;
6651         ht_mcs_mask = mask->control[band].ht_mcs;
6652         vht_mcs_mask = mask->control[band].vht_mcs;
6653         ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
6654
6655         sgi = mask->control[band].gi;
6656         if (sgi == NL80211_TXRATE_FORCE_LGI)
6657                 return -EINVAL;
6658
6659         if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) {
6660                 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
6661                                                               &rate, &nss);
6662                 if (ret) {
6663                         ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
6664                                     arvif->vdev_id, ret);
6665                         return ret;
6666                 }
6667         } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
6668                                                           &single_nss)) {
6669                 rate = WMI_FIXED_RATE_NONE;
6670                 nss = single_nss;
6671         } else {
6672                 rate = WMI_FIXED_RATE_NONE;
6673                 nss = min(ar->num_rf_chains,
6674                           max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6675                               ath10k_mac_max_vht_nss(vht_mcs_mask)));
6676
6677                 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask))
6678                         return -EINVAL;
6679
6680                 mutex_lock(&ar->conf_mutex);
6681
6682                 arvif->bitrate_mask = *mask;
6683                 ieee80211_iterate_stations_atomic(ar->hw,
6684                                                   ath10k_mac_set_bitrate_mask_iter,
6685                                                   arvif);
6686
6687                 mutex_unlock(&ar->conf_mutex);
6688         }
6689
6690         mutex_lock(&ar->conf_mutex);
6691
6692         ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
6693         if (ret) {
6694                 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
6695                             arvif->vdev_id, ret);
6696                 goto exit;
6697         }
6698
6699 exit:
6700         mutex_unlock(&ar->conf_mutex);
6701
6702         return ret;
6703 }
6704
6705 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
6706                                  struct ieee80211_vif *vif,
6707                                  struct ieee80211_sta *sta,
6708                                  u32 changed)
6709 {
6710         struct ath10k *ar = hw->priv;
6711         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6712         u32 bw, smps;
6713
6714         spin_lock_bh(&ar->data_lock);
6715
6716         ath10k_dbg(ar, ATH10K_DBG_MAC,
6717                    "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
6718                    sta->addr, changed, sta->bandwidth, sta->rx_nss,
6719                    sta->smps_mode);
6720
6721         if (changed & IEEE80211_RC_BW_CHANGED) {
6722                 bw = WMI_PEER_CHWIDTH_20MHZ;
6723
6724                 switch (sta->bandwidth) {
6725                 case IEEE80211_STA_RX_BW_20:
6726                         bw = WMI_PEER_CHWIDTH_20MHZ;
6727                         break;
6728                 case IEEE80211_STA_RX_BW_40:
6729                         bw = WMI_PEER_CHWIDTH_40MHZ;
6730                         break;
6731                 case IEEE80211_STA_RX_BW_80:
6732                         bw = WMI_PEER_CHWIDTH_80MHZ;
6733                         break;
6734                 case IEEE80211_STA_RX_BW_160:
6735                         ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
6736                                     sta->bandwidth, sta->addr);
6737                         bw = WMI_PEER_CHWIDTH_20MHZ;
6738                         break;
6739                 }
6740
6741                 arsta->bw = bw;
6742         }
6743
6744         if (changed & IEEE80211_RC_NSS_CHANGED)
6745                 arsta->nss = sta->rx_nss;
6746
6747         if (changed & IEEE80211_RC_SMPS_CHANGED) {
6748                 smps = WMI_PEER_SMPS_PS_NONE;
6749
6750                 switch (sta->smps_mode) {
6751                 case IEEE80211_SMPS_AUTOMATIC:
6752                 case IEEE80211_SMPS_OFF:
6753                         smps = WMI_PEER_SMPS_PS_NONE;
6754                         break;
6755                 case IEEE80211_SMPS_STATIC:
6756                         smps = WMI_PEER_SMPS_STATIC;
6757                         break;
6758                 case IEEE80211_SMPS_DYNAMIC:
6759                         smps = WMI_PEER_SMPS_DYNAMIC;
6760                         break;
6761                 case IEEE80211_SMPS_NUM_MODES:
6762                         ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
6763                                     sta->smps_mode, sta->addr);
6764                         smps = WMI_PEER_SMPS_PS_NONE;
6765                         break;
6766                 }
6767
6768                 arsta->smps = smps;
6769         }
6770
6771         arsta->changed |= changed;
6772
6773         spin_unlock_bh(&ar->data_lock);
6774
6775         ieee80211_queue_work(hw, &arsta->update_wk);
6776 }
6777
6778 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
6779 {
6780         /*
6781          * FIXME: Return 0 for time being. Need to figure out whether FW
6782          * has the API to fetch 64-bit local TSF
6783          */
6784
6785         return 0;
6786 }
6787
6788 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
6789                                struct ieee80211_vif *vif,
6790                                struct ieee80211_ampdu_params *params)
6791 {
6792         struct ath10k *ar = hw->priv;
6793         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6794         struct ieee80211_sta *sta = params->sta;
6795         enum ieee80211_ampdu_mlme_action action = params->action;
6796         u16 tid = params->tid;
6797
6798         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6799                    arvif->vdev_id, sta->addr, tid, action);
6800
6801         switch (action) {
6802         case IEEE80211_AMPDU_RX_START:
6803         case IEEE80211_AMPDU_RX_STOP:
6804                 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6805                  * creation/removal. Do we need to verify this?
6806                  */
6807                 return 0;
6808         case IEEE80211_AMPDU_TX_START:
6809         case IEEE80211_AMPDU_TX_STOP_CONT:
6810         case IEEE80211_AMPDU_TX_STOP_FLUSH:
6811         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6812         case IEEE80211_AMPDU_TX_OPERATIONAL:
6813                 /* Firmware offloads Tx aggregation entirely so deny mac80211
6814                  * Tx aggregation requests.
6815                  */
6816                 return -EOPNOTSUPP;
6817         }
6818
6819         return -EINVAL;
6820 }
6821
6822 static void
6823 ath10k_mac_update_rx_channel(struct ath10k *ar,
6824                              struct ieee80211_chanctx_conf *ctx,
6825                              struct ieee80211_vif_chanctx_switch *vifs,
6826                              int n_vifs)
6827 {
6828         struct cfg80211_chan_def *def = NULL;
6829
6830         /* Both locks are required because ar->rx_channel is modified. This
6831          * allows readers to hold either lock.
6832          */
6833         lockdep_assert_held(&ar->conf_mutex);
6834         lockdep_assert_held(&ar->data_lock);
6835
6836         WARN_ON(ctx && vifs);
6837         WARN_ON(vifs && n_vifs != 1);
6838
6839         /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6840          * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6841          * ppdu on Rx may reduce performance on low-end systems. It should be
6842          * possible to make tables/hashmaps to speed the lookup up (be vary of
6843          * cpu data cache lines though regarding sizes) but to keep the initial
6844          * implementation simple and less intrusive fallback to the slow lookup
6845          * only for multi-channel cases. Single-channel cases will remain to
6846          * use the old channel derival and thus performance should not be
6847          * affected much.
6848          */
6849         rcu_read_lock();
6850         if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
6851                 ieee80211_iter_chan_contexts_atomic(ar->hw,
6852                                                     ath10k_mac_get_any_chandef_iter,
6853                                                     &def);
6854
6855                 if (vifs)
6856                         def = &vifs[0].new_ctx->def;
6857
6858                 ar->rx_channel = def->chan;
6859         } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) {
6860                 ar->rx_channel = ctx->def.chan;
6861         } else {
6862                 ar->rx_channel = NULL;
6863         }
6864         rcu_read_unlock();
6865 }
6866
6867 static void
6868 ath10k_mac_update_vif_chan(struct ath10k *ar,
6869                            struct ieee80211_vif_chanctx_switch *vifs,
6870                            int n_vifs)
6871 {
6872         struct ath10k_vif *arvif;
6873         int ret;
6874         int i;
6875
6876         lockdep_assert_held(&ar->conf_mutex);
6877
6878         /* First stop monitor interface. Some FW versions crash if there's a
6879          * lone monitor interface.
6880          */
6881         if (ar->monitor_started)
6882                 ath10k_monitor_stop(ar);
6883
6884         for (i = 0; i < n_vifs; i++) {
6885                 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6886
6887                 ath10k_dbg(ar, ATH10K_DBG_MAC,
6888                            "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6889                            arvif->vdev_id,
6890                            vifs[i].old_ctx->def.chan->center_freq,
6891                            vifs[i].new_ctx->def.chan->center_freq,
6892                            vifs[i].old_ctx->def.width,
6893                            vifs[i].new_ctx->def.width);
6894
6895                 if (WARN_ON(!arvif->is_started))
6896                         continue;
6897
6898                 if (WARN_ON(!arvif->is_up))
6899                         continue;
6900
6901                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6902                 if (ret) {
6903                         ath10k_warn(ar, "failed to down vdev %d: %d\n",
6904                                     arvif->vdev_id, ret);
6905                         continue;
6906                 }
6907         }
6908
6909         /* All relevant vdevs are downed and associated channel resources
6910          * should be available for the channel switch now.
6911          */
6912
6913         spin_lock_bh(&ar->data_lock);
6914         ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
6915         spin_unlock_bh(&ar->data_lock);
6916
6917         for (i = 0; i < n_vifs; i++) {
6918                 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6919
6920                 if (WARN_ON(!arvif->is_started))
6921                         continue;
6922
6923                 if (WARN_ON(!arvif->is_up))
6924                         continue;
6925
6926                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6927                 if (ret)
6928                         ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
6929                                     ret);
6930
6931                 ret = ath10k_mac_setup_prb_tmpl(arvif);
6932                 if (ret)
6933                         ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
6934                                     ret);
6935
6936                 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
6937                 if (ret) {
6938                         ath10k_warn(ar, "failed to restart vdev %d: %d\n",
6939                                     arvif->vdev_id, ret);
6940                         continue;
6941                 }
6942
6943                 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6944                                          arvif->bssid);
6945                 if (ret) {
6946                         ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
6947                                     arvif->vdev_id, ret);
6948                         continue;
6949                 }
6950         }
6951
6952         ath10k_monitor_recalc(ar);
6953 }
6954
6955 static int
6956 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6957                           struct ieee80211_chanctx_conf *ctx)
6958 {
6959         struct ath10k *ar = hw->priv;
6960
6961         ath10k_dbg(ar, ATH10K_DBG_MAC,
6962                    "mac chanctx add freq %hu width %d ptr %p\n",
6963                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6964
6965         mutex_lock(&ar->conf_mutex);
6966
6967         spin_lock_bh(&ar->data_lock);
6968         ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
6969         spin_unlock_bh(&ar->data_lock);
6970
6971         ath10k_recalc_radar_detection(ar);
6972         ath10k_monitor_recalc(ar);
6973
6974         mutex_unlock(&ar->conf_mutex);
6975
6976         return 0;
6977 }
6978
6979 static void
6980 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6981                              struct ieee80211_chanctx_conf *ctx)
6982 {
6983         struct ath10k *ar = hw->priv;
6984
6985         ath10k_dbg(ar, ATH10K_DBG_MAC,
6986                    "mac chanctx remove freq %hu width %d ptr %p\n",
6987                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6988
6989         mutex_lock(&ar->conf_mutex);
6990
6991         spin_lock_bh(&ar->data_lock);
6992         ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
6993         spin_unlock_bh(&ar->data_lock);
6994
6995         ath10k_recalc_radar_detection(ar);
6996         ath10k_monitor_recalc(ar);
6997
6998         mutex_unlock(&ar->conf_mutex);
6999 }
7000
7001 struct ath10k_mac_change_chanctx_arg {
7002         struct ieee80211_chanctx_conf *ctx;
7003         struct ieee80211_vif_chanctx_switch *vifs;
7004         int n_vifs;
7005         int next_vif;
7006 };
7007
7008 static void
7009 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
7010                                    struct ieee80211_vif *vif)
7011 {
7012         struct ath10k_mac_change_chanctx_arg *arg = data;
7013
7014         if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx)
7015                 return;
7016
7017         arg->n_vifs++;
7018 }
7019
7020 static void
7021 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
7022                                     struct ieee80211_vif *vif)
7023 {
7024         struct ath10k_mac_change_chanctx_arg *arg = data;
7025         struct ieee80211_chanctx_conf *ctx;
7026
7027         ctx = rcu_access_pointer(vif->chanctx_conf);
7028         if (ctx != arg->ctx)
7029                 return;
7030
7031         if (WARN_ON(arg->next_vif == arg->n_vifs))
7032                 return;
7033
7034         arg->vifs[arg->next_vif].vif = vif;
7035         arg->vifs[arg->next_vif].old_ctx = ctx;
7036         arg->vifs[arg->next_vif].new_ctx = ctx;
7037         arg->next_vif++;
7038 }
7039
7040 static void
7041 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
7042                              struct ieee80211_chanctx_conf *ctx,
7043                              u32 changed)
7044 {
7045         struct ath10k *ar = hw->priv;
7046         struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };
7047
7048         mutex_lock(&ar->conf_mutex);
7049
7050         ath10k_dbg(ar, ATH10K_DBG_MAC,
7051                    "mac chanctx change freq %hu width %d ptr %p changed %x\n",
7052                    ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
7053
7054         /* This shouldn't really happen because channel switching should use
7055          * switch_vif_chanctx().
7056          */
7057         if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
7058                 goto unlock;
7059
7060         if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {
7061                 ieee80211_iterate_active_interfaces_atomic(
7062                                         hw,
7063                                         IEEE80211_IFACE_ITER_NORMAL,
7064                                         ath10k_mac_change_chanctx_cnt_iter,
7065                                         &arg);
7066                 if (arg.n_vifs == 0)
7067                         goto radar;
7068
7069                 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),
7070                                    GFP_KERNEL);
7071                 if (!arg.vifs)
7072                         goto radar;
7073
7074                 ieee80211_iterate_active_interfaces_atomic(
7075                                         hw,
7076                                         IEEE80211_IFACE_ITER_NORMAL,
7077                                         ath10k_mac_change_chanctx_fill_iter,
7078                                         &arg);
7079                 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
7080                 kfree(arg.vifs);
7081         }
7082
7083 radar:
7084         ath10k_recalc_radar_detection(ar);
7085
7086         /* FIXME: How to configure Rx chains properly? */
7087
7088         /* No other actions are actually necessary. Firmware maintains channel
7089          * definitions per vdev internally and there's no host-side channel
7090          * context abstraction to configure, e.g. channel width.
7091          */
7092
7093 unlock:
7094         mutex_unlock(&ar->conf_mutex);
7095 }
7096
7097 static int
7098 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
7099                                  struct ieee80211_vif *vif,
7100                                  struct ieee80211_chanctx_conf *ctx)
7101 {
7102         struct ath10k *ar = hw->priv;
7103         struct ath10k_vif *arvif = (void *)vif->drv_priv;
7104         int ret;
7105
7106         mutex_lock(&ar->conf_mutex);
7107
7108         ath10k_dbg(ar, ATH10K_DBG_MAC,
7109                    "mac chanctx assign ptr %p vdev_id %i\n",
7110                    ctx, arvif->vdev_id);
7111
7112         if (WARN_ON(arvif->is_started)) {
7113                 mutex_unlock(&ar->conf_mutex);
7114                 return -EBUSY;
7115         }
7116
7117         ret = ath10k_vdev_start(arvif, &ctx->def);
7118         if (ret) {
7119                 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
7120                             arvif->vdev_id, vif->addr,
7121                             ctx->def.chan->center_freq, ret);
7122                 goto err;
7123         }
7124
7125         arvif->is_started = true;
7126
7127         ret = ath10k_mac_vif_setup_ps(arvif);
7128         if (ret) {
7129                 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
7130                             arvif->vdev_id, ret);
7131                 goto err_stop;
7132         }
7133
7134         if (vif->type == NL80211_IFTYPE_MONITOR) {
7135                 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
7136                 if (ret) {
7137                         ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
7138                                     arvif->vdev_id, ret);
7139                         goto err_stop;
7140                 }
7141
7142                 arvif->is_up = true;
7143         }
7144
7145         mutex_unlock(&ar->conf_mutex);
7146         return 0;
7147
7148 err_stop:
7149         ath10k_vdev_stop(arvif);
7150         arvif->is_started = false;
7151         ath10k_mac_vif_setup_ps(arvif);
7152
7153 err:
7154         mutex_unlock(&ar->conf_mutex);
7155         return ret;
7156 }
7157
7158 static void
7159 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
7160                                    struct ieee80211_vif *vif,
7161                                    struct ieee80211_chanctx_conf *ctx)
7162 {
7163         struct ath10k *ar = hw->priv;
7164         struct ath10k_vif *arvif = (void *)vif->drv_priv;
7165         int ret;
7166
7167         mutex_lock(&ar->conf_mutex);
7168
7169         ath10k_dbg(ar, ATH10K_DBG_MAC,
7170                    "mac chanctx unassign ptr %p vdev_id %i\n",
7171                    ctx, arvif->vdev_id);
7172
7173         WARN_ON(!arvif->is_started);
7174
7175         if (vif->type == NL80211_IFTYPE_MONITOR) {
7176                 WARN_ON(!arvif->is_up);
7177
7178                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
7179                 if (ret)
7180                         ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
7181                                     arvif->vdev_id, ret);
7182
7183                 arvif->is_up = false;
7184         }
7185
7186         ret = ath10k_vdev_stop(arvif);
7187         if (ret)
7188                 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
7189                             arvif->vdev_id, ret);
7190
7191         arvif->is_started = false;
7192
7193         mutex_unlock(&ar->conf_mutex);
7194 }
7195
7196 static int
7197 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
7198                                  struct ieee80211_vif_chanctx_switch *vifs,
7199                                  int n_vifs,
7200                                  enum ieee80211_chanctx_switch_mode mode)
7201 {
7202         struct ath10k *ar = hw->priv;
7203
7204         mutex_lock(&ar->conf_mutex);
7205
7206         ath10k_dbg(ar, ATH10K_DBG_MAC,
7207                    "mac chanctx switch n_vifs %d mode %d\n",
7208                    n_vifs, mode);
7209         ath10k_mac_update_vif_chan(ar, vifs, n_vifs);
7210
7211         mutex_unlock(&ar->conf_mutex);
7212         return 0;
7213 }
7214
7215 static const struct ieee80211_ops ath10k_ops = {
7216         .tx                             = ath10k_mac_op_tx,
7217         .wake_tx_queue                  = ath10k_mac_op_wake_tx_queue,
7218         .start                          = ath10k_start,
7219         .stop                           = ath10k_stop,
7220         .config                         = ath10k_config,
7221         .add_interface                  = ath10k_add_interface,
7222         .remove_interface               = ath10k_remove_interface,
7223         .configure_filter               = ath10k_configure_filter,
7224         .bss_info_changed               = ath10k_bss_info_changed,
7225         .hw_scan                        = ath10k_hw_scan,
7226         .cancel_hw_scan                 = ath10k_cancel_hw_scan,
7227         .set_key                        = ath10k_set_key,
7228         .set_default_unicast_key        = ath10k_set_default_unicast_key,
7229         .sta_state                      = ath10k_sta_state,
7230         .conf_tx                        = ath10k_conf_tx,
7231         .remain_on_channel              = ath10k_remain_on_channel,
7232         .cancel_remain_on_channel       = ath10k_cancel_remain_on_channel,
7233         .set_rts_threshold              = ath10k_set_rts_threshold,
7234         .set_frag_threshold             = ath10k_mac_op_set_frag_threshold,
7235         .flush                          = ath10k_flush,
7236         .tx_last_beacon                 = ath10k_tx_last_beacon,
7237         .set_antenna                    = ath10k_set_antenna,
7238         .get_antenna                    = ath10k_get_antenna,
7239         .reconfig_complete              = ath10k_reconfig_complete,
7240         .get_survey                     = ath10k_get_survey,
7241         .set_bitrate_mask               = ath10k_mac_op_set_bitrate_mask,
7242         .sta_rc_update                  = ath10k_sta_rc_update,
7243         .get_tsf                        = ath10k_get_tsf,
7244         .ampdu_action                   = ath10k_ampdu_action,
7245         .get_et_sset_count              = ath10k_debug_get_et_sset_count,
7246         .get_et_stats                   = ath10k_debug_get_et_stats,
7247         .get_et_strings                 = ath10k_debug_get_et_strings,
7248         .add_chanctx                    = ath10k_mac_op_add_chanctx,
7249         .remove_chanctx                 = ath10k_mac_op_remove_chanctx,
7250         .change_chanctx                 = ath10k_mac_op_change_chanctx,
7251         .assign_vif_chanctx             = ath10k_mac_op_assign_vif_chanctx,
7252         .unassign_vif_chanctx           = ath10k_mac_op_unassign_vif_chanctx,
7253         .switch_vif_chanctx             = ath10k_mac_op_switch_vif_chanctx,
7254
7255         CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
7256
7257 #ifdef CONFIG_PM
7258         .suspend                        = ath10k_wow_op_suspend,
7259         .resume                         = ath10k_wow_op_resume,
7260 #endif
7261 #ifdef CONFIG_MAC80211_DEBUGFS
7262         .sta_add_debugfs                = ath10k_sta_add_debugfs,
7263 #endif
7264 };
7265
7266 #define CHAN2G(_channel, _freq, _flags) { \
7267         .band                   = IEEE80211_BAND_2GHZ, \
7268         .hw_value               = (_channel), \
7269         .center_freq            = (_freq), \
7270         .flags                  = (_flags), \
7271         .max_antenna_gain       = 0, \
7272         .max_power              = 30, \
7273 }
7274
7275 #define CHAN5G(_channel, _freq, _flags) { \
7276         .band                   = IEEE80211_BAND_5GHZ, \
7277         .hw_value               = (_channel), \
7278         .center_freq            = (_freq), \
7279         .flags                  = (_flags), \
7280         .max_antenna_gain       = 0, \
7281         .max_power              = 30, \
7282 }
7283
7284 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
7285         CHAN2G(1, 2412, 0),
7286         CHAN2G(2, 2417, 0),
7287         CHAN2G(3, 2422, 0),
7288         CHAN2G(4, 2427, 0),
7289         CHAN2G(5, 2432, 0),
7290         CHAN2G(6, 2437, 0),
7291         CHAN2G(7, 2442, 0),
7292         CHAN2G(8, 2447, 0),
7293         CHAN2G(9, 2452, 0),
7294         CHAN2G(10, 2457, 0),
7295         CHAN2G(11, 2462, 0),
7296         CHAN2G(12, 2467, 0),
7297         CHAN2G(13, 2472, 0),
7298         CHAN2G(14, 2484, 0),
7299 };
7300
7301 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
7302         CHAN5G(36, 5180, 0),
7303         CHAN5G(40, 5200, 0),
7304         CHAN5G(44, 5220, 0),
7305         CHAN5G(48, 5240, 0),
7306         CHAN5G(52, 5260, 0),
7307         CHAN5G(56, 5280, 0),
7308         CHAN5G(60, 5300, 0),
7309         CHAN5G(64, 5320, 0),
7310         CHAN5G(100, 5500, 0),
7311         CHAN5G(104, 5520, 0),
7312         CHAN5G(108, 5540, 0),
7313         CHAN5G(112, 5560, 0),
7314         CHAN5G(116, 5580, 0),
7315         CHAN5G(120, 5600, 0),
7316         CHAN5G(124, 5620, 0),
7317         CHAN5G(128, 5640, 0),
7318         CHAN5G(132, 5660, 0),
7319         CHAN5G(136, 5680, 0),
7320         CHAN5G(140, 5700, 0),
7321         CHAN5G(144, 5720, 0),
7322         CHAN5G(149, 5745, 0),
7323         CHAN5G(153, 5765, 0),
7324         CHAN5G(157, 5785, 0),
7325         CHAN5G(161, 5805, 0),
7326         CHAN5G(165, 5825, 0),
7327 };
7328
7329 struct ath10k *ath10k_mac_create(size_t priv_size)
7330 {
7331         struct ieee80211_hw *hw;
7332         struct ath10k *ar;
7333
7334         hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
7335         if (!hw)
7336                 return NULL;
7337
7338         ar = hw->priv;
7339         ar->hw = hw;
7340
7341         return ar;
7342 }
7343
7344 void ath10k_mac_destroy(struct ath10k *ar)
7345 {
7346         ieee80211_free_hw(ar->hw);
7347 }
7348
7349 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
7350         {
7351                 .max    = 8,
7352                 .types  = BIT(NL80211_IFTYPE_STATION)
7353                         | BIT(NL80211_IFTYPE_P2P_CLIENT)
7354         },
7355         {
7356                 .max    = 3,
7357                 .types  = BIT(NL80211_IFTYPE_P2P_GO)
7358         },
7359         {
7360                 .max    = 1,
7361                 .types  = BIT(NL80211_IFTYPE_P2P_DEVICE)
7362         },
7363         {
7364                 .max    = 7,
7365                 .types  = BIT(NL80211_IFTYPE_AP)
7366 #ifdef CONFIG_MAC80211_MESH
7367                         | BIT(NL80211_IFTYPE_MESH_POINT)
7368 #endif
7369         },
7370 };
7371
7372 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
7373         {
7374                 .max    = 8,
7375                 .types  = BIT(NL80211_IFTYPE_AP)
7376 #ifdef CONFIG_MAC80211_MESH
7377                         | BIT(NL80211_IFTYPE_MESH_POINT)
7378 #endif
7379         },
7380         {
7381                 .max    = 1,
7382                 .types  = BIT(NL80211_IFTYPE_STATION)
7383         },
7384 };
7385
7386 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
7387         {
7388                 .limits = ath10k_if_limits,
7389                 .n_limits = ARRAY_SIZE(ath10k_if_limits),
7390                 .max_interfaces = 8,
7391                 .num_different_channels = 1,
7392                 .beacon_int_infra_match = true,
7393         },
7394 };
7395
7396 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
7397         {
7398                 .limits = ath10k_10x_if_limits,
7399                 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
7400                 .max_interfaces = 8,
7401                 .num_different_channels = 1,
7402                 .beacon_int_infra_match = true,
7403 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
7404                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
7405                                         BIT(NL80211_CHAN_WIDTH_20) |
7406                                         BIT(NL80211_CHAN_WIDTH_40) |
7407                                         BIT(NL80211_CHAN_WIDTH_80),
7408 #endif
7409         },
7410 };
7411
7412 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
7413         {
7414                 .max = 2,
7415                 .types = BIT(NL80211_IFTYPE_STATION),
7416         },
7417         {
7418                 .max = 2,
7419                 .types = BIT(NL80211_IFTYPE_AP) |
7420 #ifdef CONFIG_MAC80211_MESH
7421                          BIT(NL80211_IFTYPE_MESH_POINT) |
7422 #endif
7423                          BIT(NL80211_IFTYPE_P2P_CLIENT) |
7424                          BIT(NL80211_IFTYPE_P2P_GO),
7425         },
7426         {
7427                 .max = 1,
7428                 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7429         },
7430 };
7431
7432 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
7433         {
7434                 .max = 2,
7435                 .types = BIT(NL80211_IFTYPE_STATION),
7436         },
7437         {
7438                 .max = 2,
7439                 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
7440         },
7441         {
7442                 .max = 1,
7443                 .types = BIT(NL80211_IFTYPE_AP) |
7444 #ifdef CONFIG_MAC80211_MESH
7445                          BIT(NL80211_IFTYPE_MESH_POINT) |
7446 #endif
7447                          BIT(NL80211_IFTYPE_P2P_GO),
7448         },
7449         {
7450                 .max = 1,
7451                 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7452         },
7453 };
7454
7455 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
7456         {
7457                 .max = 1,
7458                 .types = BIT(NL80211_IFTYPE_STATION),
7459         },
7460         {
7461                 .max = 1,
7462                 .types = BIT(NL80211_IFTYPE_ADHOC),
7463         },
7464 };
7465
7466 /* FIXME: This is not thouroughly tested. These combinations may over- or
7467  * underestimate hw/fw capabilities.
7468  */
7469 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
7470         {
7471                 .limits = ath10k_tlv_if_limit,
7472                 .num_different_channels = 1,
7473                 .max_interfaces = 4,
7474                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7475         },
7476         {
7477                 .limits = ath10k_tlv_if_limit_ibss,
7478                 .num_different_channels = 1,
7479                 .max_interfaces = 2,
7480                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7481         },
7482 };
7483
7484 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
7485         {
7486                 .limits = ath10k_tlv_if_limit,
7487                 .num_different_channels = 1,
7488                 .max_interfaces = 4,
7489                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7490         },
7491         {
7492                 .limits = ath10k_tlv_qcs_if_limit,
7493                 .num_different_channels = 2,
7494                 .max_interfaces = 4,
7495                 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
7496         },
7497         {
7498                 .limits = ath10k_tlv_if_limit_ibss,
7499                 .num_different_channels = 1,
7500                 .max_interfaces = 2,
7501                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7502         },
7503 };
7504
7505 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
7506         {
7507                 .max = 1,
7508                 .types = BIT(NL80211_IFTYPE_STATION),
7509         },
7510         {
7511                 .max    = 16,
7512                 .types  = BIT(NL80211_IFTYPE_AP)
7513 #ifdef CONFIG_MAC80211_MESH
7514                         | BIT(NL80211_IFTYPE_MESH_POINT)
7515 #endif
7516         },
7517 };
7518
7519 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
7520         {
7521                 .limits = ath10k_10_4_if_limits,
7522                 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
7523                 .max_interfaces = 16,
7524                 .num_different_channels = 1,
7525                 .beacon_int_infra_match = true,
7526 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
7527                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
7528                                         BIT(NL80211_CHAN_WIDTH_20) |
7529                                         BIT(NL80211_CHAN_WIDTH_40) |
7530                                         BIT(NL80211_CHAN_WIDTH_80),
7531 #endif
7532         },
7533 };
7534
7535 static void ath10k_get_arvif_iter(void *data, u8 *mac,
7536                                   struct ieee80211_vif *vif)
7537 {
7538         struct ath10k_vif_iter *arvif_iter = data;
7539         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
7540
7541         if (arvif->vdev_id == arvif_iter->vdev_id)
7542                 arvif_iter->arvif = arvif;
7543 }
7544
7545 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
7546 {
7547         struct ath10k_vif_iter arvif_iter;
7548         u32 flags;
7549
7550         memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
7551         arvif_iter.vdev_id = vdev_id;
7552
7553         flags = IEEE80211_IFACE_ITER_RESUME_ALL;
7554         ieee80211_iterate_active_interfaces_atomic(ar->hw,
7555                                                    flags,
7556                                                    ath10k_get_arvif_iter,
7557                                                    &arvif_iter);
7558         if (!arvif_iter.arvif) {
7559                 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
7560                 return NULL;
7561         }
7562
7563         return arvif_iter.arvif;
7564 }
7565
7566 int ath10k_mac_register(struct ath10k *ar)
7567 {
7568         static const u32 cipher_suites[] = {
7569                 WLAN_CIPHER_SUITE_WEP40,
7570                 WLAN_CIPHER_SUITE_WEP104,
7571                 WLAN_CIPHER_SUITE_TKIP,
7572                 WLAN_CIPHER_SUITE_CCMP,
7573                 WLAN_CIPHER_SUITE_AES_CMAC,
7574         };
7575         struct ieee80211_supported_band *band;
7576         void *channels;
7577         int ret;
7578
7579         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
7580
7581         SET_IEEE80211_DEV(ar->hw, ar->dev);
7582
7583         BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
7584                       ARRAY_SIZE(ath10k_5ghz_channels)) !=
7585                      ATH10K_NUM_CHANS);
7586
7587         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
7588                 channels = kmemdup(ath10k_2ghz_channels,
7589                                    sizeof(ath10k_2ghz_channels),
7590                                    GFP_KERNEL);
7591                 if (!channels) {
7592                         ret = -ENOMEM;
7593                         goto err_free;
7594                 }
7595
7596                 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
7597                 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
7598                 band->channels = channels;
7599                 band->n_bitrates = ath10k_g_rates_size;
7600                 band->bitrates = ath10k_g_rates;
7601
7602                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
7603         }
7604
7605         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
7606                 channels = kmemdup(ath10k_5ghz_channels,
7607                                    sizeof(ath10k_5ghz_channels),
7608                                    GFP_KERNEL);
7609                 if (!channels) {
7610                         ret = -ENOMEM;
7611                         goto err_free;
7612                 }
7613
7614                 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
7615                 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
7616                 band->channels = channels;
7617                 band->n_bitrates = ath10k_a_rates_size;
7618                 band->bitrates = ath10k_a_rates;
7619                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
7620         }
7621
7622         ath10k_mac_setup_ht_vht_cap(ar);
7623
7624         ar->hw->wiphy->interface_modes =
7625                 BIT(NL80211_IFTYPE_STATION) |
7626                 BIT(NL80211_IFTYPE_AP) |
7627                 BIT(NL80211_IFTYPE_MESH_POINT);
7628
7629         ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask;
7630         ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask;
7631
7632         if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
7633                 ar->hw->wiphy->interface_modes |=
7634                         BIT(NL80211_IFTYPE_P2P_DEVICE) |
7635                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
7636                         BIT(NL80211_IFTYPE_P2P_GO);
7637
7638         ieee80211_hw_set(ar->hw, SIGNAL_DBM);
7639         ieee80211_hw_set(ar->hw, SUPPORTS_PS);
7640         ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
7641         ieee80211_hw_set(ar->hw, MFP_CAPABLE);
7642         ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
7643         ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
7644         ieee80211_hw_set(ar->hw, AP_LINK_PS);
7645         ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
7646         ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
7647         ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
7648         ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
7649         ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
7650         ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
7651         ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
7652
7653         if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7654                 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
7655
7656         ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
7657         ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
7658
7659         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
7660                 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
7661
7662         if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
7663                 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
7664                 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
7665         }
7666
7667         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
7668         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
7669
7670         ar->hw->vif_data_size = sizeof(struct ath10k_vif);
7671         ar->hw->sta_data_size = sizeof(struct ath10k_sta);
7672         ar->hw->txq_data_size = sizeof(struct ath10k_txq);
7673
7674         ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
7675
7676         if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
7677                 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
7678
7679                 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
7680                  * that userspace (e.g. wpa_supplicant/hostapd) can generate
7681                  * correct Probe Responses. This is more of a hack advert..
7682                  */
7683                 ar->hw->wiphy->probe_resp_offload |=
7684                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
7685                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
7686                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
7687         }
7688
7689         if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))
7690                 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7691
7692         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
7693         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
7694         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
7695
7696         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
7697         ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
7698
7699         ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
7700
7701         ret = ath10k_wow_init(ar);
7702         if (ret) {
7703                 ath10k_warn(ar, "failed to init wow: %d\n", ret);
7704                 goto err_free;
7705         }
7706
7707         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
7708
7709         /*
7710          * on LL hardware queues are managed entirely by the FW
7711          * so we only advertise to mac we can do the queues thing
7712          */
7713         ar->hw->queues = IEEE80211_MAX_QUEUES;
7714
7715         /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
7716          * something that vdev_ids can't reach so that we don't stop the queue
7717          * accidentally.
7718          */
7719         ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
7720
7721         switch (ar->wmi.op_version) {
7722         case ATH10K_FW_WMI_OP_VERSION_MAIN:
7723                 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
7724                 ar->hw->wiphy->n_iface_combinations =
7725                         ARRAY_SIZE(ath10k_if_comb);
7726                 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7727                 break;
7728         case ATH10K_FW_WMI_OP_VERSION_TLV:
7729                 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
7730                         ar->hw->wiphy->iface_combinations =
7731                                 ath10k_tlv_qcs_if_comb;
7732                         ar->hw->wiphy->n_iface_combinations =
7733                                 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
7734                 } else {
7735                         ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
7736                         ar->hw->wiphy->n_iface_combinations =
7737                                 ARRAY_SIZE(ath10k_tlv_if_comb);
7738                 }
7739                 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7740                 break;
7741         case ATH10K_FW_WMI_OP_VERSION_10_1:
7742         case ATH10K_FW_WMI_OP_VERSION_10_2:
7743         case ATH10K_FW_WMI_OP_VERSION_10_2_4:
7744                 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
7745                 ar->hw->wiphy->n_iface_combinations =
7746                         ARRAY_SIZE(ath10k_10x_if_comb);
7747                 break;
7748         case ATH10K_FW_WMI_OP_VERSION_10_4:
7749                 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
7750                 ar->hw->wiphy->n_iface_combinations =
7751                         ARRAY_SIZE(ath10k_10_4_if_comb);
7752                 break;
7753         case ATH10K_FW_WMI_OP_VERSION_UNSET:
7754         case ATH10K_FW_WMI_OP_VERSION_MAX:
7755                 WARN_ON(1);
7756                 ret = -EINVAL;
7757                 goto err_free;
7758         }
7759
7760         if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7761                 ar->hw->netdev_features = NETIF_F_HW_CSUM;
7762
7763         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
7764                 /* Init ath dfs pattern detector */
7765                 ar->ath_common.debug_mask = ATH_DBG_DFS;
7766                 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
7767                                                              NL80211_DFS_UNSET);
7768
7769                 if (!ar->dfs_detector)
7770                         ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
7771         }
7772
7773         ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
7774                             ath10k_reg_notifier);
7775         if (ret) {
7776                 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
7777                 goto err_dfs_detector_exit;
7778         }
7779
7780         ar->hw->wiphy->cipher_suites = cipher_suites;
7781         ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7782
7783         ret = ieee80211_register_hw(ar->hw);
7784         if (ret) {
7785                 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
7786                 goto err_dfs_detector_exit;
7787         }
7788
7789         if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
7790                 ret = regulatory_hint(ar->hw->wiphy,
7791                                       ar->ath_common.regulatory.alpha2);
7792                 if (ret)
7793                         goto err_unregister;
7794         }
7795
7796         return 0;
7797
7798 err_unregister:
7799         ieee80211_unregister_hw(ar->hw);
7800
7801 err_dfs_detector_exit:
7802         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7803                 ar->dfs_detector->exit(ar->dfs_detector);
7804
7805 err_free:
7806         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7807         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7808
7809         SET_IEEE80211_DEV(ar->hw, NULL);
7810         return ret;
7811 }
7812
7813 void ath10k_mac_unregister(struct ath10k *ar)
7814 {
7815         ieee80211_unregister_hw(ar->hw);
7816
7817         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7818                 ar->dfs_detector->exit(ar->dfs_detector);
7819
7820         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7821         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7822
7823         SET_IEEE80211_DEV(ar->hw, NULL);
7824 }