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

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