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