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