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