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