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

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