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