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