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

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