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

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