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         mutex_lock(&arvif->ar->conf_mutex);
1895
1896         if (arvif->ar->state != ATH10K_STATE_ON)
1897                 goto unlock;
1898
1899         if (arvif->def_wep_key_idx == keyidx)
1900                 goto unlock;
1901
1902         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
1903                    arvif->vdev_id, keyidx);
1904
1905         ret = ath10k_wmi_vdev_set_param(arvif->ar,
1906                                         arvif->vdev_id,
1907                                         arvif->ar->wmi.vdev_param->def_keyid,
1908                                         keyidx);
1909         if (ret) {
1910                 ath10k_warn("failed to update wep key index for vdev %d: %d\n",
1911                             arvif->vdev_id,
1912                             ret);
1913                 goto unlock;
1914         }
1915
1916         arvif->def_wep_key_idx = keyidx;
1917
1918 unlock:
1919         mutex_unlock(&arvif->ar->conf_mutex);
1920 }
1921
1922 static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
1923 {
1924         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1925         struct ieee80211_vif *vif = info->control.vif;
1926         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1927         struct ath10k *ar = arvif->ar;
1928         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1929         struct ieee80211_key_conf *key = info->control.hw_key;
1930
1931         if (!ieee80211_has_protected(hdr->frame_control))
1932                 return;
1933
1934         if (!key)
1935                 return;
1936
1937         if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1938             key->cipher != WLAN_CIPHER_SUITE_WEP104)
1939                 return;
1940
1941         if (key->keyidx == arvif->def_wep_key_idx)
1942                 return;
1943
1944         /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1945          * queueing frames until key index is updated is not an option because
1946          * sk_buff may need more processing to be done, e.g. offchannel */
1947         arvif->def_wep_key_newidx = key->keyidx;
1948         ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
1949 }
1950
1951 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb)
1952 {
1953         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1954         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1955         struct ieee80211_vif *vif = info->control.vif;
1956         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1957
1958         /* This is case only for P2P_GO */
1959         if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1960             arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1961                 return;
1962
1963         if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1964                 spin_lock_bh(&ar->data_lock);
1965                 if (arvif->u.ap.noa_data)
1966                         if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1967                                               GFP_ATOMIC))
1968                                 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1969                                        arvif->u.ap.noa_data,
1970                                        arvif->u.ap.noa_len);
1971                 spin_unlock_bh(&ar->data_lock);
1972         }
1973 }
1974
1975 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1976 {
1977         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1978         int ret = 0;
1979
1980         if (ar->htt.target_version_major >= 3) {
1981                 /* Since HTT 3.0 there is no separate mgmt tx command */
1982                 ret = ath10k_htt_tx(&ar->htt, skb);
1983                 goto exit;
1984         }
1985
1986         if (ieee80211_is_mgmt(hdr->frame_control)) {
1987                 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
1988                              ar->fw_features)) {
1989                         if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
1990                             ATH10K_MAX_NUM_MGMT_PENDING) {
1991                                 ath10k_warn("reached WMI management tranmist queue limit\n");
1992                                 ret = -EBUSY;
1993                                 goto exit;
1994                         }
1995
1996                         skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
1997                         ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
1998                 } else {
1999                         ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2000                 }
2001         } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2002                              ar->fw_features) &&
2003                    ieee80211_is_nullfunc(hdr->frame_control)) {
2004                 /* FW does not report tx status properly for NullFunc frames
2005                  * unless they are sent through mgmt tx path. mac80211 sends
2006                  * those frames when it detects link/beacon loss and depends
2007                  * on the tx status to be correct. */
2008                 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2009         } else {
2010                 ret = ath10k_htt_tx(&ar->htt, skb);
2011         }
2012
2013 exit:
2014         if (ret) {
2015                 ath10k_warn("failed to transmit packet, dropping: %d\n", ret);
2016                 ieee80211_free_txskb(ar->hw, skb);
2017         }
2018 }
2019
2020 void ath10k_offchan_tx_purge(struct ath10k *ar)
2021 {
2022         struct sk_buff *skb;
2023
2024         for (;;) {
2025                 skb = skb_dequeue(&ar->offchan_tx_queue);
2026                 if (!skb)
2027                         break;
2028
2029                 ieee80211_free_txskb(ar->hw, skb);
2030         }
2031 }
2032
2033 void ath10k_offchan_tx_work(struct work_struct *work)
2034 {
2035         struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
2036         struct ath10k_peer *peer;
2037         struct ieee80211_hdr *hdr;
2038         struct sk_buff *skb;
2039         const u8 *peer_addr;
2040         int vdev_id;
2041         int ret;
2042
2043         /* FW requirement: We must create a peer before FW will send out
2044          * an offchannel frame. Otherwise the frame will be stuck and
2045          * never transmitted. We delete the peer upon tx completion.
2046          * It is unlikely that a peer for offchannel tx will already be
2047          * present. However it may be in some rare cases so account for that.
2048          * Otherwise we might remove a legitimate peer and break stuff. */
2049
2050         for (;;) {
2051                 skb = skb_dequeue(&ar->offchan_tx_queue);
2052                 if (!skb)
2053                         break;
2054
2055                 mutex_lock(&ar->conf_mutex);
2056
2057                 ath10k_dbg(ATH10K_DBG_MAC, "mac offchannel skb %p\n",
2058                            skb);
2059
2060                 hdr = (struct ieee80211_hdr *)skb->data;
2061                 peer_addr = ieee80211_get_DA(hdr);
2062                 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
2063
2064                 spin_lock_bh(&ar->data_lock);
2065                 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
2066                 spin_unlock_bh(&ar->data_lock);
2067
2068                 if (peer)
2069                         /* FIXME: should this use ath10k_warn()? */
2070                         ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
2071                                    peer_addr, vdev_id);
2072
2073                 if (!peer) {
2074                         ret = ath10k_peer_create(ar, vdev_id, peer_addr);
2075                         if (ret)
2076                                 ath10k_warn("failed to create peer %pM on vdev %d: %d\n",
2077                                             peer_addr, vdev_id, ret);
2078                 }
2079
2080                 spin_lock_bh(&ar->data_lock);
2081                 reinit_completion(&ar->offchan_tx_completed);
2082                 ar->offchan_tx_skb = skb;
2083                 spin_unlock_bh(&ar->data_lock);
2084
2085                 ath10k_tx_htt(ar, skb);
2086
2087                 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
2088                                                   3 * HZ);
2089                 if (ret <= 0)
2090                         ath10k_warn("timed out waiting for offchannel skb %p\n",
2091                                     skb);
2092
2093                 if (!peer) {
2094                         ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
2095                         if (ret)
2096                                 ath10k_warn("failed to delete peer %pM on vdev %d: %d\n",
2097                                             peer_addr, vdev_id, ret);
2098                 }
2099
2100                 mutex_unlock(&ar->conf_mutex);
2101         }
2102 }
2103
2104 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
2105 {
2106         struct sk_buff *skb;
2107
2108         for (;;) {
2109                 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2110                 if (!skb)
2111                         break;
2112
2113                 ieee80211_free_txskb(ar->hw, skb);
2114         }
2115 }
2116
2117 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
2118 {
2119         struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
2120         struct sk_buff *skb;
2121         int ret;
2122
2123         for (;;) {
2124                 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2125                 if (!skb)
2126                         break;
2127
2128                 ret = ath10k_wmi_mgmt_tx(ar, skb);
2129                 if (ret) {
2130                         ath10k_warn("failed to transmit management frame via WMI: %d\n",
2131                                     ret);
2132                         ieee80211_free_txskb(ar->hw, skb);
2133                 }
2134         }
2135 }
2136
2137 /************/
2138 /* Scanning */
2139 /************/
2140
2141 /*
2142  * This gets called if we dont get a heart-beat during scan.
2143  * This may indicate the FW has hung and we need to abort the
2144  * scan manually to prevent cancel_hw_scan() from deadlocking
2145  */
2146 void ath10k_reset_scan(unsigned long ptr)
2147 {
2148         struct ath10k *ar = (struct ath10k *)ptr;
2149
2150         spin_lock_bh(&ar->data_lock);
2151         if (!ar->scan.in_progress) {
2152                 spin_unlock_bh(&ar->data_lock);
2153                 return;
2154         }
2155
2156         ath10k_warn("scan timed out, firmware problem?\n");
2157
2158         if (ar->scan.is_roc)
2159                 ieee80211_remain_on_channel_expired(ar->hw);
2160         else
2161                 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
2162
2163         ar->scan.in_progress = false;
2164         complete_all(&ar->scan.completed);
2165         spin_unlock_bh(&ar->data_lock);
2166 }
2167
2168 static int ath10k_abort_scan(struct ath10k *ar)
2169 {
2170         struct wmi_stop_scan_arg arg = {
2171                 .req_id = 1, /* FIXME */
2172                 .req_type = WMI_SCAN_STOP_ONE,
2173                 .u.scan_id = ATH10K_SCAN_ID,
2174         };
2175         int ret;
2176
2177         lockdep_assert_held(&ar->conf_mutex);
2178
2179         del_timer_sync(&ar->scan.timeout);
2180
2181         spin_lock_bh(&ar->data_lock);
2182         if (!ar->scan.in_progress) {
2183                 spin_unlock_bh(&ar->data_lock);
2184                 return 0;
2185         }
2186
2187         ar->scan.aborting = true;
2188         spin_unlock_bh(&ar->data_lock);
2189
2190         ret = ath10k_wmi_stop_scan(ar, &arg);
2191         if (ret) {
2192                 ath10k_warn("failed to stop wmi scan: %d\n", ret);
2193                 spin_lock_bh(&ar->data_lock);
2194                 ar->scan.in_progress = false;
2195                 ath10k_offchan_tx_purge(ar);
2196                 spin_unlock_bh(&ar->data_lock);
2197                 return -EIO;
2198         }
2199
2200         ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
2201         if (ret == 0)
2202                 ath10k_warn("timed out while waiting for scan to stop\n");
2203
2204         /* scan completion may be done right after we timeout here, so let's
2205          * check the in_progress and tell mac80211 scan is completed. if we
2206          * don't do that and FW fails to send us scan completion indication
2207          * then userspace won't be able to scan anymore */
2208         ret = 0;
2209
2210         spin_lock_bh(&ar->data_lock);
2211         if (ar->scan.in_progress) {
2212                 ath10k_warn("failed to stop scan, it's still in progress\n");
2213                 ar->scan.in_progress = false;
2214                 ath10k_offchan_tx_purge(ar);
2215                 ret = -ETIMEDOUT;
2216         }
2217         spin_unlock_bh(&ar->data_lock);
2218
2219         return ret;
2220 }
2221
2222 static int ath10k_start_scan(struct ath10k *ar,
2223                              const struct wmi_start_scan_arg *arg)
2224 {
2225         int ret;
2226
2227         lockdep_assert_held(&ar->conf_mutex);
2228
2229         ret = ath10k_wmi_start_scan(ar, arg);
2230         if (ret)
2231                 return ret;
2232
2233         ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2234         if (ret == 0) {
2235                 ath10k_abort_scan(ar);
2236                 return ret;
2237         }
2238
2239         /* the scan can complete earlier, before we even
2240          * start the timer. in that case the timer handler
2241          * checks ar->scan.in_progress and bails out if its
2242          * false. Add a 200ms margin to account event/command
2243          * processing. */
2244         mod_timer(&ar->scan.timeout, jiffies +
2245                   msecs_to_jiffies(arg->max_scan_time+200));
2246         return 0;
2247 }
2248
2249 /**********************/
2250 /* mac80211 callbacks */
2251 /**********************/
2252
2253 static void ath10k_tx(struct ieee80211_hw *hw,
2254                       struct ieee80211_tx_control *control,
2255                       struct sk_buff *skb)
2256 {
2257         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2258         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2259         struct ath10k *ar = hw->priv;
2260         u8 tid, vdev_id;
2261
2262         /* We should disable CCK RATE due to P2P */
2263         if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2264                 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2265
2266         /* we must calculate tid before we apply qos workaround
2267          * as we'd lose the qos control field */
2268         tid = ath10k_tx_h_get_tid(hdr);
2269         vdev_id = ath10k_tx_h_get_vdev_id(ar, info);
2270
2271         /* it makes no sense to process injected frames like that */
2272         if (info->control.vif &&
2273             info->control.vif->type != NL80211_IFTYPE_MONITOR) {
2274                 ath10k_tx_h_qos_workaround(hw, control, skb);
2275                 ath10k_tx_h_update_wep_key(skb);
2276                 ath10k_tx_h_add_p2p_noa_ie(ar, skb);
2277                 ath10k_tx_h_seq_no(skb);
2278         }
2279
2280         ATH10K_SKB_CB(skb)->vdev_id = vdev_id;
2281         ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2282         ATH10K_SKB_CB(skb)->htt.tid = tid;
2283
2284         if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2285                 spin_lock_bh(&ar->data_lock);
2286                 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
2287                 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
2288                 spin_unlock_bh(&ar->data_lock);
2289
2290                 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
2291
2292                 skb_queue_tail(&ar->offchan_tx_queue, skb);
2293                 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2294                 return;
2295         }
2296
2297         ath10k_tx_htt(ar, skb);
2298 }
2299
2300 /* Must not be called with conf_mutex held as workers can use that also. */
2301 static void ath10k_drain_tx(struct ath10k *ar)
2302 {
2303         /* make sure rcu-protected mac80211 tx path itself is drained */
2304         synchronize_net();
2305
2306         ath10k_offchan_tx_purge(ar);
2307         ath10k_mgmt_over_wmi_tx_purge(ar);
2308
2309         cancel_work_sync(&ar->offchan_tx_work);
2310         cancel_work_sync(&ar->wmi_mgmt_tx_work);
2311 }
2312
2313 void ath10k_halt(struct ath10k *ar)
2314 {
2315         struct ath10k_vif *arvif;
2316
2317         lockdep_assert_held(&ar->conf_mutex);
2318
2319         if (ath10k_monitor_is_enabled(ar)) {
2320                 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
2321                 ar->promisc = false;
2322                 ar->monitor = false;
2323                 ath10k_monitor_stop(ar);
2324         }
2325
2326         del_timer_sync(&ar->scan.timeout);
2327         ath10k_reset_scan((unsigned long)ar);
2328         ath10k_peer_cleanup_all(ar);
2329         ath10k_core_stop(ar);
2330         ath10k_hif_power_down(ar);
2331
2332         spin_lock_bh(&ar->data_lock);
2333         list_for_each_entry(arvif, &ar->arvifs, list) {
2334                 if (!arvif->beacon)
2335                         continue;
2336
2337                 dma_unmap_single(arvif->ar->dev,
2338                                  ATH10K_SKB_CB(arvif->beacon)->paddr,
2339                                  arvif->beacon->len, DMA_TO_DEVICE);
2340                 dev_kfree_skb_any(arvif->beacon);
2341                 arvif->beacon = NULL;
2342         }
2343         spin_unlock_bh(&ar->data_lock);
2344 }
2345
2346 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2347 {
2348         struct ath10k *ar = hw->priv;
2349
2350         mutex_lock(&ar->conf_mutex);
2351
2352         if (ar->cfg_tx_chainmask) {
2353                 *tx_ant = ar->cfg_tx_chainmask;
2354                 *rx_ant = ar->cfg_rx_chainmask;
2355         } else {
2356                 *tx_ant = ar->supp_tx_chainmask;
2357                 *rx_ant = ar->supp_rx_chainmask;
2358         }
2359
2360         mutex_unlock(&ar->conf_mutex);
2361
2362         return 0;
2363 }
2364
2365 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
2366 {
2367         int ret;
2368
2369         lockdep_assert_held(&ar->conf_mutex);
2370
2371         ar->cfg_tx_chainmask = tx_ant;
2372         ar->cfg_rx_chainmask = rx_ant;
2373
2374         if ((ar->state != ATH10K_STATE_ON) &&
2375             (ar->state != ATH10K_STATE_RESTARTED))
2376                 return 0;
2377
2378         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
2379                                         tx_ant);
2380         if (ret) {
2381                 ath10k_warn("failed to set tx-chainmask: %d, req 0x%x\n",
2382                             ret, tx_ant);
2383                 return ret;
2384         }
2385
2386         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
2387                                         rx_ant);
2388         if (ret) {
2389                 ath10k_warn("failed to set rx-chainmask: %d, req 0x%x\n",
2390                             ret, rx_ant);
2391                 return ret;
2392         }
2393
2394         return 0;
2395 }
2396
2397 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2398 {
2399         struct ath10k *ar = hw->priv;
2400         int ret;
2401
2402         mutex_lock(&ar->conf_mutex);
2403         ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
2404         mutex_unlock(&ar->conf_mutex);
2405         return ret;
2406 }
2407
2408 static int ath10k_start(struct ieee80211_hw *hw)
2409 {
2410         struct ath10k *ar = hw->priv;
2411         int ret = 0;
2412
2413         /*
2414          * This makes sense only when restarting hw. It is harmless to call
2415          * uncoditionally. This is necessary to make sure no HTT/WMI tx
2416          * commands will be submitted while restarting.
2417          */
2418         ath10k_drain_tx(ar);
2419
2420         mutex_lock(&ar->conf_mutex);
2421
2422         switch (ar->state) {
2423         case ATH10K_STATE_OFF:
2424                 ar->state = ATH10K_STATE_ON;
2425                 break;
2426         case ATH10K_STATE_RESTARTING:
2427                 ath10k_halt(ar);
2428                 ar->state = ATH10K_STATE_RESTARTED;
2429                 break;
2430         case ATH10K_STATE_ON:
2431         case ATH10K_STATE_RESTARTED:
2432         case ATH10K_STATE_WEDGED:
2433                 WARN_ON(1);
2434                 ret = -EINVAL;
2435                 goto err;
2436         }
2437
2438         ret = ath10k_hif_power_up(ar);
2439         if (ret) {
2440                 ath10k_err("Could not init hif: %d\n", ret);
2441                 goto err_off;
2442         }
2443
2444         ret = ath10k_core_start(ar);
2445         if (ret) {
2446                 ath10k_err("Could not init core: %d\n", ret);
2447                 goto err_power_down;
2448         }
2449
2450         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
2451         if (ret) {
2452                 ath10k_warn("failed to enable PMF QOS: %d\n", ret);
2453                 goto err_core_stop;
2454         }
2455
2456         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
2457         if (ret) {
2458                 ath10k_warn("failed to enable dynamic BW: %d\n", ret);
2459                 goto err_core_stop;
2460         }
2461
2462         if (ar->cfg_tx_chainmask)
2463                 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
2464                                      ar->cfg_rx_chainmask);
2465
2466         /*
2467          * By default FW set ARP frames ac to voice (6). In that case ARP
2468          * exchange is not working properly for UAPSD enabled AP. ARP requests
2469          * which arrives with access category 0 are processed by network stack
2470          * and send back with access category 0, but FW changes access category
2471          * to 6. Set ARP frames access category to best effort (0) solves
2472          * this problem.
2473          */
2474
2475         ret = ath10k_wmi_pdev_set_param(ar,
2476                                         ar->wmi.pdev_param->arp_ac_override, 0);
2477         if (ret) {
2478                 ath10k_warn("failed to set arp ac override parameter: %d\n",
2479                             ret);
2480                 goto err_core_stop;
2481         }
2482
2483         ar->num_started_vdevs = 0;
2484         ath10k_regd_update(ar);
2485
2486         mutex_unlock(&ar->conf_mutex);
2487         return 0;
2488
2489 err_core_stop:
2490         ath10k_core_stop(ar);
2491
2492 err_power_down:
2493         ath10k_hif_power_down(ar);
2494
2495 err_off:
2496         ar->state = ATH10K_STATE_OFF;
2497
2498 err:
2499         mutex_unlock(&ar->conf_mutex);
2500         return ret;
2501 }
2502
2503 static void ath10k_stop(struct ieee80211_hw *hw)
2504 {
2505         struct ath10k *ar = hw->priv;
2506
2507         ath10k_drain_tx(ar);
2508
2509         mutex_lock(&ar->conf_mutex);
2510         if (ar->state != ATH10K_STATE_OFF) {
2511                 ath10k_halt(ar);
2512                 ar->state = ATH10K_STATE_OFF;
2513         }
2514         mutex_unlock(&ar->conf_mutex);
2515
2516         cancel_work_sync(&ar->restart_work);
2517 }
2518
2519 static int ath10k_config_ps(struct ath10k *ar)
2520 {
2521         struct ath10k_vif *arvif;
2522         int ret = 0;
2523
2524         lockdep_assert_held(&ar->conf_mutex);
2525
2526         list_for_each_entry(arvif, &ar->arvifs, list) {
2527                 ret = ath10k_mac_vif_setup_ps(arvif);
2528                 if (ret) {
2529                         ath10k_warn("failed to setup powersave: %d\n", ret);
2530                         break;
2531                 }
2532         }
2533
2534         return ret;
2535 }
2536
2537 static const char *chandef_get_width(enum nl80211_chan_width width)
2538 {
2539         switch (width) {
2540         case NL80211_CHAN_WIDTH_20_NOHT:
2541                 return "20 (noht)";
2542         case NL80211_CHAN_WIDTH_20:
2543                 return "20";
2544         case NL80211_CHAN_WIDTH_40:
2545                 return "40";
2546         case NL80211_CHAN_WIDTH_80:
2547                 return "80";
2548         case NL80211_CHAN_WIDTH_80P80:
2549                 return "80+80";
2550         case NL80211_CHAN_WIDTH_160:
2551                 return "160";
2552         case NL80211_CHAN_WIDTH_5:
2553                 return "5";
2554         case NL80211_CHAN_WIDTH_10:
2555                 return "10";
2556         }
2557         return "?";
2558 }
2559
2560 static void ath10k_config_chan(struct ath10k *ar)
2561 {
2562         struct ath10k_vif *arvif;
2563         int ret;
2564
2565         lockdep_assert_held(&ar->conf_mutex);
2566
2567         ath10k_dbg(ATH10K_DBG_MAC,
2568                    "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2569                    ar->chandef.chan->center_freq,
2570                    ar->chandef.center_freq1,
2571                    ar->chandef.center_freq2,
2572                    chandef_get_width(ar->chandef.width));
2573
2574         /* First stop monitor interface. Some FW versions crash if there's a
2575          * lone monitor interface. */
2576         if (ar->monitor_started)
2577                 ath10k_monitor_vdev_stop(ar);
2578
2579         list_for_each_entry(arvif, &ar->arvifs, list) {
2580                 if (!arvif->is_started)
2581                         continue;
2582
2583                 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2584                         continue;
2585
2586                 ret = ath10k_vdev_stop(arvif);
2587                 if (ret) {
2588                         ath10k_warn("failed to stop vdev %d: %d\n",
2589                                     arvif->vdev_id, ret);
2590                         continue;
2591                 }
2592         }
2593
2594         /* all vdevs are now stopped - now attempt to restart them */
2595
2596         list_for_each_entry(arvif, &ar->arvifs, list) {
2597                 if (!arvif->is_started)
2598                         continue;
2599
2600                 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2601                         continue;
2602
2603                 ret = ath10k_vdev_start(arvif);
2604                 if (ret) {
2605                         ath10k_warn("failed to start vdev %d: %d\n",
2606                                     arvif->vdev_id, ret);
2607                         continue;
2608                 }
2609
2610                 if (!arvif->is_up)
2611                         continue;
2612
2613                 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2614                                          arvif->bssid);
2615                 if (ret) {
2616                         ath10k_warn("failed to bring vdev up %d: %d\n",
2617                                     arvif->vdev_id, ret);
2618                         continue;
2619                 }
2620         }
2621
2622         if (ath10k_monitor_is_enabled(ar))
2623                 ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
2624 }
2625
2626 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2627 {
2628         struct ath10k *ar = hw->priv;
2629         struct ieee80211_conf *conf = &hw->conf;
2630         int ret = 0;
2631         u32 param;
2632
2633         mutex_lock(&ar->conf_mutex);
2634
2635         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2636                 ath10k_dbg(ATH10K_DBG_MAC,
2637                            "mac config channel %dMHz flags 0x%x radar %d\n",
2638                            conf->chandef.chan->center_freq,
2639                            conf->chandef.chan->flags,
2640                            conf->radar_enabled);
2641
2642                 spin_lock_bh(&ar->data_lock);
2643                 ar->rx_channel = conf->chandef.chan;
2644                 spin_unlock_bh(&ar->data_lock);
2645
2646                 ar->radar_enabled = conf->radar_enabled;
2647                 ath10k_recalc_radar_detection(ar);
2648
2649                 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
2650                         ar->chandef = conf->chandef;
2651                         ath10k_config_chan(ar);
2652                 }
2653         }
2654
2655         if (changed & IEEE80211_CONF_CHANGE_POWER) {
2656                 ath10k_dbg(ATH10K_DBG_MAC, "mac config power %d\n",
2657                            hw->conf.power_level);
2658
2659                 param = ar->wmi.pdev_param->txpower_limit2g;
2660                 ret = ath10k_wmi_pdev_set_param(ar, param,
2661                                                 hw->conf.power_level * 2);
2662                 if (ret)
2663                         ath10k_warn("failed to set 2g txpower %d: %d\n",
2664                                     hw->conf.power_level, ret);
2665
2666                 param = ar->wmi.pdev_param->txpower_limit5g;
2667                 ret = ath10k_wmi_pdev_set_param(ar, param,
2668                                                 hw->conf.power_level * 2);
2669                 if (ret)
2670                         ath10k_warn("failed to set 5g txpower %d: %d\n",
2671                                     hw->conf.power_level, ret);
2672         }
2673
2674         if (changed & IEEE80211_CONF_CHANGE_PS)
2675                 ath10k_config_ps(ar);
2676
2677         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2678                 if (conf->flags & IEEE80211_CONF_MONITOR && !ar->monitor) {
2679                         ar->monitor = true;
2680                         ret = ath10k_monitor_start(ar);
2681                         if (ret) {
2682                                 ath10k_warn("failed to start monitor (config): %d\n",
2683                                             ret);
2684                                 ar->monitor = false;
2685                         }
2686                 } else if (!(conf->flags & IEEE80211_CONF_MONITOR) &&
2687                            ar->monitor) {
2688                         ar->monitor = false;
2689                         ath10k_monitor_stop(ar);
2690                 }
2691         }
2692
2693         mutex_unlock(&ar->conf_mutex);
2694         return ret;
2695 }
2696
2697 /*
2698  * TODO:
2699  * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2700  * because we will send mgmt frames without CCK. This requirement
2701  * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2702  * in the TX packet.
2703  */
2704 static int ath10k_add_interface(struct ieee80211_hw *hw,
2705                                 struct ieee80211_vif *vif)
2706 {
2707         struct ath10k *ar = hw->priv;
2708         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2709         enum wmi_sta_powersave_param param;
2710         int ret = 0;
2711         u32 value;
2712         int bit;
2713         u32 vdev_param;
2714
2715         mutex_lock(&ar->conf_mutex);
2716
2717         memset(arvif, 0, sizeof(*arvif));
2718
2719         arvif->ar = ar;
2720         arvif->vif = vif;
2721
2722         INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
2723         INIT_LIST_HEAD(&arvif->list);
2724
2725         bit = ffs(ar->free_vdev_map);
2726         if (bit == 0) {
2727                 ret = -EBUSY;
2728                 goto err;
2729         }
2730
2731         arvif->vdev_id = bit - 1;
2732         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
2733
2734         if (ar->p2p)
2735                 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2736
2737         switch (vif->type) {
2738         case NL80211_IFTYPE_UNSPECIFIED:
2739         case NL80211_IFTYPE_STATION:
2740                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2741                 if (vif->p2p)
2742                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2743                 break;
2744         case NL80211_IFTYPE_ADHOC:
2745                 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2746                 break;
2747         case NL80211_IFTYPE_AP:
2748                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2749
2750                 if (vif->p2p)
2751                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2752                 break;
2753         case NL80211_IFTYPE_MONITOR:
2754                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2755                 break;
2756         default:
2757                 WARN_ON(1);
2758                 break;
2759         }
2760
2761         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n",
2762                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
2763
2764         ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2765                                      arvif->vdev_subtype, vif->addr);
2766         if (ret) {
2767                 ath10k_warn("failed to create WMI vdev %i: %d\n",
2768                             arvif->vdev_id, ret);
2769                 goto err;
2770         }
2771
2772         ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2773         list_add(&arvif->list, &ar->arvifs);
2774
2775         vdev_param = ar->wmi.vdev_param->def_keyid;
2776         ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
2777                                         arvif->def_wep_key_idx);
2778         if (ret) {
2779                 ath10k_warn("failed to set vdev %i default key id: %d\n",
2780                             arvif->vdev_id, ret);
2781                 goto err_vdev_delete;
2782         }
2783
2784         vdev_param = ar->wmi.vdev_param->tx_encap_type;
2785         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2786                                         ATH10K_HW_TXRX_NATIVE_WIFI);
2787         /* 10.X firmware does not support this VDEV parameter. Do not warn */
2788         if (ret && ret != -EOPNOTSUPP) {
2789                 ath10k_warn("failed to set vdev %i TX encapsulation: %d\n",
2790                             arvif->vdev_id, ret);
2791                 goto err_vdev_delete;
2792         }
2793
2794         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2795                 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2796                 if (ret) {
2797                         ath10k_warn("failed to create vdev %i peer for AP: %d\n",
2798                                     arvif->vdev_id, ret);
2799                         goto err_vdev_delete;
2800                 }
2801
2802                 ret = ath10k_mac_set_kickout(arvif);
2803                 if (ret) {
2804                         ath10k_warn("failed to set vdev %i kickout parameters: %d\n",
2805                                     arvif->vdev_id, ret);
2806                         goto err_peer_delete;
2807                 }
2808         }
2809
2810         if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2811                 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2812                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2813                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2814                                                   param, value);
2815                 if (ret) {
2816                         ath10k_warn("failed to set vdev %i RX wake policy: %d\n",
2817                                     arvif->vdev_id, ret);
2818                         goto err_peer_delete;
2819                 }
2820
2821                 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2822                 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2823                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2824                                                   param, value);
2825                 if (ret) {
2826                         ath10k_warn("failed to set vdev %i TX wake thresh: %d\n",
2827                                     arvif->vdev_id, ret);
2828                         goto err_peer_delete;
2829                 }
2830
2831                 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2832                 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2833                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2834                                                   param, value);
2835                 if (ret) {
2836                         ath10k_warn("failed to set vdev %i PSPOLL count: %d\n",
2837                                     arvif->vdev_id, ret);
2838                         goto err_peer_delete;
2839                 }
2840         }
2841
2842         ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
2843         if (ret) {
2844                 ath10k_warn("failed to set rts threshold for vdev %d: %d\n",
2845                             arvif->vdev_id, ret);
2846                 goto err_peer_delete;
2847         }
2848
2849         ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
2850         if (ret) {
2851                 ath10k_warn("failed to set frag threshold for vdev %d: %d\n",
2852                             arvif->vdev_id, ret);
2853                 goto err_peer_delete;
2854         }
2855
2856         mutex_unlock(&ar->conf_mutex);
2857         return 0;
2858
2859 err_peer_delete:
2860         if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
2861                 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
2862
2863 err_vdev_delete:
2864         ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2865         ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2866         list_del(&arvif->list);
2867
2868 err:
2869         mutex_unlock(&ar->conf_mutex);
2870
2871         return ret;
2872 }
2873
2874 static void ath10k_remove_interface(struct ieee80211_hw *hw,
2875                                     struct ieee80211_vif *vif)
2876 {
2877         struct ath10k *ar = hw->priv;
2878         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2879         int ret;
2880
2881         mutex_lock(&ar->conf_mutex);
2882
2883         cancel_work_sync(&arvif->wep_key_work);
2884
2885         spin_lock_bh(&ar->data_lock);
2886         if (arvif->beacon) {
2887                 dma_unmap_single(arvif->ar->dev,
2888                                  ATH10K_SKB_CB(arvif->beacon)->paddr,
2889                                  arvif->beacon->len, DMA_TO_DEVICE);
2890                 dev_kfree_skb_any(arvif->beacon);
2891                 arvif->beacon = NULL;
2892         }
2893         spin_unlock_bh(&ar->data_lock);
2894
2895         ar->free_vdev_map |= 1 << (arvif->vdev_id);
2896         list_del(&arvif->list);
2897
2898         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2899                 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2900                 if (ret)
2901                         ath10k_warn("failed to remove peer for AP vdev %i: %d\n",
2902                                     arvif->vdev_id, ret);
2903
2904                 kfree(arvif->u.ap.noa_data);
2905         }
2906
2907         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
2908                    arvif->vdev_id);
2909
2910         ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2911         if (ret)
2912                 ath10k_warn("failed to delete WMI vdev %i: %d\n",
2913                             arvif->vdev_id, ret);
2914
2915         ath10k_peer_cleanup(ar, arvif->vdev_id);
2916
2917         mutex_unlock(&ar->conf_mutex);
2918 }
2919
2920 /*
2921  * FIXME: Has to be verified.
2922  */
2923 #define SUPPORTED_FILTERS                       \
2924         (FIF_PROMISC_IN_BSS |                   \
2925         FIF_ALLMULTI |                          \
2926         FIF_CONTROL |                           \
2927         FIF_PSPOLL |                            \
2928         FIF_OTHER_BSS |                         \
2929         FIF_BCN_PRBRESP_PROMISC |               \
2930         FIF_PROBE_REQ |                         \
2931         FIF_FCSFAIL)
2932
2933 static void ath10k_configure_filter(struct ieee80211_hw *hw,
2934                                     unsigned int changed_flags,
2935                                     unsigned int *total_flags,
2936                                     u64 multicast)
2937 {
2938         struct ath10k *ar = hw->priv;
2939         int ret;
2940
2941         mutex_lock(&ar->conf_mutex);
2942
2943         changed_flags &= SUPPORTED_FILTERS;
2944         *total_flags &= SUPPORTED_FILTERS;
2945         ar->filter_flags = *total_flags;
2946
2947         if (ar->filter_flags & FIF_PROMISC_IN_BSS && !ar->promisc) {
2948                 ar->promisc = true;
2949                 ret = ath10k_monitor_start(ar);
2950                 if (ret) {
2951                         ath10k_warn("failed to start monitor (promisc): %d\n",
2952                                     ret);
2953                         ar->promisc = false;
2954                 }
2955         } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) && ar->promisc) {
2956                 ar->promisc = false;
2957                 ath10k_monitor_stop(ar);
2958         }
2959
2960         mutex_unlock(&ar->conf_mutex);
2961 }
2962
2963 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2964                                     struct ieee80211_vif *vif,
2965                                     struct ieee80211_bss_conf *info,
2966                                     u32 changed)
2967 {
2968         struct ath10k *ar = hw->priv;
2969         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2970         int ret = 0;
2971         u32 vdev_param, pdev_param;
2972
2973         mutex_lock(&ar->conf_mutex);
2974
2975         if (changed & BSS_CHANGED_IBSS)
2976                 ath10k_control_ibss(arvif, info, vif->addr);
2977
2978         if (changed & BSS_CHANGED_BEACON_INT) {
2979                 arvif->beacon_interval = info->beacon_int;
2980                 vdev_param = ar->wmi.vdev_param->beacon_interval;
2981                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2982                                                 arvif->beacon_interval);
2983                 ath10k_dbg(ATH10K_DBG_MAC,
2984                            "mac vdev %d beacon_interval %d\n",
2985                            arvif->vdev_id, arvif->beacon_interval);
2986
2987                 if (ret)
2988                         ath10k_warn("failed to set beacon interval for vdev %d: %i\n",
2989                                     arvif->vdev_id, ret);
2990         }
2991
2992         if (changed & BSS_CHANGED_BEACON) {
2993                 ath10k_dbg(ATH10K_DBG_MAC,
2994                            "vdev %d set beacon tx mode to staggered\n",
2995                            arvif->vdev_id);
2996
2997                 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
2998                 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
2999                                                 WMI_BEACON_STAGGERED_MODE);
3000                 if (ret)
3001                         ath10k_warn("failed to set beacon mode for vdev %d: %i\n",
3002                                     arvif->vdev_id, ret);
3003         }
3004
3005         if (changed & BSS_CHANGED_BEACON_INFO) {
3006                 arvif->dtim_period = info->dtim_period;
3007
3008                 ath10k_dbg(ATH10K_DBG_MAC,
3009                            "mac vdev %d dtim_period %d\n",
3010                            arvif->vdev_id, arvif->dtim_period);
3011
3012                 vdev_param = ar->wmi.vdev_param->dtim_period;
3013                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3014                                                 arvif->dtim_period);
3015                 if (ret)
3016                         ath10k_warn("failed to set dtim period for vdev %d: %i\n",
3017                                     arvif->vdev_id, ret);
3018         }
3019
3020         if (changed & BSS_CHANGED_SSID &&
3021             vif->type == NL80211_IFTYPE_AP) {
3022                 arvif->u.ap.ssid_len = info->ssid_len;
3023                 if (info->ssid_len)
3024                         memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3025                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3026         }
3027
3028         /*
3029          * Firmware manages AP self-peer internally so make sure to not create
3030          * it in driver. Otherwise AP self-peer deletion may timeout later.
3031          */
3032         if (changed & BSS_CHANGED_BSSID &&
3033             vif->type != NL80211_IFTYPE_AP) {
3034                 if (!is_zero_ether_addr(info->bssid)) {
3035                         ath10k_dbg(ATH10K_DBG_MAC,
3036                                    "mac vdev %d create peer %pM\n",
3037                                    arvif->vdev_id, info->bssid);
3038
3039                         ret = ath10k_peer_create(ar, arvif->vdev_id,
3040                                                  info->bssid);
3041                         if (ret)
3042                                 ath10k_warn("failed to add peer %pM for vdev %d when changing bssid: %i\n",
3043                                             info->bssid, arvif->vdev_id, ret);
3044
3045                         if (vif->type == NL80211_IFTYPE_STATION) {
3046                                 /*
3047                                  * this is never erased as we it for crypto key
3048                                  * clearing; this is FW requirement
3049                                  */
3050                                 memcpy(arvif->bssid, info->bssid, ETH_ALEN);
3051
3052                                 ath10k_dbg(ATH10K_DBG_MAC,
3053                                            "mac vdev %d start %pM\n",
3054                                            arvif->vdev_id, info->bssid);
3055
3056                                 ret = ath10k_vdev_start(arvif);
3057                                 if (ret) {
3058                                         ath10k_warn("failed to start vdev %i: %d\n",
3059                                                     arvif->vdev_id, ret);
3060                                         goto exit;
3061                                 }
3062
3063                                 arvif->is_started = true;
3064                         }
3065
3066                         /*
3067                          * Mac80211 does not keep IBSS bssid when leaving IBSS,
3068                          * so driver need to store it. It is needed when leaving
3069                          * IBSS in order to remove BSSID peer.
3070                          */
3071                         if (vif->type == NL80211_IFTYPE_ADHOC)
3072                                 memcpy(arvif->bssid, info->bssid,
3073                                        ETH_ALEN);
3074                 }
3075         }
3076
3077         if (changed & BSS_CHANGED_BEACON_ENABLED)
3078                 ath10k_control_beaconing(arvif, info);
3079
3080         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3081                 arvif->use_cts_prot = info->use_cts_prot;
3082                 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
3083                            arvif->vdev_id, info->use_cts_prot);
3084
3085                 ret = ath10k_recalc_rtscts_prot(arvif);
3086                 if (ret)
3087                         ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n",
3088                                     arvif->vdev_id, ret);
3089         }
3090
3091         if (changed & BSS_CHANGED_ERP_SLOT) {
3092                 u32 slottime;
3093                 if (info->use_short_slot)
3094                         slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3095
3096                 else
3097                         slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3098
3099                 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
3100                            arvif->vdev_id, slottime);
3101
3102                 vdev_param = ar->wmi.vdev_param->slot_time;
3103                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3104                                                 slottime);
3105                 if (ret)
3106                         ath10k_warn("failed to set erp slot for vdev %d: %i\n",
3107                                     arvif->vdev_id, ret);
3108         }
3109
3110         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3111                 u32 preamble;
3112                 if (info->use_short_preamble)
3113                         preamble = WMI_VDEV_PREAMBLE_SHORT;
3114                 else
3115                         preamble = WMI_VDEV_PREAMBLE_LONG;
3116
3117                 ath10k_dbg(ATH10K_DBG_MAC,
3118                            "mac vdev %d preamble %dn",
3119                            arvif->vdev_id, preamble);
3120
3121                 vdev_param = ar->wmi.vdev_param->preamble;
3122                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3123                                                 preamble);
3124                 if (ret)
3125                         ath10k_warn("failed to set preamble for vdev %d: %i\n",
3126                                     arvif->vdev_id, ret);
3127         }
3128
3129         if (changed & BSS_CHANGED_ASSOC) {
3130                 if (info->assoc)
3131                         ath10k_bss_assoc(hw, vif, info);
3132         }
3133
3134 exit:
3135         mutex_unlock(&ar->conf_mutex);
3136 }
3137
3138 static int ath10k_hw_scan(struct ieee80211_hw *hw,
3139                           struct ieee80211_vif *vif,
3140                           struct ieee80211_scan_request *hw_req)
3141 {
3142         struct ath10k *ar = hw->priv;
3143         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3144         struct cfg80211_scan_request *req = &hw_req->req;
3145         struct wmi_start_scan_arg arg;
3146         int ret = 0;
3147         int i;
3148
3149         mutex_lock(&ar->conf_mutex);
3150
3151         spin_lock_bh(&ar->data_lock);
3152         if (ar->scan.in_progress) {
3153                 spin_unlock_bh(&ar->data_lock);
3154                 ret = -EBUSY;
3155                 goto exit;
3156         }
3157
3158         reinit_completion(&ar->scan.started);
3159         reinit_completion(&ar->scan.completed);
3160         ar->scan.in_progress = true;
3161         ar->scan.aborting = false;
3162         ar->scan.is_roc = false;
3163         ar->scan.vdev_id = arvif->vdev_id;
3164         spin_unlock_bh(&ar->data_lock);
3165
3166         memset(&arg, 0, sizeof(arg));
3167         ath10k_wmi_start_scan_init(ar, &arg);
3168         arg.vdev_id = arvif->vdev_id;
3169         arg.scan_id = ATH10K_SCAN_ID;
3170
3171         if (!req->no_cck)
3172                 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
3173
3174         if (req->ie_len) {
3175                 arg.ie_len = req->ie_len;
3176                 memcpy(arg.ie, req->ie, arg.ie_len);
3177         }
3178
3179         if (req->n_ssids) {
3180                 arg.n_ssids = req->n_ssids;
3181                 for (i = 0; i < arg.n_ssids; i++) {
3182                         arg.ssids[i].len  = req->ssids[i].ssid_len;
3183                         arg.ssids[i].ssid = req->ssids[i].ssid;
3184                 }
3185         } else {
3186                 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3187         }
3188
3189         if (req->n_channels) {
3190                 arg.n_channels = req->n_channels;
3191                 for (i = 0; i < arg.n_channels; i++)
3192                         arg.channels[i] = req->channels[i]->center_freq;
3193         }
3194
3195         ret = ath10k_start_scan(ar, &arg);
3196         if (ret) {
3197                 ath10k_warn("failed to start hw scan: %d\n", ret);
3198                 spin_lock_bh(&ar->data_lock);
3199                 ar->scan.in_progress = false;
3200                 spin_unlock_bh(&ar->data_lock);
3201         }
3202
3203 exit:
3204         mutex_unlock(&ar->conf_mutex);
3205         return ret;
3206 }
3207
3208 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
3209                                   struct ieee80211_vif *vif)
3210 {
3211         struct ath10k *ar = hw->priv;
3212         int ret;
3213
3214         mutex_lock(&ar->conf_mutex);
3215         ret = ath10k_abort_scan(ar);
3216         if (ret) {
3217                 ath10k_warn("failed to abort scan: %d\n", ret);
3218                 ieee80211_scan_completed(hw, 1 /* aborted */);
3219         }
3220         mutex_unlock(&ar->conf_mutex);
3221 }
3222
3223 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
3224                                         struct ath10k_vif *arvif,
3225                                         enum set_key_cmd cmd,
3226                                         struct ieee80211_key_conf *key)
3227 {
3228         u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
3229         int ret;
3230
3231         /* 10.1 firmware branch requires default key index to be set to group
3232          * key index after installing it. Otherwise FW/HW Txes corrupted
3233          * frames with multi-vif APs. This is not required for main firmware
3234          * branch (e.g. 636).
3235          *
3236          * FIXME: This has been tested only in AP. It remains unknown if this
3237          * is required for multi-vif STA interfaces on 10.1 */
3238
3239         if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3240                 return;
3241
3242         if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3243                 return;
3244
3245         if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3246                 return;
3247
3248         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3249                 return;
3250
3251         if (cmd != SET_KEY)
3252                 return;
3253
3254         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3255                                         key->keyidx);
3256         if (ret)
3257                 ath10k_warn("failed to set vdev %i group key as default key: %d\n",
3258                             arvif->vdev_id, ret);
3259 }
3260
3261 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3262                           struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3263                           struct ieee80211_key_conf *key)
3264 {
3265         struct ath10k *ar = hw->priv;
3266         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3267         struct ath10k_peer *peer;
3268         const u8 *peer_addr;
3269         bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3270                       key->cipher == WLAN_CIPHER_SUITE_WEP104;
3271         int ret = 0;
3272
3273         if (key->keyidx > WMI_MAX_KEY_INDEX)
3274                 return -ENOSPC;
3275
3276         mutex_lock(&ar->conf_mutex);
3277
3278         if (sta)
3279                 peer_addr = sta->addr;
3280         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3281                 peer_addr = vif->bss_conf.bssid;
3282         else
3283                 peer_addr = vif->addr;
3284
3285         key->hw_key_idx = key->keyidx;
3286
3287         /* the peer should not disappear in mid-way (unless FW goes awry) since
3288          * we already hold conf_mutex. we just make sure its there now. */
3289         spin_lock_bh(&ar->data_lock);
3290         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3291         spin_unlock_bh(&ar->data_lock);
3292
3293         if (!peer) {
3294                 if (cmd == SET_KEY) {
3295                         ath10k_warn("failed to install key for non-existent peer %pM\n",
3296                                     peer_addr);
3297                         ret = -EOPNOTSUPP;
3298                         goto exit;
3299                 } else {
3300                         /* if the peer doesn't exist there is no key to disable
3301                          * anymore */
3302                         goto exit;
3303                 }
3304         }
3305
3306         if (is_wep) {
3307                 if (cmd == SET_KEY)
3308                         arvif->wep_keys[key->keyidx] = key;
3309                 else
3310                         arvif->wep_keys[key->keyidx] = NULL;
3311
3312                 if (cmd == DISABLE_KEY)
3313                         ath10k_clear_vdev_key(arvif, key);
3314         }
3315
3316         ret = ath10k_install_key(arvif, key, cmd, peer_addr);
3317         if (ret) {
3318                 ath10k_warn("failed to install key for vdev %i peer %pM: %d\n",
3319                             arvif->vdev_id, peer_addr, ret);
3320                 goto exit;
3321         }
3322
3323         ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3324
3325         spin_lock_bh(&ar->data_lock);
3326         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3327         if (peer && cmd == SET_KEY)
3328                 peer->keys[key->keyidx] = key;
3329         else if (peer && cmd == DISABLE_KEY)
3330                 peer->keys[key->keyidx] = NULL;
3331         else if (peer == NULL)
3332                 /* impossible unless FW goes crazy */
3333                 ath10k_warn("Peer %pM disappeared!\n", peer_addr);
3334         spin_unlock_bh(&ar->data_lock);
3335
3336 exit:
3337         mutex_unlock(&ar->conf_mutex);
3338         return ret;
3339 }
3340
3341 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
3342 {
3343         struct ath10k *ar;
3344         struct ath10k_vif *arvif;
3345         struct ath10k_sta *arsta;
3346         struct ieee80211_sta *sta;
3347         u32 changed, bw, nss, smps;
3348         int err;
3349
3350         arsta = container_of(wk, struct ath10k_sta, update_wk);
3351         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3352         arvif = arsta->arvif;
3353         ar = arvif->ar;
3354
3355         spin_lock_bh(&ar->data_lock);
3356
3357         changed = arsta->changed;
3358         arsta->changed = 0;
3359
3360         bw = arsta->bw;
3361         nss = arsta->nss;
3362         smps = arsta->smps;
3363
3364         spin_unlock_bh(&ar->data_lock);
3365
3366         mutex_lock(&ar->conf_mutex);
3367
3368         if (changed & IEEE80211_RC_BW_CHANGED) {
3369                 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
3370                            sta->addr, bw);
3371
3372                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3373                                                 WMI_PEER_CHAN_WIDTH, bw);
3374                 if (err)
3375                         ath10k_warn("failed to update STA %pM peer bw %d: %d\n",
3376                                     sta->addr, bw, err);
3377         }
3378
3379         if (changed & IEEE80211_RC_NSS_CHANGED) {
3380                 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
3381                            sta->addr, nss);
3382
3383                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3384                                                 WMI_PEER_NSS, nss);
3385                 if (err)
3386                         ath10k_warn("failed to update STA %pM nss %d: %d\n",
3387                                     sta->addr, nss, err);
3388         }
3389
3390         if (changed & IEEE80211_RC_SMPS_CHANGED) {
3391                 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
3392                            sta->addr, smps);
3393
3394                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3395                                                 WMI_PEER_SMPS_STATE, smps);
3396                 if (err)
3397                         ath10k_warn("failed to update STA %pM smps %d: %d\n",
3398                                     sta->addr, smps, err);
3399         }
3400
3401         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
3402                 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM supp rates\n",
3403                            sta->addr);
3404
3405                 err = ath10k_station_assoc(ar, arvif, sta, true);
3406                 if (err)
3407                         ath10k_warn("failed to reassociate station: %pM\n",
3408                                     sta->addr);
3409         }
3410
3411         mutex_unlock(&ar->conf_mutex);
3412 }
3413
3414 static int ath10k_sta_state(struct ieee80211_hw *hw,
3415                             struct ieee80211_vif *vif,
3416                             struct ieee80211_sta *sta,
3417                             enum ieee80211_sta_state old_state,
3418                             enum ieee80211_sta_state new_state)
3419 {
3420         struct ath10k *ar = hw->priv;
3421         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3422         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3423         int max_num_peers;
3424         int ret = 0;
3425
3426         if (old_state == IEEE80211_STA_NOTEXIST &&
3427             new_state == IEEE80211_STA_NONE) {
3428                 memset(arsta, 0, sizeof(*arsta));
3429                 arsta->arvif = arvif;
3430                 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
3431         }
3432
3433         /* cancel must be done outside the mutex to avoid deadlock */
3434         if ((old_state == IEEE80211_STA_NONE &&
3435              new_state == IEEE80211_STA_NOTEXIST))
3436                 cancel_work_sync(&arsta->update_wk);
3437
3438         mutex_lock(&ar->conf_mutex);
3439
3440         if (old_state == IEEE80211_STA_NOTEXIST &&
3441             new_state == IEEE80211_STA_NONE &&
3442             vif->type != NL80211_IFTYPE_STATION) {
3443                 /*
3444                  * New station addition.
3445                  */
3446                 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
3447                         max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1;
3448                 else
3449                         max_num_peers = TARGET_NUM_PEERS;
3450
3451                 if (ar->num_peers >= max_num_peers) {
3452                         ath10k_warn("number of peers exceeded: peers number %d (max peers %d)\n",
3453                                     ar->num_peers, max_num_peers);
3454                         ret = -ENOBUFS;
3455                         goto exit;
3456                 }
3457
3458                 ath10k_dbg(ATH10K_DBG_MAC,
3459                            "mac vdev %d peer create %pM (new sta) num_peers %d\n",
3460                            arvif->vdev_id, sta->addr, ar->num_peers);
3461
3462                 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3463                 if (ret)
3464                         ath10k_warn("failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3465                                     sta->addr, arvif->vdev_id, ret);
3466         } else if ((old_state == IEEE80211_STA_NONE &&
3467                     new_state == IEEE80211_STA_NOTEXIST)) {
3468                 /*
3469                  * Existing station deletion.
3470                  */
3471                 ath10k_dbg(ATH10K_DBG_MAC,
3472                            "mac vdev %d peer delete %pM (sta gone)\n",
3473                            arvif->vdev_id, sta->addr);
3474                 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3475                 if (ret)
3476                         ath10k_warn("failed to delete peer %pM for vdev %d: %i\n",
3477                                     sta->addr, arvif->vdev_id, ret);
3478
3479                 if (vif->type == NL80211_IFTYPE_STATION)
3480                         ath10k_bss_disassoc(hw, vif);
3481         } else if (old_state == IEEE80211_STA_AUTH &&
3482                    new_state == IEEE80211_STA_ASSOC &&
3483                    (vif->type == NL80211_IFTYPE_AP ||
3484                     vif->type == NL80211_IFTYPE_ADHOC)) {
3485                 /*
3486                  * New association.
3487                  */
3488                 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n",
3489                            sta->addr);
3490
3491                 ret = ath10k_station_assoc(ar, arvif, sta, false);
3492                 if (ret)
3493                         ath10k_warn("failed to associate station %pM for vdev %i: %i\n",
3494                                     sta->addr, arvif->vdev_id, ret);
3495         } else if (old_state == IEEE80211_STA_ASSOC &&
3496                    new_state == IEEE80211_STA_AUTH &&
3497                    (vif->type == NL80211_IFTYPE_AP ||
3498                     vif->type == NL80211_IFTYPE_ADHOC)) {
3499                 /*
3500                  * Disassociation.
3501                  */
3502                 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
3503                            sta->addr);
3504
3505                 ret = ath10k_station_disassoc(ar, arvif, sta);
3506                 if (ret)
3507                         ath10k_warn("failed to disassociate station: %pM vdev %i: %i\n",
3508                                     sta->addr, arvif->vdev_id, ret);
3509         }
3510 exit:
3511         mutex_unlock(&ar->conf_mutex);
3512         return ret;
3513 }
3514
3515 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
3516                                  u16 ac, bool enable)
3517 {
3518         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3519         u32 value = 0;
3520         int ret = 0;
3521
3522         lockdep_assert_held(&ar->conf_mutex);
3523
3524         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3525                 return 0;
3526
3527         switch (ac) {
3528         case IEEE80211_AC_VO:
3529                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3530                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3531                 break;
3532         case IEEE80211_AC_VI:
3533                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3534                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3535                 break;
3536         case IEEE80211_AC_BE:
3537                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3538                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3539                 break;
3540         case IEEE80211_AC_BK:
3541                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3542                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3543                 break;
3544         }
3545
3546         if (enable)
3547                 arvif->u.sta.uapsd |= value;
3548         else
3549                 arvif->u.sta.uapsd &= ~value;
3550
3551         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3552                                           WMI_STA_PS_PARAM_UAPSD,
3553                                           arvif->u.sta.uapsd);
3554         if (ret) {
3555                 ath10k_warn("failed to set uapsd params: %d\n", ret);
3556                 goto exit;
3557         }
3558
3559         if (arvif->u.sta.uapsd)
3560                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
3561         else
3562                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3563
3564         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3565                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
3566                                           value);
3567         if (ret)
3568                 ath10k_warn("failed to set rx wake param: %d\n", ret);
3569
3570 exit:
3571         return ret;
3572 }
3573
3574 static int ath10k_conf_tx(struct ieee80211_hw *hw,
3575                           struct ieee80211_vif *vif, u16 ac,
3576                           const struct ieee80211_tx_queue_params *params)
3577 {
3578         struct ath10k *ar = hw->priv;
3579         struct wmi_wmm_params_arg *p = NULL;
3580         int ret;
3581
3582         mutex_lock(&ar->conf_mutex);
3583
3584         switch (ac) {
3585         case IEEE80211_AC_VO:
3586                 p = &ar->wmm_params.ac_vo;
3587                 break;
3588         case IEEE80211_AC_VI:
3589                 p = &ar->wmm_params.ac_vi;
3590                 break;
3591         case IEEE80211_AC_BE:
3592                 p = &ar->wmm_params.ac_be;
3593                 break;
3594         case IEEE80211_AC_BK:
3595                 p = &ar->wmm_params.ac_bk;
3596                 break;
3597         }
3598
3599         if (WARN_ON(!p)) {
3600                 ret = -EINVAL;
3601                 goto exit;
3602         }
3603
3604         p->cwmin = params->cw_min;
3605         p->cwmax = params->cw_max;
3606         p->aifs = params->aifs;
3607
3608         /*
3609          * The channel time duration programmed in the HW is in absolute
3610          * microseconds, while mac80211 gives the txop in units of
3611          * 32 microseconds.
3612          */
3613         p->txop = params->txop * 32;
3614
3615         /* FIXME: FW accepts wmm params per hw, not per vif */
3616         ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3617         if (ret) {
3618                 ath10k_warn("failed to set wmm params: %d\n", ret);
3619                 goto exit;
3620         }
3621
3622         ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3623         if (ret)
3624                 ath10k_warn("failed to set sta uapsd: %d\n", ret);
3625
3626 exit:
3627         mutex_unlock(&ar->conf_mutex);
3628         return ret;
3629 }
3630
3631 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3632
3633 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3634                                     struct ieee80211_vif *vif,
3635                                     struct ieee80211_channel *chan,
3636                                     int duration,
3637                                     enum ieee80211_roc_type type)
3638 {
3639         struct ath10k *ar = hw->priv;
3640         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3641         struct wmi_start_scan_arg arg;
3642         int ret;
3643
3644         mutex_lock(&ar->conf_mutex);
3645
3646         spin_lock_bh(&ar->data_lock);
3647         if (ar->scan.in_progress) {
3648                 spin_unlock_bh(&ar->data_lock);
3649                 ret = -EBUSY;
3650                 goto exit;
3651         }
3652
3653         reinit_completion(&ar->scan.started);
3654         reinit_completion(&ar->scan.completed);
3655         reinit_completion(&ar->scan.on_channel);
3656         ar->scan.in_progress = true;
3657         ar->scan.aborting = false;
3658         ar->scan.is_roc = true;
3659         ar->scan.vdev_id = arvif->vdev_id;
3660         ar->scan.roc_freq = chan->center_freq;
3661         spin_unlock_bh(&ar->data_lock);
3662
3663         memset(&arg, 0, sizeof(arg));
3664         ath10k_wmi_start_scan_init(ar, &arg);
3665         arg.vdev_id = arvif->vdev_id;
3666         arg.scan_id = ATH10K_SCAN_ID;
3667         arg.n_channels = 1;
3668         arg.channels[0] = chan->center_freq;
3669         arg.dwell_time_active = duration;
3670         arg.dwell_time_passive = duration;
3671         arg.max_scan_time = 2 * duration;
3672         arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3673         arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3674
3675         ret = ath10k_start_scan(ar, &arg);
3676         if (ret) {
3677                 ath10k_warn("failed to start roc scan: %d\n", ret);
3678                 spin_lock_bh(&ar->data_lock);
3679                 ar->scan.in_progress = false;
3680                 spin_unlock_bh(&ar->data_lock);
3681                 goto exit;
3682         }
3683
3684         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3685         if (ret == 0) {
3686                 ath10k_warn("failed to switch to channel for roc scan\n");
3687                 ath10k_abort_scan(ar);
3688                 ret = -ETIMEDOUT;
3689                 goto exit;
3690         }
3691
3692         ret = 0;
3693 exit:
3694         mutex_unlock(&ar->conf_mutex);
3695         return ret;
3696 }
3697
3698 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3699 {
3700         struct ath10k *ar = hw->priv;
3701
3702         mutex_lock(&ar->conf_mutex);
3703         ath10k_abort_scan(ar);
3704         mutex_unlock(&ar->conf_mutex);
3705
3706         return 0;
3707 }
3708
3709 /*
3710  * Both RTS and Fragmentation threshold are interface-specific
3711  * in ath10k, but device-specific in mac80211.
3712  */
3713
3714 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3715 {
3716         struct ath10k *ar = hw->priv;
3717         struct ath10k_vif *arvif;
3718         int ret = 0;
3719
3720         mutex_lock(&ar->conf_mutex);
3721         list_for_each_entry(arvif, &ar->arvifs, list) {
3722                 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
3723                            arvif->vdev_id, value);
3724
3725                 ret = ath10k_mac_set_rts(arvif, value);
3726                 if (ret) {
3727                         ath10k_warn("failed to set rts threshold for vdev %d: %d\n",
3728                                     arvif->vdev_id, ret);
3729                         break;
3730                 }
3731         }
3732         mutex_unlock(&ar->conf_mutex);
3733
3734         return ret;
3735 }
3736
3737 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3738 {
3739         struct ath10k *ar = hw->priv;
3740         struct ath10k_vif *arvif;
3741         int ret = 0;
3742
3743         mutex_lock(&ar->conf_mutex);
3744         list_for_each_entry(arvif, &ar->arvifs, list) {
3745                 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
3746                            arvif->vdev_id, value);
3747
3748                 ret = ath10k_mac_set_rts(arvif, value);
3749                 if (ret) {
3750                         ath10k_warn("failed to set fragmentation threshold for vdev %d: %d\n",
3751                                     arvif->vdev_id, ret);
3752                         break;
3753                 }
3754         }
3755         mutex_unlock(&ar->conf_mutex);
3756
3757         return ret;
3758 }
3759
3760 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
3761                          u32 queues, bool drop)
3762 {
3763         struct ath10k *ar = hw->priv;
3764         bool skip;
3765         int ret;
3766
3767         /* mac80211 doesn't care if we really xmit queued frames or not
3768          * we'll collect those frames either way if we stop/delete vdevs */
3769         if (drop)
3770                 return;
3771
3772         mutex_lock(&ar->conf_mutex);
3773
3774         if (ar->state == ATH10K_STATE_WEDGED)
3775                 goto skip;
3776
3777         ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
3778                         bool empty;
3779
3780                         spin_lock_bh(&ar->htt.tx_lock);
3781                         empty = (ar->htt.num_pending_tx == 0);
3782                         spin_unlock_bh(&ar->htt.tx_lock);
3783
3784                         skip = (ar->state == ATH10K_STATE_WEDGED);
3785
3786                         (empty || skip);
3787                 }), ATH10K_FLUSH_TIMEOUT_HZ);
3788
3789         if (ret <= 0 || skip)
3790                 ath10k_warn("failed to flush transmit queue (skip %i ar-state %i): %i\n",
3791                             skip, ar->state, ret);
3792
3793 skip:
3794         mutex_unlock(&ar->conf_mutex);
3795 }
3796
3797 /* TODO: Implement this function properly
3798  * For now it is needed to reply to Probe Requests in IBSS mode.
3799  * Propably we need this information from FW.
3800  */
3801 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
3802 {
3803         return 1;
3804 }
3805
3806 #ifdef CONFIG_PM
3807 static int ath10k_suspend(struct ieee80211_hw *hw,
3808                           struct cfg80211_wowlan *wowlan)
3809 {
3810         struct ath10k *ar = hw->priv;
3811         int ret;
3812
3813         mutex_lock(&ar->conf_mutex);
3814
3815         ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
3816         if (ret) {
3817                 if (ret == -ETIMEDOUT)
3818                         goto resume;
3819                 ret = 1;
3820                 goto exit;
3821         }
3822
3823         ret = ath10k_hif_suspend(ar);
3824         if (ret) {
3825                 ath10k_warn("failed to suspend hif: %d\n", ret);
3826                 goto resume;
3827         }
3828
3829         ret = 0;
3830         goto exit;
3831 resume:
3832         ret = ath10k_wmi_pdev_resume_target(ar);
3833         if (ret)
3834                 ath10k_warn("failed to resume target: %d\n", ret);
3835
3836         ret = 1;
3837 exit:
3838         mutex_unlock(&ar->conf_mutex);
3839         return ret;
3840 }
3841
3842 static int ath10k_resume(struct ieee80211_hw *hw)
3843 {
3844         struct ath10k *ar = hw->priv;
3845         int ret;
3846
3847         mutex_lock(&ar->conf_mutex);
3848
3849         ret = ath10k_hif_resume(ar);
3850         if (ret) {
3851                 ath10k_warn("failed to resume hif: %d\n", ret);
3852                 ret = 1;
3853                 goto exit;
3854         }
3855
3856         ret = ath10k_wmi_pdev_resume_target(ar);
3857         if (ret) {
3858                 ath10k_warn("failed to resume target: %d\n", ret);
3859                 ret = 1;
3860                 goto exit;
3861         }
3862
3863         ret = 0;
3864 exit:
3865         mutex_unlock(&ar->conf_mutex);
3866         return ret;
3867 }
3868 #endif
3869
3870 static void ath10k_restart_complete(struct ieee80211_hw *hw)
3871 {
3872         struct ath10k *ar = hw->priv;
3873
3874         mutex_lock(&ar->conf_mutex);
3875
3876         /* If device failed to restart it will be in a different state, e.g.
3877          * ATH10K_STATE_WEDGED */
3878         if (ar->state == ATH10K_STATE_RESTARTED) {
3879                 ath10k_info("device successfully recovered\n");
3880                 ar->state = ATH10K_STATE_ON;
3881         }
3882
3883         mutex_unlock(&ar->conf_mutex);
3884 }
3885
3886 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
3887                              struct survey_info *survey)
3888 {
3889         struct ath10k *ar = hw->priv;
3890         struct ieee80211_supported_band *sband;
3891         struct survey_info *ar_survey = &ar->survey[idx];
3892         int ret = 0;
3893
3894         mutex_lock(&ar->conf_mutex);
3895
3896         sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
3897         if (sband && idx >= sband->n_channels) {
3898                 idx -= sband->n_channels;
3899                 sband = NULL;
3900         }
3901
3902         if (!sband)
3903                 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
3904
3905         if (!sband || idx >= sband->n_channels) {
3906                 ret = -ENOENT;
3907                 goto exit;
3908         }
3909
3910         spin_lock_bh(&ar->data_lock);
3911         memcpy(survey, ar_survey, sizeof(*survey));
3912         spin_unlock_bh(&ar->data_lock);
3913
3914         survey->channel = &sband->channels[idx];
3915
3916 exit:
3917         mutex_unlock(&ar->conf_mutex);
3918         return ret;
3919 }
3920
3921 /* Helper table for legacy fixed_rate/bitrate_mask */
3922 static const u8 cck_ofdm_rate[] = {
3923         /* CCK */
3924         3, /* 1Mbps */
3925         2, /* 2Mbps */
3926         1, /* 5.5Mbps */
3927         0, /* 11Mbps */
3928         /* OFDM */
3929         3, /* 6Mbps */
3930         7, /* 9Mbps */
3931         2, /* 12Mbps */
3932         6, /* 18Mbps */
3933         1, /* 24Mbps */
3934         5, /* 36Mbps */
3935         0, /* 48Mbps */
3936         4, /* 54Mbps */
3937 };
3938
3939 /* Check if only one bit set */
3940 static int ath10k_check_single_mask(u32 mask)
3941 {
3942         int bit;
3943
3944         bit = ffs(mask);
3945         if (!bit)
3946                 return 0;
3947
3948         mask &= ~BIT(bit - 1);
3949         if (mask)
3950                 return 2;
3951
3952         return 1;
3953 }
3954
3955 static bool
3956 ath10k_default_bitrate_mask(struct ath10k *ar,
3957                             enum ieee80211_band band,
3958                             const struct cfg80211_bitrate_mask *mask)
3959 {
3960         u32 legacy = 0x00ff;
3961         u8 ht = 0xff, i;
3962         u16 vht = 0x3ff;
3963
3964         switch (band) {
3965         case IEEE80211_BAND_2GHZ:
3966                 legacy = 0x00fff;
3967                 vht = 0;
3968                 break;
3969         case IEEE80211_BAND_5GHZ:
3970                 break;
3971         default:
3972                 return false;
3973         }
3974
3975         if (mask->control[band].legacy != legacy)
3976                 return false;
3977
3978         for (i = 0; i < ar->num_rf_chains; i++)
3979                 if (mask->control[band].ht_mcs[i] != ht)
3980                         return false;
3981
3982         for (i = 0; i < ar->num_rf_chains; i++)
3983                 if (mask->control[band].vht_mcs[i] != vht)
3984                         return false;
3985
3986         return true;
3987 }
3988
3989 static bool
3990 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
3991                         enum ieee80211_band band,
3992                         u8 *fixed_nss)
3993 {
3994         int ht_nss = 0, vht_nss = 0, i;
3995
3996         /* check legacy */
3997         if (ath10k_check_single_mask(mask->control[band].legacy))
3998                 return false;
3999
4000         /* check HT */
4001         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4002                 if (mask->control[band].ht_mcs[i] == 0xff)
4003                         continue;
4004                 else if (mask->control[band].ht_mcs[i] == 0x00)
4005                         break;
4006                 else
4007                         return false;
4008         }
4009
4010         ht_nss = i;
4011
4012         /* check VHT */
4013         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4014                 if (mask->control[band].vht_mcs[i] == 0x03ff)
4015                         continue;
4016                 else if (mask->control[band].vht_mcs[i] == 0x0000)
4017                         break;
4018                 else
4019                         return false;
4020         }
4021
4022         vht_nss = i;
4023
4024         if (ht_nss > 0 && vht_nss > 0)
4025                 return false;
4026
4027         if (ht_nss)
4028                 *fixed_nss = ht_nss;
4029         else if (vht_nss)
4030                 *fixed_nss = vht_nss;
4031         else
4032                 return false;
4033
4034         return true;
4035 }
4036
4037 static bool
4038 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
4039                             enum ieee80211_band band,
4040                             enum wmi_rate_preamble *preamble)
4041 {
4042         int legacy = 0, ht = 0, vht = 0, i;
4043
4044         *preamble = WMI_RATE_PREAMBLE_OFDM;
4045
4046         /* check legacy */
4047         legacy = ath10k_check_single_mask(mask->control[band].legacy);
4048         if (legacy > 1)
4049                 return false;
4050
4051         /* check HT */
4052         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4053                 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
4054         if (ht > 1)
4055                 return false;
4056
4057         /* check VHT */
4058         for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4059                 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
4060         if (vht > 1)
4061                 return false;
4062
4063         /* Currently we support only one fixed_rate */
4064         if ((legacy + ht + vht) != 1)
4065                 return false;
4066
4067         if (ht)
4068                 *preamble = WMI_RATE_PREAMBLE_HT;
4069         else if (vht)
4070                 *preamble = WMI_RATE_PREAMBLE_VHT;
4071
4072         return true;
4073 }
4074
4075 static bool
4076 ath10k_bitrate_mask_rate(const struct cfg80211_bitrate_mask *mask,
4077                          enum ieee80211_band band,
4078                          u8 *fixed_rate,
4079                          u8 *fixed_nss)
4080 {
4081         u8 rate = 0, pream = 0, nss = 0, i;
4082         enum wmi_rate_preamble preamble;
4083
4084         /* Check if single rate correct */
4085         if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
4086                 return false;
4087
4088         pream = preamble;
4089
4090         switch (preamble) {
4091         case WMI_RATE_PREAMBLE_CCK:
4092         case WMI_RATE_PREAMBLE_OFDM:
4093                 i = ffs(mask->control[band].legacy) - 1;
4094
4095                 if (band == IEEE80211_BAND_2GHZ && i < 4)
4096                         pream = WMI_RATE_PREAMBLE_CCK;
4097
4098                 if (band == IEEE80211_BAND_5GHZ)
4099                         i += 4;
4100
4101                 if (i >= ARRAY_SIZE(cck_ofdm_rate))
4102                         return false;
4103
4104                 rate = cck_ofdm_rate[i];
4105                 break;
4106         case WMI_RATE_PREAMBLE_HT:
4107                 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4108                         if (mask->control[band].ht_mcs[i])
4109                                 break;
4110
4111                 if (i == IEEE80211_HT_MCS_MASK_LEN)
4112                         return false;
4113
4114                 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4115                 nss = i;
4116                 break;
4117         case WMI_RATE_PREAMBLE_VHT:
4118                 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4119                         if (mask->control[band].vht_mcs[i])
4120                                 break;
4121
4122                 if (i == NL80211_VHT_NSS_MAX)
4123                         return false;
4124
4125                 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4126                 nss = i;
4127                 break;
4128         }
4129
4130         *fixed_nss = nss + 1;
4131         nss <<= 4;
4132         pream <<= 6;
4133
4134         ath10k_dbg(ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
4135                    pream, nss, rate);
4136
4137         *fixed_rate = pream | nss | rate;
4138
4139         return true;
4140 }
4141
4142 static bool ath10k_get_fixed_rate_nss(const struct cfg80211_bitrate_mask *mask,
4143                                       enum ieee80211_band band,
4144                                       u8 *fixed_rate,
4145                                       u8 *fixed_nss)
4146 {
4147         /* First check full NSS mask, if we can simply limit NSS */
4148         if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
4149                 return true;
4150
4151         /* Next Check single rate is set */
4152         return ath10k_bitrate_mask_rate(mask, band, fixed_rate, fixed_nss);
4153 }
4154
4155 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
4156                                        u8 fixed_rate,
4157                                        u8 fixed_nss,
4158                                        u8 force_sgi)
4159 {
4160         struct ath10k *ar = arvif->ar;
4161         u32 vdev_param;
4162         int ret = 0;
4163
4164         mutex_lock(&ar->conf_mutex);
4165
4166         if (arvif->fixed_rate == fixed_rate &&
4167             arvif->fixed_nss == fixed_nss &&
4168             arvif->force_sgi == force_sgi)
4169                 goto exit;
4170
4171         if (fixed_rate == WMI_FIXED_RATE_NONE)
4172                 ath10k_dbg(ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
4173
4174         if (force_sgi)
4175                 ath10k_dbg(ATH10K_DBG_MAC, "mac force sgi\n");
4176
4177         vdev_param = ar->wmi.vdev_param->fixed_rate;
4178         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4179                                         vdev_param, fixed_rate);
4180         if (ret) {
4181                 ath10k_warn("failed to set fixed rate param 0x%02x: %d\n",
4182                             fixed_rate, ret);
4183                 ret = -EINVAL;
4184                 goto exit;
4185         }
4186
4187         arvif->fixed_rate = fixed_rate;
4188
4189         vdev_param = ar->wmi.vdev_param->nss;
4190         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4191                                         vdev_param, fixed_nss);
4192
4193         if (ret) {
4194                 ath10k_warn("failed to set fixed nss param %d: %d\n",
4195                             fixed_nss, ret);
4196                 ret = -EINVAL;
4197                 goto exit;
4198         }
4199
4200         arvif->fixed_nss = fixed_nss;
4201
4202         vdev_param = ar->wmi.vdev_param->sgi;
4203         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4204                                         force_sgi);
4205
4206         if (ret) {
4207                 ath10k_warn("failed to set sgi param %d: %d\n",
4208                             force_sgi, ret);
4209                 ret = -EINVAL;
4210                 goto exit;
4211         }
4212
4213         arvif->force_sgi = force_sgi;
4214
4215 exit:
4216         mutex_unlock(&ar->conf_mutex);
4217         return ret;
4218 }
4219
4220 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
4221                                    struct ieee80211_vif *vif,
4222                                    const struct cfg80211_bitrate_mask *mask)
4223 {
4224         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4225         struct ath10k *ar = arvif->ar;
4226         enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
4227         u8 fixed_rate = WMI_FIXED_RATE_NONE;
4228         u8 fixed_nss = ar->num_rf_chains;
4229         u8 force_sgi;
4230
4231         force_sgi = mask->control[band].gi;
4232         if (force_sgi == NL80211_TXRATE_FORCE_LGI)
4233                 return -EINVAL;
4234
4235         if (!ath10k_default_bitrate_mask(ar, band, mask)) {
4236                 if (!ath10k_get_fixed_rate_nss(mask, band,
4237                                                &fixed_rate,
4238                                                &fixed_nss))
4239                         return -EINVAL;
4240         }
4241
4242         if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) {
4243                 ath10k_warn("failed to force SGI usage for default rate settings\n");
4244                 return -EINVAL;
4245         }
4246
4247         return ath10k_set_fixed_rate_param(arvif, fixed_rate,
4248                                            fixed_nss, force_sgi);
4249 }
4250
4251 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
4252                                  struct ieee80211_vif *vif,
4253                                  struct ieee80211_sta *sta,
4254                                  u32 changed)
4255 {
4256         struct ath10k *ar = hw->priv;
4257         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
4258         u32 bw, smps;
4259
4260         spin_lock_bh(&ar->data_lock);
4261
4262         ath10k_dbg(ATH10K_DBG_MAC,
4263                    "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4264                    sta->addr, changed, sta->bandwidth, sta->rx_nss,
4265                    sta->smps_mode);
4266
4267         if (changed & IEEE80211_RC_BW_CHANGED) {
4268                 bw = WMI_PEER_CHWIDTH_20MHZ;
4269
4270                 switch (sta->bandwidth) {
4271                 case IEEE80211_STA_RX_BW_20:
4272                         bw = WMI_PEER_CHWIDTH_20MHZ;
4273                         break;
4274                 case IEEE80211_STA_RX_BW_40:
4275                         bw = WMI_PEER_CHWIDTH_40MHZ;
4276                         break;
4277                 case IEEE80211_STA_RX_BW_80:
4278                         bw = WMI_PEER_CHWIDTH_80MHZ;
4279                         break;
4280                 case IEEE80211_STA_RX_BW_160:
4281                         ath10k_warn("Invalid bandwith %d in rc update for %pM\n",
4282                                     sta->bandwidth, sta->addr);
4283                         bw = WMI_PEER_CHWIDTH_20MHZ;
4284                         break;
4285                 }
4286
4287                 arsta->bw = bw;
4288         }
4289
4290         if (changed & IEEE80211_RC_NSS_CHANGED)
4291                 arsta->nss = sta->rx_nss;
4292
4293         if (changed & IEEE80211_RC_SMPS_CHANGED) {
4294                 smps = WMI_PEER_SMPS_PS_NONE;
4295
4296                 switch (sta->smps_mode) {
4297                 case IEEE80211_SMPS_AUTOMATIC:
4298                 case IEEE80211_SMPS_OFF:
4299                         smps = WMI_PEER_SMPS_PS_NONE;
4300                         break;
4301                 case IEEE80211_SMPS_STATIC:
4302                         smps = WMI_PEER_SMPS_STATIC;
4303                         break;
4304                 case IEEE80211_SMPS_DYNAMIC:
4305                         smps = WMI_PEER_SMPS_DYNAMIC;
4306                         break;
4307                 case IEEE80211_SMPS_NUM_MODES:
4308                         ath10k_warn("Invalid smps %d in sta rc update for %pM\n",
4309                                     sta->smps_mode, sta->addr);
4310                         smps = WMI_PEER_SMPS_PS_NONE;
4311                         break;
4312                 }
4313
4314                 arsta->smps = smps;
4315         }
4316
4317         arsta->changed |= changed;
4318
4319         spin_unlock_bh(&ar->data_lock);
4320
4321         ieee80211_queue_work(hw, &arsta->update_wk);
4322 }
4323
4324 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4325 {
4326         /*
4327          * FIXME: Return 0 for time being. Need to figure out whether FW
4328          * has the API to fetch 64-bit local TSF
4329          */
4330
4331         return 0;
4332 }
4333
4334 static const struct ieee80211_ops ath10k_ops = {
4335         .tx                             = ath10k_tx,
4336         .start                          = ath10k_start,
4337         .stop                           = ath10k_stop,
4338         .config                         = ath10k_config,
4339         .add_interface                  = ath10k_add_interface,
4340         .remove_interface               = ath10k_remove_interface,
4341         .configure_filter               = ath10k_configure_filter,
4342         .bss_info_changed               = ath10k_bss_info_changed,
4343         .hw_scan                        = ath10k_hw_scan,
4344         .cancel_hw_scan                 = ath10k_cancel_hw_scan,
4345         .set_key                        = ath10k_set_key,
4346         .sta_state                      = ath10k_sta_state,
4347         .conf_tx                        = ath10k_conf_tx,
4348         .remain_on_channel              = ath10k_remain_on_channel,
4349         .cancel_remain_on_channel       = ath10k_cancel_remain_on_channel,
4350         .set_rts_threshold              = ath10k_set_rts_threshold,
4351         .set_frag_threshold             = ath10k_set_frag_threshold,
4352         .flush                          = ath10k_flush,
4353         .tx_last_beacon                 = ath10k_tx_last_beacon,
4354         .set_antenna                    = ath10k_set_antenna,
4355         .get_antenna                    = ath10k_get_antenna,
4356         .restart_complete               = ath10k_restart_complete,
4357         .get_survey                     = ath10k_get_survey,
4358         .set_bitrate_mask               = ath10k_set_bitrate_mask,
4359         .sta_rc_update                  = ath10k_sta_rc_update,
4360         .get_tsf                        = ath10k_get_tsf,
4361 #ifdef CONFIG_PM
4362         .suspend                        = ath10k_suspend,
4363         .resume                         = ath10k_resume,
4364 #endif
4365 };
4366
4367 #define RATETAB_ENT(_rate, _rateid, _flags) { \
4368         .bitrate                = (_rate), \
4369         .flags                  = (_flags), \
4370         .hw_value               = (_rateid), \
4371 }
4372
4373 #define CHAN2G(_channel, _freq, _flags) { \
4374         .band                   = IEEE80211_BAND_2GHZ, \
4375         .hw_value               = (_channel), \
4376         .center_freq            = (_freq), \
4377         .flags                  = (_flags), \
4378         .max_antenna_gain       = 0, \
4379         .max_power              = 30, \
4380 }
4381
4382 #define CHAN5G(_channel, _freq, _flags) { \
4383         .band                   = IEEE80211_BAND_5GHZ, \
4384         .hw_value               = (_channel), \
4385         .center_freq            = (_freq), \
4386         .flags                  = (_flags), \
4387         .max_antenna_gain       = 0, \
4388         .max_power              = 30, \
4389 }
4390
4391 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
4392         CHAN2G(1, 2412, 0),
4393         CHAN2G(2, 2417, 0),
4394         CHAN2G(3, 2422, 0),
4395         CHAN2G(4, 2427, 0),
4396         CHAN2G(5, 2432, 0),
4397         CHAN2G(6, 2437, 0),
4398         CHAN2G(7, 2442, 0),
4399         CHAN2G(8, 2447, 0),
4400         CHAN2G(9, 2452, 0),
4401         CHAN2G(10, 2457, 0),
4402         CHAN2G(11, 2462, 0),
4403         CHAN2G(12, 2467, 0),
4404         CHAN2G(13, 2472, 0),
4405         CHAN2G(14, 2484, 0),
4406 };
4407
4408 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
4409         CHAN5G(36, 5180, 0),
4410         CHAN5G(40, 5200, 0),
4411         CHAN5G(44, 5220, 0),
4412         CHAN5G(48, 5240, 0),
4413         CHAN5G(52, 5260, 0),
4414         CHAN5G(56, 5280, 0),
4415         CHAN5G(60, 5300, 0),
4416         CHAN5G(64, 5320, 0),
4417         CHAN5G(100, 5500, 0),
4418         CHAN5G(104, 5520, 0),
4419         CHAN5G(108, 5540, 0),
4420         CHAN5G(112, 5560, 0),
4421         CHAN5G(116, 5580, 0),
4422         CHAN5G(120, 5600, 0),
4423         CHAN5G(124, 5620, 0),
4424         CHAN5G(128, 5640, 0),
4425         CHAN5G(132, 5660, 0),
4426         CHAN5G(136, 5680, 0),
4427         CHAN5G(140, 5700, 0),
4428         CHAN5G(149, 5745, 0),
4429         CHAN5G(153, 5765, 0),
4430         CHAN5G(157, 5785, 0),
4431         CHAN5G(161, 5805, 0),
4432         CHAN5G(165, 5825, 0),
4433 };
4434
4435 static struct ieee80211_rate ath10k_rates[] = {
4436         /* CCK */
4437         RATETAB_ENT(10,  0x82, 0),
4438         RATETAB_ENT(20,  0x84, 0),
4439         RATETAB_ENT(55,  0x8b, 0),
4440         RATETAB_ENT(110, 0x96, 0),
4441         /* OFDM */
4442         RATETAB_ENT(60,  0x0c, 0),
4443         RATETAB_ENT(90,  0x12, 0),
4444         RATETAB_ENT(120, 0x18, 0),
4445         RATETAB_ENT(180, 0x24, 0),
4446         RATETAB_ENT(240, 0x30, 0),
4447         RATETAB_ENT(360, 0x48, 0),
4448         RATETAB_ENT(480, 0x60, 0),
4449         RATETAB_ENT(540, 0x6c, 0),
4450 };
4451
4452 #define ath10k_a_rates (ath10k_rates + 4)
4453 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4454 #define ath10k_g_rates (ath10k_rates + 0)
4455 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4456
4457 struct ath10k *ath10k_mac_create(void)
4458 {
4459         struct ieee80211_hw *hw;
4460         struct ath10k *ar;
4461
4462         hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
4463         if (!hw)
4464                 return NULL;
4465
4466         ar = hw->priv;
4467         ar->hw = hw;
4468
4469         return ar;
4470 }
4471
4472 void ath10k_mac_destroy(struct ath10k *ar)
4473 {
4474         ieee80211_free_hw(ar->hw);
4475 }
4476
4477 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
4478         {
4479         .max    = 8,
4480         .types  = BIT(NL80211_IFTYPE_STATION)
4481                 | BIT(NL80211_IFTYPE_P2P_CLIENT)
4482         },
4483         {
4484         .max    = 3,
4485         .types  = BIT(NL80211_IFTYPE_P2P_GO)
4486         },
4487         {
4488         .max    = 7,
4489         .types  = BIT(NL80211_IFTYPE_AP)
4490         },
4491 };
4492
4493 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
4494         {
4495         .max    = 8,
4496         .types  = BIT(NL80211_IFTYPE_AP)
4497         },
4498 };
4499
4500 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
4501         {
4502                 .limits = ath10k_if_limits,
4503                 .n_limits = ARRAY_SIZE(ath10k_if_limits),
4504                 .max_interfaces = 8,
4505                 .num_different_channels = 1,
4506                 .beacon_int_infra_match = true,
4507         },
4508 };
4509
4510 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
4511         {
4512                 .limits = ath10k_10x_if_limits,
4513                 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
4514                 .max_interfaces = 8,
4515                 .num_different_channels = 1,
4516                 .beacon_int_infra_match = true,
4517 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
4518                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
4519                                         BIT(NL80211_CHAN_WIDTH_20) |
4520                                         BIT(NL80211_CHAN_WIDTH_40) |
4521                                         BIT(NL80211_CHAN_WIDTH_80),
4522 #endif
4523         },
4524 };
4525
4526 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4527 {
4528         struct ieee80211_sta_vht_cap vht_cap = {0};
4529         u16 mcs_map;
4530         int i;
4531
4532         vht_cap.vht_supported = 1;
4533         vht_cap.cap = ar->vht_cap_info;
4534
4535         mcs_map = 0;
4536         for (i = 0; i < 8; i++) {
4537                 if (i < ar->num_rf_chains)
4538                         mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
4539                 else
4540                         mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
4541         }
4542
4543         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4544         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4545
4546         return vht_cap;
4547 }
4548
4549 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4550 {
4551         int i;
4552         struct ieee80211_sta_ht_cap ht_cap = {0};
4553
4554         if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4555                 return ht_cap;
4556
4557         ht_cap.ht_supported = 1;
4558         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4559         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4560         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4561         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4562         ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4563
4564         if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4565                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4566
4567         if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4568                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4569
4570         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4571                 u32 smps;
4572
4573                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
4574                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4575
4576                 ht_cap.cap |= smps;
4577         }
4578
4579         if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4580                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4581
4582         if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4583                 u32 stbc;
4584
4585                 stbc   = ar->ht_cap_info;
4586                 stbc  &= WMI_HT_CAP_RX_STBC;
4587                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4588                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4589                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
4590
4591                 ht_cap.cap |= stbc;
4592         }
4593
4594         if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4595                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4596
4597         if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4598                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4599
4600         /* max AMSDU is implicitly taken from vht_cap_info */
4601         if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4602                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4603
4604         for (i = 0; i < ar->num_rf_chains; i++)
4605                 ht_cap.mcs.rx_mask[i] = 0xFF;
4606
4607         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4608
4609         return ht_cap;
4610 }
4611
4612
4613 static void ath10k_get_arvif_iter(void *data, u8 *mac,
4614                                   struct ieee80211_vif *vif)
4615 {
4616         struct ath10k_vif_iter *arvif_iter = data;
4617         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4618
4619         if (arvif->vdev_id == arvif_iter->vdev_id)
4620                 arvif_iter->arvif = arvif;
4621 }
4622
4623 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
4624 {
4625         struct ath10k_vif_iter arvif_iter;
4626         u32 flags;
4627
4628         memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
4629         arvif_iter.vdev_id = vdev_id;
4630
4631         flags = IEEE80211_IFACE_ITER_RESUME_ALL;
4632         ieee80211_iterate_active_interfaces_atomic(ar->hw,
4633                                                    flags,
4634                                                    ath10k_get_arvif_iter,
4635                                                    &arvif_iter);
4636         if (!arvif_iter.arvif) {
4637                 ath10k_warn("No VIF found for vdev %d\n", vdev_id);
4638                 return NULL;
4639         }
4640
4641         return arvif_iter.arvif;
4642 }
4643
4644 int ath10k_mac_register(struct ath10k *ar)
4645 {
4646         struct ieee80211_supported_band *band;
4647         struct ieee80211_sta_vht_cap vht_cap;
4648         struct ieee80211_sta_ht_cap ht_cap;
4649         void *channels;
4650         int ret;
4651
4652         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
4653
4654         SET_IEEE80211_DEV(ar->hw, ar->dev);
4655
4656         ht_cap = ath10k_get_ht_cap(ar);
4657         vht_cap = ath10k_create_vht_cap(ar);
4658
4659         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4660                 channels = kmemdup(ath10k_2ghz_channels,
4661                                    sizeof(ath10k_2ghz_channels),
4662                                    GFP_KERNEL);
4663                 if (!channels) {
4664                         ret = -ENOMEM;
4665                         goto err_free;
4666                 }
4667
4668                 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
4669                 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
4670                 band->channels = channels;
4671                 band->n_bitrates = ath10k_g_rates_size;
4672                 band->bitrates = ath10k_g_rates;
4673                 band->ht_cap = ht_cap;
4674
4675                 /* vht is not supported in 2.4 GHz */
4676
4677                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
4678         }
4679
4680         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4681                 channels = kmemdup(ath10k_5ghz_channels,
4682                                    sizeof(ath10k_5ghz_channels),
4683                                    GFP_KERNEL);
4684                 if (!channels) {
4685                         ret = -ENOMEM;
4686                         goto err_free;
4687                 }
4688
4689                 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
4690                 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
4691                 band->channels = channels;
4692                 band->n_bitrates = ath10k_a_rates_size;
4693                 band->bitrates = ath10k_a_rates;
4694                 band->ht_cap = ht_cap;
4695                 band->vht_cap = vht_cap;
4696                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
4697         }
4698
4699         ar->hw->wiphy->interface_modes =
4700                 BIT(NL80211_IFTYPE_STATION) |
4701                 BIT(NL80211_IFTYPE_ADHOC) |
4702                 BIT(NL80211_IFTYPE_AP);
4703
4704         if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4705                 /* TODO:  Have to deal with 2x2 chips if/when the come out. */
4706                 ar->supp_tx_chainmask = TARGET_10X_TX_CHAIN_MASK;
4707                 ar->supp_rx_chainmask = TARGET_10X_RX_CHAIN_MASK;
4708         } else {
4709                 ar->supp_tx_chainmask = TARGET_TX_CHAIN_MASK;
4710                 ar->supp_rx_chainmask = TARGET_RX_CHAIN_MASK;
4711         }
4712
4713         ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
4714         ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
4715
4716         if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
4717                 ar->hw->wiphy->interface_modes |=
4718                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
4719                         BIT(NL80211_IFTYPE_P2P_GO);
4720
4721         ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4722                         IEEE80211_HW_SUPPORTS_PS |
4723                         IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4724                         IEEE80211_HW_SUPPORTS_UAPSD |
4725                         IEEE80211_HW_MFP_CAPABLE |
4726                         IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4727                         IEEE80211_HW_HAS_RATE_CONTROL |
4728                         IEEE80211_HW_SUPPORTS_STATIC_SMPS |
4729                         IEEE80211_HW_AP_LINK_PS |
4730                         IEEE80211_HW_SPECTRUM_MGMT;
4731
4732         /* MSDU can have HTT TX fragment pushed in front. The additional 4
4733          * bytes is used for padding/alignment if necessary. */
4734         ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4;
4735
4736         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
4737                 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
4738
4739         if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
4740                 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
4741                 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4742         }
4743
4744         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
4745         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
4746
4747         ar->hw->vif_data_size = sizeof(struct ath10k_vif);
4748         ar->hw->sta_data_size = sizeof(struct ath10k_sta);
4749
4750         ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
4751
4752         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
4753         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
4754         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
4755
4756         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4757         /*
4758          * on LL hardware queues are managed entirely by the FW
4759          * so we only advertise to mac we can do the queues thing
4760          */
4761         ar->hw->queues = 4;
4762
4763         if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4764                 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
4765                 ar->hw->wiphy->n_iface_combinations =
4766                         ARRAY_SIZE(ath10k_10x_if_comb);
4767         } else {
4768                 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
4769                 ar->hw->wiphy->n_iface_combinations =
4770                         ARRAY_SIZE(ath10k_if_comb);
4771         }
4772
4773         ar->hw->netdev_features = NETIF_F_HW_CSUM;
4774
4775         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
4776                 /* Init ath dfs pattern detector */
4777                 ar->ath_common.debug_mask = ATH_DBG_DFS;
4778                 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
4779                                                              NL80211_DFS_UNSET);
4780
4781                 if (!ar->dfs_detector)
4782                         ath10k_warn("failed to initialise DFS pattern detector\n");
4783         }
4784
4785         ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
4786                             ath10k_reg_notifier);
4787         if (ret) {
4788                 ath10k_err("failed to initialise regulatory: %i\n", ret);
4789                 goto err_free;
4790         }
4791
4792         ret = ieee80211_register_hw(ar->hw);
4793         if (ret) {
4794                 ath10k_err("failed to register ieee80211: %d\n", ret);
4795                 goto err_free;
4796         }
4797
4798         if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
4799                 ret = regulatory_hint(ar->hw->wiphy,
4800                                       ar->ath_common.regulatory.alpha2);
4801                 if (ret)
4802                         goto err_unregister;
4803         }
4804
4805         return 0;
4806
4807 err_unregister:
4808         ieee80211_unregister_hw(ar->hw);
4809 err_free:
4810         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4811         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4812
4813         return ret;
4814 }
4815
4816 void ath10k_mac_unregister(struct ath10k *ar)
4817 {
4818         ieee80211_unregister_hw(ar->hw);
4819
4820         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
4821                 ar->dfs_detector->exit(ar->dfs_detector);
4822
4823         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4824         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4825
4826         SET_IEEE80211_DEV(ar->hw, NULL);
4827 }