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 cfg80211_scan_request *req)
3141 {
3142         struct ath10k *ar = hw->priv;
3143         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3144         struct wmi_start_scan_arg arg;
3145         int ret = 0;
3146         int i;
3147
3148         mutex_lock(&ar->conf_mutex);
3149
3150         spin_lock_bh(&ar->data_lock);
3151         if (ar->scan.in_progress) {
3152                 spin_unlock_bh(&ar->data_lock);
3153                 ret = -EBUSY;
3154                 goto exit;
3155         }
3156
3157         reinit_completion(&ar->scan.started);
3158         reinit_completion(&ar->scan.completed);
3159         ar->scan.in_progress = true;
3160         ar->scan.aborting = false;
3161         ar->scan.is_roc = false;
3162         ar->scan.vdev_id = arvif->vdev_id;
3163         spin_unlock_bh(&ar->data_lock);
3164
3165         memset(&arg, 0, sizeof(arg));
3166         ath10k_wmi_start_scan_init(ar, &arg);
3167         arg.vdev_id = arvif->vdev_id;
3168         arg.scan_id = ATH10K_SCAN_ID;
3169
3170         if (!req->no_cck)
3171                 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
3172
3173         if (req->ie_len) {
3174                 arg.ie_len = req->ie_len;
3175                 memcpy(arg.ie, req->ie, arg.ie_len);
3176         }
3177
3178         if (req->n_ssids) {
3179                 arg.n_ssids = req->n_ssids;
3180                 for (i = 0; i < arg.n_ssids; i++) {
3181                         arg.ssids[i].len  = req->ssids[i].ssid_len;
3182                         arg.ssids[i].ssid = req->ssids[i].ssid;
3183                 }
3184         } else {
3185                 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3186         }
3187
3188         if (req->n_channels) {
3189                 arg.n_channels = req->n_channels;
3190                 for (i = 0; i < arg.n_channels; i++)
3191                         arg.channels[i] = req->channels[i]->center_freq;
3192         }
3193
3194         ret = ath10k_start_scan(ar, &arg);
3195         if (ret) {
3196                 ath10k_warn("failed to start hw scan: %d\n", ret);
3197                 spin_lock_bh(&ar->data_lock);
3198                 ar->scan.in_progress = false;
3199                 spin_unlock_bh(&ar->data_lock);
3200         }
3201
3202 exit:
3203         mutex_unlock(&ar->conf_mutex);
3204         return ret;
3205 }
3206
3207 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
3208                                   struct ieee80211_vif *vif)
3209 {
3210         struct ath10k *ar = hw->priv;
3211         int ret;
3212
3213         mutex_lock(&ar->conf_mutex);
3214         ret = ath10k_abort_scan(ar);
3215         if (ret) {
3216                 ath10k_warn("failed to abort scan: %d\n", ret);
3217                 ieee80211_scan_completed(hw, 1 /* aborted */);
3218         }
3219         mutex_unlock(&ar->conf_mutex);
3220 }
3221
3222 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
3223                                         struct ath10k_vif *arvif,
3224                                         enum set_key_cmd cmd,
3225                                         struct ieee80211_key_conf *key)
3226 {
3227         u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
3228         int ret;
3229
3230         /* 10.1 firmware branch requires default key index to be set to group
3231          * key index after installing it. Otherwise FW/HW Txes corrupted
3232          * frames with multi-vif APs. This is not required for main firmware
3233          * branch (e.g. 636).
3234          *
3235          * FIXME: This has been tested only in AP. It remains unknown if this
3236          * is required for multi-vif STA interfaces on 10.1 */
3237
3238         if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3239                 return;
3240
3241         if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3242                 return;
3243
3244         if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3245                 return;
3246
3247         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3248                 return;
3249
3250         if (cmd != SET_KEY)
3251                 return;
3252
3253         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3254                                         key->keyidx);
3255         if (ret)
3256                 ath10k_warn("failed to set vdev %i group key as default key: %d\n",
3257                             arvif->vdev_id, ret);
3258 }
3259
3260 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3261                           struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3262                           struct ieee80211_key_conf *key)
3263 {
3264         struct ath10k *ar = hw->priv;
3265         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3266         struct ath10k_peer *peer;
3267         const u8 *peer_addr;
3268         bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3269                       key->cipher == WLAN_CIPHER_SUITE_WEP104;
3270         int ret = 0;
3271
3272         if (key->keyidx > WMI_MAX_KEY_INDEX)
3273                 return -ENOSPC;
3274
3275         mutex_lock(&ar->conf_mutex);
3276
3277         if (sta)
3278                 peer_addr = sta->addr;
3279         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3280                 peer_addr = vif->bss_conf.bssid;
3281         else
3282                 peer_addr = vif->addr;
3283
3284         key->hw_key_idx = key->keyidx;
3285
3286         /* the peer should not disappear in mid-way (unless FW goes awry) since
3287          * we already hold conf_mutex. we just make sure its there now. */
3288         spin_lock_bh(&ar->data_lock);
3289         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3290         spin_unlock_bh(&ar->data_lock);
3291
3292         if (!peer) {
3293                 if (cmd == SET_KEY) {
3294                         ath10k_warn("failed to install key for non-existent peer %pM\n",
3295                                     peer_addr);
3296                         ret = -EOPNOTSUPP;
3297                         goto exit;
3298                 } else {
3299                         /* if the peer doesn't exist there is no key to disable
3300                          * anymore */
3301                         goto exit;
3302                 }
3303         }
3304
3305         if (is_wep) {
3306                 if (cmd == SET_KEY)
3307                         arvif->wep_keys[key->keyidx] = key;
3308                 else
3309                         arvif->wep_keys[key->keyidx] = NULL;
3310
3311                 if (cmd == DISABLE_KEY)
3312                         ath10k_clear_vdev_key(arvif, key);
3313         }
3314
3315         ret = ath10k_install_key(arvif, key, cmd, peer_addr);
3316         if (ret) {
3317                 ath10k_warn("failed to install key for vdev %i peer %pM: %d\n",
3318                             arvif->vdev_id, peer_addr, ret);
3319                 goto exit;
3320         }
3321
3322         ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3323
3324         spin_lock_bh(&ar->data_lock);
3325         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3326         if (peer && cmd == SET_KEY)
3327                 peer->keys[key->keyidx] = key;
3328         else if (peer && cmd == DISABLE_KEY)
3329                 peer->keys[key->keyidx] = NULL;
3330         else if (peer == NULL)
3331                 /* impossible unless FW goes crazy */
3332                 ath10k_warn("Peer %pM disappeared!\n", peer_addr);
3333         spin_unlock_bh(&ar->data_lock);
3334
3335 exit:
3336         mutex_unlock(&ar->conf_mutex);
3337         return ret;
3338 }
3339
3340 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
3341 {
3342         struct ath10k *ar;
3343         struct ath10k_vif *arvif;
3344         struct ath10k_sta *arsta;
3345         struct ieee80211_sta *sta;
3346         u32 changed, bw, nss, smps;
3347         int err;
3348
3349         arsta = container_of(wk, struct ath10k_sta, update_wk);
3350         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3351         arvif = arsta->arvif;
3352         ar = arvif->ar;
3353
3354         spin_lock_bh(&ar->data_lock);
3355
3356         changed = arsta->changed;
3357         arsta->changed = 0;
3358
3359         bw = arsta->bw;
3360         nss = arsta->nss;
3361         smps = arsta->smps;
3362
3363         spin_unlock_bh(&ar->data_lock);
3364
3365         mutex_lock(&ar->conf_mutex);
3366
3367         if (changed & IEEE80211_RC_BW_CHANGED) {
3368                 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
3369                            sta->addr, bw);
3370
3371                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3372                                                 WMI_PEER_CHAN_WIDTH, bw);
3373                 if (err)
3374                         ath10k_warn("failed to update STA %pM peer bw %d: %d\n",
3375                                     sta->addr, bw, err);
3376         }
3377
3378         if (changed & IEEE80211_RC_NSS_CHANGED) {
3379                 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
3380                            sta->addr, nss);
3381
3382                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3383                                                 WMI_PEER_NSS, nss);
3384                 if (err)
3385                         ath10k_warn("failed to update STA %pM nss %d: %d\n",
3386                                     sta->addr, nss, err);
3387         }
3388
3389         if (changed & IEEE80211_RC_SMPS_CHANGED) {
3390                 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
3391                            sta->addr, smps);
3392
3393                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3394                                                 WMI_PEER_SMPS_STATE, smps);
3395                 if (err)
3396                         ath10k_warn("failed to update STA %pM smps %d: %d\n",
3397                                     sta->addr, smps, err);
3398         }
3399
3400         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
3401                 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM supp rates\n",
3402                            sta->addr);
3403
3404                 err = ath10k_station_assoc(ar, arvif, sta, true);
3405                 if (err)
3406                         ath10k_warn("failed to reassociate station: %pM\n",
3407                                     sta->addr);
3408         }
3409
3410         mutex_unlock(&ar->conf_mutex);
3411 }
3412
3413 static int ath10k_sta_state(struct ieee80211_hw *hw,
3414                             struct ieee80211_vif *vif,
3415                             struct ieee80211_sta *sta,
3416                             enum ieee80211_sta_state old_state,
3417                             enum ieee80211_sta_state new_state)
3418 {
3419         struct ath10k *ar = hw->priv;
3420         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3421         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3422         int max_num_peers;
3423         int ret = 0;
3424
3425         if (old_state == IEEE80211_STA_NOTEXIST &&
3426             new_state == IEEE80211_STA_NONE) {
3427                 memset(arsta, 0, sizeof(*arsta));
3428                 arsta->arvif = arvif;
3429                 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
3430         }
3431
3432         /* cancel must be done outside the mutex to avoid deadlock */
3433         if ((old_state == IEEE80211_STA_NONE &&
3434              new_state == IEEE80211_STA_NOTEXIST))
3435                 cancel_work_sync(&arsta->update_wk);
3436
3437         mutex_lock(&ar->conf_mutex);
3438
3439         if (old_state == IEEE80211_STA_NOTEXIST &&
3440             new_state == IEEE80211_STA_NONE &&
3441             vif->type != NL80211_IFTYPE_STATION) {
3442                 /*
3443                  * New station addition.
3444                  */
3445                 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
3446                         max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1;
3447                 else
3448                         max_num_peers = TARGET_NUM_PEERS;
3449
3450                 if (ar->num_peers >= max_num_peers) {
3451                         ath10k_warn("number of peers exceeded: peers number %d (max peers %d)\n",
3452                                     ar->num_peers, max_num_peers);
3453                         ret = -ENOBUFS;
3454                         goto exit;
3455                 }
3456
3457                 ath10k_dbg(ATH10K_DBG_MAC,
3458                            "mac vdev %d peer create %pM (new sta) num_peers %d\n",
3459                            arvif->vdev_id, sta->addr, ar->num_peers);
3460
3461                 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3462                 if (ret)
3463                         ath10k_warn("failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3464                                     sta->addr, arvif->vdev_id, ret);
3465         } else if ((old_state == IEEE80211_STA_NONE &&
3466                     new_state == IEEE80211_STA_NOTEXIST)) {
3467                 /*
3468                  * Existing station deletion.
3469                  */
3470                 ath10k_dbg(ATH10K_DBG_MAC,
3471                            "mac vdev %d peer delete %pM (sta gone)\n",
3472                            arvif->vdev_id, sta->addr);
3473                 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3474                 if (ret)
3475                         ath10k_warn("failed to delete peer %pM for vdev %d: %i\n",
3476                                     sta->addr, arvif->vdev_id, ret);
3477
3478                 if (vif->type == NL80211_IFTYPE_STATION)
3479                         ath10k_bss_disassoc(hw, vif);
3480         } else if (old_state == IEEE80211_STA_AUTH &&
3481                    new_state == IEEE80211_STA_ASSOC &&
3482                    (vif->type == NL80211_IFTYPE_AP ||
3483                     vif->type == NL80211_IFTYPE_ADHOC)) {
3484                 /*
3485                  * New association.
3486                  */
3487                 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n",
3488                            sta->addr);
3489
3490                 ret = ath10k_station_assoc(ar, arvif, sta, false);
3491                 if (ret)
3492                         ath10k_warn("failed to associate station %pM for vdev %i: %i\n",
3493                                     sta->addr, arvif->vdev_id, ret);
3494         } else if (old_state == IEEE80211_STA_ASSOC &&
3495                    new_state == IEEE80211_STA_AUTH &&
3496                    (vif->type == NL80211_IFTYPE_AP ||
3497                     vif->type == NL80211_IFTYPE_ADHOC)) {
3498                 /*
3499                  * Disassociation.
3500                  */
3501                 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
3502                            sta->addr);
3503
3504                 ret = ath10k_station_disassoc(ar, arvif, sta);
3505                 if (ret)
3506                         ath10k_warn("failed to disassociate station: %pM vdev %i: %i\n",
3507                                     sta->addr, arvif->vdev_id, ret);
3508         }
3509 exit:
3510         mutex_unlock(&ar->conf_mutex);
3511         return ret;
3512 }
3513
3514 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
3515                                  u16 ac, bool enable)
3516 {
3517         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3518         u32 value = 0;
3519         int ret = 0;
3520
3521         lockdep_assert_held(&ar->conf_mutex);
3522
3523         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3524                 return 0;
3525
3526         switch (ac) {
3527         case IEEE80211_AC_VO:
3528                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3529                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3530                 break;
3531         case IEEE80211_AC_VI:
3532                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3533                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3534                 break;
3535         case IEEE80211_AC_BE:
3536                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3537                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3538                 break;
3539         case IEEE80211_AC_BK:
3540                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3541                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3542                 break;
3543         }
3544
3545         if (enable)
3546                 arvif->u.sta.uapsd |= value;
3547         else
3548                 arvif->u.sta.uapsd &= ~value;
3549
3550         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3551                                           WMI_STA_PS_PARAM_UAPSD,
3552                                           arvif->u.sta.uapsd);
3553         if (ret) {
3554                 ath10k_warn("failed to set uapsd params: %d\n", ret);
3555                 goto exit;
3556         }
3557
3558         if (arvif->u.sta.uapsd)
3559                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
3560         else
3561                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3562
3563         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3564                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
3565                                           value);
3566         if (ret)
3567                 ath10k_warn("failed to set rx wake param: %d\n", ret);
3568
3569 exit:
3570         return ret;
3571 }
3572
3573 static int ath10k_conf_tx(struct ieee80211_hw *hw,
3574                           struct ieee80211_vif *vif, u16 ac,
3575                           const struct ieee80211_tx_queue_params *params)
3576 {
3577         struct ath10k *ar = hw->priv;
3578         struct wmi_wmm_params_arg *p = NULL;
3579         int ret;
3580
3581         mutex_lock(&ar->conf_mutex);
3582
3583         switch (ac) {
3584         case IEEE80211_AC_VO:
3585                 p = &ar->wmm_params.ac_vo;
3586                 break;
3587         case IEEE80211_AC_VI:
3588                 p = &ar->wmm_params.ac_vi;
3589                 break;
3590         case IEEE80211_AC_BE:
3591                 p = &ar->wmm_params.ac_be;
3592                 break;
3593         case IEEE80211_AC_BK:
3594                 p = &ar->wmm_params.ac_bk;
3595                 break;
3596         }
3597
3598         if (WARN_ON(!p)) {
3599                 ret = -EINVAL;
3600                 goto exit;
3601         }
3602
3603         p->cwmin = params->cw_min;
3604         p->cwmax = params->cw_max;
3605         p->aifs = params->aifs;
3606
3607         /*
3608          * The channel time duration programmed in the HW is in absolute
3609          * microseconds, while mac80211 gives the txop in units of
3610          * 32 microseconds.
3611          */
3612         p->txop = params->txop * 32;
3613
3614         /* FIXME: FW accepts wmm params per hw, not per vif */
3615         ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3616         if (ret) {
3617                 ath10k_warn("failed to set wmm params: %d\n", ret);
3618                 goto exit;
3619         }
3620
3621         ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3622         if (ret)
3623                 ath10k_warn("failed to set sta uapsd: %d\n", ret);
3624
3625 exit:
3626         mutex_unlock(&ar->conf_mutex);
3627         return ret;
3628 }
3629
3630 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3631
3632 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3633                                     struct ieee80211_vif *vif,
3634                                     struct ieee80211_channel *chan,
3635                                     int duration,
3636                                     enum ieee80211_roc_type type)
3637 {
3638         struct ath10k *ar = hw->priv;
3639         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3640         struct wmi_start_scan_arg arg;
3641         int ret;
3642
3643         mutex_lock(&ar->conf_mutex);
3644
3645         spin_lock_bh(&ar->data_lock);
3646         if (ar->scan.in_progress) {
3647                 spin_unlock_bh(&ar->data_lock);
3648                 ret = -EBUSY;
3649                 goto exit;
3650         }
3651
3652         reinit_completion(&ar->scan.started);
3653         reinit_completion(&ar->scan.completed);
3654         reinit_completion(&ar->scan.on_channel);
3655         ar->scan.in_progress = true;
3656         ar->scan.aborting = false;
3657         ar->scan.is_roc = true;
3658         ar->scan.vdev_id = arvif->vdev_id;
3659         ar->scan.roc_freq = chan->center_freq;
3660         spin_unlock_bh(&ar->data_lock);
3661
3662         memset(&arg, 0, sizeof(arg));
3663         ath10k_wmi_start_scan_init(ar, &arg);
3664         arg.vdev_id = arvif->vdev_id;
3665         arg.scan_id = ATH10K_SCAN_ID;
3666         arg.n_channels = 1;
3667         arg.channels[0] = chan->center_freq;
3668         arg.dwell_time_active = duration;
3669         arg.dwell_time_passive = duration;
3670         arg.max_scan_time = 2 * duration;
3671         arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3672         arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3673
3674         ret = ath10k_start_scan(ar, &arg);
3675         if (ret) {
3676                 ath10k_warn("failed to start roc scan: %d\n", ret);
3677                 spin_lock_bh(&ar->data_lock);
3678                 ar->scan.in_progress = false;
3679                 spin_unlock_bh(&ar->data_lock);
3680                 goto exit;
3681         }
3682
3683         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3684         if (ret == 0) {
3685                 ath10k_warn("failed to switch to channel for roc scan\n");
3686                 ath10k_abort_scan(ar);
3687                 ret = -ETIMEDOUT;
3688                 goto exit;
3689         }
3690
3691         ret = 0;
3692 exit:
3693         mutex_unlock(&ar->conf_mutex);
3694         return ret;
3695 }
3696
3697 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3698 {
3699         struct ath10k *ar = hw->priv;
3700
3701         mutex_lock(&ar->conf_mutex);
3702         ath10k_abort_scan(ar);
3703         mutex_unlock(&ar->conf_mutex);
3704
3705         return 0;
3706 }
3707
3708 /*
3709  * Both RTS and Fragmentation threshold are interface-specific
3710  * in ath10k, but device-specific in mac80211.
3711  */
3712
3713 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3714 {
3715         struct ath10k *ar = hw->priv;
3716         struct ath10k_vif *arvif;
3717         int ret = 0;
3718
3719         mutex_lock(&ar->conf_mutex);
3720         list_for_each_entry(arvif, &ar->arvifs, list) {
3721                 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
3722                            arvif->vdev_id, value);
3723
3724                 ret = ath10k_mac_set_rts(arvif, value);
3725                 if (ret) {
3726                         ath10k_warn("failed to set rts threshold for vdev %d: %d\n",
3727                                     arvif->vdev_id, ret);
3728                         break;
3729                 }
3730         }
3731         mutex_unlock(&ar->conf_mutex);
3732
3733         return ret;
3734 }
3735
3736 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3737 {
3738         struct ath10k *ar = hw->priv;
3739         struct ath10k_vif *arvif;
3740         int ret = 0;
3741
3742         mutex_lock(&ar->conf_mutex);
3743         list_for_each_entry(arvif, &ar->arvifs, list) {
3744                 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
3745                            arvif->vdev_id, value);
3746
3747                 ret = ath10k_mac_set_rts(arvif, value);
3748                 if (ret) {
3749                         ath10k_warn("failed to set fragmentation threshold for vdev %d: %d\n",
3750                                     arvif->vdev_id, ret);
3751                         break;
3752                 }
3753         }
3754         mutex_unlock(&ar->conf_mutex);
3755
3756         return ret;
3757 }
3758
3759 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
3760                          u32 queues, bool drop)
3761 {
3762         struct ath10k *ar = hw->priv;
3763         bool skip;
3764         int ret;
3765
3766         /* mac80211 doesn't care if we really xmit queued frames or not
3767          * we'll collect those frames either way if we stop/delete vdevs */
3768         if (drop)
3769                 return;
3770
3771         mutex_lock(&ar->conf_mutex);
3772
3773         if (ar->state == ATH10K_STATE_WEDGED)
3774                 goto skip;
3775
3776         ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
3777                         bool empty;
3778
3779                         spin_lock_bh(&ar->htt.tx_lock);
3780                         empty = (ar->htt.num_pending_tx == 0);
3781                         spin_unlock_bh(&ar->htt.tx_lock);
3782
3783                         skip = (ar->state == ATH10K_STATE_WEDGED);
3784
3785                         (empty || skip);
3786                 }), ATH10K_FLUSH_TIMEOUT_HZ);
3787
3788         if (ret <= 0 || skip)
3789                 ath10k_warn("failed to flush transmit queue (skip %i ar-state %i): %i\n",
3790                             skip, ar->state, ret);
3791
3792 skip:
3793         mutex_unlock(&ar->conf_mutex);
3794 }
3795
3796 /* TODO: Implement this function properly
3797  * For now it is needed to reply to Probe Requests in IBSS mode.
3798  * Propably we need this information from FW.
3799  */
3800 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
3801 {
3802         return 1;
3803 }
3804
3805 #ifdef CONFIG_PM
3806 static int ath10k_suspend(struct ieee80211_hw *hw,
3807                           struct cfg80211_wowlan *wowlan)
3808 {
3809         struct ath10k *ar = hw->priv;
3810         int ret;
3811
3812         mutex_lock(&ar->conf_mutex);
3813
3814         ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
3815         if (ret) {
3816                 if (ret == -ETIMEDOUT)
3817                         goto resume;
3818                 ret = 1;
3819                 goto exit;
3820         }
3821
3822         ret = ath10k_hif_suspend(ar);
3823         if (ret) {
3824                 ath10k_warn("failed to suspend hif: %d\n", ret);
3825                 goto resume;
3826         }
3827
3828         ret = 0;
3829         goto exit;
3830 resume:
3831         ret = ath10k_wmi_pdev_resume_target(ar);
3832         if (ret)
3833                 ath10k_warn("failed to resume target: %d\n", ret);
3834
3835         ret = 1;
3836 exit:
3837         mutex_unlock(&ar->conf_mutex);
3838         return ret;
3839 }
3840
3841 static int ath10k_resume(struct ieee80211_hw *hw)
3842 {
3843         struct ath10k *ar = hw->priv;
3844         int ret;
3845
3846         mutex_lock(&ar->conf_mutex);
3847
3848         ret = ath10k_hif_resume(ar);
3849         if (ret) {
3850                 ath10k_warn("failed to resume hif: %d\n", ret);
3851                 ret = 1;
3852                 goto exit;
3853         }
3854
3855         ret = ath10k_wmi_pdev_resume_target(ar);
3856         if (ret) {
3857                 ath10k_warn("failed to resume target: %d\n", ret);
3858                 ret = 1;
3859                 goto exit;
3860         }
3861
3862         ret = 0;
3863 exit:
3864         mutex_unlock(&ar->conf_mutex);
3865         return ret;
3866 }
3867 #endif
3868
3869 static void ath10k_restart_complete(struct ieee80211_hw *hw)
3870 {
3871         struct ath10k *ar = hw->priv;
3872
3873         mutex_lock(&ar->conf_mutex);
3874
3875         /* If device failed to restart it will be in a different state, e.g.
3876          * ATH10K_STATE_WEDGED */
3877         if (ar->state == ATH10K_STATE_RESTARTED) {
3878                 ath10k_info("device successfully recovered\n");
3879                 ar->state = ATH10K_STATE_ON;
3880         }
3881
3882         mutex_unlock(&ar->conf_mutex);
3883 }
3884
3885 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
3886                              struct survey_info *survey)
3887 {
3888         struct ath10k *ar = hw->priv;
3889         struct ieee80211_supported_band *sband;
3890         struct survey_info *ar_survey = &ar->survey[idx];
3891         int ret = 0;
3892
3893         mutex_lock(&ar->conf_mutex);
3894
3895         sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
3896         if (sband && idx >= sband->n_channels) {
3897                 idx -= sband->n_channels;
3898                 sband = NULL;
3899         }
3900
3901         if (!sband)
3902                 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
3903
3904         if (!sband || idx >= sband->n_channels) {
3905                 ret = -ENOENT;
3906                 goto exit;
3907         }
3908
3909         spin_lock_bh(&ar->data_lock);
3910         memcpy(survey, ar_survey, sizeof(*survey));
3911         spin_unlock_bh(&ar->data_lock);
3912
3913         survey->channel = &sband->channels[idx];
3914
3915 exit:
3916         mutex_unlock(&ar->conf_mutex);
3917         return ret;
3918 }
3919
3920 /* Helper table for legacy fixed_rate/bitrate_mask */
3921 static const u8 cck_ofdm_rate[] = {
3922         /* CCK */
3923         3, /* 1Mbps */
3924         2, /* 2Mbps */
3925         1, /* 5.5Mbps */
3926         0, /* 11Mbps */
3927         /* OFDM */
3928         3, /* 6Mbps */
3929         7, /* 9Mbps */
3930         2, /* 12Mbps */
3931         6, /* 18Mbps */
3932         1, /* 24Mbps */
3933         5, /* 36Mbps */
3934         0, /* 48Mbps */
3935         4, /* 54Mbps */
3936 };
3937
3938 /* Check if only one bit set */
3939 static int ath10k_check_single_mask(u32 mask)
3940 {
3941         int bit;
3942
3943         bit = ffs(mask);
3944         if (!bit)
3945                 return 0;
3946
3947         mask &= ~BIT(bit - 1);
3948         if (mask)
3949                 return 2;
3950
3951         return 1;
3952 }
3953
3954 static bool
3955 ath10k_default_bitrate_mask(struct ath10k *ar,
3956                             enum ieee80211_band band,
3957                             const struct cfg80211_bitrate_mask *mask)
3958 {
3959         u32 legacy = 0x00ff;
3960         u8 ht = 0xff, i;
3961         u16 vht = 0x3ff;
3962
3963         switch (band) {
3964         case IEEE80211_BAND_2GHZ:
3965                 legacy = 0x00fff;
3966                 vht = 0;
3967                 break;
3968         case IEEE80211_BAND_5GHZ:
3969                 break;
3970         default:
3971                 return false;
3972         }
3973
3974         if (mask->control[band].legacy != legacy)
3975                 return false;
3976
3977         for (i = 0; i < ar->num_rf_chains; i++)
3978                 if (mask->control[band].ht_mcs[i] != ht)
3979                         return false;
3980
3981         for (i = 0; i < ar->num_rf_chains; i++)
3982                 if (mask->control[band].vht_mcs[i] != vht)
3983                         return false;
3984
3985         return true;
3986 }
3987
3988 static bool
3989 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
3990                         enum ieee80211_band band,
3991                         u8 *fixed_nss)
3992 {
3993         int ht_nss = 0, vht_nss = 0, i;
3994
3995         /* check legacy */
3996         if (ath10k_check_single_mask(mask->control[band].legacy))
3997                 return false;
3998
3999         /* check HT */
4000         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4001                 if (mask->control[band].ht_mcs[i] == 0xff)
4002                         continue;
4003                 else if (mask->control[band].ht_mcs[i] == 0x00)
4004                         break;
4005                 else
4006                         return false;
4007         }
4008
4009         ht_nss = i;
4010
4011         /* check VHT */
4012         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4013                 if (mask->control[band].vht_mcs[i] == 0x03ff)
4014                         continue;
4015                 else if (mask->control[band].vht_mcs[i] == 0x0000)
4016                         break;
4017                 else
4018                         return false;
4019         }
4020
4021         vht_nss = i;
4022
4023         if (ht_nss > 0 && vht_nss > 0)
4024                 return false;
4025
4026         if (ht_nss)
4027                 *fixed_nss = ht_nss;
4028         else if (vht_nss)
4029                 *fixed_nss = vht_nss;
4030         else
4031                 return false;
4032
4033         return true;
4034 }
4035
4036 static bool
4037 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
4038                             enum ieee80211_band band,
4039                             enum wmi_rate_preamble *preamble)
4040 {
4041         int legacy = 0, ht = 0, vht = 0, i;
4042
4043         *preamble = WMI_RATE_PREAMBLE_OFDM;
4044
4045         /* check legacy */
4046         legacy = ath10k_check_single_mask(mask->control[band].legacy);
4047         if (legacy > 1)
4048                 return false;
4049
4050         /* check HT */
4051         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4052                 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
4053         if (ht > 1)
4054                 return false;
4055
4056         /* check VHT */
4057         for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4058                 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
4059         if (vht > 1)
4060                 return false;
4061
4062         /* Currently we support only one fixed_rate */
4063         if ((legacy + ht + vht) != 1)
4064                 return false;
4065
4066         if (ht)
4067                 *preamble = WMI_RATE_PREAMBLE_HT;
4068         else if (vht)
4069                 *preamble = WMI_RATE_PREAMBLE_VHT;
4070
4071         return true;
4072 }
4073
4074 static bool
4075 ath10k_bitrate_mask_rate(const struct cfg80211_bitrate_mask *mask,
4076                          enum ieee80211_band band,
4077                          u8 *fixed_rate,
4078                          u8 *fixed_nss)
4079 {
4080         u8 rate = 0, pream = 0, nss = 0, i;
4081         enum wmi_rate_preamble preamble;
4082
4083         /* Check if single rate correct */
4084         if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
4085                 return false;
4086
4087         pream = preamble;
4088
4089         switch (preamble) {
4090         case WMI_RATE_PREAMBLE_CCK:
4091         case WMI_RATE_PREAMBLE_OFDM:
4092                 i = ffs(mask->control[band].legacy) - 1;
4093
4094                 if (band == IEEE80211_BAND_2GHZ && i < 4)
4095                         pream = WMI_RATE_PREAMBLE_CCK;
4096
4097                 if (band == IEEE80211_BAND_5GHZ)
4098                         i += 4;
4099
4100                 if (i >= ARRAY_SIZE(cck_ofdm_rate))
4101                         return false;
4102
4103                 rate = cck_ofdm_rate[i];
4104                 break;
4105         case WMI_RATE_PREAMBLE_HT:
4106                 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4107                         if (mask->control[band].ht_mcs[i])
4108                                 break;
4109
4110                 if (i == IEEE80211_HT_MCS_MASK_LEN)
4111                         return false;
4112
4113                 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4114                 nss = i;
4115                 break;
4116         case WMI_RATE_PREAMBLE_VHT:
4117                 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4118                         if (mask->control[band].vht_mcs[i])
4119                                 break;
4120
4121                 if (i == NL80211_VHT_NSS_MAX)
4122                         return false;
4123
4124                 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4125                 nss = i;
4126                 break;
4127         }
4128
4129         *fixed_nss = nss + 1;
4130         nss <<= 4;
4131         pream <<= 6;
4132
4133         ath10k_dbg(ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
4134                    pream, nss, rate);
4135
4136         *fixed_rate = pream | nss | rate;
4137
4138         return true;
4139 }
4140
4141 static bool ath10k_get_fixed_rate_nss(const struct cfg80211_bitrate_mask *mask,
4142                                       enum ieee80211_band band,
4143                                       u8 *fixed_rate,
4144                                       u8 *fixed_nss)
4145 {
4146         /* First check full NSS mask, if we can simply limit NSS */
4147         if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
4148                 return true;
4149
4150         /* Next Check single rate is set */
4151         return ath10k_bitrate_mask_rate(mask, band, fixed_rate, fixed_nss);
4152 }
4153
4154 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
4155                                        u8 fixed_rate,
4156                                        u8 fixed_nss,
4157                                        u8 force_sgi)
4158 {
4159         struct ath10k *ar = arvif->ar;
4160         u32 vdev_param;
4161         int ret = 0;
4162
4163         mutex_lock(&ar->conf_mutex);
4164
4165         if (arvif->fixed_rate == fixed_rate &&
4166             arvif->fixed_nss == fixed_nss &&
4167             arvif->force_sgi == force_sgi)
4168                 goto exit;
4169
4170         if (fixed_rate == WMI_FIXED_RATE_NONE)
4171                 ath10k_dbg(ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
4172
4173         if (force_sgi)
4174                 ath10k_dbg(ATH10K_DBG_MAC, "mac force sgi\n");
4175
4176         vdev_param = ar->wmi.vdev_param->fixed_rate;
4177         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4178                                         vdev_param, fixed_rate);
4179         if (ret) {
4180                 ath10k_warn("failed to set fixed rate param 0x%02x: %d\n",
4181                             fixed_rate, ret);
4182                 ret = -EINVAL;
4183                 goto exit;
4184         }
4185
4186         arvif->fixed_rate = fixed_rate;
4187
4188         vdev_param = ar->wmi.vdev_param->nss;
4189         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4190                                         vdev_param, fixed_nss);
4191
4192         if (ret) {
4193                 ath10k_warn("failed to set fixed nss param %d: %d\n",
4194                             fixed_nss, ret);
4195                 ret = -EINVAL;
4196                 goto exit;
4197         }
4198
4199         arvif->fixed_nss = fixed_nss;
4200
4201         vdev_param = ar->wmi.vdev_param->sgi;
4202         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4203                                         force_sgi);
4204
4205         if (ret) {
4206                 ath10k_warn("failed to set sgi param %d: %d\n",
4207                             force_sgi, ret);
4208                 ret = -EINVAL;
4209                 goto exit;
4210         }
4211
4212         arvif->force_sgi = force_sgi;
4213
4214 exit:
4215         mutex_unlock(&ar->conf_mutex);
4216         return ret;
4217 }
4218
4219 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
4220                                    struct ieee80211_vif *vif,
4221                                    const struct cfg80211_bitrate_mask *mask)
4222 {
4223         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4224         struct ath10k *ar = arvif->ar;
4225         enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
4226         u8 fixed_rate = WMI_FIXED_RATE_NONE;
4227         u8 fixed_nss = ar->num_rf_chains;
4228         u8 force_sgi;
4229
4230         force_sgi = mask->control[band].gi;
4231         if (force_sgi == NL80211_TXRATE_FORCE_LGI)
4232                 return -EINVAL;
4233
4234         if (!ath10k_default_bitrate_mask(ar, band, mask)) {
4235                 if (!ath10k_get_fixed_rate_nss(mask, band,
4236                                                &fixed_rate,
4237                                                &fixed_nss))
4238                         return -EINVAL;
4239         }
4240
4241         if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) {
4242                 ath10k_warn("failed to force SGI usage for default rate settings\n");
4243                 return -EINVAL;
4244         }
4245
4246         return ath10k_set_fixed_rate_param(arvif, fixed_rate,
4247                                            fixed_nss, force_sgi);
4248 }
4249
4250 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
4251                                  struct ieee80211_vif *vif,
4252                                  struct ieee80211_sta *sta,
4253                                  u32 changed)
4254 {
4255         struct ath10k *ar = hw->priv;
4256         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
4257         u32 bw, smps;
4258
4259         spin_lock_bh(&ar->data_lock);
4260
4261         ath10k_dbg(ATH10K_DBG_MAC,
4262                    "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4263                    sta->addr, changed, sta->bandwidth, sta->rx_nss,
4264                    sta->smps_mode);
4265
4266         if (changed & IEEE80211_RC_BW_CHANGED) {
4267                 bw = WMI_PEER_CHWIDTH_20MHZ;
4268
4269                 switch (sta->bandwidth) {
4270                 case IEEE80211_STA_RX_BW_20:
4271                         bw = WMI_PEER_CHWIDTH_20MHZ;
4272                         break;
4273                 case IEEE80211_STA_RX_BW_40:
4274                         bw = WMI_PEER_CHWIDTH_40MHZ;
4275                         break;
4276                 case IEEE80211_STA_RX_BW_80:
4277                         bw = WMI_PEER_CHWIDTH_80MHZ;
4278                         break;
4279                 case IEEE80211_STA_RX_BW_160:
4280                         ath10k_warn("Invalid bandwith %d in rc update for %pM\n",
4281                                     sta->bandwidth, sta->addr);
4282                         bw = WMI_PEER_CHWIDTH_20MHZ;
4283                         break;
4284                 }
4285
4286                 arsta->bw = bw;
4287         }
4288
4289         if (changed & IEEE80211_RC_NSS_CHANGED)
4290                 arsta->nss = sta->rx_nss;
4291
4292         if (changed & IEEE80211_RC_SMPS_CHANGED) {
4293                 smps = WMI_PEER_SMPS_PS_NONE;
4294
4295                 switch (sta->smps_mode) {
4296                 case IEEE80211_SMPS_AUTOMATIC:
4297                 case IEEE80211_SMPS_OFF:
4298                         smps = WMI_PEER_SMPS_PS_NONE;
4299                         break;
4300                 case IEEE80211_SMPS_STATIC:
4301                         smps = WMI_PEER_SMPS_STATIC;
4302                         break;
4303                 case IEEE80211_SMPS_DYNAMIC:
4304                         smps = WMI_PEER_SMPS_DYNAMIC;
4305                         break;
4306                 case IEEE80211_SMPS_NUM_MODES:
4307                         ath10k_warn("Invalid smps %d in sta rc update for %pM\n",
4308                                     sta->smps_mode, sta->addr);
4309                         smps = WMI_PEER_SMPS_PS_NONE;
4310                         break;
4311                 }
4312
4313                 arsta->smps = smps;
4314         }
4315
4316         arsta->changed |= changed;
4317
4318         spin_unlock_bh(&ar->data_lock);
4319
4320         ieee80211_queue_work(hw, &arsta->update_wk);
4321 }
4322
4323 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4324 {
4325         /*
4326          * FIXME: Return 0 for time being. Need to figure out whether FW
4327          * has the API to fetch 64-bit local TSF
4328          */
4329
4330         return 0;
4331 }
4332
4333 static const struct ieee80211_ops ath10k_ops = {
4334         .tx                             = ath10k_tx,
4335         .start                          = ath10k_start,
4336         .stop                           = ath10k_stop,
4337         .config                         = ath10k_config,
4338         .add_interface                  = ath10k_add_interface,
4339         .remove_interface               = ath10k_remove_interface,
4340         .configure_filter               = ath10k_configure_filter,
4341         .bss_info_changed               = ath10k_bss_info_changed,
4342         .hw_scan                        = ath10k_hw_scan,
4343         .cancel_hw_scan                 = ath10k_cancel_hw_scan,
4344         .set_key                        = ath10k_set_key,
4345         .sta_state                      = ath10k_sta_state,
4346         .conf_tx                        = ath10k_conf_tx,
4347         .remain_on_channel              = ath10k_remain_on_channel,
4348         .cancel_remain_on_channel       = ath10k_cancel_remain_on_channel,
4349         .set_rts_threshold              = ath10k_set_rts_threshold,
4350         .set_frag_threshold             = ath10k_set_frag_threshold,
4351         .flush                          = ath10k_flush,
4352         .tx_last_beacon                 = ath10k_tx_last_beacon,
4353         .set_antenna                    = ath10k_set_antenna,
4354         .get_antenna                    = ath10k_get_antenna,
4355         .restart_complete               = ath10k_restart_complete,
4356         .get_survey                     = ath10k_get_survey,
4357         .set_bitrate_mask               = ath10k_set_bitrate_mask,
4358         .sta_rc_update                  = ath10k_sta_rc_update,
4359         .get_tsf                        = ath10k_get_tsf,
4360 #ifdef CONFIG_PM
4361         .suspend                        = ath10k_suspend,
4362         .resume                         = ath10k_resume,
4363 #endif
4364 };
4365
4366 #define RATETAB_ENT(_rate, _rateid, _flags) { \
4367         .bitrate                = (_rate), \
4368         .flags                  = (_flags), \
4369         .hw_value               = (_rateid), \
4370 }
4371
4372 #define CHAN2G(_channel, _freq, _flags) { \
4373         .band                   = IEEE80211_BAND_2GHZ, \
4374         .hw_value               = (_channel), \
4375         .center_freq            = (_freq), \
4376         .flags                  = (_flags), \
4377         .max_antenna_gain       = 0, \
4378         .max_power              = 30, \
4379 }
4380
4381 #define CHAN5G(_channel, _freq, _flags) { \
4382         .band                   = IEEE80211_BAND_5GHZ, \
4383         .hw_value               = (_channel), \
4384         .center_freq            = (_freq), \
4385         .flags                  = (_flags), \
4386         .max_antenna_gain       = 0, \
4387         .max_power              = 30, \
4388 }
4389
4390 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
4391         CHAN2G(1, 2412, 0),
4392         CHAN2G(2, 2417, 0),
4393         CHAN2G(3, 2422, 0),
4394         CHAN2G(4, 2427, 0),
4395         CHAN2G(5, 2432, 0),
4396         CHAN2G(6, 2437, 0),
4397         CHAN2G(7, 2442, 0),
4398         CHAN2G(8, 2447, 0),
4399         CHAN2G(9, 2452, 0),
4400         CHAN2G(10, 2457, 0),
4401         CHAN2G(11, 2462, 0),
4402         CHAN2G(12, 2467, 0),
4403         CHAN2G(13, 2472, 0),
4404         CHAN2G(14, 2484, 0),
4405 };
4406
4407 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
4408         CHAN5G(36, 5180, 0),
4409         CHAN5G(40, 5200, 0),
4410         CHAN5G(44, 5220, 0),
4411         CHAN5G(48, 5240, 0),
4412         CHAN5G(52, 5260, 0),
4413         CHAN5G(56, 5280, 0),
4414         CHAN5G(60, 5300, 0),
4415         CHAN5G(64, 5320, 0),
4416         CHAN5G(100, 5500, 0),
4417         CHAN5G(104, 5520, 0),
4418         CHAN5G(108, 5540, 0),
4419         CHAN5G(112, 5560, 0),
4420         CHAN5G(116, 5580, 0),
4421         CHAN5G(120, 5600, 0),
4422         CHAN5G(124, 5620, 0),
4423         CHAN5G(128, 5640, 0),
4424         CHAN5G(132, 5660, 0),
4425         CHAN5G(136, 5680, 0),
4426         CHAN5G(140, 5700, 0),
4427         CHAN5G(149, 5745, 0),
4428         CHAN5G(153, 5765, 0),
4429         CHAN5G(157, 5785, 0),
4430         CHAN5G(161, 5805, 0),
4431         CHAN5G(165, 5825, 0),
4432 };
4433
4434 static struct ieee80211_rate ath10k_rates[] = {
4435         /* CCK */
4436         RATETAB_ENT(10,  0x82, 0),
4437         RATETAB_ENT(20,  0x84, 0),
4438         RATETAB_ENT(55,  0x8b, 0),
4439         RATETAB_ENT(110, 0x96, 0),
4440         /* OFDM */
4441         RATETAB_ENT(60,  0x0c, 0),
4442         RATETAB_ENT(90,  0x12, 0),
4443         RATETAB_ENT(120, 0x18, 0),
4444         RATETAB_ENT(180, 0x24, 0),
4445         RATETAB_ENT(240, 0x30, 0),
4446         RATETAB_ENT(360, 0x48, 0),
4447         RATETAB_ENT(480, 0x60, 0),
4448         RATETAB_ENT(540, 0x6c, 0),
4449 };
4450
4451 #define ath10k_a_rates (ath10k_rates + 4)
4452 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4453 #define ath10k_g_rates (ath10k_rates + 0)
4454 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4455
4456 struct ath10k *ath10k_mac_create(void)
4457 {
4458         struct ieee80211_hw *hw;
4459         struct ath10k *ar;
4460
4461         hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
4462         if (!hw)
4463                 return NULL;
4464
4465         ar = hw->priv;
4466         ar->hw = hw;
4467
4468         return ar;
4469 }
4470
4471 void ath10k_mac_destroy(struct ath10k *ar)
4472 {
4473         ieee80211_free_hw(ar->hw);
4474 }
4475
4476 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
4477         {
4478         .max    = 8,
4479         .types  = BIT(NL80211_IFTYPE_STATION)
4480                 | BIT(NL80211_IFTYPE_P2P_CLIENT)
4481         },
4482         {
4483         .max    = 3,
4484         .types  = BIT(NL80211_IFTYPE_P2P_GO)
4485         },
4486         {
4487         .max    = 7,
4488         .types  = BIT(NL80211_IFTYPE_AP)
4489         },
4490 };
4491
4492 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
4493         {
4494         .max    = 8,
4495         .types  = BIT(NL80211_IFTYPE_AP)
4496         },
4497 };
4498
4499 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
4500         {
4501                 .limits = ath10k_if_limits,
4502                 .n_limits = ARRAY_SIZE(ath10k_if_limits),
4503                 .max_interfaces = 8,
4504                 .num_different_channels = 1,
4505                 .beacon_int_infra_match = true,
4506         },
4507 };
4508
4509 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
4510         {
4511                 .limits = ath10k_10x_if_limits,
4512                 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
4513                 .max_interfaces = 8,
4514                 .num_different_channels = 1,
4515                 .beacon_int_infra_match = true,
4516 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
4517                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
4518                                         BIT(NL80211_CHAN_WIDTH_20) |
4519                                         BIT(NL80211_CHAN_WIDTH_40) |
4520                                         BIT(NL80211_CHAN_WIDTH_80),
4521 #endif
4522         },
4523 };
4524
4525 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4526 {
4527         struct ieee80211_sta_vht_cap vht_cap = {0};
4528         u16 mcs_map;
4529         int i;
4530
4531         vht_cap.vht_supported = 1;
4532         vht_cap.cap = ar->vht_cap_info;
4533
4534         mcs_map = 0;
4535         for (i = 0; i < 8; i++) {
4536                 if (i < ar->num_rf_chains)
4537                         mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
4538                 else
4539                         mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
4540         }
4541
4542         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4543         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4544
4545         return vht_cap;
4546 }
4547
4548 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4549 {
4550         int i;
4551         struct ieee80211_sta_ht_cap ht_cap = {0};
4552
4553         if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4554                 return ht_cap;
4555
4556         ht_cap.ht_supported = 1;
4557         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4558         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4559         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4560         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4561         ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4562
4563         if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4564                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4565
4566         if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4567                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4568
4569         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4570                 u32 smps;
4571
4572                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
4573                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4574
4575                 ht_cap.cap |= smps;
4576         }
4577
4578         if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4579                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4580
4581         if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4582                 u32 stbc;
4583
4584                 stbc   = ar->ht_cap_info;
4585                 stbc  &= WMI_HT_CAP_RX_STBC;
4586                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4587                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4588                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
4589
4590                 ht_cap.cap |= stbc;
4591         }
4592
4593         if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4594                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4595
4596         if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4597                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4598
4599         /* max AMSDU is implicitly taken from vht_cap_info */
4600         if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4601                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4602
4603         for (i = 0; i < ar->num_rf_chains; i++)
4604                 ht_cap.mcs.rx_mask[i] = 0xFF;
4605
4606         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4607
4608         return ht_cap;
4609 }
4610
4611
4612 static void ath10k_get_arvif_iter(void *data, u8 *mac,
4613                                   struct ieee80211_vif *vif)
4614 {
4615         struct ath10k_vif_iter *arvif_iter = data;
4616         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4617
4618         if (arvif->vdev_id == arvif_iter->vdev_id)
4619                 arvif_iter->arvif = arvif;
4620 }
4621
4622 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
4623 {
4624         struct ath10k_vif_iter arvif_iter;
4625         u32 flags;
4626
4627         memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
4628         arvif_iter.vdev_id = vdev_id;
4629
4630         flags = IEEE80211_IFACE_ITER_RESUME_ALL;
4631         ieee80211_iterate_active_interfaces_atomic(ar->hw,
4632                                                    flags,
4633                                                    ath10k_get_arvif_iter,
4634                                                    &arvif_iter);
4635         if (!arvif_iter.arvif) {
4636                 ath10k_warn("No VIF found for vdev %d\n", vdev_id);
4637                 return NULL;
4638         }
4639
4640         return arvif_iter.arvif;
4641 }
4642
4643 int ath10k_mac_register(struct ath10k *ar)
4644 {
4645         struct ieee80211_supported_band *band;
4646         struct ieee80211_sta_vht_cap vht_cap;
4647         struct ieee80211_sta_ht_cap ht_cap;
4648         void *channels;
4649         int ret;
4650
4651         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
4652
4653         SET_IEEE80211_DEV(ar->hw, ar->dev);
4654
4655         ht_cap = ath10k_get_ht_cap(ar);
4656         vht_cap = ath10k_create_vht_cap(ar);
4657
4658         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4659                 channels = kmemdup(ath10k_2ghz_channels,
4660                                    sizeof(ath10k_2ghz_channels),
4661                                    GFP_KERNEL);
4662                 if (!channels) {
4663                         ret = -ENOMEM;
4664                         goto err_free;
4665                 }
4666
4667                 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
4668                 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
4669                 band->channels = channels;
4670                 band->n_bitrates = ath10k_g_rates_size;
4671                 band->bitrates = ath10k_g_rates;
4672                 band->ht_cap = ht_cap;
4673
4674                 /* vht is not supported in 2.4 GHz */
4675
4676                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
4677         }
4678
4679         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4680                 channels = kmemdup(ath10k_5ghz_channels,
4681                                    sizeof(ath10k_5ghz_channels),
4682                                    GFP_KERNEL);
4683                 if (!channels) {
4684                         ret = -ENOMEM;
4685                         goto err_free;
4686                 }
4687
4688                 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
4689                 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
4690                 band->channels = channels;
4691                 band->n_bitrates = ath10k_a_rates_size;
4692                 band->bitrates = ath10k_a_rates;
4693                 band->ht_cap = ht_cap;
4694                 band->vht_cap = vht_cap;
4695                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
4696         }
4697
4698         ar->hw->wiphy->interface_modes =
4699                 BIT(NL80211_IFTYPE_STATION) |
4700                 BIT(NL80211_IFTYPE_ADHOC) |
4701                 BIT(NL80211_IFTYPE_AP);
4702
4703         if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4704                 /* TODO:  Have to deal with 2x2 chips if/when the come out. */
4705                 ar->supp_tx_chainmask = TARGET_10X_TX_CHAIN_MASK;
4706                 ar->supp_rx_chainmask = TARGET_10X_RX_CHAIN_MASK;
4707         } else {
4708                 ar->supp_tx_chainmask = TARGET_TX_CHAIN_MASK;
4709                 ar->supp_rx_chainmask = TARGET_RX_CHAIN_MASK;
4710         }
4711
4712         ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
4713         ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
4714
4715         if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
4716                 ar->hw->wiphy->interface_modes |=
4717                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
4718                         BIT(NL80211_IFTYPE_P2P_GO);
4719
4720         ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4721                         IEEE80211_HW_SUPPORTS_PS |
4722                         IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4723                         IEEE80211_HW_SUPPORTS_UAPSD |
4724                         IEEE80211_HW_MFP_CAPABLE |
4725                         IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4726                         IEEE80211_HW_HAS_RATE_CONTROL |
4727                         IEEE80211_HW_SUPPORTS_STATIC_SMPS |
4728                         IEEE80211_HW_AP_LINK_PS |
4729                         IEEE80211_HW_SPECTRUM_MGMT;
4730
4731         /* MSDU can have HTT TX fragment pushed in front. The additional 4
4732          * bytes is used for padding/alignment if necessary. */
4733         ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4;
4734
4735         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
4736                 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
4737
4738         if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
4739                 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
4740                 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4741         }
4742
4743         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
4744         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
4745
4746         ar->hw->vif_data_size = sizeof(struct ath10k_vif);
4747         ar->hw->sta_data_size = sizeof(struct ath10k_sta);
4748
4749         ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
4750
4751         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
4752         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
4753         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
4754
4755         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4756         /*
4757          * on LL hardware queues are managed entirely by the FW
4758          * so we only advertise to mac we can do the queues thing
4759          */
4760         ar->hw->queues = 4;
4761
4762         if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4763                 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
4764                 ar->hw->wiphy->n_iface_combinations =
4765                         ARRAY_SIZE(ath10k_10x_if_comb);
4766         } else {
4767                 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
4768                 ar->hw->wiphy->n_iface_combinations =
4769                         ARRAY_SIZE(ath10k_if_comb);
4770         }
4771
4772         ar->hw->netdev_features = NETIF_F_HW_CSUM;
4773
4774         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
4775                 /* Init ath dfs pattern detector */
4776                 ar->ath_common.debug_mask = ATH_DBG_DFS;
4777                 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
4778                                                              NL80211_DFS_UNSET);
4779
4780                 if (!ar->dfs_detector)
4781                         ath10k_warn("failed to initialise DFS pattern detector\n");
4782         }
4783
4784         ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
4785                             ath10k_reg_notifier);
4786         if (ret) {
4787                 ath10k_err("failed to initialise regulatory: %i\n", ret);
4788                 goto err_free;
4789         }
4790
4791         ret = ieee80211_register_hw(ar->hw);
4792         if (ret) {
4793                 ath10k_err("failed to register ieee80211: %d\n", ret);
4794                 goto err_free;
4795         }
4796
4797         if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
4798                 ret = regulatory_hint(ar->hw->wiphy,
4799                                       ar->ath_common.regulatory.alpha2);
4800                 if (ret)
4801                         goto err_unregister;
4802         }
4803
4804         return 0;
4805
4806 err_unregister:
4807         ieee80211_unregister_hw(ar->hw);
4808 err_free:
4809         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4810         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4811
4812         return ret;
4813 }
4814
4815 void ath10k_mac_unregister(struct ath10k *ar)
4816 {
4817         ieee80211_unregister_hw(ar->hw);
4818
4819         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
4820                 ar->dfs_detector->exit(ar->dfs_detector);
4821
4822         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4823         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4824
4825         SET_IEEE80211_DEV(ar->hw, NULL);
4826 }