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

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