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