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