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