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