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-ops.h"
  32
  33 /**********/
  34 /* Crypto */
  35 /**********/
  36
  37 static int ath10k_send_key(struct ath10k_vif *arvif,
  38                            struct ieee80211_key_conf *key,
  39                            enum set_key_cmd cmd,
  40                            const u8 *macaddr, bool def_idx)
  41 {
  42         struct ath10k *ar = arvif->ar;
  43         struct wmi_vdev_install_key_arg arg = {
  44                 .vdev_id = arvif->vdev_id,
  45                 .key_idx = key->keyidx,
  46                 .key_len = key->keylen,
  47                 .key_data = key->key,
  48                 .macaddr = macaddr,
  49         };
  50
  51         lockdep_assert_held(&arvif->ar->conf_mutex);
  52
  53         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
  54                 arg.key_flags = WMI_KEY_PAIRWISE;
  55         else
  56                 arg.key_flags = WMI_KEY_GROUP;
  57
  58         switch (key->cipher) {
  59         case WLAN_CIPHER_SUITE_CCMP:
  60                 arg.key_cipher = WMI_CIPHER_AES_CCM;
  61                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
  62                 break;
  63         case WLAN_CIPHER_SUITE_TKIP:
  64                 arg.key_cipher = WMI_CIPHER_TKIP;
  65                 arg.key_txmic_len = 8;
  66                 arg.key_rxmic_len = 8;
  67                 break;
  68         case WLAN_CIPHER_SUITE_WEP40:
  69         case WLAN_CIPHER_SUITE_WEP104:
  70                 arg.key_cipher = WMI_CIPHER_WEP;
  71                 /* AP/IBSS mode requires self-key to be groupwise
  72                  * Otherwise pairwise key must be set */
  73                 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
  74                         arg.key_flags = WMI_KEY_PAIRWISE;
  75
  76                 if (def_idx)
  77                         arg.key_flags |= WMI_KEY_TX_USAGE;
  78                 break;
  79         case WLAN_CIPHER_SUITE_AES_CMAC:
  80                 /* this one needs to be done in software */
  81                 return 1;
  82         default:
  83                 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
  84                 return -EOPNOTSUPP;
  85         }
  86
  87         if (cmd == DISABLE_KEY) {
  88                 arg.key_cipher = WMI_CIPHER_NONE;
  89                 arg.key_data = NULL;
  90         }
  91
  92         return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
  93 }
  94
  95 static int ath10k_install_key(struct ath10k_vif *arvif,
  96                               struct ieee80211_key_conf *key,
  97                               enum set_key_cmd cmd,
  98                               const u8 *macaddr, bool def_idx)
  99 {
 100         struct ath10k *ar = arvif->ar;
 101         int ret;
 102
 103         lockdep_assert_held(&ar->conf_mutex);
 104
 105         reinit_completion(&ar->install_key_done);
 106
 107         ret = ath10k_send_key(arvif, key, cmd, macaddr, def_idx);
 108         if (ret)
 109                 return ret;
 110
 111         ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
 112         if (ret == 0)
 113                 return -ETIMEDOUT;
 114
 115         return 0;
 116 }
 117
 118 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
 119                                         const u8 *addr)
 120 {
 121         struct ath10k *ar = arvif->ar;
 122         struct ath10k_peer *peer;
 123         int ret;
 124         int i;
 125         bool def_idx;
 126
 127         lockdep_assert_held(&ar->conf_mutex);
 128
 129         spin_lock_bh(&ar->data_lock);
 130         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
 131         spin_unlock_bh(&ar->data_lock);
 132
 133         if (!peer)
 134                 return -ENOENT;
 135
 136         for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
 137                 if (arvif->wep_keys[i] == NULL)
 138                         continue;
 139                 /* set TX_USAGE flag for default key id */
 140                 if (arvif->def_wep_key_idx == i)
 141                         def_idx = true;
 142                 else
 143                         def_idx = false;
 144
 145                 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
 146                                          addr, def_idx);
 147                 if (ret)
 148                         return ret;
 149
 150                 spin_lock_bh(&ar->data_lock);
 151                 peer->keys[i] = arvif->wep_keys[i];
 152                 spin_unlock_bh(&ar->data_lock);
 153         }
 154
 155         return 0;
 156 }
 157
 158 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
 159                                   const u8 *addr)
 160 {
 161         struct ath10k *ar = arvif->ar;
 162         struct ath10k_peer *peer;
 163         int first_errno = 0;
 164         int ret;
 165         int i;
 166
 167         lockdep_assert_held(&ar->conf_mutex);
 168
 169         spin_lock_bh(&ar->data_lock);
 170         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
 171         spin_unlock_bh(&ar->data_lock);
 172
 173         if (!peer)
 174                 return -ENOENT;
 175
 176         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
 177                 if (peer->keys[i] == NULL)
 178                         continue;
 179
 180                 /* key flags are not required to delete the key */
 181                 ret = ath10k_install_key(arvif, peer->keys[i],
 182                                          DISABLE_KEY, addr, false);
 183                 if (ret && first_errno == 0)
 184                         first_errno = ret;
 185
 186                 if (ret)
 187                         ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
 188                                     i, ret);
 189
 190                 spin_lock_bh(&ar->data_lock);
 191                 peer->keys[i] = NULL;
 192                 spin_unlock_bh(&ar->data_lock);
 193         }
 194
 195         return first_errno;
 196 }
 197
 198 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,
 199                                     u8 keyidx)
 200 {
 201         struct ath10k_peer *peer;
 202         int i;
 203
 204         lockdep_assert_held(&ar->data_lock);
 205
 206         /* We don't know which vdev this peer belongs to,
 207          * since WMI doesn't give us that information.
 208          *
 209          * FIXME: multi-bss needs to be handled.
 210          */
 211         peer = ath10k_peer_find(ar, 0, addr);
 212         if (!peer)
 213                 return false;
 214
 215         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
 216                 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)
 217                         return true;
 218         }
 219
 220         return false;
 221 }
 222
 223 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
 224                                  struct ieee80211_key_conf *key)
 225 {
 226         struct ath10k *ar = arvif->ar;
 227         struct ath10k_peer *peer;
 228         u8 addr[ETH_ALEN];
 229         int first_errno = 0;
 230         int ret;
 231         int i;
 232
 233         lockdep_assert_held(&ar->conf_mutex);
 234
 235         for (;;) {
 236                 /* since ath10k_install_key we can't hold data_lock all the
 237                  * time, so we try to remove the keys incrementally */
 238                 spin_lock_bh(&ar->data_lock);
 239                 i = 0;
 240                 list_for_each_entry(peer, &ar->peers, list) {
 241                         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
 242                                 if (peer->keys[i] == key) {
 243                                         ether_addr_copy(addr, peer->addr);
 244                                         peer->keys[i] = NULL;
 245                                         break;
 246                                 }
 247                         }
 248
 249                         if (i < ARRAY_SIZE(peer->keys))
 250                                 break;
 251                 }
 252                 spin_unlock_bh(&ar->data_lock);
 253
 254                 if (i == ARRAY_SIZE(peer->keys))
 255                         break;
 256                 /* key flags are not required to delete the key */
 257                 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, false);
 258                 if (ret && first_errno == 0)
 259                         first_errno = ret;
 260
 261                 if (ret)
 262                         ath10k_warn(ar, "failed to remove key for %pM: %d\n",
 263                                     addr, ret);
 264         }
 265
 266         return first_errno;
 267 }
 268
 269 /*********************/
 270 /* General utilities */
 271 /*********************/
 272
 273 static inline enum wmi_phy_mode
 274 chan_to_phymode(const struct cfg80211_chan_def *chandef)
 275 {
 276         enum wmi_phy_mode phymode = MODE_UNKNOWN;
 277
 278         switch (chandef->chan->band) {
 279         case IEEE80211_BAND_2GHZ:
 280                 switch (chandef->width) {
 281                 case NL80211_CHAN_WIDTH_20_NOHT:
 282                         if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)
 283                                 phymode = MODE_11B;
 284                         else
 285                                 phymode = MODE_11G;
 286                         break;
 287                 case NL80211_CHAN_WIDTH_20:
 288                         phymode = MODE_11NG_HT20;
 289                         break;
 290                 case NL80211_CHAN_WIDTH_40:
 291                         phymode = MODE_11NG_HT40;
 292                         break;
 293                 case NL80211_CHAN_WIDTH_5:
 294                 case NL80211_CHAN_WIDTH_10:
 295                 case NL80211_CHAN_WIDTH_80:
 296                 case NL80211_CHAN_WIDTH_80P80:
 297                 case NL80211_CHAN_WIDTH_160:
 298                         phymode = MODE_UNKNOWN;
 299                         break;
 300                 }
 301                 break;
 302         case IEEE80211_BAND_5GHZ:
 303                 switch (chandef->width) {
 304                 case NL80211_CHAN_WIDTH_20_NOHT:
 305                         phymode = MODE_11A;
 306                         break;
 307                 case NL80211_CHAN_WIDTH_20:
 308                         phymode = MODE_11NA_HT20;
 309                         break;
 310                 case NL80211_CHAN_WIDTH_40:
 311                         phymode = MODE_11NA_HT40;
 312                         break;
 313                 case NL80211_CHAN_WIDTH_80:
 314                         phymode = MODE_11AC_VHT80;
 315                         break;
 316                 case NL80211_CHAN_WIDTH_5:
 317                 case NL80211_CHAN_WIDTH_10:
 318                 case NL80211_CHAN_WIDTH_80P80:
 319                 case NL80211_CHAN_WIDTH_160:
 320                         phymode = MODE_UNKNOWN;
 321                         break;
 322                 }
 323                 break;
 324         default:
 325                 break;
 326         }
 327
 328         WARN_ON(phymode == MODE_UNKNOWN);
 329         return phymode;
 330 }
 331
 332 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
 333 {
 334 /*
 335  * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
 336  *   0 for no restriction
 337  *   1 for 1/4 us
 338  *   2 for 1/2 us
 339  *   3 for 1 us
 340  *   4 for 2 us
 341  *   5 for 4 us
 342  *   6 for 8 us
 343  *   7 for 16 us
 344  */
 345         switch (mpdudensity) {
 346         case 0:
 347                 return 0;
 348         case 1:
 349         case 2:
 350         case 3:
 351         /* Our lower layer calculations limit our precision to
 352            1 microsecond */
 353                 return 1;
 354         case 4:
 355                 return 2;
 356         case 5:
 357                 return 4;
 358         case 6:
 359                 return 8;
 360         case 7:
 361                 return 16;
 362         default:
 363                 return 0;
 364         }
 365 }
 366
 367 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
 368 {
 369         int ret;
 370
 371         lockdep_assert_held(&ar->conf_mutex);
 372
 373         if (ar->num_peers >= ar->max_num_peers)
 374                 return -ENOBUFS;
 375
 376         ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
 377         if (ret) {
 378                 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
 379                             addr, vdev_id, ret);
 380                 return ret;
 381         }
 382
 383         ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
 384         if (ret) {
 385                 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
 386                             addr, vdev_id, ret);
 387                 return ret;
 388         }
 389
 390         ar->num_peers++;
 391
 392         return 0;
 393 }
 394
 395 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
 396 {
 397         struct ath10k *ar = arvif->ar;
 398         u32 param;
 399         int ret;
 400
 401         param = ar->wmi.pdev_param->sta_kickout_th;
 402         ret = ath10k_wmi_pdev_set_param(ar, param,
 403                                         ATH10K_KICKOUT_THRESHOLD);
 404         if (ret) {
 405                 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
 406                             arvif->vdev_id, ret);
 407                 return ret;
 408         }
 409
 410         param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
 411         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
 412                                         ATH10K_KEEPALIVE_MIN_IDLE);
 413         if (ret) {
 414                 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
 415                             arvif->vdev_id, ret);
 416                 return ret;
 417         }
 418
 419         param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
 420         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
 421                                         ATH10K_KEEPALIVE_MAX_IDLE);
 422         if (ret) {
 423                 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
 424                             arvif->vdev_id, ret);
 425                 return ret;
 426         }
 427
 428         param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
 429         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
 430                                         ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
 431         if (ret) {
 432                 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
 433                             arvif->vdev_id, ret);
 434                 return ret;
 435         }
 436
 437         return 0;
 438 }
 439
 440 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
 441 {
 442         struct ath10k *ar = arvif->ar;
 443         u32 vdev_param;
 444
 445         vdev_param = ar->wmi.vdev_param->rts_threshold;
 446         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
 447 }
 448
 449 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
 450 {
 451         struct ath10k *ar = arvif->ar;
 452         u32 vdev_param;
 453
 454         if (value != 0xFFFFFFFF)
 455                 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
 456                                 ATH10K_FRAGMT_THRESHOLD_MIN,
 457                                 ATH10K_FRAGMT_THRESHOLD_MAX);
 458
 459         vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
 460         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
 461 }
 462
 463 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
 464 {
 465         int ret;
 466
 467         lockdep_assert_held(&ar->conf_mutex);
 468
 469         ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
 470         if (ret)
 471                 return ret;
 472
 473         ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
 474         if (ret)
 475                 return ret;
 476
 477         ar->num_peers--;
 478
 479         return 0;
 480 }
 481
 482 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
 483 {
 484         struct ath10k_peer *peer, *tmp;
 485
 486         lockdep_assert_held(&ar->conf_mutex);
 487
 488         spin_lock_bh(&ar->data_lock);
 489         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
 490                 if (peer->vdev_id != vdev_id)
 491                         continue;
 492
 493                 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
 494                             peer->addr, vdev_id);
 495
 496                 list_del(&peer->list);
 497                 kfree(peer);
 498                 ar->num_peers--;
 499         }
 500         spin_unlock_bh(&ar->data_lock);
 501 }
 502
 503 static void ath10k_peer_cleanup_all(struct ath10k *ar)
 504 {
 505         struct ath10k_peer *peer, *tmp;
 506
 507         lockdep_assert_held(&ar->conf_mutex);
 508
 509         spin_lock_bh(&ar->data_lock);
 510         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
 511                 list_del(&peer->list);
 512                 kfree(peer);
 513         }
 514         spin_unlock_bh(&ar->data_lock);
 515
 516         ar->num_peers = 0;
 517         ar->num_stations = 0;
 518 }
 519
 520 /************************/
 521 /* Interface management */
 522 /************************/
 523
 524 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
 525 {
 526         struct ath10k *ar = arvif->ar;
 527
 528         lockdep_assert_held(&ar->data_lock);
 529
 530         if (!arvif->beacon)
 531                 return;
 532
 533         if (!arvif->beacon_buf)
 534                 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
 535                                  arvif->beacon->len, DMA_TO_DEVICE);
 536
 537         if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED &&
 538                     arvif->beacon_state != ATH10K_BEACON_SENT))
 539                 return;
 540
 541         dev_kfree_skb_any(arvif->beacon);
 542
 543         arvif->beacon = NULL;
 544         arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
 545 }
 546
 547 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
 548 {
 549         struct ath10k *ar = arvif->ar;
 550
 551         lockdep_assert_held(&ar->data_lock);
 552
 553         ath10k_mac_vif_beacon_free(arvif);
 554
 555         if (arvif->beacon_buf) {
 556                 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
 557                                   arvif->beacon_buf, arvif->beacon_paddr);
 558                 arvif->beacon_buf = NULL;
 559         }
 560 }
 561
 562 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
 563 {
 564         int ret;
 565
 566         lockdep_assert_held(&ar->conf_mutex);
 567
 568         if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
 569                 return -ESHUTDOWN;
 570
 571         ret = wait_for_completion_timeout(&ar->vdev_setup_done,
 572                                           ATH10K_VDEV_SETUP_TIMEOUT_HZ);
 573         if (ret == 0)
 574                 return -ETIMEDOUT;
 575
 576         return 0;
 577 }
 578
 579 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
 580 {
 581         struct cfg80211_chan_def *chandef = &ar->chandef;
 582         struct ieee80211_channel *channel = chandef->chan;
 583         struct wmi_vdev_start_request_arg arg = {};
 584         int ret = 0;
 585
 586         lockdep_assert_held(&ar->conf_mutex);
 587
 588         arg.vdev_id = vdev_id;
 589         arg.channel.freq = channel->center_freq;
 590         arg.channel.band_center_freq1 = chandef->center_freq1;
 591
 592         /* TODO setup this dynamically, what in case we
 593            don't have any vifs? */
 594         arg.channel.mode = chan_to_phymode(chandef);
 595         arg.channel.chan_radar =
 596                         !!(channel->flags & IEEE80211_CHAN_RADAR);
 597
 598         arg.channel.min_power = 0;
 599         arg.channel.max_power = channel->max_power * 2;
 600         arg.channel.max_reg_power = channel->max_reg_power * 2;
 601         arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
 602
 603         reinit_completion(&ar->vdev_setup_done);
 604
 605         ret = ath10k_wmi_vdev_start(ar, &arg);
 606         if (ret) {
 607                 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
 608                             vdev_id, ret);
 609                 return ret;
 610         }
 611
 612         ret = ath10k_vdev_setup_sync(ar);
 613         if (ret) {
 614                 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i: %d\n",
 615                             vdev_id, ret);
 616                 return ret;
 617         }
 618
 619         ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
 620         if (ret) {
 621                 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
 622                             vdev_id, ret);
 623                 goto vdev_stop;
 624         }
 625
 626         ar->monitor_vdev_id = vdev_id;
 627
 628         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
 629                    ar->monitor_vdev_id);
 630         return 0;
 631
 632 vdev_stop:
 633         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
 634         if (ret)
 635                 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
 636                             ar->monitor_vdev_id, ret);
 637
 638         return ret;
 639 }
 640
 641 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
 642 {
 643         int ret = 0;
 644
 645         lockdep_assert_held(&ar->conf_mutex);
 646
 647         ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
 648         if (ret)
 649                 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
 650                             ar->monitor_vdev_id, ret);
 651
 652         reinit_completion(&ar->vdev_setup_done);
 653
 654         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
 655         if (ret)
 656                 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
 657                             ar->monitor_vdev_id, ret);
 658
 659         ret = ath10k_vdev_setup_sync(ar);
 660         if (ret)
 661                 ath10k_warn(ar, "failed to synchronise monitor vdev %i: %d\n",
 662                             ar->monitor_vdev_id, ret);
 663
 664         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
 665                    ar->monitor_vdev_id);
 666         return ret;
 667 }
 668
 669 static int ath10k_monitor_vdev_create(struct ath10k *ar)
 670 {
 671         int bit, ret = 0;
 672
 673         lockdep_assert_held(&ar->conf_mutex);
 674
 675         if (ar->free_vdev_map == 0) {
 676                 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
 677                 return -ENOMEM;
 678         }
 679
 680         bit = __ffs64(ar->free_vdev_map);
 681
 682         ar->monitor_vdev_id = bit;
 683
 684         ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
 685                                      WMI_VDEV_TYPE_MONITOR,
 686                                      0, ar->mac_addr);
 687         if (ret) {
 688                 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
 689                             ar->monitor_vdev_id, ret);
 690                 return ret;
 691         }
 692
 693         ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
 694         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
 695                    ar->monitor_vdev_id);
 696
 697         return 0;
 698 }
 699
 700 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
 701 {
 702         int ret = 0;
 703
 704         lockdep_assert_held(&ar->conf_mutex);
 705
 706         ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
 707         if (ret) {
 708                 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
 709                             ar->monitor_vdev_id, ret);
 710                 return ret;
 711         }
 712
 713         ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
 714
 715         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
 716                    ar->monitor_vdev_id);
 717         return ret;
 718 }
 719
 720 static int ath10k_monitor_start(struct ath10k *ar)
 721 {
 722         int ret;
 723
 724         lockdep_assert_held(&ar->conf_mutex);
 725
 726         ret = ath10k_monitor_vdev_create(ar);
 727         if (ret) {
 728                 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
 729                 return ret;
 730         }
 731
 732         ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
 733         if (ret) {
 734                 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
 735                 ath10k_monitor_vdev_delete(ar);
 736                 return ret;
 737         }
 738
 739         ar->monitor_started = true;
 740         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
 741
 742         return 0;
 743 }
 744
 745 static int ath10k_monitor_stop(struct ath10k *ar)
 746 {
 747         int ret;
 748
 749         lockdep_assert_held(&ar->conf_mutex);
 750
 751         ret = ath10k_monitor_vdev_stop(ar);
 752         if (ret) {
 753                 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
 754                 return ret;
 755         }
 756
 757         ret = ath10k_monitor_vdev_delete(ar);
 758         if (ret) {
 759                 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
 760                 return ret;
 761         }
 762
 763         ar->monitor_started = false;
 764         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
 765
 766         return 0;
 767 }
 768
 769 static int ath10k_monitor_recalc(struct ath10k *ar)
 770 {
 771         bool should_start;
 772
 773         lockdep_assert_held(&ar->conf_mutex);
 774
 775         should_start = ar->monitor ||
 776                        ar->filter_flags & FIF_PROMISC_IN_BSS ||
 777                        test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
 778
 779         ath10k_dbg(ar, ATH10K_DBG_MAC,
 780                    "mac monitor recalc started? %d should? %d\n",
 781                    ar->monitor_started, should_start);
 782
 783         if (should_start == ar->monitor_started)
 784                 return 0;
 785
 786         if (should_start)
 787                 return ath10k_monitor_start(ar);
 788
 789         return ath10k_monitor_stop(ar);
 790 }
 791
 792 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
 793 {
 794         struct ath10k *ar = arvif->ar;
 795         u32 vdev_param, rts_cts = 0;
 796
 797         lockdep_assert_held(&ar->conf_mutex);
 798
 799         vdev_param = ar->wmi.vdev_param->enable_rtscts;
 800
 801         if (arvif->use_cts_prot || arvif->num_legacy_stations > 0)
 802                 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
 803
 804         if (arvif->num_legacy_stations > 0)
 805                 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
 806                               WMI_RTSCTS_PROFILE);
 807
 808         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
 809                                          rts_cts);
 810 }
 811
 812 static int ath10k_start_cac(struct ath10k *ar)
 813 {
 814         int ret;
 815
 816         lockdep_assert_held(&ar->conf_mutex);
 817
 818         set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
 819
 820         ret = ath10k_monitor_recalc(ar);
 821         if (ret) {
 822                 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
 823                 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
 824                 return ret;
 825         }
 826
 827         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
 828                    ar->monitor_vdev_id);
 829
 830         return 0;
 831 }
 832
 833 static int ath10k_stop_cac(struct ath10k *ar)
 834 {
 835         lockdep_assert_held(&ar->conf_mutex);
 836
 837         /* CAC is not running - do nothing */
 838         if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
 839                 return 0;
 840
 841         clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
 842         ath10k_monitor_stop(ar);
 843
 844         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
 845
 846         return 0;
 847 }
 848
 849 static void ath10k_recalc_radar_detection(struct ath10k *ar)
 850 {
 851         int ret;
 852
 853         lockdep_assert_held(&ar->conf_mutex);
 854
 855         ath10k_stop_cac(ar);
 856
 857         if (!ar->radar_enabled)
 858                 return;
 859
 860         if (ar->num_started_vdevs > 0)
 861                 return;
 862
 863         ret = ath10k_start_cac(ar);
 864         if (ret) {
 865                 /*
 866                  * Not possible to start CAC on current channel so starting
 867                  * radiation is not allowed, make this channel DFS_UNAVAILABLE
 868                  * by indicating that radar was detected.
 869                  */
 870                 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
 871                 ieee80211_radar_detected(ar->hw);
 872         }
 873 }
 874
 875 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif, bool restart)
 876 {
 877         struct ath10k *ar = arvif->ar;
 878         struct cfg80211_chan_def *chandef = &ar->chandef;
 879         struct wmi_vdev_start_request_arg arg = {};
 880         int ret = 0;
 881
 882         lockdep_assert_held(&ar->conf_mutex);
 883
 884         reinit_completion(&ar->vdev_setup_done);
 885
 886         arg.vdev_id = arvif->vdev_id;
 887         arg.dtim_period = arvif->dtim_period;
 888         arg.bcn_intval = arvif->beacon_interval;
 889
 890         arg.channel.freq = chandef->chan->center_freq;
 891         arg.channel.band_center_freq1 = chandef->center_freq1;
 892         arg.channel.mode = chan_to_phymode(chandef);
 893
 894         arg.channel.min_power = 0;
 895         arg.channel.max_power = chandef->chan->max_power * 2;
 896         arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
 897         arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
 898
 899         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
 900                 arg.ssid = arvif->u.ap.ssid;
 901                 arg.ssid_len = arvif->u.ap.ssid_len;
 902                 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
 903
 904                 /* For now allow DFS for AP mode */
 905                 arg.channel.chan_radar =
 906                         !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
 907         } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
 908                 arg.ssid = arvif->vif->bss_conf.ssid;
 909                 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
 910         }
 911
 912         ath10k_dbg(ar, ATH10K_DBG_MAC,
 913                    "mac vdev %d start center_freq %d phymode %s\n",
 914                    arg.vdev_id, arg.channel.freq,
 915                    ath10k_wmi_phymode_str(arg.channel.mode));
 916
 917         if (restart)
 918                 ret = ath10k_wmi_vdev_restart(ar, &arg);
 919         else
 920                 ret = ath10k_wmi_vdev_start(ar, &arg);
 921
 922         if (ret) {
 923                 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
 924                             arg.vdev_id, ret);
 925                 return ret;
 926         }
 927
 928         ret = ath10k_vdev_setup_sync(ar);
 929         if (ret) {
 930                 ath10k_warn(ar, "failed to synchronise setup for vdev %i: %d\n",
 931                             arg.vdev_id, ret);
 932                 return ret;
 933         }
 934
 935         ar->num_started_vdevs++;
 936         ath10k_recalc_radar_detection(ar);
 937
 938         return ret;
 939 }
 940
 941 static int ath10k_vdev_start(struct ath10k_vif *arvif)
 942 {
 943         return ath10k_vdev_start_restart(arvif, false);
 944 }
 945
 946 static int ath10k_vdev_restart(struct ath10k_vif *arvif)
 947 {
 948         return ath10k_vdev_start_restart(arvif, true);
 949 }
 950
 951 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
 952 {
 953         struct ath10k *ar = arvif->ar;
 954         int ret;
 955
 956         lockdep_assert_held(&ar->conf_mutex);
 957
 958         reinit_completion(&ar->vdev_setup_done);
 959
 960         ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
 961         if (ret) {
 962                 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
 963                             arvif->vdev_id, ret);
 964                 return ret;
 965         }
 966
 967         ret = ath10k_vdev_setup_sync(ar);
 968         if (ret) {
 969                 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n",
 970                             arvif->vdev_id, ret);
 971                 return ret;
 972         }
 973
 974         WARN_ON(ar->num_started_vdevs == 0);
 975
 976         if (ar->num_started_vdevs != 0) {
 977                 ar->num_started_vdevs--;
 978                 ath10k_recalc_radar_detection(ar);
 979         }
 980
 981         return ret;
 982 }
 983
 984 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif,
 985                                        struct sk_buff *bcn)
 986 {
 987         struct ath10k *ar = arvif->ar;
 988         struct ieee80211_mgmt *mgmt;
 989         const u8 *p2p_ie;
 990         int ret;
 991
 992         if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
 993                 return 0;
 994
 995         if (arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
 996                 return 0;
 997
 998         mgmt = (void *)bcn->data;
 999         p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1000                                          mgmt->u.beacon.variable,
1001                                          bcn->len - (mgmt->u.beacon.variable -
1002                                                      bcn->data));
1003         if (!p2p_ie)
1004                 return -ENOENT;
1005
1006         ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie);
1007         if (ret) {
1008                 ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n",
1009                             arvif->vdev_id, ret);
1010                 return ret;
1011         }
1012
1013         return 0;
1014 }
1015
1016 static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui,
1017                                        u8 oui_type, size_t ie_offset)
1018 {
1019         size_t len;
1020         const u8 *next;
1021         const u8 *end;
1022         u8 *ie;
1023
1024         if (WARN_ON(skb->len < ie_offset))
1025                 return -EINVAL;
1026
1027         ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
1028                                            skb->data + ie_offset,
1029                                            skb->len - ie_offset);
1030         if (!ie)
1031                 return -ENOENT;
1032
1033         len = ie[1] + 2;
1034         end = skb->data + skb->len;
1035         next = ie + len;
1036
1037         if (WARN_ON(next > end))
1038                 return -EINVAL;
1039
1040         memmove(ie, next, end - next);
1041         skb_trim(skb, skb->len - len);
1042
1043         return 0;
1044 }
1045
1046 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif)
1047 {
1048         struct ath10k *ar = arvif->ar;
1049         struct ieee80211_hw *hw = ar->hw;
1050         struct ieee80211_vif *vif = arvif->vif;
1051         struct ieee80211_mutable_offsets offs = {};
1052         struct sk_buff *bcn;
1053         int ret;
1054
1055         if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1056                 return 0;
1057
1058         bcn = ieee80211_beacon_get_template(hw, vif, &offs);
1059         if (!bcn) {
1060                 ath10k_warn(ar, "failed to get beacon template from mac80211\n");
1061                 return -EPERM;
1062         }
1063
1064         ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn);
1065         if (ret) {
1066                 ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret);
1067                 kfree_skb(bcn);
1068                 return ret;
1069         }
1070
1071         /* P2P IE is inserted by firmware automatically (as configured above)
1072          * so remove it from the base beacon template to avoid duplicate P2P
1073          * IEs in beacon frames.
1074          */
1075         ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1076                                     offsetof(struct ieee80211_mgmt,
1077                                              u.beacon.variable));
1078
1079         ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0,
1080                                   0, NULL, 0);
1081         kfree_skb(bcn);
1082
1083         if (ret) {
1084                 ath10k_warn(ar, "failed to submit beacon template command: %d\n",
1085                             ret);
1086                 return ret;
1087         }
1088
1089         return 0;
1090 }
1091
1092 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif)
1093 {
1094         struct ath10k *ar = arvif->ar;
1095         struct ieee80211_hw *hw = ar->hw;
1096         struct ieee80211_vif *vif = arvif->vif;
1097         struct sk_buff *prb;
1098         int ret;
1099
1100         if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1101                 return 0;
1102
1103         prb = ieee80211_proberesp_get(hw, vif);
1104         if (!prb) {
1105                 ath10k_warn(ar, "failed to get probe resp template from mac80211\n");
1106                 return -EPERM;
1107         }
1108
1109         ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb);
1110         kfree_skb(prb);
1111
1112         if (ret) {
1113                 ath10k_warn(ar, "failed to submit probe resp template command: %d\n",
1114                             ret);
1115                 return ret;
1116         }
1117
1118         return 0;
1119 }
1120
1121 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
1122                                      struct ieee80211_bss_conf *info)
1123 {
1124         struct ath10k *ar = arvif->ar;
1125         int ret = 0;
1126
1127         lockdep_assert_held(&arvif->ar->conf_mutex);
1128
1129         if (!info->enable_beacon) {
1130                 ath10k_vdev_stop(arvif);
1131
1132                 arvif->is_started = false;
1133                 arvif->is_up = false;
1134
1135                 spin_lock_bh(&arvif->ar->data_lock);
1136                 ath10k_mac_vif_beacon_free(arvif);
1137                 spin_unlock_bh(&arvif->ar->data_lock);
1138
1139                 return;
1140         }
1141
1142         arvif->tx_seq_no = 0x1000;
1143
1144         ret = ath10k_vdev_start(arvif);
1145         if (ret)
1146                 return;
1147
1148         arvif->aid = 0;
1149         ether_addr_copy(arvif->bssid, info->bssid);
1150
1151         ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1152                                  arvif->bssid);
1153         if (ret) {
1154                 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
1155                             arvif->vdev_id, ret);
1156                 ath10k_vdev_stop(arvif);
1157                 return;
1158         }
1159
1160         arvif->is_started = true;
1161         arvif->is_up = true;
1162
1163         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1164 }
1165
1166 static void ath10k_control_ibss(struct ath10k_vif *arvif,
1167                                 struct ieee80211_bss_conf *info,
1168                                 const u8 self_peer[ETH_ALEN])
1169 {
1170         struct ath10k *ar = arvif->ar;
1171         u32 vdev_param;
1172         int ret = 0;
1173
1174         lockdep_assert_held(&arvif->ar->conf_mutex);
1175
1176         if (!info->ibss_joined) {
1177                 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
1178                 if (ret)
1179                         ath10k_warn(ar, "failed to delete IBSS self peer %pM for vdev %d: %d\n",
1180                                     self_peer, arvif->vdev_id, ret);
1181
1182                 if (is_zero_ether_addr(arvif->bssid))
1183                         return;
1184
1185                 memset(arvif->bssid, 0, ETH_ALEN);
1186
1187                 return;
1188         }
1189
1190         ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
1191         if (ret) {
1192                 ath10k_warn(ar, "failed to create IBSS self peer %pM for vdev %d: %d\n",
1193                             self_peer, arvif->vdev_id, ret);
1194                 return;
1195         }
1196
1197         vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1198         ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1199                                         ATH10K_DEFAULT_ATIM);
1200         if (ret)
1201                 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
1202                             arvif->vdev_id, ret);
1203 }
1204
1205 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif)
1206 {
1207         struct ath10k *ar = arvif->ar;
1208         u32 param;
1209         u32 value;
1210         int ret;
1211
1212         lockdep_assert_held(&arvif->ar->conf_mutex);
1213
1214         if (arvif->u.sta.uapsd)
1215                 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER;
1216         else
1217                 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
1218
1219         param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
1220         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value);
1221         if (ret) {
1222                 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n",
1223                             value, arvif->vdev_id, ret);
1224                 return ret;
1225         }
1226
1227         return 0;
1228 }
1229
1230 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif)
1231 {
1232         struct ath10k *ar = arvif->ar;
1233         u32 param;
1234         u32 value;
1235         int ret;
1236
1237         lockdep_assert_held(&arvif->ar->conf_mutex);
1238
1239         if (arvif->u.sta.uapsd)
1240                 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD;
1241         else
1242                 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
1243
1244         param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
1245         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1246                                           param, value);
1247         if (ret) {
1248                 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n",
1249                             value, arvif->vdev_id, ret);
1250                 return ret;
1251         }
1252
1253         return 0;
1254 }
1255
1256 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1257 {
1258         struct ath10k *ar = arvif->ar;
1259         struct ieee80211_vif *vif = arvif->vif;
1260         struct ieee80211_conf *conf = &ar->hw->conf;
1261         enum wmi_sta_powersave_param param;
1262         enum wmi_sta_ps_mode psmode;
1263         int ret;
1264         int ps_timeout;
1265
1266         lockdep_assert_held(&arvif->ar->conf_mutex);
1267
1268         if (arvif->vif->type != NL80211_IFTYPE_STATION)
1269                 return 0;
1270
1271         if (vif->bss_conf.ps) {
1272                 psmode = WMI_STA_PS_MODE_ENABLED;
1273                 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1274
1275                 ps_timeout = conf->dynamic_ps_timeout;
1276                 if (ps_timeout == 0) {
1277                         /* Firmware doesn't like 0 */
1278                         ps_timeout = ieee80211_tu_to_usec(
1279                                 vif->bss_conf.beacon_int) / 1000;
1280                 }
1281
1282                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1283                                                   ps_timeout);
1284                 if (ret) {
1285                         ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1286                                     arvif->vdev_id, ret);
1287                         return ret;
1288                 }
1289         } else {
1290                 psmode = WMI_STA_PS_MODE_DISABLED;
1291         }
1292
1293         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1294                    arvif->vdev_id, psmode ? "enable" : "disable");
1295
1296         ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1297         if (ret) {
1298                 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1299                             psmode, arvif->vdev_id, ret);
1300                 return ret;
1301         }
1302
1303         return 0;
1304 }
1305
1306 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif)
1307 {
1308         struct ath10k *ar = arvif->ar;
1309         struct wmi_sta_keepalive_arg arg = {};
1310         int ret;
1311
1312         lockdep_assert_held(&arvif->ar->conf_mutex);
1313
1314         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
1315                 return 0;
1316
1317         if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map))
1318                 return 0;
1319
1320         /* Some firmware revisions have a bug and ignore the `enabled` field.
1321          * Instead use the interval to disable the keepalive.
1322          */
1323         arg.vdev_id = arvif->vdev_id;
1324         arg.enabled = 1;
1325         arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
1326         arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE;
1327
1328         ret = ath10k_wmi_sta_keepalive(ar, &arg);
1329         if (ret) {
1330                 ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n",
1331                             arvif->vdev_id, ret);
1332                 return ret;
1333         }
1334
1335         return 0;
1336 }
1337
1338 /**********************/
1339 /* Station management */
1340 /**********************/
1341
1342 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
1343                                              struct ieee80211_vif *vif)
1344 {
1345         /* Some firmware revisions have unstable STA powersave when listen
1346          * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1347          * generate NullFunc frames properly even if buffered frames have been
1348          * indicated in Beacon TIM. Firmware would seldom wake up to pull
1349          * buffered frames. Often pinging the device from AP would simply fail.
1350          *
1351          * As a workaround set it to 1.
1352          */
1353         if (vif->type == NL80211_IFTYPE_STATION)
1354                 return 1;
1355
1356         return ar->hw->conf.listen_interval;
1357 }
1358
1359 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1360                                       struct ieee80211_vif *vif,
1361                                       struct ieee80211_sta *sta,
1362                                       struct wmi_peer_assoc_complete_arg *arg)
1363 {
1364         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1365
1366         lockdep_assert_held(&ar->conf_mutex);
1367
1368         ether_addr_copy(arg->addr, sta->addr);
1369         arg->vdev_id = arvif->vdev_id;
1370         arg->peer_aid = sta->aid;
1371         arg->peer_flags |= WMI_PEER_AUTH;
1372         arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
1373         arg->peer_num_spatial_streams = 1;
1374         arg->peer_caps = vif->bss_conf.assoc_capability;
1375 }
1376
1377 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1378                                        struct ieee80211_vif *vif,
1379                                        struct wmi_peer_assoc_complete_arg *arg)
1380 {
1381         struct ieee80211_bss_conf *info = &vif->bss_conf;
1382         struct cfg80211_bss *bss;
1383         const u8 *rsnie = NULL;
1384         const u8 *wpaie = NULL;
1385
1386         lockdep_assert_held(&ar->conf_mutex);
1387
1388         bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
1389                                info->bssid, NULL, 0, 0, 0);
1390         if (bss) {
1391                 const struct cfg80211_bss_ies *ies;
1392
1393                 rcu_read_lock();
1394                 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1395
1396                 ies = rcu_dereference(bss->ies);
1397
1398                 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1399                                                 WLAN_OUI_TYPE_MICROSOFT_WPA,
1400                                                 ies->data,
1401                                                 ies->len);
1402                 rcu_read_unlock();
1403                 cfg80211_put_bss(ar->hw->wiphy, bss);
1404         }
1405
1406         /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1407         if (rsnie || wpaie) {
1408                 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
1409                 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1410         }
1411
1412         if (wpaie) {
1413                 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
1414                 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1415         }
1416 }
1417
1418 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
1419                                       struct ieee80211_sta *sta,
1420                                       struct wmi_peer_assoc_complete_arg *arg)
1421 {
1422         struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1423         const struct ieee80211_supported_band *sband;
1424         const struct ieee80211_rate *rates;
1425         u32 ratemask;
1426         int i;
1427
1428         lockdep_assert_held(&ar->conf_mutex);
1429
1430         sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
1431         ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
1432         rates = sband->bitrates;
1433
1434         rateset->num_rates = 0;
1435
1436         for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1437                 if (!(ratemask & 1))
1438                         continue;
1439
1440                 rateset->rates[rateset->num_rates] = rates->hw_value;
1441                 rateset->num_rates++;
1442         }
1443 }
1444
1445 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1446                                    struct ieee80211_sta *sta,
1447                                    struct wmi_peer_assoc_complete_arg *arg)
1448 {
1449         const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1450         int i, n;
1451         u32 stbc;
1452
1453         lockdep_assert_held(&ar->conf_mutex);
1454
1455         if (!ht_cap->ht_supported)
1456                 return;
1457
1458         arg->peer_flags |= WMI_PEER_HT;
1459         arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1460                                     ht_cap->ampdu_factor)) - 1;
1461
1462         arg->peer_mpdu_density =
1463                 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1464
1465         arg->peer_ht_caps = ht_cap->cap;
1466         arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1467
1468         if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1469                 arg->peer_flags |= WMI_PEER_LDPC;
1470
1471         if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1472                 arg->peer_flags |= WMI_PEER_40MHZ;
1473                 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1474         }
1475
1476         if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1477                 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1478
1479         if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1480                 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1481
1482         if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1483                 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1484                 arg->peer_flags |= WMI_PEER_STBC;
1485         }
1486
1487         if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1488                 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1489                 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1490                 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1491                 arg->peer_rate_caps |= stbc;
1492                 arg->peer_flags |= WMI_PEER_STBC;
1493         }
1494
1495         if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1496                 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1497         else if (ht_cap->mcs.rx_mask[1])
1498                 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1499
1500         for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1501                 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1502                         arg->peer_ht_rates.rates[n++] = i;
1503
1504         /*
1505          * This is a workaround for HT-enabled STAs which break the spec
1506          * and have no HT capabilities RX mask (no HT RX MCS map).
1507          *
1508          * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1509          * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1510          *
1511          * Firmware asserts if such situation occurs.
1512          */
1513         if (n == 0) {
1514                 arg->peer_ht_rates.num_rates = 8;
1515                 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1516                         arg->peer_ht_rates.rates[i] = i;
1517         } else {
1518                 arg->peer_ht_rates.num_rates = n;
1519                 arg->peer_num_spatial_streams = sta->rx_nss;
1520         }
1521
1522         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1523                    arg->addr,
1524                    arg->peer_ht_rates.num_rates,
1525                    arg->peer_num_spatial_streams);
1526 }
1527
1528 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
1529                                     struct ath10k_vif *arvif,
1530                                     struct ieee80211_sta *sta)
1531 {
1532         u32 uapsd = 0;
1533         u32 max_sp = 0;
1534         int ret = 0;
1535
1536         lockdep_assert_held(&ar->conf_mutex);
1537
1538         if (sta->wme && sta->uapsd_queues) {
1539                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
1540                            sta->uapsd_queues, sta->max_sp);
1541
1542                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1543                         uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1544                                  WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1545                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1546                         uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1547                                  WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1548                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1549                         uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1550                                  WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1551                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1552                         uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1553                                  WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1554
1555                 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1556                         max_sp = sta->max_sp;
1557
1558                 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1559                                                  sta->addr,
1560                                                  WMI_AP_PS_PEER_PARAM_UAPSD,
1561                                                  uapsd);
1562                 if (ret) {
1563                         ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
1564                                     arvif->vdev_id, ret);
1565                         return ret;
1566                 }
1567
1568                 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1569                                                  sta->addr,
1570                                                  WMI_AP_PS_PEER_PARAM_MAX_SP,
1571                                                  max_sp);
1572                 if (ret) {
1573                         ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
1574                                     arvif->vdev_id, ret);
1575                         return ret;
1576                 }
1577
1578                 /* TODO setup this based on STA listen interval and
1579                    beacon interval. Currently we don't know
1580                    sta->listen_interval - mac80211 patch required.
1581                    Currently use 10 seconds */
1582                 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
1583                                                  WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1584                                                  10);
1585                 if (ret) {
1586                         ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
1587                                     arvif->vdev_id, ret);
1588                         return ret;
1589                 }
1590         }
1591
1592         return 0;
1593 }
1594
1595 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1596                                     struct ieee80211_sta *sta,
1597                                     struct wmi_peer_assoc_complete_arg *arg)
1598 {
1599         const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1600         u8 ampdu_factor;
1601
1602         if (!vht_cap->vht_supported)
1603                 return;
1604
1605         arg->peer_flags |= WMI_PEER_VHT;
1606
1607         if (ar->hw->conf.chandef.chan->band == IEEE80211_BAND_2GHZ)
1608                 arg->peer_flags |= WMI_PEER_VHT_2G;
1609
1610         arg->peer_vht_caps = vht_cap->cap;
1611
1612         ampdu_factor = (vht_cap->cap &
1613                         IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1614                        IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1615
1616         /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1617          * zero in VHT IE. Using it would result in degraded throughput.
1618          * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1619          * it if VHT max_mpdu is smaller. */
1620         arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1621                                  (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1622                                         ampdu_factor)) - 1);
1623
1624         if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1625                 arg->peer_flags |= WMI_PEER_80MHZ;
1626
1627         arg->peer_vht_rates.rx_max_rate =
1628                 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1629         arg->peer_vht_rates.rx_mcs_set =
1630                 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1631         arg->peer_vht_rates.tx_max_rate =
1632                 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1633         arg->peer_vht_rates.tx_mcs_set =
1634                 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1635
1636         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1637                    sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1638 }
1639
1640 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1641                                     struct ieee80211_vif *vif,
1642                                     struct ieee80211_sta *sta,
1643                                     struct wmi_peer_assoc_complete_arg *arg)
1644 {
1645         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1646
1647         switch (arvif->vdev_type) {
1648         case WMI_VDEV_TYPE_AP:
1649                 if (sta->wme)
1650                         arg->peer_flags |= WMI_PEER_QOS;
1651
1652                 if (sta->wme && sta->uapsd_queues) {
1653                         arg->peer_flags |= WMI_PEER_APSD;
1654                         arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1655                 }
1656                 break;
1657         case WMI_VDEV_TYPE_STA:
1658                 if (vif->bss_conf.qos)
1659                         arg->peer_flags |= WMI_PEER_QOS;
1660                 break;
1661         case WMI_VDEV_TYPE_IBSS:
1662                 if (sta->wme)
1663                         arg->peer_flags |= WMI_PEER_QOS;
1664                 break;
1665         default:
1666                 break;
1667         }
1668
1669         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n",
1670                    sta->addr, !!(arg->peer_flags & WMI_PEER_QOS));
1671 }
1672
1673 static bool ath10k_mac_sta_has_11g_rates(struct ieee80211_sta *sta)
1674 {
1675         /* First 4 rates in ath10k_rates are CCK (11b) rates. */
1676         return sta->supp_rates[IEEE80211_BAND_2GHZ] >> 4;
1677 }
1678
1679 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1680                                         struct ieee80211_vif *vif,
1681                                         struct ieee80211_sta *sta,
1682                                         struct wmi_peer_assoc_complete_arg *arg)
1683 {
1684         enum wmi_phy_mode phymode = MODE_UNKNOWN;
1685
1686         switch (ar->hw->conf.chandef.chan->band) {
1687         case IEEE80211_BAND_2GHZ:
1688                 if (sta->vht_cap.vht_supported) {
1689                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1690                                 phymode = MODE_11AC_VHT40;
1691                         else
1692                                 phymode = MODE_11AC_VHT20;
1693                 } else if (sta->ht_cap.ht_supported) {
1694                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1695                                 phymode = MODE_11NG_HT40;
1696                         else
1697                                 phymode = MODE_11NG_HT20;
1698                 } else if (ath10k_mac_sta_has_11g_rates(sta)) {
1699                         phymode = MODE_11G;
1700                 } else {
1701                         phymode = MODE_11B;
1702                 }
1703
1704                 break;
1705         case IEEE80211_BAND_5GHZ:
1706                 /*
1707                  * Check VHT first.
1708                  */
1709                 if (sta->vht_cap.vht_supported) {
1710                         if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1711                                 phymode = MODE_11AC_VHT80;
1712                         else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1713                                 phymode = MODE_11AC_VHT40;
1714                         else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1715                                 phymode = MODE_11AC_VHT20;
1716                 } else if (sta->ht_cap.ht_supported) {
1717                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1718                                 phymode = MODE_11NA_HT40;
1719                         else
1720                                 phymode = MODE_11NA_HT20;
1721                 } else {
1722                         phymode = MODE_11A;
1723                 }
1724
1725                 break;
1726         default:
1727                 break;
1728         }
1729
1730         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1731                    sta->addr, ath10k_wmi_phymode_str(phymode));
1732
1733         arg->peer_phymode = phymode;
1734         WARN_ON(phymode == MODE_UNKNOWN);
1735 }
1736
1737 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1738                                      struct ieee80211_vif *vif,
1739                                      struct ieee80211_sta *sta,
1740                                      struct wmi_peer_assoc_complete_arg *arg)
1741 {
1742         lockdep_assert_held(&ar->conf_mutex);
1743
1744         memset(arg, 0, sizeof(*arg));
1745
1746         ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
1747         ath10k_peer_assoc_h_crypto(ar, vif, arg);
1748         ath10k_peer_assoc_h_rates(ar, sta, arg);
1749         ath10k_peer_assoc_h_ht(ar, sta, arg);
1750         ath10k_peer_assoc_h_vht(ar, sta, arg);
1751         ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
1752         ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
1753
1754         return 0;
1755 }
1756
1757 static const u32 ath10k_smps_map[] = {
1758         [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
1759         [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
1760         [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
1761         [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
1762 };
1763
1764 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
1765                                   const u8 *addr,
1766                                   const struct ieee80211_sta_ht_cap *ht_cap)
1767 {
1768         int smps;
1769
1770         if (!ht_cap->ht_supported)
1771                 return 0;
1772
1773         smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1774         smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1775
1776         if (smps >= ARRAY_SIZE(ath10k_smps_map))
1777                 return -EINVAL;
1778
1779         return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
1780                                          WMI_PEER_SMPS_STATE,
1781                                          ath10k_smps_map[smps]);
1782 }
1783
1784 /* can be called only in mac80211 callbacks due to `key_count` usage */
1785 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1786                              struct ieee80211_vif *vif,
1787                              struct ieee80211_bss_conf *bss_conf)
1788 {
1789         struct ath10k *ar = hw->priv;
1790         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1791         struct ieee80211_sta_ht_cap ht_cap;
1792         struct wmi_peer_assoc_complete_arg peer_arg;
1793         struct ieee80211_sta *ap_sta;
1794         int ret;
1795
1796         lockdep_assert_held(&ar->conf_mutex);
1797
1798         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
1799                    arvif->vdev_id, arvif->bssid, arvif->aid);
1800
1801         rcu_read_lock();
1802
1803         ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1804         if (!ap_sta) {
1805                 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
1806                             bss_conf->bssid, arvif->vdev_id);
1807                 rcu_read_unlock();
1808                 return;
1809         }
1810
1811         /* ap_sta must be accessed only within rcu section which must be left
1812          * before calling ath10k_setup_peer_smps() which might sleep. */
1813         ht_cap = ap_sta->ht_cap;
1814
1815         ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
1816         if (ret) {
1817                 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
1818                             bss_conf->bssid, arvif->vdev_id, ret);
1819                 rcu_read_unlock();
1820                 return;
1821         }
1822
1823         rcu_read_unlock();
1824
1825         ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1826         if (ret) {
1827                 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
1828                             bss_conf->bssid, arvif->vdev_id, ret);
1829                 return;
1830         }
1831
1832         ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
1833         if (ret) {
1834                 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
1835                             arvif->vdev_id, ret);
1836                 return;
1837         }
1838
1839         ath10k_dbg(ar, ATH10K_DBG_MAC,
1840                    "mac vdev %d up (associated) bssid %pM aid %d\n",
1841                    arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1842
1843         WARN_ON(arvif->is_up);
1844
1845         arvif->aid = bss_conf->aid;
1846         ether_addr_copy(arvif->bssid, bss_conf->bssid);
1847
1848         ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
1849         if (ret) {
1850                 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
1851                             arvif->vdev_id, ret);
1852                 return;
1853         }
1854
1855         arvif->is_up = true;
1856 }
1857
1858 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1859                                 struct ieee80211_vif *vif)
1860 {
1861         struct ath10k *ar = hw->priv;
1862         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1863         int ret;
1864
1865         lockdep_assert_held(&ar->conf_mutex);
1866
1867         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
1868                    arvif->vdev_id, arvif->bssid);
1869
1870         ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1871         if (ret)
1872                 ath10k_warn(ar, "faield to down vdev %i: %d\n",
1873                             arvif->vdev_id, ret);
1874
1875         arvif->def_wep_key_idx = -1;
1876
1877         arvif->is_up = false;
1878 }
1879
1880 static int ath10k_station_assoc(struct ath10k *ar,
1881                                 struct ieee80211_vif *vif,
1882                                 struct ieee80211_sta *sta,
1883                                 bool reassoc)
1884 {
1885         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1886         struct wmi_peer_assoc_complete_arg peer_arg;
1887         int ret = 0;
1888
1889         lockdep_assert_held(&ar->conf_mutex);
1890
1891         ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
1892         if (ret) {
1893                 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
1894                             sta->addr, arvif->vdev_id, ret);
1895                 return ret;
1896         }
1897
1898         peer_arg.peer_reassoc = reassoc;
1899         ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1900         if (ret) {
1901                 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
1902                             sta->addr, arvif->vdev_id, ret);
1903                 return ret;
1904         }
1905
1906         /* Re-assoc is run only to update supported rates for given station. It
1907          * doesn't make much sense to reconfigure the peer completely.
1908          */
1909         if (!reassoc) {
1910                 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
1911                                              &sta->ht_cap);
1912                 if (ret) {
1913                         ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
1914                                     arvif->vdev_id, ret);
1915                         return ret;
1916                 }
1917
1918                 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
1919                 if (ret) {
1920                         ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
1921                                     sta->addr, arvif->vdev_id, ret);
1922                         return ret;
1923                 }
1924
1925                 if (!sta->wme) {
1926                         arvif->num_legacy_stations++;
1927                         ret  = ath10k_recalc_rtscts_prot(arvif);
1928                         if (ret) {
1929                                 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1930                                             arvif->vdev_id, ret);
1931                                 return ret;
1932                         }
1933                 }
1934
1935                 /* Plumb cached keys only for static WEP */
1936                 if (arvif->def_wep_key_idx != -1) {
1937                         ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1938                         if (ret) {
1939                                 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
1940                                             arvif->vdev_id, ret);
1941                                 return ret;
1942                         }
1943                 }
1944         }
1945
1946         return ret;
1947 }
1948
1949 static int ath10k_station_disassoc(struct ath10k *ar,
1950                                    struct ieee80211_vif *vif,
1951                                    struct ieee80211_sta *sta)
1952 {
1953         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1954         int ret = 0;
1955
1956         lockdep_assert_held(&ar->conf_mutex);
1957
1958         if (!sta->wme) {
1959                 arvif->num_legacy_stations--;
1960                 ret = ath10k_recalc_rtscts_prot(arvif);
1961                 if (ret) {
1962                         ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1963                                     arvif->vdev_id, ret);
1964                         return ret;
1965                 }
1966         }
1967
1968         ret = ath10k_clear_peer_keys(arvif, sta->addr);
1969         if (ret) {
1970                 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
1971                             arvif->vdev_id, ret);
1972                 return ret;
1973         }
1974
1975         return ret;
1976 }
1977
1978 /**************/
1979 /* Regulatory */
1980 /**************/
1981
1982 static int ath10k_update_channel_list(struct ath10k *ar)
1983 {
1984         struct ieee80211_hw *hw = ar->hw;
1985         struct ieee80211_supported_band **bands;
1986         enum ieee80211_band band;
1987         struct ieee80211_channel *channel;
1988         struct wmi_scan_chan_list_arg arg = {0};
1989         struct wmi_channel_arg *ch;
1990         bool passive;
1991         int len;
1992         int ret;
1993         int i;
1994
1995         lockdep_assert_held(&ar->conf_mutex);
1996
1997         bands = hw->wiphy->bands;
1998         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1999                 if (!bands[band])
2000                         continue;
2001
2002                 for (i = 0; i < bands[band]->n_channels; i++) {
2003                         if (bands[band]->channels[i].flags &
2004                             IEEE80211_CHAN_DISABLED)
2005                                 continue;
2006
2007                         arg.n_channels++;
2008                 }
2009         }
2010
2011         len = sizeof(struct wmi_channel_arg) * arg.n_channels;
2012         arg.channels = kzalloc(len, GFP_KERNEL);
2013         if (!arg.channels)
2014                 return -ENOMEM;
2015
2016         ch = arg.channels;
2017         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2018                 if (!bands[band])
2019                         continue;
2020
2021                 for (i = 0; i < bands[band]->n_channels; i++) {
2022                         channel = &bands[band]->channels[i];
2023
2024                         if (channel->flags & IEEE80211_CHAN_DISABLED)
2025                                 continue;
2026
2027                         ch->allow_ht   = true;
2028
2029                         /* FIXME: when should we really allow VHT? */
2030                         ch->allow_vht = true;
2031
2032                         ch->allow_ibss =
2033                                 !(channel->flags & IEEE80211_CHAN_NO_IR);
2034
2035                         ch->ht40plus =
2036                                 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
2037
2038                         ch->chan_radar =
2039                                 !!(channel->flags & IEEE80211_CHAN_RADAR);
2040
2041                         passive = channel->flags & IEEE80211_CHAN_NO_IR;
2042                         ch->passive = passive;
2043
2044                         ch->freq = channel->center_freq;
2045                         ch->band_center_freq1 = channel->center_freq;
2046                         ch->min_power = 0;
2047                         ch->max_power = channel->max_power * 2;
2048                         ch->max_reg_power = channel->max_reg_power * 2;
2049                         ch->max_antenna_gain = channel->max_antenna_gain * 2;
2050                         ch->reg_class_id = 0; /* FIXME */
2051
2052                         /* FIXME: why use only legacy modes, why not any
2053                          * HT/VHT modes? Would that even make any
2054                          * difference? */
2055                         if (channel->band == IEEE80211_BAND_2GHZ)
2056                                 ch->mode = MODE_11G;
2057                         else
2058                                 ch->mode = MODE_11A;
2059
2060                         if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
2061                                 continue;
2062
2063                         ath10k_dbg(ar, ATH10K_DBG_WMI,
2064                                    "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
2065                                     ch - arg.channels, arg.n_channels,
2066                                    ch->freq, ch->max_power, ch->max_reg_power,
2067                                    ch->max_antenna_gain, ch->mode);
2068
2069                         ch++;
2070                 }
2071         }
2072
2073         ret = ath10k_wmi_scan_chan_list(ar, &arg);
2074         kfree(arg.channels);
2075
2076         return ret;
2077 }
2078
2079 static enum wmi_dfs_region
2080 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
2081 {
2082         switch (dfs_region) {
2083         case NL80211_DFS_UNSET:
2084                 return WMI_UNINIT_DFS_DOMAIN;
2085         case NL80211_DFS_FCC:
2086                 return WMI_FCC_DFS_DOMAIN;
2087         case NL80211_DFS_ETSI:
2088                 return WMI_ETSI_DFS_DOMAIN;
2089         case NL80211_DFS_JP:
2090                 return WMI_MKK4_DFS_DOMAIN;
2091         }
2092         return WMI_UNINIT_DFS_DOMAIN;
2093 }
2094
2095 static void ath10k_regd_update(struct ath10k *ar)
2096 {
2097         struct reg_dmn_pair_mapping *regpair;
2098         int ret;
2099         enum wmi_dfs_region wmi_dfs_reg;
2100         enum nl80211_dfs_regions nl_dfs_reg;
2101
2102         lockdep_assert_held(&ar->conf_mutex);
2103
2104         ret = ath10k_update_channel_list(ar);
2105         if (ret)
2106                 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
2107
2108         regpair = ar->ath_common.regulatory.regpair;
2109
2110         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2111                 nl_dfs_reg = ar->dfs_detector->region;
2112                 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
2113         } else {
2114                 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
2115         }
2116
2117         /* Target allows setting up per-band regdomain but ath_common provides
2118          * a combined one only */
2119         ret = ath10k_wmi_pdev_set_regdomain(ar,
2120                                             regpair->reg_domain,
2121                                             regpair->reg_domain, /* 2ghz */
2122                                             regpair->reg_domain, /* 5ghz */
2123                                             regpair->reg_2ghz_ctl,
2124                                             regpair->reg_5ghz_ctl,
2125                                             wmi_dfs_reg);
2126         if (ret)
2127                 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
2128 }
2129
2130 static void ath10k_reg_notifier(struct wiphy *wiphy,
2131                                 struct regulatory_request *request)
2132 {
2133         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
2134         struct ath10k *ar = hw->priv;
2135         bool result;
2136
2137         ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
2138
2139         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2140                 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
2141                            request->dfs_region);
2142                 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
2143                                                           request->dfs_region);
2144                 if (!result)
2145                         ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
2146                                     request->dfs_region);
2147         }
2148
2149         mutex_lock(&ar->conf_mutex);
2150         if (ar->state == ATH10K_STATE_ON)
2151                 ath10k_regd_update(ar);
2152         mutex_unlock(&ar->conf_mutex);
2153 }
2154
2155 /***************/
2156 /* TX handlers */
2157 /***************/
2158
2159 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
2160 {
2161         if (ieee80211_is_mgmt(hdr->frame_control))
2162                 return HTT_DATA_TX_EXT_TID_MGMT;
2163
2164         if (!ieee80211_is_data_qos(hdr->frame_control))
2165                 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
2166
2167         if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
2168                 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
2169
2170         return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
2171 }
2172
2173 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar, struct ieee80211_vif *vif)
2174 {
2175         if (vif)
2176                 return ath10k_vif_to_arvif(vif)->vdev_id;
2177
2178         if (ar->monitor_started)
2179                 return ar->monitor_vdev_id;
2180
2181         ath10k_warn(ar, "failed to resolve vdev id\n");
2182         return 0;
2183 }
2184
2185 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
2186  * Control in the header.
2187  */
2188 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
2189 {
2190         struct ieee80211_hdr *hdr = (void *)skb->data;
2191         struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
2192         u8 *qos_ctl;
2193
2194         if (!ieee80211_is_data_qos(hdr->frame_control))
2195                 return;
2196
2197         qos_ctl = ieee80211_get_qos_ctl(hdr);
2198         memmove(skb->data + IEEE80211_QOS_CTL_LEN,
2199                 skb->data, (void *)qos_ctl - (void *)skb->data);
2200         skb_pull(skb, IEEE80211_QOS_CTL_LEN);
2201
2202         /* Fw/Hw generates a corrupted QoS Control Field for QoS NullFunc
2203          * frames. Powersave is handled by the fw/hw so QoS NyllFunc frames are
2204          * used only for CQM purposes (e.g. hostapd station keepalive ping) so
2205          * it is safe to downgrade to NullFunc.
2206          */
2207         hdr = (void *)skb->data;
2208         if (ieee80211_is_qos_nullfunc(hdr->frame_control)) {
2209                 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
2210                 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
2211         }
2212 }
2213
2214 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
2215                                        struct ieee80211_vif *vif,
2216                                        struct sk_buff *skb)
2217 {
2218         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2219         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2220
2221         /* This is case only for P2P_GO */
2222         if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
2223             arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
2224                 return;
2225
2226         if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
2227                 spin_lock_bh(&ar->data_lock);
2228                 if (arvif->u.ap.noa_data)
2229                         if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
2230                                               GFP_ATOMIC))
2231                                 memcpy(skb_put(skb, arvif->u.ap.noa_len),
2232                                        arvif->u.ap.noa_data,
2233                                        arvif->u.ap.noa_len);
2234                 spin_unlock_bh(&ar->data_lock);
2235         }
2236 }
2237
2238 static bool ath10k_mac_need_offchan_tx_work(struct ath10k *ar)
2239 {
2240         /* FIXME: Not really sure since when the behaviour changed. At some
2241          * point new firmware stopped requiring creation of peer entries for
2242          * offchannel tx (and actually creating them causes issues with wmi-htc
2243          * tx credit replenishment and reliability). Assuming it's at least 3.4
2244          * because that's when the `freq` was introduced to TX_FRM HTT command.
2245          */
2246         return !(ar->htt.target_version_major >= 3 &&
2247                  ar->htt.target_version_minor >= 4);
2248 }
2249
2250 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
2251 {
2252         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2253         int ret = 0;
2254
2255         if (ar->htt.target_version_major >= 3) {
2256                 /* Since HTT 3.0 there is no separate mgmt tx command */
2257                 ret = ath10k_htt_tx(&ar->htt, skb);
2258                 goto exit;
2259         }
2260
2261         if (ieee80211_is_mgmt(hdr->frame_control)) {
2262                 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2263                              ar->fw_features)) {
2264                         if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
2265                             ATH10K_MAX_NUM_MGMT_PENDING) {
2266                                 ath10k_warn(ar, "reached WMI management transmit queue limit\n");
2267                                 ret = -EBUSY;
2268                                 goto exit;
2269                         }
2270
2271                         skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
2272                         ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
2273                 } else {
2274                         ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2275                 }
2276         } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2277                              ar->fw_features) &&
2278                    ieee80211_is_nullfunc(hdr->frame_control)) {
2279                 /* FW does not report tx status properly for NullFunc frames
2280                  * unless they are sent through mgmt tx path. mac80211 sends
2281                  * those frames when it detects link/beacon loss and depends
2282                  * on the tx status to be correct. */
2283                 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2284         } else {
2285                 ret = ath10k_htt_tx(&ar->htt, skb);
2286         }
2287
2288 exit:
2289         if (ret) {
2290                 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
2291                             ret);
2292                 ieee80211_free_txskb(ar->hw, skb);
2293         }
2294 }
2295
2296 void ath10k_offchan_tx_purge(struct ath10k *ar)
2297 {
2298         struct sk_buff *skb;
2299
2300         for (;;) {
2301                 skb = skb_dequeue(&ar->offchan_tx_queue);
2302                 if (!skb)
2303                         break;
2304
2305                 ieee80211_free_txskb(ar->hw, skb);
2306         }
2307 }
2308
2309 void ath10k_offchan_tx_work(struct work_struct *work)
2310 {
2311         struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
2312         struct ath10k_peer *peer;
2313         struct ieee80211_hdr *hdr;
2314         struct sk_buff *skb;
2315         const u8 *peer_addr;
2316         int vdev_id;
2317         int ret;
2318
2319         /* FW requirement: We must create a peer before FW will send out
2320          * an offchannel frame. Otherwise the frame will be stuck and
2321          * never transmitted. We delete the peer upon tx completion.
2322          * It is unlikely that a peer for offchannel tx will already be
2323          * present. However it may be in some rare cases so account for that.
2324          * Otherwise we might remove a legitimate peer and break stuff. */
2325
2326         for (;;) {
2327                 skb = skb_dequeue(&ar->offchan_tx_queue);
2328                 if (!skb)
2329                         break;
2330
2331                 mutex_lock(&ar->conf_mutex);
2332
2333                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n",
2334                            skb);
2335
2336                 hdr = (struct ieee80211_hdr *)skb->data;
2337                 peer_addr = ieee80211_get_DA(hdr);
2338                 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
2339
2340                 spin_lock_bh(&ar->data_lock);
2341                 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
2342                 spin_unlock_bh(&ar->data_lock);
2343
2344                 if (peer)
2345                         /* FIXME: should this use ath10k_warn()? */
2346                         ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
2347                                    peer_addr, vdev_id);
2348
2349                 if (!peer) {
2350                         ret = ath10k_peer_create(ar, vdev_id, peer_addr);
2351                         if (ret)
2352                                 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
2353                                             peer_addr, vdev_id, ret);
2354                 }
2355
2356                 spin_lock_bh(&ar->data_lock);
2357                 reinit_completion(&ar->offchan_tx_completed);
2358                 ar->offchan_tx_skb = skb;
2359                 spin_unlock_bh(&ar->data_lock);
2360
2361                 ath10k_tx_htt(ar, skb);
2362
2363                 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
2364                                                   3 * HZ);
2365                 if (ret == 0)
2366                         ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
2367                                     skb);
2368
2369                 if (!peer) {
2370                         ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
2371                         if (ret)
2372                                 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
2373                                             peer_addr, vdev_id, ret);
2374                 }
2375
2376                 mutex_unlock(&ar->conf_mutex);
2377         }
2378 }
2379
2380 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
2381 {
2382         struct sk_buff *skb;
2383
2384         for (;;) {
2385                 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2386                 if (!skb)
2387                         break;
2388
2389                 ieee80211_free_txskb(ar->hw, skb);
2390         }
2391 }
2392
2393 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
2394 {
2395         struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
2396         struct sk_buff *skb;
2397         int ret;
2398
2399         for (;;) {
2400                 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2401                 if (!skb)
2402                         break;
2403
2404                 ret = ath10k_wmi_mgmt_tx(ar, skb);
2405                 if (ret) {
2406                         ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
2407                                     ret);
2408                         ieee80211_free_txskb(ar->hw, skb);
2409                 }
2410         }
2411 }
2412
2413 /************/
2414 /* Scanning */
2415 /************/
2416
2417 void __ath10k_scan_finish(struct ath10k *ar)
2418 {
2419         lockdep_assert_held(&ar->data_lock);
2420
2421         switch (ar->scan.state) {
2422         case ATH10K_SCAN_IDLE:
2423                 break;
2424         case ATH10K_SCAN_RUNNING:
2425                 if (ar->scan.is_roc)
2426                         ieee80211_remain_on_channel_expired(ar->hw);
2427                 /* fall through */
2428         case ATH10K_SCAN_ABORTING:
2429                 if (!ar->scan.is_roc)
2430                         ieee80211_scan_completed(ar->hw,
2431                                                  (ar->scan.state ==
2432                                                   ATH10K_SCAN_ABORTING));
2433                 /* fall through */
2434         case ATH10K_SCAN_STARTING:
2435                 ar->scan.state = ATH10K_SCAN_IDLE;
2436                 ar->scan_channel = NULL;
2437                 ath10k_offchan_tx_purge(ar);
2438                 cancel_delayed_work(&ar->scan.timeout);
2439                 complete_all(&ar->scan.completed);
2440                 break;
2441         }
2442 }
2443
2444 void ath10k_scan_finish(struct ath10k *ar)
2445 {
2446         spin_lock_bh(&ar->data_lock);
2447         __ath10k_scan_finish(ar);
2448         spin_unlock_bh(&ar->data_lock);
2449 }
2450
2451 static int ath10k_scan_stop(struct ath10k *ar)
2452 {
2453         struct wmi_stop_scan_arg arg = {
2454                 .req_id = 1, /* FIXME */
2455                 .req_type = WMI_SCAN_STOP_ONE,
2456                 .u.scan_id = ATH10K_SCAN_ID,
2457         };
2458         int ret;
2459
2460         lockdep_assert_held(&ar->conf_mutex);
2461
2462         ret = ath10k_wmi_stop_scan(ar, &arg);
2463         if (ret) {
2464                 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
2465                 goto out;
2466         }
2467
2468         ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
2469         if (ret == 0) {
2470                 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
2471                 ret = -ETIMEDOUT;
2472         } else if (ret > 0) {
2473                 ret = 0;
2474         }
2475
2476 out:
2477         /* Scan state should be updated upon scan completion but in case
2478          * firmware fails to deliver the event (for whatever reason) it is
2479          * desired to clean up scan state anyway. Firmware may have just
2480          * dropped the scan completion event delivery due to transport pipe
2481          * being overflown with data and/or it can recover on its own before
2482          * next scan request is submitted.
2483          */
2484         spin_lock_bh(&ar->data_lock);
2485         if (ar->scan.state != ATH10K_SCAN_IDLE)
2486                 __ath10k_scan_finish(ar);
2487         spin_unlock_bh(&ar->data_lock);
2488
2489         return ret;
2490 }
2491
2492 static void ath10k_scan_abort(struct ath10k *ar)
2493 {
2494         int ret;
2495
2496         lockdep_assert_held(&ar->conf_mutex);
2497
2498         spin_lock_bh(&ar->data_lock);
2499
2500         switch (ar->scan.state) {
2501         case ATH10K_SCAN_IDLE:
2502                 /* This can happen if timeout worker kicked in and called
2503                  * abortion while scan completion was being processed.
2504                  */
2505                 break;
2506         case ATH10K_SCAN_STARTING:
2507         case ATH10K_SCAN_ABORTING:
2508                 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
2509                             ath10k_scan_state_str(ar->scan.state),
2510                             ar->scan.state);
2511                 break;
2512         case ATH10K_SCAN_RUNNING:
2513                 ar->scan.state = ATH10K_SCAN_ABORTING;
2514                 spin_unlock_bh(&ar->data_lock);
2515
2516                 ret = ath10k_scan_stop(ar);
2517                 if (ret)
2518                         ath10k_warn(ar, "failed to abort scan: %d\n", ret);
2519
2520                 spin_lock_bh(&ar->data_lock);
2521                 break;
2522         }
2523
2524         spin_unlock_bh(&ar->data_lock);
2525 }
2526
2527 void ath10k_scan_timeout_work(struct work_struct *work)
2528 {
2529         struct ath10k *ar = container_of(work, struct ath10k,
2530                                          scan.timeout.work);
2531
2532         mutex_lock(&ar->conf_mutex);
2533         ath10k_scan_abort(ar);
2534         mutex_unlock(&ar->conf_mutex);
2535 }
2536
2537 static int ath10k_start_scan(struct ath10k *ar,
2538                              const struct wmi_start_scan_arg *arg)
2539 {
2540         int ret;
2541
2542         lockdep_assert_held(&ar->conf_mutex);
2543
2544         ret = ath10k_wmi_start_scan(ar, arg);
2545         if (ret)
2546                 return ret;
2547
2548         ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2549         if (ret == 0) {
2550                 ret = ath10k_scan_stop(ar);
2551                 if (ret)
2552                         ath10k_warn(ar, "failed to stop scan: %d\n", ret);
2553
2554                 return -ETIMEDOUT;
2555         }
2556
2557         /* Add a 200ms margin to account for event/command processing */
2558         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
2559                                      msecs_to_jiffies(arg->max_scan_time+200));
2560         return 0;
2561 }
2562
2563 /**********************/
2564 /* mac80211 callbacks */
2565 /**********************/
2566
2567 static void ath10k_tx(struct ieee80211_hw *hw,
2568                       struct ieee80211_tx_control *control,
2569                       struct sk_buff *skb)
2570 {
2571         struct ath10k *ar = hw->priv;
2572         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2573         struct ieee80211_vif *vif = info->control.vif;
2574         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2575
2576         /* We should disable CCK RATE due to P2P */
2577         if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2578                 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2579
2580         ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2581         ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
2582         ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, vif);
2583
2584         /* it makes no sense to process injected frames like that */
2585         if (vif && vif->type != NL80211_IFTYPE_MONITOR) {
2586                 ath10k_tx_h_nwifi(hw, skb);
2587                 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
2588                 ath10k_tx_h_seq_no(vif, skb);
2589         }
2590
2591         if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2592                 spin_lock_bh(&ar->data_lock);
2593                 ATH10K_SKB_CB(skb)->htt.freq = ar->scan.roc_freq;
2594                 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
2595                 spin_unlock_bh(&ar->data_lock);
2596
2597                 if (ath10k_mac_need_offchan_tx_work(ar)) {
2598                         ATH10K_SKB_CB(skb)->htt.freq = 0;
2599                         ATH10K_SKB_CB(skb)->htt.is_offchan = true;
2600
2601                         ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
2602                                    skb);
2603
2604                         skb_queue_tail(&ar->offchan_tx_queue, skb);
2605                         ieee80211_queue_work(hw, &ar->offchan_tx_work);
2606                         return;
2607                 }
2608         }
2609
2610         ath10k_tx_htt(ar, skb);
2611 }
2612
2613 /* Must not be called with conf_mutex held as workers can use that also. */
2614 void ath10k_drain_tx(struct ath10k *ar)
2615 {
2616         /* make sure rcu-protected mac80211 tx path itself is drained */
2617         synchronize_net();
2618
2619         ath10k_offchan_tx_purge(ar);
2620         ath10k_mgmt_over_wmi_tx_purge(ar);
2621
2622         cancel_work_sync(&ar->offchan_tx_work);
2623         cancel_work_sync(&ar->wmi_mgmt_tx_work);
2624 }
2625
2626 void ath10k_halt(struct ath10k *ar)
2627 {
2628         struct ath10k_vif *arvif;
2629
2630         lockdep_assert_held(&ar->conf_mutex);
2631
2632         clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
2633         ar->filter_flags = 0;
2634         ar->monitor = false;
2635
2636         if (ar->monitor_started)
2637                 ath10k_monitor_stop(ar);
2638
2639         ar->monitor_started = false;
2640
2641         ath10k_scan_finish(ar);
2642         ath10k_peer_cleanup_all(ar);
2643         ath10k_core_stop(ar);
2644         ath10k_hif_power_down(ar);
2645
2646         spin_lock_bh(&ar->data_lock);
2647         list_for_each_entry(arvif, &ar->arvifs, list)
2648                 ath10k_mac_vif_beacon_cleanup(arvif);
2649         spin_unlock_bh(&ar->data_lock);
2650 }
2651
2652 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2653 {
2654         struct ath10k *ar = hw->priv;
2655
2656         mutex_lock(&ar->conf_mutex);
2657
2658         if (ar->cfg_tx_chainmask) {
2659                 *tx_ant = ar->cfg_tx_chainmask;
2660                 *rx_ant = ar->cfg_rx_chainmask;
2661         } else {
2662                 *tx_ant = ar->supp_tx_chainmask;
2663                 *rx_ant = ar->supp_rx_chainmask;
2664         }
2665
2666         mutex_unlock(&ar->conf_mutex);
2667
2668         return 0;
2669 }
2670
2671 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
2672 {
2673         /* It is not clear that allowing gaps in chainmask
2674          * is helpful.  Probably it will not do what user
2675          * is hoping for, so warn in that case.
2676          */
2677         if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
2678                 return;
2679
2680         ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x.  Suggested values: 15, 7, 3, 1 or 0.\n",
2681                     dbg, cm);
2682 }
2683
2684 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
2685 {
2686         int ret;
2687
2688         lockdep_assert_held(&ar->conf_mutex);
2689
2690         ath10k_check_chain_mask(ar, tx_ant, "tx");
2691         ath10k_check_chain_mask(ar, rx_ant, "rx");
2692
2693         ar->cfg_tx_chainmask = tx_ant;
2694         ar->cfg_rx_chainmask = rx_ant;
2695
2696         if ((ar->state != ATH10K_STATE_ON) &&
2697             (ar->state != ATH10K_STATE_RESTARTED))
2698                 return 0;
2699
2700         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
2701                                         tx_ant);
2702         if (ret) {
2703                 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
2704                             ret, tx_ant);
2705                 return ret;
2706         }
2707
2708         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
2709                                         rx_ant);
2710         if (ret) {
2711                 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
2712                             ret, rx_ant);
2713                 return ret;
2714         }
2715
2716         return 0;
2717 }
2718
2719 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2720 {
2721         struct ath10k *ar = hw->priv;
2722         int ret;
2723
2724         mutex_lock(&ar->conf_mutex);
2725         ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
2726         mutex_unlock(&ar->conf_mutex);
2727         return ret;
2728 }
2729
2730 static int ath10k_start(struct ieee80211_hw *hw)
2731 {
2732         struct ath10k *ar = hw->priv;
2733         int ret = 0;
2734
2735         /*
2736          * This makes sense only when restarting hw. It is harmless to call
2737          * uncoditionally. This is necessary to make sure no HTT/WMI tx
2738          * commands will be submitted while restarting.
2739          */
2740         ath10k_drain_tx(ar);
2741
2742         mutex_lock(&ar->conf_mutex);
2743
2744         switch (ar->state) {
2745         case ATH10K_STATE_OFF:
2746                 ar->state = ATH10K_STATE_ON;
2747                 break;
2748         case ATH10K_STATE_RESTARTING:
2749                 ath10k_halt(ar);
2750                 ar->state = ATH10K_STATE_RESTARTED;
2751                 break;
2752         case ATH10K_STATE_ON:
2753         case ATH10K_STATE_RESTARTED:
2754         case ATH10K_STATE_WEDGED:
2755                 WARN_ON(1);
2756                 ret = -EINVAL;
2757                 goto err;
2758         case ATH10K_STATE_UTF:
2759                 ret = -EBUSY;
2760                 goto err;
2761         }
2762
2763         ret = ath10k_hif_power_up(ar);
2764         if (ret) {
2765                 ath10k_err(ar, "Could not init hif: %d\n", ret);
2766                 goto err_off;
2767         }
2768
2769         ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
2770         if (ret) {
2771                 ath10k_err(ar, "Could not init core: %d\n", ret);
2772                 goto err_power_down;
2773         }
2774
2775         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
2776         if (ret) {
2777                 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
2778                 goto err_core_stop;
2779         }
2780
2781         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
2782         if (ret) {
2783                 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
2784                 goto err_core_stop;
2785         }
2786
2787         if (ar->cfg_tx_chainmask)
2788                 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
2789                                      ar->cfg_rx_chainmask);
2790
2791         /*
2792          * By default FW set ARP frames ac to voice (6). In that case ARP
2793          * exchange is not working properly for UAPSD enabled AP. ARP requests
2794          * which arrives with access category 0 are processed by network stack
2795          * and send back with access category 0, but FW changes access category
2796          * to 6. Set ARP frames access category to best effort (0) solves
2797          * this problem.
2798          */
2799
2800         ret = ath10k_wmi_pdev_set_param(ar,
2801                                         ar->wmi.pdev_param->arp_ac_override, 0);
2802         if (ret) {
2803                 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
2804                             ret);
2805                 goto err_core_stop;
2806         }
2807
2808         ar->num_started_vdevs = 0;
2809         ath10k_regd_update(ar);
2810
2811         ath10k_spectral_start(ar);
2812
2813         mutex_unlock(&ar->conf_mutex);
2814         return 0;
2815
2816 err_core_stop:
2817         ath10k_core_stop(ar);
2818
2819 err_power_down:
2820         ath10k_hif_power_down(ar);
2821
2822 err_off:
2823         ar->state = ATH10K_STATE_OFF;
2824
2825 err:
2826         mutex_unlock(&ar->conf_mutex);
2827         return ret;
2828 }
2829
2830 static void ath10k_stop(struct ieee80211_hw *hw)
2831 {
2832         struct ath10k *ar = hw->priv;
2833
2834         ath10k_drain_tx(ar);
2835
2836         mutex_lock(&ar->conf_mutex);
2837         if (ar->state != ATH10K_STATE_OFF) {
2838                 ath10k_halt(ar);
2839                 ar->state = ATH10K_STATE_OFF;
2840         }
2841         mutex_unlock(&ar->conf_mutex);
2842
2843         cancel_delayed_work_sync(&ar->scan.timeout);
2844         cancel_work_sync(&ar->restart_work);
2845 }
2846
2847 static int ath10k_config_ps(struct ath10k *ar)
2848 {
2849         struct ath10k_vif *arvif;
2850         int ret = 0;
2851
2852         lockdep_assert_held(&ar->conf_mutex);
2853
2854         list_for_each_entry(arvif, &ar->arvifs, list) {
2855                 ret = ath10k_mac_vif_setup_ps(arvif);
2856                 if (ret) {
2857                         ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
2858                         break;
2859                 }
2860         }
2861
2862         return ret;
2863 }
2864
2865 static const char *chandef_get_width(enum nl80211_chan_width width)
2866 {
2867         switch (width) {
2868         case NL80211_CHAN_WIDTH_20_NOHT:
2869                 return "20 (noht)";
2870         case NL80211_CHAN_WIDTH_20:
2871                 return "20";
2872         case NL80211_CHAN_WIDTH_40:
2873                 return "40";
2874         case NL80211_CHAN_WIDTH_80:
2875                 return "80";
2876         case NL80211_CHAN_WIDTH_80P80:
2877                 return "80+80";
2878         case NL80211_CHAN_WIDTH_160:
2879                 return "160";
2880         case NL80211_CHAN_WIDTH_5:
2881                 return "5";
2882         case NL80211_CHAN_WIDTH_10:
2883                 return "10";
2884         }
2885         return "?";
2886 }
2887
2888 static void ath10k_config_chan(struct ath10k *ar)
2889 {
2890         struct ath10k_vif *arvif;
2891         int ret;
2892
2893         lockdep_assert_held(&ar->conf_mutex);
2894
2895         ath10k_dbg(ar, ATH10K_DBG_MAC,
2896                    "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2897                    ar->chandef.chan->center_freq,
2898                    ar->chandef.center_freq1,
2899                    ar->chandef.center_freq2,
2900                    chandef_get_width(ar->chandef.width));
2901
2902         /* First stop monitor interface. Some FW versions crash if there's a
2903          * lone monitor interface. */
2904         if (ar->monitor_started)
2905                 ath10k_monitor_stop(ar);
2906
2907         list_for_each_entry(arvif, &ar->arvifs, list) {
2908                 if (!arvif->is_started)
2909                         continue;
2910
2911                 if (!arvif->is_up)
2912                         continue;
2913
2914                 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2915                         continue;
2916
2917                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
2918                 if (ret) {
2919                         ath10k_warn(ar, "failed to down vdev %d: %d\n",
2920                                     arvif->vdev_id, ret);
2921                         continue;
2922                 }
2923         }
2924
2925         /* all vdevs are downed now - attempt to restart and re-up them */
2926
2927         list_for_each_entry(arvif, &ar->arvifs, list) {
2928                 if (!arvif->is_started)
2929                         continue;
2930
2931                 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2932                         continue;
2933
2934                 ret = ath10k_vdev_restart(arvif);
2935                 if (ret) {
2936                         ath10k_warn(ar, "failed to restart vdev %d: %d\n",
2937                                     arvif->vdev_id, ret);
2938                         continue;
2939                 }
2940
2941                 if (!arvif->is_up)
2942                         continue;
2943
2944                 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2945                                          arvif->bssid);
2946                 if (ret) {
2947                         ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
2948                                     arvif->vdev_id, ret);
2949                         continue;
2950                 }
2951         }
2952
2953         ath10k_monitor_recalc(ar);
2954 }
2955
2956 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
2957 {
2958         int ret;
2959         u32 param;
2960
2961         lockdep_assert_held(&ar->conf_mutex);
2962
2963         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
2964
2965         param = ar->wmi.pdev_param->txpower_limit2g;
2966         ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
2967         if (ret) {
2968                 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
2969                             txpower, ret);
2970                 return ret;
2971         }
2972
2973         param = ar->wmi.pdev_param->txpower_limit5g;
2974         ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
2975         if (ret) {
2976                 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
2977                             txpower, ret);
2978                 return ret;
2979         }
2980
2981         return 0;
2982 }
2983
2984 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
2985 {
2986         struct ath10k_vif *arvif;
2987         int ret, txpower = -1;
2988
2989         lockdep_assert_held(&ar->conf_mutex);
2990
2991         list_for_each_entry(arvif, &ar->arvifs, list) {
2992                 WARN_ON(arvif->txpower < 0);
2993
2994                 if (txpower == -1)
2995                         txpower = arvif->txpower;
2996                 else
2997                         txpower = min(txpower, arvif->txpower);
2998         }
2999
3000         if (WARN_ON(txpower == -1))
3001                 return -EINVAL;
3002
3003         ret = ath10k_mac_txpower_setup(ar, txpower);
3004         if (ret) {
3005                 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
3006                             txpower, ret);
3007                 return ret;
3008         }
3009
3010         return 0;
3011 }
3012
3013 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
3014 {
3015         struct ath10k *ar = hw->priv;
3016         struct ieee80211_conf *conf = &hw->conf;
3017         int ret = 0;
3018
3019         mutex_lock(&ar->conf_mutex);
3020
3021         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
3022                 ath10k_dbg(ar, ATH10K_DBG_MAC,
3023                            "mac config channel %dMHz flags 0x%x radar %d\n",
3024                            conf->chandef.chan->center_freq,
3025                            conf->chandef.chan->flags,
3026                            conf->radar_enabled);
3027
3028                 spin_lock_bh(&ar->data_lock);
3029                 ar->rx_channel = conf->chandef.chan;
3030                 spin_unlock_bh(&ar->data_lock);
3031
3032                 ar->radar_enabled = conf->radar_enabled;
3033                 ath10k_recalc_radar_detection(ar);
3034
3035                 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
3036                         ar->chandef = conf->chandef;
3037                         ath10k_config_chan(ar);
3038                 }
3039         }
3040
3041         if (changed & IEEE80211_CONF_CHANGE_PS)
3042                 ath10k_config_ps(ar);
3043
3044         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
3045                 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
3046                 ret = ath10k_monitor_recalc(ar);
3047                 if (ret)
3048                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
3049         }
3050
3051         mutex_unlock(&ar->conf_mutex);
3052         return ret;
3053 }
3054
3055 static u32 get_nss_from_chainmask(u16 chain_mask)
3056 {
3057         if ((chain_mask & 0x15) == 0x15)
3058                 return 4;
3059         else if ((chain_mask & 0x7) == 0x7)
3060                 return 3;
3061         else if ((chain_mask & 0x3) == 0x3)
3062                 return 2;
3063         return 1;
3064 }
3065
3066 /*
3067  * TODO:
3068  * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
3069  * because we will send mgmt frames without CCK. This requirement
3070  * for P2P_FIND/GO_NEG should be handled by checking CCK flag
3071  * in the TX packet.
3072  */
3073 static int ath10k_add_interface(struct ieee80211_hw *hw,
3074                                 struct ieee80211_vif *vif)
3075 {
3076         struct ath10k *ar = hw->priv;
3077         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3078         enum wmi_sta_powersave_param param;
3079         int ret = 0;
3080         u32 value;
3081         int bit;
3082         u32 vdev_param;
3083
3084         vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
3085
3086         mutex_lock(&ar->conf_mutex);
3087
3088         memset(arvif, 0, sizeof(*arvif));
3089
3090         arvif->ar = ar;
3091         arvif->vif = vif;
3092
3093         INIT_LIST_HEAD(&arvif->list);
3094
3095         if (ar->free_vdev_map == 0) {
3096                 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
3097                 ret = -EBUSY;
3098                 goto err;
3099         }
3100         bit = __ffs64(ar->free_vdev_map);
3101
3102         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
3103                    bit, ar->free_vdev_map);
3104
3105         arvif->vdev_id = bit;
3106         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
3107
3108         switch (vif->type) {
3109         case NL80211_IFTYPE_P2P_DEVICE:
3110                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
3111                 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
3112                 break;
3113         case NL80211_IFTYPE_UNSPECIFIED:
3114         case NL80211_IFTYPE_STATION:
3115                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
3116                 if (vif->p2p)
3117                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
3118                 break;
3119         case NL80211_IFTYPE_ADHOC:
3120                 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
3121                 break;
3122         case NL80211_IFTYPE_AP:
3123                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
3124
3125                 if (vif->p2p)
3126                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
3127                 break;
3128         case NL80211_IFTYPE_MONITOR:
3129                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
3130                 break;
3131         default:
3132                 WARN_ON(1);
3133                 break;
3134         }
3135
3136         /* Some firmware revisions don't wait for beacon tx completion before
3137          * sending another SWBA event. This could lead to hardware using old
3138          * (freed) beacon data in some cases, e.g. tx credit starvation
3139          * combined with missed TBTT. This is very very rare.
3140          *
3141          * On non-IOMMU-enabled hosts this could be a possible security issue
3142          * because hw could beacon some random data on the air.  On
3143          * IOMMU-enabled hosts DMAR faults would occur in most cases and target
3144          * device would crash.
3145          *
3146          * Since there are no beacon tx completions (implicit nor explicit)
3147          * propagated to host the only workaround for this is to allocate a
3148          * DMA-coherent buffer for a lifetime of a vif and use it for all
3149          * beacon tx commands. Worst case for this approach is some beacons may
3150          * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
3151          */
3152         if (vif->type == NL80211_IFTYPE_ADHOC ||
3153             vif->type == NL80211_IFTYPE_AP) {
3154                 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
3155                                                         IEEE80211_MAX_FRAME_LEN,
3156                                                         &arvif->beacon_paddr,
3157                                                         GFP_ATOMIC);
3158                 if (!arvif->beacon_buf) {
3159                         ret = -ENOMEM;
3160                         ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
3161                                     ret);
3162                         goto err;
3163                 }
3164         }
3165
3166         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
3167                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
3168                    arvif->beacon_buf ? "single-buf" : "per-skb");
3169
3170         ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
3171                                      arvif->vdev_subtype, vif->addr);
3172         if (ret) {
3173                 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
3174                             arvif->vdev_id, ret);
3175                 goto err;
3176         }
3177
3178         ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
3179         list_add(&arvif->list, &ar->arvifs);
3180
3181         /* It makes no sense to have firmware do keepalives. mac80211 already
3182          * takes care of this with idle connection polling.
3183          */
3184         ret = ath10k_mac_vif_disable_keepalive(arvif);
3185         if (ret) {
3186                 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
3187                             arvif->vdev_id, ret);
3188                 goto err_vdev_delete;
3189         }
3190
3191         arvif->def_wep_key_idx = -1;
3192
3193         vdev_param = ar->wmi.vdev_param->tx_encap_type;
3194         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3195                                         ATH10K_HW_TXRX_NATIVE_WIFI);
3196         /* 10.X firmware does not support this VDEV parameter. Do not warn */
3197         if (ret && ret != -EOPNOTSUPP) {
3198                 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
3199                             arvif->vdev_id, ret);
3200                 goto err_vdev_delete;
3201         }
3202
3203         if (ar->cfg_tx_chainmask) {
3204                 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
3205
3206                 vdev_param = ar->wmi.vdev_param->nss;
3207                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3208                                                 nss);
3209                 if (ret) {
3210                         ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
3211                                     arvif->vdev_id, ar->cfg_tx_chainmask, nss,
3212                                     ret);
3213                         goto err_vdev_delete;
3214                 }
3215         }
3216
3217         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
3218                 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
3219                 if (ret) {
3220                         ath10k_warn(ar, "failed to create vdev %i peer for AP: %d\n",
3221                                     arvif->vdev_id, ret);
3222                         goto err_vdev_delete;
3223                 }
3224
3225                 ret = ath10k_mac_set_kickout(arvif);
3226                 if (ret) {
3227                         ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
3228                                     arvif->vdev_id, ret);
3229                         goto err_peer_delete;
3230                 }
3231         }
3232
3233         if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
3234                 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
3235                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3236                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3237                                                   param, value);
3238                 if (ret) {
3239                         ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
3240                                     arvif->vdev_id, ret);
3241                         goto err_peer_delete;
3242                 }
3243
3244                 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
3245                 if (ret) {
3246                         ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
3247                                     arvif->vdev_id, ret);
3248                         goto err_peer_delete;
3249                 }
3250
3251                 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
3252                 if (ret) {
3253                         ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
3254                                     arvif->vdev_id, ret);
3255                         goto err_peer_delete;
3256                 }
3257         }
3258
3259         ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
3260         if (ret) {
3261                 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
3262                             arvif->vdev_id, ret);
3263                 goto err_peer_delete;
3264         }
3265
3266         ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
3267         if (ret) {
3268                 ath10k_warn(ar, "failed to set frag threshold for vdev %d: %d\n",
3269                             arvif->vdev_id, ret);
3270                 goto err_peer_delete;
3271         }
3272
3273         arvif->txpower = vif->bss_conf.txpower;
3274         ret = ath10k_mac_txpower_recalc(ar);
3275         if (ret) {
3276                 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
3277                 goto err_peer_delete;
3278         }
3279
3280         mutex_unlock(&ar->conf_mutex);
3281         return 0;
3282
3283 err_peer_delete:
3284         if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
3285                 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
3286
3287 err_vdev_delete:
3288         ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
3289         ar->free_vdev_map |= 1LL << arvif->vdev_id;
3290         list_del(&arvif->list);
3291
3292 err:
3293         if (arvif->beacon_buf) {
3294                 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
3295                                   arvif->beacon_buf, arvif->beacon_paddr);
3296                 arvif->beacon_buf = NULL;
3297         }
3298
3299         mutex_unlock(&ar->conf_mutex);
3300
3301         return ret;
3302 }
3303
3304 static void ath10k_remove_interface(struct ieee80211_hw *hw,
3305                                     struct ieee80211_vif *vif)
3306 {
3307         struct ath10k *ar = hw->priv;
3308         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3309         int ret;
3310
3311         mutex_lock(&ar->conf_mutex);
3312
3313         spin_lock_bh(&ar->data_lock);
3314         ath10k_mac_vif_beacon_cleanup(arvif);
3315         spin_unlock_bh(&ar->data_lock);
3316
3317         ret = ath10k_spectral_vif_stop(arvif);
3318         if (ret)
3319                 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
3320                             arvif->vdev_id, ret);
3321
3322         ar->free_vdev_map |= 1LL << arvif->vdev_id;
3323         list_del(&arvif->list);
3324
3325         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
3326                 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
3327                 if (ret)
3328                         ath10k_warn(ar, "failed to remove peer for AP vdev %i: %d\n",
3329                                     arvif->vdev_id, ret);
3330
3331                 kfree(arvif->u.ap.noa_data);
3332         }
3333
3334         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
3335                    arvif->vdev_id);
3336
3337         ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
3338         if (ret)
3339                 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
3340                             arvif->vdev_id, ret);
3341
3342         ath10k_peer_cleanup(ar, arvif->vdev_id);
3343
3344         mutex_unlock(&ar->conf_mutex);
3345 }
3346
3347 /*
3348  * FIXME: Has to be verified.
3349  */
3350 #define SUPPORTED_FILTERS                       \
3351         (FIF_PROMISC_IN_BSS |                   \
3352         FIF_ALLMULTI |                          \
3353         FIF_CONTROL |                           \
3354         FIF_PSPOLL |                            \
3355         FIF_OTHER_BSS |                         \
3356         FIF_BCN_PRBRESP_PROMISC |               \
3357         FIF_PROBE_REQ |                         \
3358         FIF_FCSFAIL)
3359
3360 static void ath10k_configure_filter(struct ieee80211_hw *hw,
3361                                     unsigned int changed_flags,
3362                                     unsigned int *total_flags,
3363                                     u64 multicast)
3364 {
3365         struct ath10k *ar = hw->priv;
3366         int ret;
3367
3368         mutex_lock(&ar->conf_mutex);
3369
3370         changed_flags &= SUPPORTED_FILTERS;
3371         *total_flags &= SUPPORTED_FILTERS;
3372         ar->filter_flags = *total_flags;
3373
3374         ret = ath10k_monitor_recalc(ar);
3375         if (ret)
3376                 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
3377
3378         mutex_unlock(&ar->conf_mutex);
3379 }
3380
3381 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
3382                                     struct ieee80211_vif *vif,
3383                                     struct ieee80211_bss_conf *info,
3384                                     u32 changed)
3385 {
3386         struct ath10k *ar = hw->priv;
3387         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3388         int ret = 0;
3389         u32 vdev_param, pdev_param, slottime, preamble;
3390
3391         mutex_lock(&ar->conf_mutex);
3392
3393         if (changed & BSS_CHANGED_IBSS)
3394                 ath10k_control_ibss(arvif, info, vif->addr);
3395
3396         if (changed & BSS_CHANGED_BEACON_INT) {
3397                 arvif->beacon_interval = info->beacon_int;
3398                 vdev_param = ar->wmi.vdev_param->beacon_interval;
3399                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3400                                                 arvif->beacon_interval);
3401                 ath10k_dbg(ar, ATH10K_DBG_MAC,
3402                            "mac vdev %d beacon_interval %d\n",
3403                            arvif->vdev_id, arvif->beacon_interval);
3404
3405                 if (ret)
3406                         ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
3407                                     arvif->vdev_id, ret);
3408         }
3409
3410         if (changed & BSS_CHANGED_BEACON) {
3411                 ath10k_dbg(ar, ATH10K_DBG_MAC,
3412                            "vdev %d set beacon tx mode to staggered\n",
3413                            arvif->vdev_id);
3414
3415                 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
3416                 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
3417                                                 WMI_BEACON_STAGGERED_MODE);
3418                 if (ret)
3419                         ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
3420                                     arvif->vdev_id, ret);
3421
3422                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
3423                 if (ret)
3424                         ath10k_warn(ar, "failed to update beacon template: %d\n",
3425                                     ret);
3426         }
3427
3428         if (changed & BSS_CHANGED_AP_PROBE_RESP) {
3429                 ret = ath10k_mac_setup_prb_tmpl(arvif);
3430                 if (ret)
3431                         ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
3432                                     arvif->vdev_id, ret);
3433         }
3434
3435         if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
3436                 arvif->dtim_period = info->dtim_period;
3437
3438                 ath10k_dbg(ar, ATH10K_DBG_MAC,
3439                            "mac vdev %d dtim_period %d\n",
3440                            arvif->vdev_id, arvif->dtim_period);
3441
3442                 vdev_param = ar->wmi.vdev_param->dtim_period;
3443                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3444                                                 arvif->dtim_period);
3445                 if (ret)
3446                         ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
3447                                     arvif->vdev_id, ret);
3448         }
3449
3450         if (changed & BSS_CHANGED_SSID &&
3451             vif->type == NL80211_IFTYPE_AP) {
3452                 arvif->u.ap.ssid_len = info->ssid_len;
3453                 if (info->ssid_len)
3454                         memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3455                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3456         }
3457
3458         if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3459                 ether_addr_copy(arvif->bssid, info->bssid);
3460
3461         if (changed & BSS_CHANGED_BEACON_ENABLED)
3462                 ath10k_control_beaconing(arvif, info);
3463
3464         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3465                 arvif->use_cts_prot = info->use_cts_prot;
3466                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
3467                            arvif->vdev_id, info->use_cts_prot);
3468
3469                 ret = ath10k_recalc_rtscts_prot(arvif);
3470                 if (ret)
3471                         ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
3472                                     arvif->vdev_id, ret);
3473         }
3474
3475         if (changed & BSS_CHANGED_ERP_SLOT) {
3476                 if (info->use_short_slot)
3477                         slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3478
3479                 else
3480                         slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3481
3482                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
3483                            arvif->vdev_id, slottime);
3484
3485                 vdev_param = ar->wmi.vdev_param->slot_time;
3486                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3487                                                 slottime);
3488                 if (ret)
3489                         ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
3490                                     arvif->vdev_id, ret);
3491         }
3492
3493         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3494                 if (info->use_short_preamble)
3495                         preamble = WMI_VDEV_PREAMBLE_SHORT;
3496                 else
3497                         preamble = WMI_VDEV_PREAMBLE_LONG;
3498
3499                 ath10k_dbg(ar, ATH10K_DBG_MAC,
3500                            "mac vdev %d preamble %dn",
3501                            arvif->vdev_id, preamble);
3502
3503                 vdev_param = ar->wmi.vdev_param->preamble;
3504                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3505                                                 preamble);
3506                 if (ret)
3507                         ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
3508                                     arvif->vdev_id, ret);
3509         }
3510
3511         if (changed & BSS_CHANGED_ASSOC) {
3512                 if (info->assoc) {
3513                         /* Workaround: Make sure monitor vdev is not running
3514                          * when associating to prevent some firmware revisions
3515                          * (e.g. 10.1 and 10.2) from crashing.
3516                          */
3517                         if (ar->monitor_started)
3518                                 ath10k_monitor_stop(ar);
3519                         ath10k_bss_assoc(hw, vif, info);
3520                         ath10k_monitor_recalc(ar);
3521                 } else {
3522                         ath10k_bss_disassoc(hw, vif);
3523                 }
3524         }
3525
3526         if (changed & BSS_CHANGED_TXPOWER) {
3527                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
3528                            arvif->vdev_id, info->txpower);
3529
3530                 arvif->txpower = info->txpower;
3531                 ret = ath10k_mac_txpower_recalc(ar);
3532                 if (ret)
3533                         ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
3534         }
3535
3536         if (changed & BSS_CHANGED_PS) {
3537                 ret = ath10k_mac_vif_setup_ps(arvif);
3538                 if (ret)
3539                         ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
3540                                     arvif->vdev_id, ret);
3541         }
3542
3543         mutex_unlock(&ar->conf_mutex);
3544 }
3545
3546 static int ath10k_hw_scan(struct ieee80211_hw *hw,
3547                           struct ieee80211_vif *vif,
3548                           struct ieee80211_scan_request *hw_req)
3549 {
3550         struct ath10k *ar = hw->priv;
3551         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3552         struct cfg80211_scan_request *req = &hw_req->req;
3553         struct wmi_start_scan_arg arg;
3554         int ret = 0;
3555         int i;
3556
3557         mutex_lock(&ar->conf_mutex);
3558
3559         spin_lock_bh(&ar->data_lock);
3560         switch (ar->scan.state) {
3561         case ATH10K_SCAN_IDLE:
3562                 reinit_completion(&ar->scan.started);
3563                 reinit_completion(&ar->scan.completed);
3564                 ar->scan.state = ATH10K_SCAN_STARTING;
3565                 ar->scan.is_roc = false;
3566                 ar->scan.vdev_id = arvif->vdev_id;
3567                 ret = 0;
3568                 break;
3569         case ATH10K_SCAN_STARTING:
3570         case ATH10K_SCAN_RUNNING:
3571         case ATH10K_SCAN_ABORTING:
3572                 ret = -EBUSY;
3573                 break;
3574         }
3575         spin_unlock_bh(&ar->data_lock);
3576
3577         if (ret)
3578                 goto exit;
3579
3580         memset(&arg, 0, sizeof(arg));
3581         ath10k_wmi_start_scan_init(ar, &arg);
3582         arg.vdev_id = arvif->vdev_id;
3583         arg.scan_id = ATH10K_SCAN_ID;
3584
3585         if (!req->no_cck)
3586                 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
3587
3588         if (req->ie_len) {
3589                 arg.ie_len = req->ie_len;
3590                 memcpy(arg.ie, req->ie, arg.ie_len);
3591         }
3592
3593         if (req->n_ssids) {
3594                 arg.n_ssids = req->n_ssids;
3595                 for (i = 0; i < arg.n_ssids; i++) {
3596                         arg.ssids[i].len  = req->ssids[i].ssid_len;
3597                         arg.ssids[i].ssid = req->ssids[i].ssid;
3598                 }
3599         } else {
3600                 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3601         }
3602
3603         if (req->n_channels) {
3604                 arg.n_channels = req->n_channels;
3605                 for (i = 0; i < arg.n_channels; i++)
3606                         arg.channels[i] = req->channels[i]->center_freq;
3607         }
3608
3609         ret = ath10k_start_scan(ar, &arg);
3610         if (ret) {
3611                 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
3612                 spin_lock_bh(&ar->data_lock);
3613                 ar->scan.state = ATH10K_SCAN_IDLE;
3614                 spin_unlock_bh(&ar->data_lock);
3615         }
3616
3617 exit:
3618         mutex_unlock(&ar->conf_mutex);
3619         return ret;
3620 }
3621
3622 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
3623                                   struct ieee80211_vif *vif)
3624 {
3625         struct ath10k *ar = hw->priv;
3626
3627         mutex_lock(&ar->conf_mutex);
3628         ath10k_scan_abort(ar);
3629         mutex_unlock(&ar->conf_mutex);
3630
3631         cancel_delayed_work_sync(&ar->scan.timeout);
3632 }
3633
3634 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
3635                                         struct ath10k_vif *arvif,
3636                                         enum set_key_cmd cmd,
3637                                         struct ieee80211_key_conf *key)
3638 {
3639         u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
3640         int ret;
3641
3642         /* 10.1 firmware branch requires default key index to be set to group
3643          * key index after installing it. Otherwise FW/HW Txes corrupted
3644          * frames with multi-vif APs. This is not required for main firmware
3645          * branch (e.g. 636).
3646          *
3647          * FIXME: This has been tested only in AP. It remains unknown if this
3648          * is required for multi-vif STA interfaces on 10.1 */
3649
3650         if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3651                 return;
3652
3653         if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3654                 return;
3655
3656         if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3657                 return;
3658
3659         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3660                 return;
3661
3662         if (cmd != SET_KEY)
3663                 return;
3664
3665         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3666                                         key->keyidx);
3667         if (ret)
3668                 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
3669                             arvif->vdev_id, ret);
3670 }
3671
3672 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3673                           struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3674                           struct ieee80211_key_conf *key)
3675 {
3676         struct ath10k *ar = hw->priv;
3677         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3678         struct ath10k_peer *peer;
3679         const u8 *peer_addr;
3680         bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3681                       key->cipher == WLAN_CIPHER_SUITE_WEP104;
3682         bool def_idx = false;
3683         int ret = 0;
3684
3685         if (key->keyidx > WMI_MAX_KEY_INDEX)
3686                 return -ENOSPC;
3687
3688         mutex_lock(&ar->conf_mutex);
3689
3690         if (sta)
3691                 peer_addr = sta->addr;
3692         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3693                 peer_addr = vif->bss_conf.bssid;
3694         else
3695                 peer_addr = vif->addr;
3696
3697         key->hw_key_idx = key->keyidx;
3698
3699         /* the peer should not disappear in mid-way (unless FW goes awry) since
3700          * we already hold conf_mutex. we just make sure its there now. */
3701         spin_lock_bh(&ar->data_lock);
3702         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3703         spin_unlock_bh(&ar->data_lock);
3704
3705         if (!peer) {
3706                 if (cmd == SET_KEY) {
3707                         ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
3708                                     peer_addr);
3709                         ret = -EOPNOTSUPP;
3710                         goto exit;
3711                 } else {
3712                         /* if the peer doesn't exist there is no key to disable
3713                          * anymore */
3714                         goto exit;
3715                 }
3716         }
3717
3718         if (is_wep) {
3719                 if (cmd == SET_KEY)
3720                         arvif->wep_keys[key->keyidx] = key;
3721                 else
3722                         arvif->wep_keys[key->keyidx] = NULL;
3723
3724                 if (cmd == DISABLE_KEY)
3725                         ath10k_clear_vdev_key(arvif, key);
3726         }
3727
3728         /* set TX_USAGE flag for all the keys incase of dot1x-WEP. For
3729          * static WEP, do not set this flag for the keys whose key id
3730          * is  greater than default key id.
3731          */
3732         if (arvif->def_wep_key_idx == -1)
3733                 def_idx = true;
3734
3735         ret = ath10k_install_key(arvif, key, cmd, peer_addr, def_idx);
3736         if (ret) {
3737                 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
3738                             arvif->vdev_id, peer_addr, ret);
3739                 goto exit;
3740         }
3741
3742         ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3743
3744         spin_lock_bh(&ar->data_lock);
3745         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3746         if (peer && cmd == SET_KEY)
3747                 peer->keys[key->keyidx] = key;
3748         else if (peer && cmd == DISABLE_KEY)
3749                 peer->keys[key->keyidx] = NULL;
3750         else if (peer == NULL)
3751                 /* impossible unless FW goes crazy */
3752                 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
3753         spin_unlock_bh(&ar->data_lock);
3754
3755 exit:
3756         mutex_unlock(&ar->conf_mutex);
3757         return ret;
3758 }
3759
3760 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
3761                                            struct ieee80211_vif *vif,
3762                                            int keyidx)
3763 {
3764         struct ath10k *ar = hw->priv;
3765         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3766         int ret;
3767
3768         mutex_lock(&arvif->ar->conf_mutex);
3769
3770         if (arvif->ar->state != ATH10K_STATE_ON)
3771                 goto unlock;
3772
3773         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
3774                    arvif->vdev_id, keyidx);
3775
3776         ret = ath10k_wmi_vdev_set_param(arvif->ar,
3777                                         arvif->vdev_id,
3778                                         arvif->ar->wmi.vdev_param->def_keyid,
3779                                         keyidx);
3780
3781         if (ret) {
3782                 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
3783                             arvif->vdev_id,
3784                             ret);
3785                 goto unlock;
3786         }
3787
3788         arvif->def_wep_key_idx = keyidx;
3789 unlock:
3790         mutex_unlock(&arvif->ar->conf_mutex);
3791 }
3792
3793 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
3794 {
3795         struct ath10k *ar;
3796         struct ath10k_vif *arvif;
3797         struct ath10k_sta *arsta;
3798         struct ieee80211_sta *sta;
3799         u32 changed, bw, nss, smps;
3800         int err;
3801
3802         arsta = container_of(wk, struct ath10k_sta, update_wk);
3803         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3804         arvif = arsta->arvif;
3805         ar = arvif->ar;
3806
3807         spin_lock_bh(&ar->data_lock);
3808
3809         changed = arsta->changed;
3810         arsta->changed = 0;
3811
3812         bw = arsta->bw;
3813         nss = arsta->nss;
3814         smps = arsta->smps;
3815
3816         spin_unlock_bh(&ar->data_lock);
3817
3818         mutex_lock(&ar->conf_mutex);
3819
3820         if (changed & IEEE80211_RC_BW_CHANGED) {
3821                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
3822                            sta->addr, bw);
3823
3824                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3825                                                 WMI_PEER_CHAN_WIDTH, bw);
3826                 if (err)
3827                         ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
3828                                     sta->addr, bw, err);
3829         }
3830
3831         if (changed & IEEE80211_RC_NSS_CHANGED) {
3832                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
3833                            sta->addr, nss);
3834
3835                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3836                                                 WMI_PEER_NSS, nss);
3837                 if (err)
3838                         ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
3839                                     sta->addr, nss, err);
3840         }
3841
3842         if (changed & IEEE80211_RC_SMPS_CHANGED) {
3843                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
3844                            sta->addr, smps);
3845
3846                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3847                                                 WMI_PEER_SMPS_STATE, smps);
3848                 if (err)
3849                         ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
3850                                     sta->addr, smps, err);
3851         }
3852
3853         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
3854             changed & IEEE80211_RC_NSS_CHANGED) {
3855                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
3856                            sta->addr);
3857
3858                 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
3859                 if (err)
3860                         ath10k_warn(ar, "failed to reassociate station: %pM\n",
3861                                     sta->addr);
3862         }
3863
3864         mutex_unlock(&ar->conf_mutex);
3865 }
3866
3867 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif)
3868 {
3869         struct ath10k *ar = arvif->ar;
3870
3871         lockdep_assert_held(&ar->conf_mutex);
3872
3873         if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
3874             arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
3875                 return 0;
3876
3877         if (ar->num_stations >= ar->max_num_stations)
3878                 return -ENOBUFS;
3879
3880         ar->num_stations++;
3881
3882         return 0;
3883 }
3884
3885 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif)
3886 {
3887         struct ath10k *ar = arvif->ar;
3888
3889         lockdep_assert_held(&ar->conf_mutex);
3890
3891         if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
3892             arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
3893                 return;
3894
3895         ar->num_stations--;
3896 }
3897
3898 static int ath10k_sta_state(struct ieee80211_hw *hw,
3899                             struct ieee80211_vif *vif,
3900                             struct ieee80211_sta *sta,
3901                             enum ieee80211_sta_state old_state,
3902                             enum ieee80211_sta_state new_state)
3903 {
3904         struct ath10k *ar = hw->priv;
3905         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3906         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3907         int ret = 0;
3908
3909         if (old_state == IEEE80211_STA_NOTEXIST &&
3910             new_state == IEEE80211_STA_NONE) {
3911                 memset(arsta, 0, sizeof(*arsta));
3912                 arsta->arvif = arvif;
3913                 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
3914         }
3915
3916         /* cancel must be done outside the mutex to avoid deadlock */
3917         if ((old_state == IEEE80211_STA_NONE &&
3918              new_state == IEEE80211_STA_NOTEXIST))
3919                 cancel_work_sync(&arsta->update_wk);
3920
3921         mutex_lock(&ar->conf_mutex);
3922
3923         if (old_state == IEEE80211_STA_NOTEXIST &&
3924             new_state == IEEE80211_STA_NONE) {
3925                 /*
3926                  * New station addition.
3927                  */
3928                 ath10k_dbg(ar, ATH10K_DBG_MAC,
3929                            "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
3930                            arvif->vdev_id, sta->addr,
3931                            ar->num_stations + 1, ar->max_num_stations,
3932                            ar->num_peers + 1, ar->max_num_peers);
3933
3934                 ret = ath10k_mac_inc_num_stations(arvif);
3935                 if (ret) {
3936                         ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
3937                                     ar->max_num_stations);
3938                         goto exit;
3939                 }
3940
3941                 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3942                 if (ret) {
3943                         ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3944                                     sta->addr, arvif->vdev_id, ret);
3945                         ath10k_mac_dec_num_stations(arvif);
3946                         goto exit;
3947                 }
3948
3949                 if (vif->type == NL80211_IFTYPE_STATION) {
3950                         WARN_ON(arvif->is_started);
3951
3952                         ret = ath10k_vdev_start(arvif);
3953                         if (ret) {
3954                                 ath10k_warn(ar, "failed to start vdev %i: %d\n",
3955                                             arvif->vdev_id, ret);
3956                                 WARN_ON(ath10k_peer_delete(ar, arvif->vdev_id,
3957                                                            sta->addr));
3958                                 ath10k_mac_dec_num_stations(arvif);
3959                                 goto exit;
3960                         }
3961
3962                         arvif->is_started = true;
3963                 }
3964         } else if ((old_state == IEEE80211_STA_NONE &&
3965                     new_state == IEEE80211_STA_NOTEXIST)) {
3966                 /*
3967                  * Existing station deletion.
3968                  */
3969                 ath10k_dbg(ar, ATH10K_DBG_MAC,
3970                            "mac vdev %d peer delete %pM (sta gone)\n",
3971                            arvif->vdev_id, sta->addr);
3972
3973                 if (vif->type == NL80211_IFTYPE_STATION) {
3974                         WARN_ON(!arvif->is_started);
3975
3976                         ret = ath10k_vdev_stop(arvif);
3977                         if (ret)
3978                                 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
3979                                             arvif->vdev_id, ret);
3980
3981                         arvif->is_started = false;
3982                 }
3983
3984                 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3985                 if (ret)
3986                         ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
3987                                     sta->addr, arvif->vdev_id, ret);
3988
3989                 ath10k_mac_dec_num_stations(arvif);
3990         } else if (old_state == IEEE80211_STA_AUTH &&
3991                    new_state == IEEE80211_STA_ASSOC &&
3992                    (vif->type == NL80211_IFTYPE_AP ||
3993                     vif->type == NL80211_IFTYPE_ADHOC)) {
3994                 /*
3995                  * New association.
3996                  */
3997                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
3998                            sta->addr);
3999
4000                 ret = ath10k_station_assoc(ar, vif, sta, false);
4001                 if (ret)
4002                         ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
4003                                     sta->addr, arvif->vdev_id, ret);
4004         } else if (old_state == IEEE80211_STA_ASSOC &&
4005                    new_state == IEEE80211_STA_AUTH &&
4006                    (vif->type == NL80211_IFTYPE_AP ||
4007                     vif->type == NL80211_IFTYPE_ADHOC)) {
4008                 /*
4009                  * Disassociation.
4010                  */
4011                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
4012                            sta->addr);
4013
4014                 ret = ath10k_station_disassoc(ar, vif, sta);
4015                 if (ret)
4016                         ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
4017                                     sta->addr, arvif->vdev_id, ret);
4018         }
4019 exit:
4020         mutex_unlock(&ar->conf_mutex);
4021         return ret;
4022 }
4023
4024 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
4025                                 u16 ac, bool enable)
4026 {
4027         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4028         struct wmi_sta_uapsd_auto_trig_arg arg = {};
4029         u32 prio = 0, acc = 0;
4030         u32 value = 0;
4031         int ret = 0;
4032
4033         lockdep_assert_held(&ar->conf_mutex);
4034
4035         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
4036                 return 0;
4037
4038         switch (ac) {
4039         case IEEE80211_AC_VO:
4040                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
4041                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
4042                 prio = 7;
4043                 acc = 3;
4044                 break;
4045         case IEEE80211_AC_VI:
4046                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
4047                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
4048                 prio = 5;
4049                 acc = 2;
4050                 break;
4051         case IEEE80211_AC_BE:
4052                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
4053                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
4054                 prio = 2;
4055                 acc = 1;
4056                 break;
4057         case IEEE80211_AC_BK:
4058                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
4059                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
4060                 prio = 0;
4061                 acc = 0;
4062                 break;
4063         }
4064
4065         if (enable)
4066                 arvif->u.sta.uapsd |= value;
4067         else
4068                 arvif->u.sta.uapsd &= ~value;
4069
4070         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4071                                           WMI_STA_PS_PARAM_UAPSD,
4072                                           arvif->u.sta.uapsd);
4073         if (ret) {
4074                 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
4075                 goto exit;
4076         }
4077
4078         if (arvif->u.sta.uapsd)
4079                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
4080         else
4081                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4082
4083         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4084                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
4085                                           value);
4086         if (ret)
4087                 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
4088
4089         ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4090         if (ret) {
4091                 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4092                             arvif->vdev_id, ret);
4093                 return ret;
4094         }
4095
4096         ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4097         if (ret) {
4098                 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4099                             arvif->vdev_id, ret);
4100                 return ret;
4101         }
4102
4103         if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
4104             test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
4105                 /* Only userspace can make an educated decision when to send
4106                  * trigger frame. The following effectively disables u-UAPSD
4107                  * autotrigger in firmware (which is enabled by default
4108                  * provided the autotrigger service is available).
4109                  */
4110
4111                 arg.wmm_ac = acc;
4112                 arg.user_priority = prio;
4113                 arg.service_interval = 0;
4114                 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
4115                 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
4116
4117                 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
4118                                                 arvif->bssid, &arg, 1);
4119                 if (ret) {
4120                         ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
4121                                     ret);
4122                         return ret;
4123                 }
4124         }
4125
4126 exit:
4127         return ret;
4128 }
4129
4130 static int ath10k_conf_tx(struct ieee80211_hw *hw,
4131                           struct ieee80211_vif *vif, u16 ac,
4132                           const struct ieee80211_tx_queue_params *params)
4133 {
4134         struct ath10k *ar = hw->priv;
4135         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4136         struct wmi_wmm_params_arg *p = NULL;
4137         int ret;
4138
4139         mutex_lock(&ar->conf_mutex);
4140
4141         switch (ac) {
4142         case IEEE80211_AC_VO:
4143                 p = &arvif->wmm_params.ac_vo;
4144                 break;
4145         case IEEE80211_AC_VI:
4146                 p = &arvif->wmm_params.ac_vi;
4147                 break;
4148         case IEEE80211_AC_BE:
4149                 p = &arvif->wmm_params.ac_be;
4150                 break;
4151         case IEEE80211_AC_BK:
4152                 p = &arvif->wmm_params.ac_bk;
4153                 break;
4154         }
4155
4156         if (WARN_ON(!p)) {
4157                 ret = -EINVAL;
4158                 goto exit;
4159         }
4160
4161         p->cwmin = params->cw_min;
4162         p->cwmax = params->cw_max;
4163         p->aifs = params->aifs;
4164
4165         /*
4166          * The channel time duration programmed in the HW is in absolute
4167          * microseconds, while mac80211 gives the txop in units of
4168          * 32 microseconds.
4169          */
4170         p->txop = params->txop * 32;
4171
4172         if (ar->wmi.ops->gen_vdev_wmm_conf) {
4173                 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
4174                                                &arvif->wmm_params);
4175                 if (ret) {
4176                         ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
4177                                     arvif->vdev_id, ret);
4178                         goto exit;
4179                 }
4180         } else {
4181                 /* This won't work well with multi-interface cases but it's
4182                  * better than nothing.
4183                  */
4184                 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
4185                 if (ret) {
4186                         ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
4187                         goto exit;
4188                 }
4189         }
4190
4191         ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
4192         if (ret)
4193                 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
4194
4195 exit:
4196         mutex_unlock(&ar->conf_mutex);
4197         return ret;
4198 }
4199
4200 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
4201
4202 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
4203                                     struct ieee80211_vif *vif,
4204                                     struct ieee80211_channel *chan,
4205                                     int duration,
4206                                     enum ieee80211_roc_type type)
4207 {
4208         struct ath10k *ar = hw->priv;
4209         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4210         struct wmi_start_scan_arg arg;
4211         int ret = 0;
4212
4213         mutex_lock(&ar->conf_mutex);
4214
4215         spin_lock_bh(&ar->data_lock);
4216         switch (ar->scan.state) {
4217         case ATH10K_SCAN_IDLE:
4218                 reinit_completion(&ar->scan.started);
4219                 reinit_completion(&ar->scan.completed);
4220                 reinit_completion(&ar->scan.on_channel);
4221                 ar->scan.state = ATH10K_SCAN_STARTING;
4222                 ar->scan.is_roc = true;
4223                 ar->scan.vdev_id = arvif->vdev_id;
4224                 ar->scan.roc_freq = chan->center_freq;
4225                 ret = 0;
4226                 break;
4227         case ATH10K_SCAN_STARTING:
4228         case ATH10K_SCAN_RUNNING:
4229         case ATH10K_SCAN_ABORTING:
4230                 ret = -EBUSY;
4231                 break;
4232         }
4233         spin_unlock_bh(&ar->data_lock);
4234
4235         if (ret)
4236                 goto exit;
4237
4238         duration = max(duration, WMI_SCAN_CHAN_MIN_TIME_MSEC);
4239
4240         memset(&arg, 0, sizeof(arg));
4241         ath10k_wmi_start_scan_init(ar, &arg);
4242         arg.vdev_id = arvif->vdev_id;
4243         arg.scan_id = ATH10K_SCAN_ID;
4244         arg.n_channels = 1;
4245         arg.channels[0] = chan->center_freq;
4246         arg.dwell_time_active = duration;
4247         arg.dwell_time_passive = duration;
4248         arg.max_scan_time = 2 * duration;
4249         arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4250         arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
4251
4252         ret = ath10k_start_scan(ar, &arg);
4253         if (ret) {
4254                 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
4255                 spin_lock_bh(&ar->data_lock);
4256                 ar->scan.state = ATH10K_SCAN_IDLE;
4257                 spin_unlock_bh(&ar->data_lock);
4258                 goto exit;
4259         }
4260
4261         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
4262         if (ret == 0) {
4263                 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
4264
4265                 ret = ath10k_scan_stop(ar);
4266                 if (ret)
4267                         ath10k_warn(ar, "failed to stop scan: %d\n", ret);
4268
4269                 ret = -ETIMEDOUT;
4270                 goto exit;
4271         }
4272
4273         ret = 0;
4274 exit:
4275         mutex_unlock(&ar->conf_mutex);
4276         return ret;
4277 }
4278
4279 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
4280 {
4281         struct ath10k *ar = hw->priv;
4282
4283         mutex_lock(&ar->conf_mutex);
4284         ath10k_scan_abort(ar);
4285         mutex_unlock(&ar->conf_mutex);
4286
4287         cancel_delayed_work_sync(&ar->scan.timeout);
4288
4289         return 0;
4290 }
4291
4292 /*
4293  * Both RTS and Fragmentation threshold are interface-specific
4294  * in ath10k, but device-specific in mac80211.
4295  */
4296
4297 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
4298 {
4299         struct ath10k *ar = hw->priv;
4300         struct ath10k_vif *arvif;
4301         int ret = 0;
4302
4303         mutex_lock(&ar->conf_mutex);
4304         list_for_each_entry(arvif, &ar->arvifs, list) {
4305                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
4306                            arvif->vdev_id, value);
4307
4308                 ret = ath10k_mac_set_rts(arvif, value);
4309                 if (ret) {
4310                         ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4311                                     arvif->vdev_id, ret);
4312                         break;
4313                 }
4314         }
4315         mutex_unlock(&ar->conf_mutex);
4316
4317         return ret;
4318 }
4319
4320 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
4321                          u32 queues, bool drop)
4322 {
4323         struct ath10k *ar = hw->priv;
4324         bool skip;
4325         int ret;
4326
4327         /* mac80211 doesn't care if we really xmit queued frames or not
4328          * we'll collect those frames either way if we stop/delete vdevs */
4329         if (drop)
4330                 return;
4331
4332         mutex_lock(&ar->conf_mutex);
4333
4334         if (ar->state == ATH10K_STATE_WEDGED)
4335                 goto skip;
4336
4337         ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
4338                         bool empty;
4339
4340                         spin_lock_bh(&ar->htt.tx_lock);
4341                         empty = (ar->htt.num_pending_tx == 0);
4342                         spin_unlock_bh(&ar->htt.tx_lock);
4343
4344                         skip = (ar->state == ATH10K_STATE_WEDGED) ||
4345                                test_bit(ATH10K_FLAG_CRASH_FLUSH,
4346                                         &ar->dev_flags);
4347
4348                         (empty || skip);
4349                 }), ATH10K_FLUSH_TIMEOUT_HZ);
4350
4351         if (ret <= 0 || skip)
4352                 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %i\n",
4353                             skip, ar->state, ret);
4354
4355 skip:
4356         mutex_unlock(&ar->conf_mutex);
4357 }
4358
4359 /* TODO: Implement this function properly
4360  * For now it is needed to reply to Probe Requests in IBSS mode.
4361  * Propably we need this information from FW.
4362  */
4363 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
4364 {
4365         return 1;
4366 }
4367
4368 #ifdef CONFIG_PM
4369 static int ath10k_suspend(struct ieee80211_hw *hw,
4370                           struct cfg80211_wowlan *wowlan)
4371 {
4372         struct ath10k *ar = hw->priv;
4373         int ret;
4374
4375         mutex_lock(&ar->conf_mutex);
4376
4377         ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
4378         if (ret) {
4379                 if (ret == -ETIMEDOUT)
4380                         goto resume;
4381                 ret = 1;
4382                 goto exit;
4383         }
4384
4385         ret = ath10k_hif_suspend(ar);
4386         if (ret) {
4387                 ath10k_warn(ar, "failed to suspend hif: %d\n", ret);
4388                 goto resume;
4389         }
4390
4391         ret = 0;
4392         goto exit;
4393 resume:
4394         ret = ath10k_wmi_pdev_resume_target(ar);
4395         if (ret)
4396                 ath10k_warn(ar, "failed to resume target: %d\n", ret);
4397
4398         ret = 1;
4399 exit:
4400         mutex_unlock(&ar->conf_mutex);
4401         return ret;
4402 }
4403
4404 static int ath10k_resume(struct ieee80211_hw *hw)
4405 {
4406         struct ath10k *ar = hw->priv;
4407         int ret;
4408
4409         mutex_lock(&ar->conf_mutex);
4410
4411         ret = ath10k_hif_resume(ar);
4412         if (ret) {
4413                 ath10k_warn(ar, "failed to resume hif: %d\n", ret);
4414                 ret = 1;
4415                 goto exit;
4416         }
4417
4418         ret = ath10k_wmi_pdev_resume_target(ar);
4419         if (ret) {
4420                 ath10k_warn(ar, "failed to resume target: %d\n", ret);
4421                 ret = 1;
4422                 goto exit;
4423         }
4424
4425         ret = 0;
4426 exit:
4427         mutex_unlock(&ar->conf_mutex);
4428         return ret;
4429 }
4430 #endif
4431
4432 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
4433                                      enum ieee80211_reconfig_type reconfig_type)
4434 {
4435         struct ath10k *ar = hw->priv;
4436
4437         if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
4438                 return;
4439
4440         mutex_lock(&ar->conf_mutex);
4441
4442         /* If device failed to restart it will be in a different state, e.g.
4443          * ATH10K_STATE_WEDGED */
4444         if (ar->state == ATH10K_STATE_RESTARTED) {
4445                 ath10k_info(ar, "device successfully recovered\n");
4446                 ar->state = ATH10K_STATE_ON;
4447                 ieee80211_wake_queues(ar->hw);
4448         }
4449
4450         mutex_unlock(&ar->conf_mutex);
4451 }
4452
4453 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
4454                              struct survey_info *survey)
4455 {
4456         struct ath10k *ar = hw->priv;
4457         struct ieee80211_supported_band *sband;
4458         struct survey_info *ar_survey = &ar->survey[idx];
4459         int ret = 0;
4460
4461         mutex_lock(&ar->conf_mutex);
4462
4463         sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
4464         if (sband && idx >= sband->n_channels) {
4465                 idx -= sband->n_channels;
4466                 sband = NULL;
4467         }
4468
4469         if (!sband)
4470                 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
4471
4472         if (!sband || idx >= sband->n_channels) {
4473                 ret = -ENOENT;
4474                 goto exit;
4475         }
4476
4477         spin_lock_bh(&ar->data_lock);
4478         memcpy(survey, ar_survey, sizeof(*survey));
4479         spin_unlock_bh(&ar->data_lock);
4480
4481         survey->channel = &sband->channels[idx];
4482
4483         if (ar->rx_channel == survey->channel)
4484                 survey->filled |= SURVEY_INFO_IN_USE;
4485
4486 exit:
4487         mutex_unlock(&ar->conf_mutex);
4488         return ret;
4489 }
4490
4491 /* Helper table for legacy fixed_rate/bitrate_mask */
4492 static const u8 cck_ofdm_rate[] = {
4493         /* CCK */
4494         3, /* 1Mbps */
4495         2, /* 2Mbps */
4496         1, /* 5.5Mbps */
4497         0, /* 11Mbps */
4498         /* OFDM */
4499         3, /* 6Mbps */
4500         7, /* 9Mbps */
4501         2, /* 12Mbps */
4502         6, /* 18Mbps */
4503         1, /* 24Mbps */
4504         5, /* 36Mbps */
4505         0, /* 48Mbps */
4506         4, /* 54Mbps */
4507 };
4508
4509 /* Check if only one bit set */
4510 static int ath10k_check_single_mask(u32 mask)
4511 {
4512         int bit;
4513
4514         bit = ffs(mask);
4515         if (!bit)
4516                 return 0;
4517
4518         mask &= ~BIT(bit - 1);
4519         if (mask)
4520                 return 2;
4521
4522         return 1;
4523 }
4524
4525 static bool
4526 ath10k_default_bitrate_mask(struct ath10k *ar,
4527                             enum ieee80211_band band,
4528                             const struct cfg80211_bitrate_mask *mask)
4529 {
4530         u32 legacy = 0x00ff;
4531         u8 ht = 0xff, i;
4532         u16 vht = 0x3ff;
4533         u16 nrf = ar->num_rf_chains;
4534
4535         if (ar->cfg_tx_chainmask)
4536                 nrf = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4537
4538         switch (band) {
4539         case IEEE80211_BAND_2GHZ:
4540                 legacy = 0x00fff;
4541                 vht = 0;
4542                 break;
4543         case IEEE80211_BAND_5GHZ:
4544                 break;
4545         default:
4546                 return false;
4547         }
4548
4549         if (mask->control[band].legacy != legacy)
4550                 return false;
4551
4552         for (i = 0; i < nrf; i++)
4553                 if (mask->control[band].ht_mcs[i] != ht)
4554                         return false;
4555
4556         for (i = 0; i < nrf; i++)
4557                 if (mask->control[band].vht_mcs[i] != vht)
4558                         return false;
4559
4560         return true;
4561 }
4562
4563 static bool
4564 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
4565                         enum ieee80211_band band,
4566                         u8 *fixed_nss)
4567 {
4568         int ht_nss = 0, vht_nss = 0, i;
4569
4570         /* check legacy */
4571         if (ath10k_check_single_mask(mask->control[band].legacy))
4572                 return false;
4573
4574         /* check HT */
4575         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4576                 if (mask->control[band].ht_mcs[i] == 0xff)
4577                         continue;
4578                 else if (mask->control[band].ht_mcs[i] == 0x00)
4579                         break;
4580
4581                 return false;
4582         }
4583
4584         ht_nss = i;
4585
4586         /* check VHT */
4587         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4588                 if (mask->control[band].vht_mcs[i] == 0x03ff)
4589                         continue;
4590                 else if (mask->control[band].vht_mcs[i] == 0x0000)
4591                         break;
4592
4593                 return false;
4594         }
4595
4596         vht_nss = i;
4597
4598         if (ht_nss > 0 && vht_nss > 0)
4599                 return false;
4600
4601         if (ht_nss)
4602                 *fixed_nss = ht_nss;
4603         else if (vht_nss)
4604                 *fixed_nss = vht_nss;
4605         else
4606                 return false;
4607
4608         return true;
4609 }
4610
4611 static bool
4612 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
4613                             enum ieee80211_band band,
4614                             enum wmi_rate_preamble *preamble)
4615 {
4616         int legacy = 0, ht = 0, vht = 0, i;
4617
4618         *preamble = WMI_RATE_PREAMBLE_OFDM;
4619
4620         /* check legacy */
4621         legacy = ath10k_check_single_mask(mask->control[band].legacy);
4622         if (legacy > 1)
4623                 return false;
4624
4625         /* check HT */
4626         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4627                 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
4628         if (ht > 1)
4629                 return false;
4630
4631         /* check VHT */
4632         for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4633                 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
4634         if (vht > 1)
4635                 return false;
4636
4637         /* Currently we support only one fixed_rate */
4638         if ((legacy + ht + vht) != 1)
4639                 return false;
4640
4641         if (ht)
4642                 *preamble = WMI_RATE_PREAMBLE_HT;
4643         else if (vht)
4644                 *preamble = WMI_RATE_PREAMBLE_VHT;
4645
4646         return true;
4647 }
4648
4649 static bool
4650 ath10k_bitrate_mask_rate(struct ath10k *ar,
4651                          const struct cfg80211_bitrate_mask *mask,
4652                          enum ieee80211_band band,
4653                          u8 *fixed_rate,
4654                          u8 *fixed_nss)
4655 {
4656         u8 rate = 0, pream = 0, nss = 0, i;
4657         enum wmi_rate_preamble preamble;
4658
4659         /* Check if single rate correct */
4660         if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
4661                 return false;
4662
4663         pream = preamble;
4664
4665         switch (preamble) {
4666         case WMI_RATE_PREAMBLE_CCK:
4667         case WMI_RATE_PREAMBLE_OFDM:
4668                 i = ffs(mask->control[band].legacy) - 1;
4669
4670                 if (band == IEEE80211_BAND_2GHZ && i < 4)
4671                         pream = WMI_RATE_PREAMBLE_CCK;
4672
4673                 if (band == IEEE80211_BAND_5GHZ)
4674                         i += 4;
4675
4676                 if (i >= ARRAY_SIZE(cck_ofdm_rate))
4677                         return false;
4678
4679                 rate = cck_ofdm_rate[i];
4680                 break;
4681         case WMI_RATE_PREAMBLE_HT:
4682                 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4683                         if (mask->control[band].ht_mcs[i])
4684                                 break;
4685
4686                 if (i == IEEE80211_HT_MCS_MASK_LEN)
4687                         return false;
4688
4689                 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4690                 nss = i;
4691                 break;
4692         case WMI_RATE_PREAMBLE_VHT:
4693                 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4694                         if (mask->control[band].vht_mcs[i])
4695                                 break;
4696
4697                 if (i == NL80211_VHT_NSS_MAX)
4698                         return false;
4699
4700                 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4701                 nss = i;
4702                 break;
4703         }
4704
4705         *fixed_nss = nss + 1;
4706         nss <<= 4;
4707         pream <<= 6;
4708
4709         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
4710                    pream, nss, rate);
4711
4712         *fixed_rate = pream | nss | rate;
4713
4714         return true;
4715 }
4716
4717 static bool ath10k_get_fixed_rate_nss(struct ath10k *ar,
4718                                       const struct cfg80211_bitrate_mask *mask,
4719                                       enum ieee80211_band band,
4720                                       u8 *fixed_rate,
4721                                       u8 *fixed_nss)
4722 {
4723         /* First check full NSS mask, if we can simply limit NSS */
4724         if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
4725                 return true;
4726
4727         /* Next Check single rate is set */
4728         return ath10k_bitrate_mask_rate(ar, mask, band, fixed_rate, fixed_nss);
4729 }
4730
4731 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
4732                                        u8 fixed_rate,
4733                                        u8 fixed_nss,
4734                                        u8 force_sgi)
4735 {
4736         struct ath10k *ar = arvif->ar;
4737         u32 vdev_param;
4738         int ret = 0;
4739
4740         mutex_lock(&ar->conf_mutex);
4741
4742         if (arvif->fixed_rate == fixed_rate &&
4743             arvif->fixed_nss == fixed_nss &&
4744             arvif->force_sgi == force_sgi)
4745                 goto exit;
4746
4747         if (fixed_rate == WMI_FIXED_RATE_NONE)
4748                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
4749
4750         if (force_sgi)
4751                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac force sgi\n");
4752
4753         vdev_param = ar->wmi.vdev_param->fixed_rate;
4754         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4755                                         vdev_param, fixed_rate);
4756         if (ret) {
4757                 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
4758                             fixed_rate, ret);
4759                 ret = -EINVAL;
4760                 goto exit;
4761         }
4762
4763         arvif->fixed_rate = fixed_rate;
4764
4765         vdev_param = ar->wmi.vdev_param->nss;
4766         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4767                                         vdev_param, fixed_nss);
4768
4769         if (ret) {
4770                 ath10k_warn(ar, "failed to set fixed nss param %d: %d\n",
4771                             fixed_nss, ret);
4772                 ret = -EINVAL;
4773                 goto exit;
4774         }
4775
4776         arvif->fixed_nss = fixed_nss;
4777
4778         vdev_param = ar->wmi.vdev_param->sgi;
4779         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4780                                         force_sgi);
4781
4782         if (ret) {
4783                 ath10k_warn(ar, "failed to set sgi param %d: %d\n",
4784                             force_sgi, ret);
4785                 ret = -EINVAL;
4786                 goto exit;
4787         }
4788
4789         arvif->force_sgi = force_sgi;
4790
4791 exit:
4792         mutex_unlock(&ar->conf_mutex);
4793         return ret;
4794 }
4795
4796 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
4797                                    struct ieee80211_vif *vif,
4798                                    const struct cfg80211_bitrate_mask *mask)
4799 {
4800         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4801         struct ath10k *ar = arvif->ar;
4802         enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
4803         u8 fixed_rate = WMI_FIXED_RATE_NONE;
4804         u8 fixed_nss = ar->num_rf_chains;
4805         u8 force_sgi;
4806
4807         if (ar->cfg_tx_chainmask)
4808                 fixed_nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4809
4810         force_sgi = mask->control[band].gi;
4811         if (force_sgi == NL80211_TXRATE_FORCE_LGI)
4812                 return -EINVAL;
4813
4814         if (!ath10k_default_bitrate_mask(ar, band, mask)) {
4815                 if (!ath10k_get_fixed_rate_nss(ar, mask, band,
4816                                                &fixed_rate,
4817                                                &fixed_nss))
4818                         return -EINVAL;
4819         }
4820
4821         if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) {
4822                 ath10k_warn(ar, "failed to force SGI usage for default rate settings\n");
4823                 return -EINVAL;
4824         }
4825
4826         return ath10k_set_fixed_rate_param(arvif, fixed_rate,
4827                                            fixed_nss, force_sgi);
4828 }
4829
4830 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
4831                                  struct ieee80211_vif *vif,
4832                                  struct ieee80211_sta *sta,
4833                                  u32 changed)
4834 {
4835         struct ath10k *ar = hw->priv;
4836         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
4837         u32 bw, smps;
4838
4839         spin_lock_bh(&ar->data_lock);
4840
4841         ath10k_dbg(ar, ATH10K_DBG_MAC,
4842                    "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4843                    sta->addr, changed, sta->bandwidth, sta->rx_nss,
4844                    sta->smps_mode);
4845
4846         if (changed & IEEE80211_RC_BW_CHANGED) {
4847                 bw = WMI_PEER_CHWIDTH_20MHZ;
4848
4849                 switch (sta->bandwidth) {
4850                 case IEEE80211_STA_RX_BW_20:
4851                         bw = WMI_PEER_CHWIDTH_20MHZ;
4852                         break;
4853                 case IEEE80211_STA_RX_BW_40:
4854                         bw = WMI_PEER_CHWIDTH_40MHZ;
4855                         break;
4856                 case IEEE80211_STA_RX_BW_80:
4857                         bw = WMI_PEER_CHWIDTH_80MHZ;
4858                         break;
4859                 case IEEE80211_STA_RX_BW_160:
4860                         ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
4861                                     sta->bandwidth, sta->addr);
4862                         bw = WMI_PEER_CHWIDTH_20MHZ;
4863                         break;
4864                 }
4865
4866                 arsta->bw = bw;
4867         }
4868
4869         if (changed & IEEE80211_RC_NSS_CHANGED)
4870                 arsta->nss = sta->rx_nss;
4871
4872         if (changed & IEEE80211_RC_SMPS_CHANGED) {
4873                 smps = WMI_PEER_SMPS_PS_NONE;
4874
4875                 switch (sta->smps_mode) {
4876                 case IEEE80211_SMPS_AUTOMATIC:
4877                 case IEEE80211_SMPS_OFF:
4878                         smps = WMI_PEER_SMPS_PS_NONE;
4879                         break;
4880                 case IEEE80211_SMPS_STATIC:
4881                         smps = WMI_PEER_SMPS_STATIC;
4882                         break;
4883                 case IEEE80211_SMPS_DYNAMIC:
4884                         smps = WMI_PEER_SMPS_DYNAMIC;
4885                         break;
4886                 case IEEE80211_SMPS_NUM_MODES:
4887                         ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
4888                                     sta->smps_mode, sta->addr);
4889                         smps = WMI_PEER_SMPS_PS_NONE;
4890                         break;
4891                 }
4892
4893                 arsta->smps = smps;
4894         }
4895
4896         arsta->changed |= changed;
4897
4898         spin_unlock_bh(&ar->data_lock);
4899
4900         ieee80211_queue_work(hw, &arsta->update_wk);
4901 }
4902
4903 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4904 {
4905         /*
4906          * FIXME: Return 0 for time being. Need to figure out whether FW
4907          * has the API to fetch 64-bit local TSF
4908          */
4909
4910         return 0;
4911 }
4912
4913 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
4914                                struct ieee80211_vif *vif,
4915                                enum ieee80211_ampdu_mlme_action action,
4916                                struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4917                                u8 buf_size)
4918 {
4919         struct ath10k *ar = hw->priv;
4920         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4921
4922         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
4923                    arvif->vdev_id, sta->addr, tid, action);
4924
4925         switch (action) {
4926         case IEEE80211_AMPDU_RX_START:
4927         case IEEE80211_AMPDU_RX_STOP:
4928                 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
4929                  * creation/removal. Do we need to verify this?
4930                  */
4931                 return 0;
4932         case IEEE80211_AMPDU_TX_START:
4933         case IEEE80211_AMPDU_TX_STOP_CONT:
4934         case IEEE80211_AMPDU_TX_STOP_FLUSH:
4935         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
4936         case IEEE80211_AMPDU_TX_OPERATIONAL:
4937                 /* Firmware offloads Tx aggregation entirely so deny mac80211
4938                  * Tx aggregation requests.
4939                  */
4940                 return -EOPNOTSUPP;
4941         }
4942
4943         return -EINVAL;
4944 }
4945
4946 static const struct ieee80211_ops ath10k_ops = {
4947         .tx                             = ath10k_tx,
4948         .start                          = ath10k_start,
4949         .stop                           = ath10k_stop,
4950         .config                         = ath10k_config,
4951         .add_interface                  = ath10k_add_interface,
4952         .remove_interface               = ath10k_remove_interface,
4953         .configure_filter               = ath10k_configure_filter,
4954         .bss_info_changed               = ath10k_bss_info_changed,
4955         .hw_scan                        = ath10k_hw_scan,
4956         .cancel_hw_scan                 = ath10k_cancel_hw_scan,
4957         .set_key                        = ath10k_set_key,
4958         .set_default_unicast_key        = ath10k_set_default_unicast_key,
4959         .sta_state                      = ath10k_sta_state,
4960         .conf_tx                        = ath10k_conf_tx,
4961         .remain_on_channel              = ath10k_remain_on_channel,
4962         .cancel_remain_on_channel       = ath10k_cancel_remain_on_channel,
4963         .set_rts_threshold              = ath10k_set_rts_threshold,
4964         .flush                          = ath10k_flush,
4965         .tx_last_beacon                 = ath10k_tx_last_beacon,
4966         .set_antenna                    = ath10k_set_antenna,
4967         .get_antenna                    = ath10k_get_antenna,
4968         .reconfig_complete              = ath10k_reconfig_complete,
4969         .get_survey                     = ath10k_get_survey,
4970         .set_bitrate_mask               = ath10k_set_bitrate_mask,
4971         .sta_rc_update                  = ath10k_sta_rc_update,
4972         .get_tsf                        = ath10k_get_tsf,
4973         .ampdu_action                   = ath10k_ampdu_action,
4974         .get_et_sset_count              = ath10k_debug_get_et_sset_count,
4975         .get_et_stats                   = ath10k_debug_get_et_stats,
4976         .get_et_strings                 = ath10k_debug_get_et_strings,
4977
4978         CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
4979
4980 #ifdef CONFIG_PM
4981         .suspend                        = ath10k_suspend,
4982         .resume                         = ath10k_resume,
4983 #endif
4984 #ifdef CONFIG_MAC80211_DEBUGFS
4985         .sta_add_debugfs                = ath10k_sta_add_debugfs,
4986 #endif
4987 };
4988
4989 #define RATETAB_ENT(_rate, _rateid, _flags) { \
4990         .bitrate                = (_rate), \
4991         .flags                  = (_flags), \
4992         .hw_value               = (_rateid), \
4993 }
4994
4995 #define CHAN2G(_channel, _freq, _flags) { \
4996         .band                   = IEEE80211_BAND_2GHZ, \
4997         .hw_value               = (_channel), \
4998         .center_freq            = (_freq), \
4999         .flags                  = (_flags), \
5000         .max_antenna_gain       = 0, \
5001         .max_power              = 30, \
5002 }
5003
5004 #define CHAN5G(_channel, _freq, _flags) { \
5005         .band                   = IEEE80211_BAND_5GHZ, \
5006         .hw_value               = (_channel), \
5007         .center_freq            = (_freq), \
5008         .flags                  = (_flags), \
5009         .max_antenna_gain       = 0, \
5010         .max_power              = 30, \
5011 }
5012
5013 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
5014         CHAN2G(1, 2412, 0),
5015         CHAN2G(2, 2417, 0),
5016         CHAN2G(3, 2422, 0),
5017         CHAN2G(4, 2427, 0),
5018         CHAN2G(5, 2432, 0),
5019         CHAN2G(6, 2437, 0),
5020         CHAN2G(7, 2442, 0),
5021         CHAN2G(8, 2447, 0),
5022         CHAN2G(9, 2452, 0),
5023         CHAN2G(10, 2457, 0),
5024         CHAN2G(11, 2462, 0),
5025         CHAN2G(12, 2467, 0),
5026         CHAN2G(13, 2472, 0),
5027         CHAN2G(14, 2484, 0),
5028 };
5029
5030 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
5031         CHAN5G(36, 5180, 0),
5032         CHAN5G(40, 5200, 0),
5033         CHAN5G(44, 5220, 0),
5034         CHAN5G(48, 5240, 0),
5035         CHAN5G(52, 5260, 0),
5036         CHAN5G(56, 5280, 0),
5037         CHAN5G(60, 5300, 0),
5038         CHAN5G(64, 5320, 0),
5039         CHAN5G(100, 5500, 0),
5040         CHAN5G(104, 5520, 0),
5041         CHAN5G(108, 5540, 0),
5042         CHAN5G(112, 5560, 0),
5043         CHAN5G(116, 5580, 0),
5044         CHAN5G(120, 5600, 0),
5045         CHAN5G(124, 5620, 0),
5046         CHAN5G(128, 5640, 0),
5047         CHAN5G(132, 5660, 0),
5048         CHAN5G(136, 5680, 0),
5049         CHAN5G(140, 5700, 0),
5050         CHAN5G(149, 5745, 0),
5051         CHAN5G(153, 5765, 0),
5052         CHAN5G(157, 5785, 0),
5053         CHAN5G(161, 5805, 0),
5054         CHAN5G(165, 5825, 0),
5055 };
5056
5057 /* Note: Be careful if you re-order these. There is code which depends on this
5058  * ordering.
5059  */
5060 static struct ieee80211_rate ath10k_rates[] = {
5061         /* CCK */
5062         RATETAB_ENT(10,  0x82, 0),
5063         RATETAB_ENT(20,  0x84, 0),
5064         RATETAB_ENT(55,  0x8b, 0),
5065         RATETAB_ENT(110, 0x96, 0),
5066         /* OFDM */
5067         RATETAB_ENT(60,  0x0c, 0),
5068         RATETAB_ENT(90,  0x12, 0),
5069         RATETAB_ENT(120, 0x18, 0),
5070         RATETAB_ENT(180, 0x24, 0),
5071         RATETAB_ENT(240, 0x30, 0),
5072         RATETAB_ENT(360, 0x48, 0),
5073         RATETAB_ENT(480, 0x60, 0),
5074         RATETAB_ENT(540, 0x6c, 0),
5075 };
5076
5077 #define ath10k_a_rates (ath10k_rates + 4)
5078 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
5079 #define ath10k_g_rates (ath10k_rates + 0)
5080 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
5081
5082 struct ath10k *ath10k_mac_create(size_t priv_size)
5083 {
5084         struct ieee80211_hw *hw;
5085         struct ath10k *ar;
5086
5087         hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
5088         if (!hw)
5089                 return NULL;
5090
5091         ar = hw->priv;
5092         ar->hw = hw;
5093
5094         return ar;
5095 }
5096
5097 void ath10k_mac_destroy(struct ath10k *ar)
5098 {
5099         ieee80211_free_hw(ar->hw);
5100 }
5101
5102 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
5103         {
5104         .max    = 8,
5105         .types  = BIT(NL80211_IFTYPE_STATION)
5106                 | BIT(NL80211_IFTYPE_P2P_CLIENT)
5107         },
5108         {
5109         .max    = 3,
5110         .types  = BIT(NL80211_IFTYPE_P2P_GO)
5111         },
5112         {
5113         .max    = 1,
5114         .types  = BIT(NL80211_IFTYPE_P2P_DEVICE)
5115         },
5116         {
5117         .max    = 7,
5118         .types  = BIT(NL80211_IFTYPE_AP)
5119         },
5120 };
5121
5122 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
5123         {
5124         .max    = 8,
5125         .types  = BIT(NL80211_IFTYPE_AP)
5126         },
5127 };
5128
5129 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
5130         {
5131                 .limits = ath10k_if_limits,
5132                 .n_limits = ARRAY_SIZE(ath10k_if_limits),
5133                 .max_interfaces = 8,
5134                 .num_different_channels = 1,
5135                 .beacon_int_infra_match = true,
5136         },
5137 };
5138
5139 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
5140         {
5141                 .limits = ath10k_10x_if_limits,
5142                 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
5143                 .max_interfaces = 8,
5144                 .num_different_channels = 1,
5145                 .beacon_int_infra_match = true,
5146 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
5147                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
5148                                         BIT(NL80211_CHAN_WIDTH_20) |
5149                                         BIT(NL80211_CHAN_WIDTH_40) |
5150                                         BIT(NL80211_CHAN_WIDTH_80),
5151 #endif
5152         },
5153 };
5154
5155 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
5156 {
5157         struct ieee80211_sta_vht_cap vht_cap = {0};
5158         u16 mcs_map;
5159         int i;
5160
5161         vht_cap.vht_supported = 1;
5162         vht_cap.cap = ar->vht_cap_info;
5163
5164         mcs_map = 0;
5165         for (i = 0; i < 8; i++) {
5166                 if (i < ar->num_rf_chains)
5167                         mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
5168                 else
5169                         mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
5170         }
5171
5172         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
5173         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
5174
5175         return vht_cap;
5176 }
5177
5178 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
5179 {
5180         int i;
5181         struct ieee80211_sta_ht_cap ht_cap = {0};
5182
5183         if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
5184                 return ht_cap;
5185
5186         ht_cap.ht_supported = 1;
5187         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
5188         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
5189         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
5190         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
5191         ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
5192
5193         if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
5194                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
5195
5196         if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
5197                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
5198
5199         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
5200                 u32 smps;
5201
5202                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
5203                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
5204
5205                 ht_cap.cap |= smps;
5206         }
5207
5208         if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
5209                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
5210
5211         if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
5212                 u32 stbc;
5213
5214                 stbc   = ar->ht_cap_info;
5215                 stbc  &= WMI_HT_CAP_RX_STBC;
5216                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
5217                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
5218                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
5219
5220                 ht_cap.cap |= stbc;
5221         }
5222
5223         if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
5224                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
5225
5226         if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
5227                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
5228
5229         /* max AMSDU is implicitly taken from vht_cap_info */
5230         if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
5231                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
5232
5233         for (i = 0; i < ar->num_rf_chains; i++)
5234                 ht_cap.mcs.rx_mask[i] = 0xFF;
5235
5236         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
5237
5238         return ht_cap;
5239 }
5240
5241 static void ath10k_get_arvif_iter(void *data, u8 *mac,
5242                                   struct ieee80211_vif *vif)
5243 {
5244         struct ath10k_vif_iter *arvif_iter = data;
5245         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5246
5247         if (arvif->vdev_id == arvif_iter->vdev_id)
5248                 arvif_iter->arvif = arvif;
5249 }
5250
5251 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
5252 {
5253         struct ath10k_vif_iter arvif_iter;
5254         u32 flags;
5255
5256         memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
5257         arvif_iter.vdev_id = vdev_id;
5258
5259         flags = IEEE80211_IFACE_ITER_RESUME_ALL;
5260         ieee80211_iterate_active_interfaces_atomic(ar->hw,
5261                                                    flags,
5262                                                    ath10k_get_arvif_iter,
5263                                                    &arvif_iter);
5264         if (!arvif_iter.arvif) {
5265                 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
5266                 return NULL;
5267         }
5268
5269         return arvif_iter.arvif;
5270 }
5271
5272 int ath10k_mac_register(struct ath10k *ar)
5273 {
5274         static const u32 cipher_suites[] = {
5275                 WLAN_CIPHER_SUITE_WEP40,
5276                 WLAN_CIPHER_SUITE_WEP104,
5277                 WLAN_CIPHER_SUITE_TKIP,
5278                 WLAN_CIPHER_SUITE_CCMP,
5279                 WLAN_CIPHER_SUITE_AES_CMAC,
5280         };
5281         struct ieee80211_supported_band *band;
5282         struct ieee80211_sta_vht_cap vht_cap;
5283         struct ieee80211_sta_ht_cap ht_cap;
5284         void *channels;
5285         int ret;
5286
5287         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
5288
5289         SET_IEEE80211_DEV(ar->hw, ar->dev);
5290
5291         ht_cap = ath10k_get_ht_cap(ar);
5292         vht_cap = ath10k_create_vht_cap(ar);
5293
5294         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
5295                 channels = kmemdup(ath10k_2ghz_channels,
5296                                    sizeof(ath10k_2ghz_channels),
5297                                    GFP_KERNEL);
5298                 if (!channels) {
5299                         ret = -ENOMEM;
5300                         goto err_free;
5301                 }
5302
5303                 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
5304                 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
5305                 band->channels = channels;
5306                 band->n_bitrates = ath10k_g_rates_size;
5307                 band->bitrates = ath10k_g_rates;
5308                 band->ht_cap = ht_cap;
5309
5310                 /* Enable the VHT support at 2.4 GHz */
5311                 band->vht_cap = vht_cap;
5312
5313                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
5314         }
5315
5316         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
5317                 channels = kmemdup(ath10k_5ghz_channels,
5318                                    sizeof(ath10k_5ghz_channels),
5319                                    GFP_KERNEL);
5320                 if (!channels) {
5321                         ret = -ENOMEM;
5322                         goto err_free;
5323                 }
5324
5325                 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
5326                 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
5327                 band->channels = channels;
5328                 band->n_bitrates = ath10k_a_rates_size;
5329                 band->bitrates = ath10k_a_rates;
5330                 band->ht_cap = ht_cap;
5331                 band->vht_cap = vht_cap;
5332                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
5333         }
5334
5335         ar->hw->wiphy->interface_modes =
5336                 BIT(NL80211_IFTYPE_STATION) |
5337                 BIT(NL80211_IFTYPE_AP);
5338
5339         ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
5340         ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
5341
5342         if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
5343                 ar->hw->wiphy->interface_modes |=
5344                         BIT(NL80211_IFTYPE_P2P_DEVICE) |
5345                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
5346                         BIT(NL80211_IFTYPE_P2P_GO);
5347
5348         ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
5349                         IEEE80211_HW_SUPPORTS_PS |
5350                         IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
5351                         IEEE80211_HW_MFP_CAPABLE |
5352                         IEEE80211_HW_REPORTS_TX_ACK_STATUS |
5353                         IEEE80211_HW_HAS_RATE_CONTROL |
5354                         IEEE80211_HW_AP_LINK_PS |
5355                         IEEE80211_HW_SPECTRUM_MGMT |
5356                         IEEE80211_HW_SW_CRYPTO_CONTROL;
5357
5358         ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
5359
5360         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
5361                 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
5362
5363         if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
5364                 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
5365                 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
5366         }
5367
5368         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
5369         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
5370
5371         ar->hw->vif_data_size = sizeof(struct ath10k_vif);
5372         ar->hw->sta_data_size = sizeof(struct ath10k_sta);
5373
5374         ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
5375
5376         if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
5377                 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
5378
5379                 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
5380                  * that userspace (e.g. wpa_supplicant/hostapd) can generate
5381                  * correct Probe Responses. This is more of a hack advert..
5382                  */
5383                 ar->hw->wiphy->probe_resp_offload |=
5384                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
5385                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
5386                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
5387         }
5388
5389         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
5390         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
5391         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
5392
5393         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
5394         ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
5395
5396         /*
5397          * on LL hardware queues are managed entirely by the FW
5398          * so we only advertise to mac we can do the queues thing
5399          */
5400         ar->hw->queues = 4;
5401
5402         switch (ar->wmi.op_version) {
5403         case ATH10K_FW_WMI_OP_VERSION_MAIN:
5404         case ATH10K_FW_WMI_OP_VERSION_TLV:
5405                 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
5406                 ar->hw->wiphy->n_iface_combinations =
5407                         ARRAY_SIZE(ath10k_if_comb);
5408                 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
5409                 break;
5410         case ATH10K_FW_WMI_OP_VERSION_10_1:
5411         case ATH10K_FW_WMI_OP_VERSION_10_2:
5412         case ATH10K_FW_WMI_OP_VERSION_10_2_4:
5413                 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
5414                 ar->hw->wiphy->n_iface_combinations =
5415                         ARRAY_SIZE(ath10k_10x_if_comb);
5416                 break;
5417         case ATH10K_FW_WMI_OP_VERSION_UNSET:
5418         case ATH10K_FW_WMI_OP_VERSION_MAX:
5419                 WARN_ON(1);
5420                 ret = -EINVAL;
5421                 goto err_free;
5422         }
5423
5424         ar->hw->netdev_features = NETIF_F_HW_CSUM;
5425
5426         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
5427                 /* Init ath dfs pattern detector */
5428                 ar->ath_common.debug_mask = ATH_DBG_DFS;
5429                 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
5430                                                              NL80211_DFS_UNSET);
5431
5432                 if (!ar->dfs_detector)
5433                         ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
5434         }
5435
5436         ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
5437                             ath10k_reg_notifier);
5438         if (ret) {
5439                 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
5440                 goto err_free;
5441         }
5442
5443         ar->hw->wiphy->cipher_suites = cipher_suites;
5444         ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
5445
5446         ret = ieee80211_register_hw(ar->hw);
5447         if (ret) {
5448                 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
5449                 goto err_free;
5450         }
5451
5452         if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
5453                 ret = regulatory_hint(ar->hw->wiphy,
5454                                       ar->ath_common.regulatory.alpha2);
5455                 if (ret)
5456                         goto err_unregister;
5457         }
5458
5459         return 0;
5460
5461 err_unregister:
5462         ieee80211_unregister_hw(ar->hw);
5463 err_free:
5464         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
5465         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
5466
5467         return ret;
5468 }
5469
5470 void ath10k_mac_unregister(struct ath10k *ar)
5471 {
5472         ieee80211_unregister_hw(ar->hw);
5473
5474         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
5475                 ar->dfs_detector->exit(ar->dfs_detector);
5476
5477         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
5478         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
5479
5480         SET_IEEE80211_DEV(ar->hw, NULL);
5481 }