drivers/net/wireless/ath/ath10k/mac.c

   1 /*
   2  * Copyright (c) 2005-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include "mac.h"
  19
  20 #include <net/mac80211.h>
  21 #include <linux/etherdevice.h>
  22
  23 #include "hif.h"
  24 #include "core.h"
  25 #include "debug.h"
  26 #include "wmi.h"
  27 #include "htt.h"
  28 #include "txrx.h"
  29
  30 /**********/
  31 /* Crypto */
  32 /**********/
  33
  34 static int ath10k_send_key(struct ath10k_vif *arvif,
  35                            struct ieee80211_key_conf *key,
  36                            enum set_key_cmd cmd,
  37                            const u8 *macaddr)
  38 {
  39         struct wmi_vdev_install_key_arg arg = {
  40                 .vdev_id = arvif->vdev_id,
  41                 .key_idx = key->keyidx,
  42                 .key_len = key->keylen,
  43                 .key_data = key->key,
  44                 .macaddr = macaddr,
  45         };
  46
  47         lockdep_assert_held(&arvif->ar->conf_mutex);
  48
  49         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
  50                 arg.key_flags = WMI_KEY_PAIRWISE;
  51         else
  52                 arg.key_flags = WMI_KEY_GROUP;
  53
  54         switch (key->cipher) {
  55         case WLAN_CIPHER_SUITE_CCMP:
  56                 arg.key_cipher = WMI_CIPHER_AES_CCM;
  57                 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
  58                 break;
  59         case WLAN_CIPHER_SUITE_TKIP:
  60                 arg.key_cipher = WMI_CIPHER_TKIP;
  61                 arg.key_txmic_len = 8;
  62                 arg.key_rxmic_len = 8;
  63                 break;
  64         case WLAN_CIPHER_SUITE_WEP40:
  65         case WLAN_CIPHER_SUITE_WEP104:
  66                 arg.key_cipher = WMI_CIPHER_WEP;
  67                 /* AP/IBSS mode requires self-key to be groupwise
  68                  * Otherwise pairwise key must be set */
  69                 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
  70                         arg.key_flags = WMI_KEY_PAIRWISE;
  71                 break;
  72         default:
  73                 ath10k_warn("cipher %d is not supported\n", key->cipher);
  74                 return -EOPNOTSUPP;
  75         }
  76
  77         if (cmd == DISABLE_KEY) {
  78                 arg.key_cipher = WMI_CIPHER_NONE;
  79                 arg.key_data = NULL;
  80         }
  81
  82         return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
  83 }
  84
  85 static int ath10k_install_key(struct ath10k_vif *arvif,
  86                               struct ieee80211_key_conf *key,
  87                               enum set_key_cmd cmd,
  88                               const u8 *macaddr)
  89 {
  90         struct ath10k *ar = arvif->ar;
  91         int ret;
  92
  93         lockdep_assert_held(&ar->conf_mutex);
  94
  95         INIT_COMPLETION(ar->install_key_done);
  96
  97         ret = ath10k_send_key(arvif, key, cmd, macaddr);
  98         if (ret)
  99                 return ret;
 100
 101         ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
 102         if (ret == 0)
 103                 return -ETIMEDOUT;
 104
 105         return 0;
 106 }
 107
 108 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
 109                                         const u8 *addr)
 110 {
 111         struct ath10k *ar = arvif->ar;
 112         struct ath10k_peer *peer;
 113         int ret;
 114         int i;
 115
 116         lockdep_assert_held(&ar->conf_mutex);
 117
 118         spin_lock_bh(&ar->data_lock);
 119         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
 120         spin_unlock_bh(&ar->data_lock);
 121
 122         if (!peer)
 123                 return -ENOENT;
 124
 125         for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
 126                 if (arvif->wep_keys[i] == NULL)
 127                         continue;
 128
 129                 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
 130                                          addr);
 131                 if (ret)
 132                         return ret;
 133
 134                 peer->keys[i] = arvif->wep_keys[i];
 135         }
 136
 137         return 0;
 138 }
 139
 140 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
 141                                   const u8 *addr)
 142 {
 143         struct ath10k *ar = arvif->ar;
 144         struct ath10k_peer *peer;
 145         int first_errno = 0;
 146         int ret;
 147         int i;
 148
 149         lockdep_assert_held(&ar->conf_mutex);
 150
 151         spin_lock_bh(&ar->data_lock);
 152         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
 153         spin_unlock_bh(&ar->data_lock);
 154
 155         if (!peer)
 156                 return -ENOENT;
 157
 158         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
 159                 if (peer->keys[i] == NULL)
 160                         continue;
 161
 162                 ret = ath10k_install_key(arvif, peer->keys[i],
 163                                          DISABLE_KEY, addr);
 164                 if (ret && first_errno == 0)
 165                         first_errno = ret;
 166
 167                 if (ret)
 168                         ath10k_warn("could not remove peer wep key %d (%d)\n",
 169                                     i, ret);
 170
 171                 peer->keys[i] = NULL;
 172         }
 173
 174         return first_errno;
 175 }
 176
 177 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
 178                                  struct ieee80211_key_conf *key)
 179 {
 180         struct ath10k *ar = arvif->ar;
 181         struct ath10k_peer *peer;
 182         u8 addr[ETH_ALEN];
 183         int first_errno = 0;
 184         int ret;
 185         int i;
 186
 187         lockdep_assert_held(&ar->conf_mutex);
 188
 189         for (;;) {
 190                 /* since ath10k_install_key we can't hold data_lock all the
 191                  * time, so we try to remove the keys incrementally */
 192                 spin_lock_bh(&ar->data_lock);
 193                 i = 0;
 194                 list_for_each_entry(peer, &ar->peers, list) {
 195                         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
 196                                 if (peer->keys[i] == key) {
 197                                         memcpy(addr, peer->addr, ETH_ALEN);
 198                                         peer->keys[i] = NULL;
 199                                         break;
 200                                 }
 201                         }
 202
 203                         if (i < ARRAY_SIZE(peer->keys))
 204                                 break;
 205                 }
 206                 spin_unlock_bh(&ar->data_lock);
 207
 208                 if (i == ARRAY_SIZE(peer->keys))
 209                         break;
 210
 211                 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
 212                 if (ret && first_errno == 0)
 213                         first_errno = ret;
 214
 215                 if (ret)
 216                         ath10k_warn("could not remove key for %pM\n", addr);
 217         }
 218
 219         return first_errno;
 220 }
 221
 222
 223 /*********************/
 224 /* General utilities */
 225 /*********************/
 226
 227 static inline enum wmi_phy_mode
 228 chan_to_phymode(const struct cfg80211_chan_def *chandef)
 229 {
 230         enum wmi_phy_mode phymode = MODE_UNKNOWN;
 231
 232         switch (chandef->chan->band) {
 233         case IEEE80211_BAND_2GHZ:
 234                 switch (chandef->width) {
 235                 case NL80211_CHAN_WIDTH_20_NOHT:
 236                         phymode = MODE_11G;
 237                         break;
 238                 case NL80211_CHAN_WIDTH_20:
 239                         phymode = MODE_11NG_HT20;
 240                         break;
 241                 case NL80211_CHAN_WIDTH_40:
 242                         phymode = MODE_11NG_HT40;
 243                         break;
 244                 case NL80211_CHAN_WIDTH_5:
 245                 case NL80211_CHAN_WIDTH_10:
 246                 case NL80211_CHAN_WIDTH_80:
 247                 case NL80211_CHAN_WIDTH_80P80:
 248                 case NL80211_CHAN_WIDTH_160:
 249                         phymode = MODE_UNKNOWN;
 250                         break;
 251                 }
 252                 break;
 253         case IEEE80211_BAND_5GHZ:
 254                 switch (chandef->width) {
 255                 case NL80211_CHAN_WIDTH_20_NOHT:
 256                         phymode = MODE_11A;
 257                         break;
 258                 case NL80211_CHAN_WIDTH_20:
 259                         phymode = MODE_11NA_HT20;
 260                         break;
 261                 case NL80211_CHAN_WIDTH_40:
 262                         phymode = MODE_11NA_HT40;
 263                         break;
 264                 case NL80211_CHAN_WIDTH_80:
 265                         phymode = MODE_11AC_VHT80;
 266                         break;
 267                 case NL80211_CHAN_WIDTH_5:
 268                 case NL80211_CHAN_WIDTH_10:
 269                 case NL80211_CHAN_WIDTH_80P80:
 270                 case NL80211_CHAN_WIDTH_160:
 271                         phymode = MODE_UNKNOWN;
 272                         break;
 273                 }
 274                 break;
 275         default:
 276                 break;
 277         }
 278
 279         WARN_ON(phymode == MODE_UNKNOWN);
 280         return phymode;
 281 }
 282
 283 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
 284 {
 285 /*
 286  * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
 287  *   0 for no restriction
 288  *   1 for 1/4 us
 289  *   2 for 1/2 us
 290  *   3 for 1 us
 291  *   4 for 2 us
 292  *   5 for 4 us
 293  *   6 for 8 us
 294  *   7 for 16 us
 295  */
 296         switch (mpdudensity) {
 297         case 0:
 298                 return 0;
 299         case 1:
 300         case 2:
 301         case 3:
 302         /* Our lower layer calculations limit our precision to
 303            1 microsecond */
 304                 return 1;
 305         case 4:
 306                 return 2;
 307         case 5:
 308                 return 4;
 309         case 6:
 310                 return 8;
 311         case 7:
 312                 return 16;
 313         default:
 314                 return 0;
 315         }
 316 }
 317
 318 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
 319 {
 320         int ret;
 321
 322         lockdep_assert_held(&ar->conf_mutex);
 323
 324         ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
 325         if (ret)
 326                 return ret;
 327
 328         ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
 329         if (ret)
 330                 return ret;
 331
 332         return 0;
 333 }
 334
 335 static int  ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
 336 {
 337         if (value != 0xFFFFFFFF)
 338                 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
 339                               ATH10K_RTS_MAX);
 340
 341         return ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
 342                                          WMI_VDEV_PARAM_RTS_THRESHOLD,
 343                                          value);
 344 }
 345
 346 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
 347 {
 348         if (value != 0xFFFFFFFF)
 349                 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
 350                                 ATH10K_FRAGMT_THRESHOLD_MIN,
 351                                 ATH10K_FRAGMT_THRESHOLD_MAX);
 352
 353         return ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
 354                                          WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
 355                                          value);
 356 }
 357
 358 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
 359 {
 360         int ret;
 361
 362         lockdep_assert_held(&ar->conf_mutex);
 363
 364         ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
 365         if (ret)
 366                 return ret;
 367
 368         ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
 369         if (ret)
 370                 return ret;
 371
 372         return 0;
 373 }
 374
 375 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
 376 {
 377         struct ath10k_peer *peer, *tmp;
 378
 379         lockdep_assert_held(&ar->conf_mutex);
 380
 381         spin_lock_bh(&ar->data_lock);
 382         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
 383                 if (peer->vdev_id != vdev_id)
 384                         continue;
 385
 386                 ath10k_warn("removing stale peer %pM from vdev_id %d\n",
 387                             peer->addr, vdev_id);
 388
 389                 list_del(&peer->list);
 390                 kfree(peer);
 391         }
 392         spin_unlock_bh(&ar->data_lock);
 393 }
 394
 395 static void ath10k_peer_cleanup_all(struct ath10k *ar)
 396 {
 397         struct ath10k_peer *peer, *tmp;
 398
 399         lockdep_assert_held(&ar->conf_mutex);
 400
 401         spin_lock_bh(&ar->data_lock);
 402         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
 403                 list_del(&peer->list);
 404                 kfree(peer);
 405         }
 406         spin_unlock_bh(&ar->data_lock);
 407 }
 408
 409 /************************/
 410 /* Interface management */
 411 /************************/
 412
 413 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
 414 {
 415         int ret;
 416
 417         lockdep_assert_held(&ar->conf_mutex);
 418
 419         ret = wait_for_completion_timeout(&ar->vdev_setup_done,
 420                                           ATH10K_VDEV_SETUP_TIMEOUT_HZ);
 421         if (ret == 0)
 422                 return -ETIMEDOUT;
 423
 424         return 0;
 425 }
 426
 427 static int ath10k_vdev_start(struct ath10k_vif *arvif)
 428 {
 429         struct ath10k *ar = arvif->ar;
 430         struct ieee80211_conf *conf = &ar->hw->conf;
 431         struct ieee80211_channel *channel = conf->chandef.chan;
 432         struct wmi_vdev_start_request_arg arg = {};
 433         int ret = 0;
 434
 435         lockdep_assert_held(&ar->conf_mutex);
 436
 437         INIT_COMPLETION(ar->vdev_setup_done);
 438
 439         arg.vdev_id = arvif->vdev_id;
 440         arg.dtim_period = arvif->dtim_period;
 441         arg.bcn_intval = arvif->beacon_interval;
 442
 443         arg.channel.freq = channel->center_freq;
 444
 445         arg.channel.band_center_freq1 = conf->chandef.center_freq1;
 446
 447         arg.channel.mode = chan_to_phymode(&conf->chandef);
 448
 449         arg.channel.min_power = channel->max_power * 3;
 450         arg.channel.max_power = channel->max_power * 4;
 451         arg.channel.max_reg_power = channel->max_reg_power * 4;
 452         arg.channel.max_antenna_gain = channel->max_antenna_gain;
 453
 454         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
 455                 arg.ssid = arvif->u.ap.ssid;
 456                 arg.ssid_len = arvif->u.ap.ssid_len;
 457                 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
 458         } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
 459                 arg.ssid = arvif->vif->bss_conf.ssid;
 460                 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
 461         }
 462
 463         ret = ath10k_wmi_vdev_start(ar, &arg);
 464         if (ret) {
 465                 ath10k_warn("WMI vdev start failed: ret %d\n", ret);
 466                 return ret;
 467         }
 468
 469         ret = ath10k_vdev_setup_sync(ar);
 470         if (ret) {
 471                 ath10k_warn("vdev setup failed %d\n", ret);
 472                 return ret;
 473         }
 474
 475         return ret;
 476 }
 477
 478 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
 479 {
 480         struct ath10k *ar = arvif->ar;
 481         int ret;
 482
 483         lockdep_assert_held(&ar->conf_mutex);
 484
 485         INIT_COMPLETION(ar->vdev_setup_done);
 486
 487         ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
 488         if (ret) {
 489                 ath10k_warn("WMI vdev stop failed: ret %d\n", ret);
 490                 return ret;
 491         }
 492
 493         ret = ath10k_vdev_setup_sync(ar);
 494         if (ret) {
 495                 ath10k_warn("vdev setup failed %d\n", ret);
 496                 return ret;
 497         }
 498
 499         return ret;
 500 }
 501
 502 static int ath10k_monitor_start(struct ath10k *ar, int vdev_id)
 503 {
 504         struct ieee80211_channel *channel = ar->hw->conf.chandef.chan;
 505         struct wmi_vdev_start_request_arg arg = {};
 506         int ret = 0;
 507
 508         lockdep_assert_held(&ar->conf_mutex);
 509
 510         arg.vdev_id = vdev_id;
 511         arg.channel.freq = channel->center_freq;
 512         arg.channel.band_center_freq1 = ar->hw->conf.chandef.center_freq1;
 513
 514         /* TODO setup this dynamically, what in case we
 515            don't have any vifs? */
 516         arg.channel.mode = chan_to_phymode(&ar->hw->conf.chandef);
 517
 518         arg.channel.min_power = channel->max_power * 3;
 519         arg.channel.max_power = channel->max_power * 4;
 520         arg.channel.max_reg_power = channel->max_reg_power * 4;
 521         arg.channel.max_antenna_gain = channel->max_antenna_gain;
 522
 523         ret = ath10k_wmi_vdev_start(ar, &arg);
 524         if (ret) {
 525                 ath10k_warn("Monitor vdev start failed: ret %d\n", ret);
 526                 return ret;
 527         }
 528
 529         ret = ath10k_vdev_setup_sync(ar);
 530         if (ret) {
 531                 ath10k_warn("Monitor vdev setup failed %d\n", ret);
 532                 return ret;
 533         }
 534
 535         ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
 536         if (ret) {
 537                 ath10k_warn("Monitor vdev up failed: %d\n", ret);
 538                 goto vdev_stop;
 539         }
 540
 541         ar->monitor_vdev_id = vdev_id;
 542         ar->monitor_enabled = true;
 543
 544         return 0;
 545
 546 vdev_stop:
 547         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
 548         if (ret)
 549                 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
 550
 551         return ret;
 552 }
 553
 554 static int ath10k_monitor_stop(struct ath10k *ar)
 555 {
 556         int ret = 0;
 557
 558         lockdep_assert_held(&ar->conf_mutex);
 559
 560         /* For some reasons, ath10k_wmi_vdev_down() here couse
 561          * often ath10k_wmi_vdev_stop() to fail. Next we could
 562          * not run monitor vdev and driver reload
 563          * required. Don't see such problems we skip
 564          * ath10k_wmi_vdev_down() here.
 565          */
 566
 567         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
 568         if (ret)
 569                 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
 570
 571         ret = ath10k_vdev_setup_sync(ar);
 572         if (ret)
 573                 ath10k_warn("Monitor_down sync failed: %d\n", ret);
 574
 575         ar->monitor_enabled = false;
 576         return ret;
 577 }
 578
 579 static int ath10k_monitor_create(struct ath10k *ar)
 580 {
 581         int bit, ret = 0;
 582
 583         lockdep_assert_held(&ar->conf_mutex);
 584
 585         if (ar->monitor_present) {
 586                 ath10k_warn("Monitor mode already enabled\n");
 587                 return 0;
 588         }
 589
 590         bit = ffs(ar->free_vdev_map);
 591         if (bit == 0) {
 592                 ath10k_warn("No free VDEV slots\n");
 593                 return -ENOMEM;
 594         }
 595
 596         ar->monitor_vdev_id = bit - 1;
 597         ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
 598
 599         ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
 600                                      WMI_VDEV_TYPE_MONITOR,
 601                                      0, ar->mac_addr);
 602         if (ret) {
 603                 ath10k_warn("WMI vdev monitor create failed: ret %d\n", ret);
 604                 goto vdev_fail;
 605         }
 606
 607         ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface created, vdev id: %d\n",
 608                    ar->monitor_vdev_id);
 609
 610         ar->monitor_present = true;
 611         return 0;
 612
 613 vdev_fail:
 614         /*
 615          * Restore the ID to the global map.
 616          */
 617         ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
 618         return ret;
 619 }
 620
 621 static int ath10k_monitor_destroy(struct ath10k *ar)
 622 {
 623         int ret = 0;
 624
 625         lockdep_assert_held(&ar->conf_mutex);
 626
 627         if (!ar->monitor_present)
 628                 return 0;
 629
 630         ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
 631         if (ret) {
 632                 ath10k_warn("WMI vdev monitor delete failed: %d\n", ret);
 633                 return ret;
 634         }
 635
 636         ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
 637         ar->monitor_present = false;
 638
 639         ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface destroyed, vdev id: %d\n",
 640                    ar->monitor_vdev_id);
 641         return ret;
 642 }
 643
 644 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
 645                                 struct ieee80211_bss_conf *info)
 646 {
 647         int ret = 0;
 648
 649         lockdep_assert_held(&arvif->ar->conf_mutex);
 650
 651         if (!info->enable_beacon) {
 652                 ath10k_vdev_stop(arvif);
 653                 return;
 654         }
 655
 656         arvif->tx_seq_no = 0x1000;
 657
 658         ret = ath10k_vdev_start(arvif);
 659         if (ret)
 660                 return;
 661
 662         ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, 0, info->bssid);
 663         if (ret) {
 664                 ath10k_warn("Failed to bring up VDEV: %d\n",
 665                             arvif->vdev_id);
 666                 return;
 667         }
 668         ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d up\n", arvif->vdev_id);
 669 }
 670
 671 static void ath10k_control_ibss(struct ath10k_vif *arvif,
 672                                 struct ieee80211_bss_conf *info,
 673                                 const u8 self_peer[ETH_ALEN])
 674 {
 675         int ret = 0;
 676
 677         lockdep_assert_held(&arvif->ar->conf_mutex);
 678
 679         if (!info->ibss_joined) {
 680                 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
 681                 if (ret)
 682                         ath10k_warn("Failed to delete IBSS self peer:%pM for VDEV:%d ret:%d\n",
 683                                     self_peer, arvif->vdev_id, ret);
 684
 685                 if (is_zero_ether_addr(arvif->u.ibss.bssid))
 686                         return;
 687
 688                 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
 689                                          arvif->u.ibss.bssid);
 690                 if (ret) {
 691                         ath10k_warn("Failed to delete IBSS BSSID peer:%pM for VDEV:%d ret:%d\n",
 692                                     arvif->u.ibss.bssid, arvif->vdev_id, ret);
 693                         return;
 694                 }
 695
 696                 memset(arvif->u.ibss.bssid, 0, ETH_ALEN);
 697
 698                 return;
 699         }
 700
 701         ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
 702         if (ret) {
 703                 ath10k_warn("Failed to create IBSS self peer:%pM for VDEV:%d ret:%d\n",
 704                             self_peer, arvif->vdev_id, ret);
 705                 return;
 706         }
 707
 708         ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
 709                                         WMI_VDEV_PARAM_ATIM_WINDOW,
 710                                         ATH10K_DEFAULT_ATIM);
 711         if (ret)
 712                 ath10k_warn("Failed to set IBSS ATIM for VDEV:%d ret:%d\n",
 713                             arvif->vdev_id, ret);
 714 }
 715
 716 /*
 717  * Review this when mac80211 gains per-interface powersave support.
 718  */
 719 static void ath10k_ps_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 720 {
 721         struct ath10k_generic_iter *ar_iter = data;
 722         struct ieee80211_conf *conf = &ar_iter->ar->hw->conf;
 723         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
 724         enum wmi_sta_powersave_param param;
 725         enum wmi_sta_ps_mode psmode;
 726         int ret;
 727
 728         lockdep_assert_held(&arvif->ar->conf_mutex);
 729
 730         if (vif->type != NL80211_IFTYPE_STATION)
 731                 return;
 732
 733         if (conf->flags & IEEE80211_CONF_PS) {
 734                 psmode = WMI_STA_PS_MODE_ENABLED;
 735                 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
 736
 737                 ret = ath10k_wmi_set_sta_ps_param(ar_iter->ar,
 738                                                   arvif->vdev_id,
 739                                                   param,
 740                                                   conf->dynamic_ps_timeout);
 741                 if (ret) {
 742                         ath10k_warn("Failed to set inactivity time for VDEV: %d\n",
 743                                     arvif->vdev_id);
 744                         return;
 745                 }
 746
 747                 ar_iter->ret = ret;
 748         } else {
 749                 psmode = WMI_STA_PS_MODE_DISABLED;
 750         }
 751
 752         ar_iter->ret = ath10k_wmi_set_psmode(ar_iter->ar, arvif->vdev_id,
 753                                              psmode);
 754         if (ar_iter->ret)
 755                 ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n",
 756                             psmode, arvif->vdev_id);
 757         else
 758                 ath10k_dbg(ATH10K_DBG_MAC, "Set PS Mode: %d for VDEV: %d\n",
 759                            psmode, arvif->vdev_id);
 760 }
 761
 762 /**********************/
 763 /* Station management */
 764 /**********************/
 765
 766 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
 767                                       struct ath10k_vif *arvif,
 768                                       struct ieee80211_sta *sta,
 769                                       struct ieee80211_bss_conf *bss_conf,
 770                                       struct wmi_peer_assoc_complete_arg *arg)
 771 {
 772         lockdep_assert_held(&ar->conf_mutex);
 773
 774         memcpy(arg->addr, sta->addr, ETH_ALEN);
 775         arg->vdev_id = arvif->vdev_id;
 776         arg->peer_aid = sta->aid;
 777         arg->peer_flags |= WMI_PEER_AUTH;
 778
 779         if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
 780                 /*
 781                  * Seems FW have problems with Power Save in STA
 782                  * mode when we setup this parameter to high (eg. 5).
 783                  * Often we see that FW don't send NULL (with clean P flags)
 784                  * frame even there is info about buffered frames in beacons.
 785                  * Sometimes we have to wait more than 10 seconds before FW
 786                  * will wakeup. Often sending one ping from AP to our device
 787                  * just fail (more than 50%).
 788                  *
 789                  * Seems setting this FW parameter to 1 couse FW
 790                  * will check every beacon and will wakup immediately
 791                  * after detection buffered data.
 792                  */
 793                 arg->peer_listen_intval = 1;
 794         else
 795                 arg->peer_listen_intval = ar->hw->conf.listen_interval;
 796
 797         arg->peer_num_spatial_streams = 1;
 798
 799         /*
 800          * The assoc capabilities are available only in managed mode.
 801          */
 802         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
 803                 arg->peer_caps = bss_conf->assoc_capability;
 804 }
 805
 806 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
 807                                        struct ath10k_vif *arvif,
 808                                        struct wmi_peer_assoc_complete_arg *arg)
 809 {
 810         struct ieee80211_vif *vif = arvif->vif;
 811         struct ieee80211_bss_conf *info = &vif->bss_conf;
 812         struct cfg80211_bss *bss;
 813         const u8 *rsnie = NULL;
 814         const u8 *wpaie = NULL;
 815
 816         lockdep_assert_held(&ar->conf_mutex);
 817
 818         bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
 819                                info->bssid, NULL, 0, 0, 0);
 820         if (bss) {
 821                 const struct cfg80211_bss_ies *ies;
 822
 823                 rcu_read_lock();
 824                 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
 825
 826                 ies = rcu_dereference(bss->ies);
 827
 828                 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
 829                                 WLAN_OUI_TYPE_MICROSOFT_WPA,
 830                                 ies->data,
 831                                 ies->len);
 832                 rcu_read_unlock();
 833                 cfg80211_put_bss(ar->hw->wiphy, bss);
 834         }
 835
 836         /* FIXME: base on RSN IE/WPA IE is a correct idea? */
 837         if (rsnie || wpaie) {
 838                 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
 839                 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
 840         }
 841
 842         if (wpaie) {
 843                 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
 844                 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
 845         }
 846 }
 847
 848 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
 849                                       struct ieee80211_sta *sta,
 850                                       struct wmi_peer_assoc_complete_arg *arg)
 851 {
 852         struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
 853         const struct ieee80211_supported_band *sband;
 854         const struct ieee80211_rate *rates;
 855         u32 ratemask;
 856         int i;
 857
 858         lockdep_assert_held(&ar->conf_mutex);
 859
 860         sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
 861         ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
 862         rates = sband->bitrates;
 863
 864         rateset->num_rates = 0;
 865
 866         for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
 867                 if (!(ratemask & 1))
 868                         continue;
 869
 870                 rateset->rates[rateset->num_rates] = rates->hw_value;
 871                 rateset->num_rates++;
 872         }
 873 }
 874
 875 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
 876                                    struct ieee80211_sta *sta,
 877                                    struct wmi_peer_assoc_complete_arg *arg)
 878 {
 879         const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
 880         int smps;
 881         int i, n;
 882
 883         lockdep_assert_held(&ar->conf_mutex);
 884
 885         if (!ht_cap->ht_supported)
 886                 return;
 887
 888         arg->peer_flags |= WMI_PEER_HT;
 889         arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
 890                                     ht_cap->ampdu_factor)) - 1;
 891
 892         arg->peer_mpdu_density =
 893                 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
 894
 895         arg->peer_ht_caps = ht_cap->cap;
 896         arg->peer_rate_caps |= WMI_RC_HT_FLAG;
 897
 898         if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
 899                 arg->peer_flags |= WMI_PEER_LDPC;
 900
 901         if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
 902                 arg->peer_flags |= WMI_PEER_40MHZ;
 903                 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
 904         }
 905
 906         if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
 907                 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
 908
 909         if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
 910                 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
 911
 912         if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
 913                 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
 914                 arg->peer_flags |= WMI_PEER_STBC;
 915         }
 916
 917         if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
 918                 u32 stbc;
 919                 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
 920                 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
 921                 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
 922                 arg->peer_rate_caps |= stbc;
 923                 arg->peer_flags |= WMI_PEER_STBC;
 924         }
 925
 926         smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
 927         smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
 928
 929         if (smps == WLAN_HT_CAP_SM_PS_STATIC) {
 930                 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
 931                 arg->peer_flags |= WMI_PEER_STATIC_MIMOPS;
 932         } else if (smps == WLAN_HT_CAP_SM_PS_DYNAMIC) {
 933                 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
 934                 arg->peer_flags |= WMI_PEER_DYN_MIMOPS;
 935         }
 936
 937         if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
 938                 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
 939         else if (ht_cap->mcs.rx_mask[1])
 940                 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
 941
 942         for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
 943                 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
 944                         arg->peer_ht_rates.rates[n++] = i;
 945
 946         arg->peer_ht_rates.num_rates = n;
 947         arg->peer_num_spatial_streams = max((n+7) / 8, 1);
 948
 949         ath10k_dbg(ATH10K_DBG_MAC, "mcs cnt %d nss %d\n",
 950                    arg->peer_ht_rates.num_rates,
 951                    arg->peer_num_spatial_streams);
 952 }
 953
 954 static void ath10k_peer_assoc_h_qos_ap(struct ath10k *ar,
 955                                        struct ath10k_vif *arvif,
 956                                        struct ieee80211_sta *sta,
 957                                        struct ieee80211_bss_conf *bss_conf,
 958                                        struct wmi_peer_assoc_complete_arg *arg)
 959 {
 960         u32 uapsd = 0;
 961         u32 max_sp = 0;
 962
 963         lockdep_assert_held(&ar->conf_mutex);
 964
 965         if (sta->wme)
 966                 arg->peer_flags |= WMI_PEER_QOS;
 967
 968         if (sta->wme && sta->uapsd_queues) {
 969                 ath10k_dbg(ATH10K_DBG_MAC, "uapsd_queues: 0x%X, max_sp: %d\n",
 970                            sta->uapsd_queues, sta->max_sp);
 971
 972                 arg->peer_flags |= WMI_PEER_APSD;
 973                 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
 974
 975                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
 976                         uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
 977                                  WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
 978                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
 979                         uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
 980                                  WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
 981                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
 982                         uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
 983                                  WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
 984                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
 985                         uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
 986                                  WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
 987
 988
 989                 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
 990                         max_sp = sta->max_sp;
 991
 992                 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
 993                                            sta->addr,
 994                                            WMI_AP_PS_PEER_PARAM_UAPSD,
 995                                            uapsd);
 996
 997                 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
 998                                            sta->addr,
 999                                            WMI_AP_PS_PEER_PARAM_MAX_SP,
1000                                            max_sp);
1001
1002                 /* TODO setup this based on STA listen interval and
1003                    beacon interval. Currently we don't know
1004                    sta->listen_interval - mac80211 patch required.
1005                    Currently use 10 seconds */
1006                 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1007                                            sta->addr,
1008                                            WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1009                                            10);
1010         }
1011 }
1012
1013 static void ath10k_peer_assoc_h_qos_sta(struct ath10k *ar,
1014                                         struct ath10k_vif *arvif,
1015                                         struct ieee80211_sta *sta,
1016                                         struct ieee80211_bss_conf *bss_conf,
1017                                         struct wmi_peer_assoc_complete_arg *arg)
1018 {
1019         if (bss_conf->qos)
1020                 arg->peer_flags |= WMI_PEER_QOS;
1021 }
1022
1023 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1024                                     struct ieee80211_sta *sta,
1025                                     struct wmi_peer_assoc_complete_arg *arg)
1026 {
1027         const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1028
1029         if (!vht_cap->vht_supported)
1030                 return;
1031
1032         arg->peer_flags |= WMI_PEER_VHT;
1033
1034         arg->peer_vht_caps = vht_cap->cap;
1035
1036         if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1037                 arg->peer_flags |= WMI_PEER_80MHZ;
1038
1039         arg->peer_vht_rates.rx_max_rate =
1040                 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1041         arg->peer_vht_rates.rx_mcs_set =
1042                 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1043         arg->peer_vht_rates.tx_max_rate =
1044                 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1045         arg->peer_vht_rates.tx_mcs_set =
1046                 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1047
1048         ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer\n");
1049 }
1050
1051 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1052                                     struct ath10k_vif *arvif,
1053                                     struct ieee80211_sta *sta,
1054                                     struct ieee80211_bss_conf *bss_conf,
1055                                     struct wmi_peer_assoc_complete_arg *arg)
1056 {
1057         switch (arvif->vdev_type) {
1058         case WMI_VDEV_TYPE_AP:
1059                 ath10k_peer_assoc_h_qos_ap(ar, arvif, sta, bss_conf, arg);
1060                 break;
1061         case WMI_VDEV_TYPE_STA:
1062                 ath10k_peer_assoc_h_qos_sta(ar, arvif, sta, bss_conf, arg);
1063                 break;
1064         default:
1065                 break;
1066         }
1067 }
1068
1069 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1070                                         struct ath10k_vif *arvif,
1071                                         struct ieee80211_sta *sta,
1072                                         struct wmi_peer_assoc_complete_arg *arg)
1073 {
1074         enum wmi_phy_mode phymode = MODE_UNKNOWN;
1075
1076         /* FIXME: add VHT */
1077
1078         switch (ar->hw->conf.chandef.chan->band) {
1079         case IEEE80211_BAND_2GHZ:
1080                 if (sta->ht_cap.ht_supported) {
1081                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1082                                 phymode = MODE_11NG_HT40;
1083                         else
1084                                 phymode = MODE_11NG_HT20;
1085                 } else {
1086                         phymode = MODE_11G;
1087                 }
1088
1089                 break;
1090         case IEEE80211_BAND_5GHZ:
1091                 if (sta->ht_cap.ht_supported) {
1092                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1093                                 phymode = MODE_11NA_HT40;
1094                         else
1095                                 phymode = MODE_11NA_HT20;
1096                 } else {
1097                         phymode = MODE_11A;
1098                 }
1099
1100                 break;
1101         default:
1102                 break;
1103         }
1104
1105         arg->peer_phymode = phymode;
1106         WARN_ON(phymode == MODE_UNKNOWN);
1107 }
1108
1109 static int ath10k_peer_assoc(struct ath10k *ar,
1110                              struct ath10k_vif *arvif,
1111                              struct ieee80211_sta *sta,
1112                              struct ieee80211_bss_conf *bss_conf)
1113 {
1114         struct wmi_peer_assoc_complete_arg arg;
1115
1116         lockdep_assert_held(&ar->conf_mutex);
1117
1118         memset(&arg, 0, sizeof(struct wmi_peer_assoc_complete_arg));
1119
1120         ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, &arg);
1121         ath10k_peer_assoc_h_crypto(ar, arvif, &arg);
1122         ath10k_peer_assoc_h_rates(ar, sta, &arg);
1123         ath10k_peer_assoc_h_ht(ar, sta, &arg);
1124         ath10k_peer_assoc_h_vht(ar, sta, &arg);
1125         ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, &arg);
1126         ath10k_peer_assoc_h_phymode(ar, arvif, sta, &arg);
1127
1128         return ath10k_wmi_peer_assoc(ar, &arg);
1129 }
1130
1131 /* can be called only in mac80211 callbacks due to `key_count` usage */
1132 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1133                              struct ieee80211_vif *vif,
1134                              struct ieee80211_bss_conf *bss_conf)
1135 {
1136         struct ath10k *ar = hw->priv;
1137         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1138         struct ieee80211_sta *ap_sta;
1139         int ret;
1140
1141         lockdep_assert_held(&ar->conf_mutex);
1142
1143         rcu_read_lock();
1144
1145         ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1146         if (!ap_sta) {
1147                 ath10k_warn("Failed to find station entry for %pM\n",
1148                             bss_conf->bssid);
1149                 rcu_read_unlock();
1150                 return;
1151         }
1152
1153         ret = ath10k_peer_assoc(ar, arvif, ap_sta, bss_conf);
1154         if (ret) {
1155                 ath10k_warn("Peer assoc failed for %pM\n", bss_conf->bssid);
1156                 rcu_read_unlock();
1157                 return;
1158         }
1159
1160         rcu_read_unlock();
1161
1162         ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, bss_conf->aid,
1163                                  bss_conf->bssid);
1164         if (ret)
1165                 ath10k_warn("VDEV: %d up failed: ret %d\n",
1166                             arvif->vdev_id, ret);
1167         else
1168                 ath10k_dbg(ATH10K_DBG_MAC,
1169                            "VDEV: %d associated, BSSID: %pM, AID: %d\n",
1170                            arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1171 }
1172
1173 /*
1174  * FIXME: flush TIDs
1175  */
1176 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1177                                 struct ieee80211_vif *vif)
1178 {
1179         struct ath10k *ar = hw->priv;
1180         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1181         int ret;
1182
1183         lockdep_assert_held(&ar->conf_mutex);
1184
1185         /*
1186          * For some reason, calling VDEV-DOWN before VDEV-STOP
1187          * makes the FW to send frames via HTT after disassociation.
1188          * No idea why this happens, even though VDEV-DOWN is supposed
1189          * to be analogous to link down, so just stop the VDEV.
1190          */
1191         ret = ath10k_vdev_stop(arvif);
1192         if (!ret)
1193                 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d stopped\n",
1194                            arvif->vdev_id);
1195
1196         /*
1197          * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1198          * report beacons from previously associated network through HTT.
1199          * This in turn would spam mac80211 WARN_ON if we bring down all
1200          * interfaces as it expects there is no rx when no interface is
1201          * running.
1202          */
1203         ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1204         if (ret)
1205                 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d ath10k_wmi_vdev_down failed (%d)\n",
1206                            arvif->vdev_id, ret);
1207
1208         ath10k_wmi_flush_tx(ar);
1209
1210         arvif->def_wep_key_index = 0;
1211 }
1212
1213 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1214                                 struct ieee80211_sta *sta)
1215 {
1216         int ret = 0;
1217
1218         lockdep_assert_held(&ar->conf_mutex);
1219
1220         ret = ath10k_peer_assoc(ar, arvif, sta, NULL);
1221         if (ret) {
1222                 ath10k_warn("WMI peer assoc failed for %pM\n", sta->addr);
1223                 return ret;
1224         }
1225
1226         ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1227         if (ret) {
1228                 ath10k_warn("could not install peer wep keys (%d)\n", ret);
1229                 return ret;
1230         }
1231
1232         return ret;
1233 }
1234
1235 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1236                                    struct ieee80211_sta *sta)
1237 {
1238         int ret = 0;
1239
1240         lockdep_assert_held(&ar->conf_mutex);
1241
1242         ret = ath10k_clear_peer_keys(arvif, sta->addr);
1243         if (ret) {
1244                 ath10k_warn("could not clear all peer wep keys (%d)\n", ret);
1245                 return ret;
1246         }
1247
1248         return ret;
1249 }
1250
1251 /**************/
1252 /* Regulatory */
1253 /**************/
1254
1255 static int ath10k_update_channel_list(struct ath10k *ar)
1256 {
1257         struct ieee80211_hw *hw = ar->hw;
1258         struct ieee80211_supported_band **bands;
1259         enum ieee80211_band band;
1260         struct ieee80211_channel *channel;
1261         struct wmi_scan_chan_list_arg arg = {0};
1262         struct wmi_channel_arg *ch;
1263         bool passive;
1264         int len;
1265         int ret;
1266         int i;
1267
1268         lockdep_assert_held(&ar->conf_mutex);
1269
1270         bands = hw->wiphy->bands;
1271         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1272                 if (!bands[band])
1273                         continue;
1274
1275                 for (i = 0; i < bands[band]->n_channels; i++) {
1276                         if (bands[band]->channels[i].flags &
1277                             IEEE80211_CHAN_DISABLED)
1278                                 continue;
1279
1280                         arg.n_channels++;
1281                 }
1282         }
1283
1284         len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1285         arg.channels = kzalloc(len, GFP_KERNEL);
1286         if (!arg.channels)
1287                 return -ENOMEM;
1288
1289         ch = arg.channels;
1290         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1291                 if (!bands[band])
1292                         continue;
1293
1294                 for (i = 0; i < bands[band]->n_channels; i++) {
1295                         channel = &bands[band]->channels[i];
1296
1297                         if (channel->flags & IEEE80211_CHAN_DISABLED)
1298                                 continue;
1299
1300                         ch->allow_ht   = true;
1301
1302                         /* FIXME: when should we really allow VHT? */
1303                         ch->allow_vht = true;
1304
1305                         ch->allow_ibss =
1306                                 !(channel->flags & IEEE80211_CHAN_NO_IBSS);
1307
1308                         ch->ht40plus =
1309                                 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1310
1311                         passive = channel->flags & IEEE80211_CHAN_PASSIVE_SCAN;
1312                         ch->passive = passive;
1313
1314                         ch->freq = channel->center_freq;
1315                         ch->min_power = channel->max_power * 3;
1316                         ch->max_power = channel->max_power * 4;
1317                         ch->max_reg_power = channel->max_reg_power * 4;
1318                         ch->max_antenna_gain = channel->max_antenna_gain;
1319                         ch->reg_class_id = 0; /* FIXME */
1320
1321                         /* FIXME: why use only legacy modes, why not any
1322                          * HT/VHT modes? Would that even make any
1323                          * difference? */
1324                         if (channel->band == IEEE80211_BAND_2GHZ)
1325                                 ch->mode = MODE_11G;
1326                         else
1327                                 ch->mode = MODE_11A;
1328
1329                         if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1330                                 continue;
1331
1332                         ath10k_dbg(ATH10K_DBG_WMI,
1333                                    "%s: [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1334                                    __func__, ch - arg.channels, arg.n_channels,
1335                                    ch->freq, ch->max_power, ch->max_reg_power,
1336                                    ch->max_antenna_gain, ch->mode);
1337
1338                         ch++;
1339                 }
1340         }
1341
1342         ret = ath10k_wmi_scan_chan_list(ar, &arg);
1343         kfree(arg.channels);
1344
1345         return ret;
1346 }
1347
1348 static void ath10k_regd_update(struct ath10k *ar)
1349 {
1350         struct reg_dmn_pair_mapping *regpair;
1351         int ret;
1352
1353         lockdep_assert_held(&ar->conf_mutex);
1354
1355         ret = ath10k_update_channel_list(ar);
1356         if (ret)
1357                 ath10k_warn("could not update channel list (%d)\n", ret);
1358
1359         regpair = ar->ath_common.regulatory.regpair;
1360
1361         /* Target allows setting up per-band regdomain but ath_common provides
1362          * a combined one only */
1363         ret = ath10k_wmi_pdev_set_regdomain(ar,
1364                                             regpair->regDmnEnum,
1365                                             regpair->regDmnEnum, /* 2ghz */
1366                                             regpair->regDmnEnum, /* 5ghz */
1367                                             regpair->reg_2ghz_ctl,
1368                                             regpair->reg_5ghz_ctl);
1369         if (ret)
1370                 ath10k_warn("could not set pdev regdomain (%d)\n", ret);
1371 }
1372
1373 static void ath10k_reg_notifier(struct wiphy *wiphy,
1374                                 struct regulatory_request *request)
1375 {
1376         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1377         struct ath10k *ar = hw->priv;
1378
1379         ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1380
1381         mutex_lock(&ar->conf_mutex);
1382         if (ar->state == ATH10K_STATE_ON)
1383                 ath10k_regd_update(ar);
1384         mutex_unlock(&ar->conf_mutex);
1385 }
1386
1387 /***************/
1388 /* TX handlers */
1389 /***************/
1390
1391 /*
1392  * Frames sent to the FW have to be in "Native Wifi" format.
1393  * Strip the QoS field from the 802.11 header.
1394  */
1395 static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw,
1396                                        struct ieee80211_tx_control *control,
1397                                        struct sk_buff *skb)
1398 {
1399         struct ieee80211_hdr *hdr = (void *)skb->data;
1400         u8 *qos_ctl;
1401
1402         if (!ieee80211_is_data_qos(hdr->frame_control))
1403                 return;
1404
1405         qos_ctl = ieee80211_get_qos_ctl(hdr);
1406         memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1407                 skb->data, (void *)qos_ctl - (void *)skb->data);
1408         skb_pull(skb, IEEE80211_QOS_CTL_LEN);
1409 }
1410
1411 static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
1412 {
1413         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1414         struct ieee80211_vif *vif = info->control.vif;
1415         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1416         struct ath10k *ar = arvif->ar;
1417         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1418         struct ieee80211_key_conf *key = info->control.hw_key;
1419         int ret;
1420
1421         /* TODO AP mode should be implemented */
1422         if (vif->type != NL80211_IFTYPE_STATION)
1423                 return;
1424
1425         if (!ieee80211_has_protected(hdr->frame_control))
1426                 return;
1427
1428         if (!key)
1429                 return;
1430
1431         if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1432             key->cipher != WLAN_CIPHER_SUITE_WEP104)
1433                 return;
1434
1435         if (key->keyidx == arvif->def_wep_key_index)
1436                 return;
1437
1438         ath10k_dbg(ATH10K_DBG_MAC, "new wep keyidx will be %d\n", key->keyidx);
1439
1440         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
1441                                         WMI_VDEV_PARAM_DEF_KEYID,
1442                                         key->keyidx);
1443         if (ret) {
1444                 ath10k_warn("could not update wep keyidx (%d)\n", ret);
1445                 return;
1446         }
1447
1448         arvif->def_wep_key_index = key->keyidx;
1449 }
1450
1451 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb)
1452 {
1453         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1454         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1455         struct ieee80211_vif *vif = info->control.vif;
1456         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1457
1458         /* This is case only for P2P_GO */
1459         if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1460             arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1461                 return;
1462
1463         if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1464                 spin_lock_bh(&ar->data_lock);
1465                 if (arvif->u.ap.noa_data)
1466                         if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1467                                               GFP_ATOMIC))
1468                                 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1469                                        arvif->u.ap.noa_data,
1470                                        arvif->u.ap.noa_len);
1471                 spin_unlock_bh(&ar->data_lock);
1472         }
1473 }
1474
1475 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1476 {
1477         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1478         int ret;
1479
1480         if (ieee80211_is_mgmt(hdr->frame_control))
1481                 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
1482         else if (ieee80211_is_nullfunc(hdr->frame_control))
1483                 /* FW does not report tx status properly for NullFunc frames
1484                  * unless they are sent through mgmt tx path. mac80211 sends
1485                  * those frames when it detects link/beacon loss and depends on
1486                  * the tx status to be correct. */
1487                 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
1488         else
1489                 ret = ath10k_htt_tx(&ar->htt, skb);
1490
1491         if (ret) {
1492                 ath10k_warn("tx failed (%d). dropping packet.\n", ret);
1493                 ieee80211_free_txskb(ar->hw, skb);
1494         }
1495 }
1496
1497 void ath10k_offchan_tx_purge(struct ath10k *ar)
1498 {
1499         struct sk_buff *skb;
1500
1501         for (;;) {
1502                 skb = skb_dequeue(&ar->offchan_tx_queue);
1503                 if (!skb)
1504                         break;
1505
1506                 ieee80211_free_txskb(ar->hw, skb);
1507         }
1508 }
1509
1510 void ath10k_offchan_tx_work(struct work_struct *work)
1511 {
1512         struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
1513         struct ath10k_peer *peer;
1514         struct ieee80211_hdr *hdr;
1515         struct sk_buff *skb;
1516         const u8 *peer_addr;
1517         int vdev_id;
1518         int ret;
1519
1520         /* FW requirement: We must create a peer before FW will send out
1521          * an offchannel frame. Otherwise the frame will be stuck and
1522          * never transmitted. We delete the peer upon tx completion.
1523          * It is unlikely that a peer for offchannel tx will already be
1524          * present. However it may be in some rare cases so account for that.
1525          * Otherwise we might remove a legitimate peer and break stuff. */
1526
1527         for (;;) {
1528                 skb = skb_dequeue(&ar->offchan_tx_queue);
1529                 if (!skb)
1530                         break;
1531
1532                 mutex_lock(&ar->conf_mutex);
1533
1534                 ath10k_dbg(ATH10K_DBG_MAC, "processing offchannel skb %p\n",
1535                            skb);
1536
1537                 hdr = (struct ieee80211_hdr *)skb->data;
1538                 peer_addr = ieee80211_get_DA(hdr);
1539                 vdev_id = ATH10K_SKB_CB(skb)->htt.vdev_id;
1540
1541                 spin_lock_bh(&ar->data_lock);
1542                 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
1543                 spin_unlock_bh(&ar->data_lock);
1544
1545                 if (peer)
1546                         ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
1547                                    peer_addr, vdev_id);
1548
1549                 if (!peer) {
1550                         ret = ath10k_peer_create(ar, vdev_id, peer_addr);
1551                         if (ret)
1552                                 ath10k_warn("peer %pM on vdev %d not created (%d)\n",
1553                                             peer_addr, vdev_id, ret);
1554                 }
1555
1556                 spin_lock_bh(&ar->data_lock);
1557                 INIT_COMPLETION(ar->offchan_tx_completed);
1558                 ar->offchan_tx_skb = skb;
1559                 spin_unlock_bh(&ar->data_lock);
1560
1561                 ath10k_tx_htt(ar, skb);
1562
1563                 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
1564                                                   3 * HZ);
1565                 if (ret <= 0)
1566                         ath10k_warn("timed out waiting for offchannel skb %p\n",
1567                                     skb);
1568
1569                 if (!peer) {
1570                         ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
1571                         if (ret)
1572                                 ath10k_warn("peer %pM on vdev %d not deleted (%d)\n",
1573                                             peer_addr, vdev_id, ret);
1574                 }
1575
1576                 mutex_unlock(&ar->conf_mutex);
1577         }
1578 }
1579
1580 /************/
1581 /* Scanning */
1582 /************/
1583
1584 /*
1585  * This gets called if we dont get a heart-beat during scan.
1586  * This may indicate the FW has hung and we need to abort the
1587  * scan manually to prevent cancel_hw_scan() from deadlocking
1588  */
1589 void ath10k_reset_scan(unsigned long ptr)
1590 {
1591         struct ath10k *ar = (struct ath10k *)ptr;
1592
1593         spin_lock_bh(&ar->data_lock);
1594         if (!ar->scan.in_progress) {
1595                 spin_unlock_bh(&ar->data_lock);
1596                 return;
1597         }
1598
1599         ath10k_warn("scan timeout. resetting. fw issue?\n");
1600
1601         if (ar->scan.is_roc)
1602                 ieee80211_remain_on_channel_expired(ar->hw);
1603         else
1604                 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
1605
1606         ar->scan.in_progress = false;
1607         complete_all(&ar->scan.completed);
1608         spin_unlock_bh(&ar->data_lock);
1609 }
1610
1611 static int ath10k_abort_scan(struct ath10k *ar)
1612 {
1613         struct wmi_stop_scan_arg arg = {
1614                 .req_id = 1, /* FIXME */
1615                 .req_type = WMI_SCAN_STOP_ONE,
1616                 .u.scan_id = ATH10K_SCAN_ID,
1617         };
1618         int ret;
1619
1620         lockdep_assert_held(&ar->conf_mutex);
1621
1622         del_timer_sync(&ar->scan.timeout);
1623
1624         spin_lock_bh(&ar->data_lock);
1625         if (!ar->scan.in_progress) {
1626                 spin_unlock_bh(&ar->data_lock);
1627                 return 0;
1628         }
1629
1630         ar->scan.aborting = true;
1631         spin_unlock_bh(&ar->data_lock);
1632
1633         ret = ath10k_wmi_stop_scan(ar, &arg);
1634         if (ret) {
1635                 ath10k_warn("could not submit wmi stop scan (%d)\n", ret);
1636                 spin_lock_bh(&ar->data_lock);
1637                 ar->scan.in_progress = false;
1638                 ath10k_offchan_tx_purge(ar);
1639                 spin_unlock_bh(&ar->data_lock);
1640                 return -EIO;
1641         }
1642
1643         ath10k_wmi_flush_tx(ar);
1644
1645         ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
1646         if (ret == 0)
1647                 ath10k_warn("timed out while waiting for scan to stop\n");
1648
1649         /* scan completion may be done right after we timeout here, so let's
1650          * check the in_progress and tell mac80211 scan is completed. if we
1651          * don't do that and FW fails to send us scan completion indication
1652          * then userspace won't be able to scan anymore */
1653         ret = 0;
1654
1655         spin_lock_bh(&ar->data_lock);
1656         if (ar->scan.in_progress) {
1657                 ath10k_warn("could not stop scan. its still in progress\n");
1658                 ar->scan.in_progress = false;
1659                 ath10k_offchan_tx_purge(ar);
1660                 ret = -ETIMEDOUT;
1661         }
1662         spin_unlock_bh(&ar->data_lock);
1663
1664         return ret;
1665 }
1666
1667 static int ath10k_start_scan(struct ath10k *ar,
1668                              const struct wmi_start_scan_arg *arg)
1669 {
1670         int ret;
1671
1672         lockdep_assert_held(&ar->conf_mutex);
1673
1674         ret = ath10k_wmi_start_scan(ar, arg);
1675         if (ret)
1676                 return ret;
1677
1678         /* make sure we submit the command so the completion
1679         * timeout makes sense */
1680         ath10k_wmi_flush_tx(ar);
1681
1682         ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
1683         if (ret == 0) {
1684                 ath10k_abort_scan(ar);
1685                 return ret;
1686         }
1687
1688         /* the scan can complete earlier, before we even
1689          * start the timer. in that case the timer handler
1690          * checks ar->scan.in_progress and bails out if its
1691          * false. Add a 200ms margin to account event/command
1692          * processing. */
1693         mod_timer(&ar->scan.timeout, jiffies +
1694                   msecs_to_jiffies(arg->max_scan_time+200));
1695         return 0;
1696 }
1697
1698 /**********************/
1699 /* mac80211 callbacks */
1700 /**********************/
1701
1702 static void ath10k_tx(struct ieee80211_hw *hw,
1703                       struct ieee80211_tx_control *control,
1704                       struct sk_buff *skb)
1705 {
1706         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1707         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1708         struct ath10k *ar = hw->priv;
1709         struct ath10k_vif *arvif = NULL;
1710         u32 vdev_id = 0;
1711         u8 tid;
1712
1713         if (info->control.vif) {
1714                 arvif = ath10k_vif_to_arvif(info->control.vif);
1715                 vdev_id = arvif->vdev_id;
1716         } else if (ar->monitor_enabled) {
1717                 vdev_id = ar->monitor_vdev_id;
1718         }
1719
1720         /* We should disable CCK RATE due to P2P */
1721         if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
1722                 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
1723
1724         /* we must calculate tid before we apply qos workaround
1725          * as we'd lose the qos control field */
1726         tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1727         if (ieee80211_is_data_qos(hdr->frame_control) &&
1728             is_unicast_ether_addr(ieee80211_get_DA(hdr))) {
1729                 u8 *qc = ieee80211_get_qos_ctl(hdr);
1730                 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
1731         }
1732
1733         /* it makes no sense to process injected frames like that */
1734         if (info->control.vif &&
1735             info->control.vif->type != NL80211_IFTYPE_MONITOR) {
1736                 ath10k_tx_h_qos_workaround(hw, control, skb);
1737                 ath10k_tx_h_update_wep_key(skb);
1738                 ath10k_tx_h_add_p2p_noa_ie(ar, skb);
1739                 ath10k_tx_h_seq_no(skb);
1740         }
1741
1742         memset(ATH10K_SKB_CB(skb), 0, sizeof(*ATH10K_SKB_CB(skb)));
1743         ATH10K_SKB_CB(skb)->htt.vdev_id = vdev_id;
1744         ATH10K_SKB_CB(skb)->htt.tid = tid;
1745
1746         if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
1747                 spin_lock_bh(&ar->data_lock);
1748                 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
1749                 ATH10K_SKB_CB(skb)->htt.vdev_id = ar->scan.vdev_id;
1750                 spin_unlock_bh(&ar->data_lock);
1751
1752                 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
1753
1754                 skb_queue_tail(&ar->offchan_tx_queue, skb);
1755                 ieee80211_queue_work(hw, &ar->offchan_tx_work);
1756                 return;
1757         }
1758
1759         ath10k_tx_htt(ar, skb);
1760 }
1761
1762 /*
1763  * Initialize various parameters with default vaules.
1764  */
1765 void ath10k_halt(struct ath10k *ar)
1766 {
1767         lockdep_assert_held(&ar->conf_mutex);
1768
1769         del_timer_sync(&ar->scan.timeout);
1770         ath10k_offchan_tx_purge(ar);
1771         ath10k_peer_cleanup_all(ar);
1772         ath10k_core_stop(ar);
1773         ath10k_hif_power_down(ar);
1774
1775         spin_lock_bh(&ar->data_lock);
1776         if (ar->scan.in_progress) {
1777                 del_timer(&ar->scan.timeout);
1778                 ar->scan.in_progress = false;
1779                 ieee80211_scan_completed(ar->hw, true);
1780         }
1781         spin_unlock_bh(&ar->data_lock);
1782 }
1783
1784 static int ath10k_start(struct ieee80211_hw *hw)
1785 {
1786         struct ath10k *ar = hw->priv;
1787         int ret = 0;
1788
1789         mutex_lock(&ar->conf_mutex);
1790
1791         if (ar->state != ATH10K_STATE_OFF &&
1792             ar->state != ATH10K_STATE_RESTARTING) {
1793                 ret = -EINVAL;
1794                 goto exit;
1795         }
1796
1797         ret = ath10k_hif_power_up(ar);
1798         if (ret) {
1799                 ath10k_err("could not init hif (%d)\n", ret);
1800                 ar->state = ATH10K_STATE_OFF;
1801                 goto exit;
1802         }
1803
1804         ret = ath10k_core_start(ar);
1805         if (ret) {
1806                 ath10k_err("could not init core (%d)\n", ret);
1807                 ath10k_hif_power_down(ar);
1808                 ar->state = ATH10K_STATE_OFF;
1809                 goto exit;
1810         }
1811
1812         if (ar->state == ATH10K_STATE_OFF)
1813                 ar->state = ATH10K_STATE_ON;
1814         else if (ar->state == ATH10K_STATE_RESTARTING)
1815                 ar->state = ATH10K_STATE_RESTARTED;
1816
1817         ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 1);
1818         if (ret)
1819                 ath10k_warn("could not enable WMI_PDEV_PARAM_PMF_QOS (%d)\n",
1820                             ret);
1821
1822         ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 0);
1823         if (ret)
1824                 ath10k_warn("could not init WMI_PDEV_PARAM_DYNAMIC_BW (%d)\n",
1825                             ret);
1826
1827         ath10k_regd_update(ar);
1828
1829 exit:
1830         mutex_unlock(&ar->conf_mutex);
1831         return 0;
1832 }
1833
1834 static void ath10k_stop(struct ieee80211_hw *hw)
1835 {
1836         struct ath10k *ar = hw->priv;
1837
1838         mutex_lock(&ar->conf_mutex);
1839         if (ar->state == ATH10K_STATE_ON ||
1840             ar->state == ATH10K_STATE_RESTARTED ||
1841             ar->state == ATH10K_STATE_WEDGED)
1842                 ath10k_halt(ar);
1843
1844         ar->state = ATH10K_STATE_OFF;
1845         mutex_unlock(&ar->conf_mutex);
1846
1847         cancel_work_sync(&ar->offchan_tx_work);
1848         cancel_work_sync(&ar->restart_work);
1849 }
1850
1851 static void ath10k_config_ps(struct ath10k *ar)
1852 {
1853         struct ath10k_generic_iter ar_iter;
1854
1855         lockdep_assert_held(&ar->conf_mutex);
1856
1857         /* During HW reconfiguration mac80211 reports all interfaces that were
1858          * running until reconfiguration was started. Since FW doesn't have any
1859          * vdevs at this point we must not iterate over this interface list.
1860          * This setting will be updated upon add_interface(). */
1861         if (ar->state == ATH10K_STATE_RESTARTED)
1862                 return;
1863
1864         memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
1865         ar_iter.ar = ar;
1866
1867         ieee80211_iterate_active_interfaces_atomic(
1868                 ar->hw, IEEE80211_IFACE_ITER_NORMAL,
1869                 ath10k_ps_iter, &ar_iter);
1870
1871         if (ar_iter.ret)
1872                 ath10k_warn("failed to set ps config (%d)\n", ar_iter.ret);
1873 }
1874
1875 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
1876 {
1877         struct ath10k *ar = hw->priv;
1878         struct ieee80211_conf *conf = &hw->conf;
1879         int ret = 0;
1880
1881         mutex_lock(&ar->conf_mutex);
1882
1883         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1884                 ath10k_dbg(ATH10K_DBG_MAC, "Config channel %d mhz\n",
1885                            conf->chandef.chan->center_freq);
1886                 spin_lock_bh(&ar->data_lock);
1887                 ar->rx_channel = conf->chandef.chan;
1888                 spin_unlock_bh(&ar->data_lock);
1889         }
1890
1891         if (changed & IEEE80211_CONF_CHANGE_PS)
1892                 ath10k_config_ps(ar);
1893
1894         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1895                 if (conf->flags & IEEE80211_CONF_MONITOR)
1896                         ret = ath10k_monitor_create(ar);
1897                 else
1898                         ret = ath10k_monitor_destroy(ar);
1899         }
1900
1901         ath10k_wmi_flush_tx(ar);
1902         mutex_unlock(&ar->conf_mutex);
1903         return ret;
1904 }
1905
1906 /*
1907  * TODO:
1908  * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
1909  * because we will send mgmt frames without CCK. This requirement
1910  * for P2P_FIND/GO_NEG should be handled by checking CCK flag
1911  * in the TX packet.
1912  */
1913 static int ath10k_add_interface(struct ieee80211_hw *hw,
1914                                 struct ieee80211_vif *vif)
1915 {
1916         struct ath10k *ar = hw->priv;
1917         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1918         enum wmi_sta_powersave_param param;
1919         int ret = 0;
1920         u32 value;
1921         int bit;
1922
1923         mutex_lock(&ar->conf_mutex);
1924
1925         memset(arvif, 0, sizeof(*arvif));
1926
1927         arvif->ar = ar;
1928         arvif->vif = vif;
1929
1930         if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) {
1931                 ath10k_warn("Only one monitor interface allowed\n");
1932                 ret = -EBUSY;
1933                 goto exit;
1934         }
1935
1936         bit = ffs(ar->free_vdev_map);
1937         if (bit == 0) {
1938                 ret = -EBUSY;
1939                 goto exit;
1940         }
1941
1942         arvif->vdev_id = bit - 1;
1943         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
1944         ar->free_vdev_map &= ~(1 << arvif->vdev_id);
1945
1946         if (ar->p2p)
1947                 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
1948
1949         switch (vif->type) {
1950         case NL80211_IFTYPE_UNSPECIFIED:
1951         case NL80211_IFTYPE_STATION:
1952                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
1953                 if (vif->p2p)
1954                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
1955                 break;
1956         case NL80211_IFTYPE_ADHOC:
1957                 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
1958                 break;
1959         case NL80211_IFTYPE_AP:
1960                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
1961
1962                 if (vif->p2p)
1963                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
1964                 break;
1965         case NL80211_IFTYPE_MONITOR:
1966                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
1967                 break;
1968         default:
1969                 WARN_ON(1);
1970                 break;
1971         }
1972
1973         ath10k_dbg(ATH10K_DBG_MAC, "Add interface: id %d type %d subtype %d\n",
1974                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
1975
1976         ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
1977                                      arvif->vdev_subtype, vif->addr);
1978         if (ret) {
1979                 ath10k_warn("WMI vdev create failed: ret %d\n", ret);
1980                 goto exit;
1981         }
1982
1983         ret = ath10k_wmi_vdev_set_param(ar, 0, WMI_VDEV_PARAM_DEF_KEYID,
1984                                         arvif->def_wep_key_index);
1985         if (ret)
1986                 ath10k_warn("Failed to set default keyid: %d\n", ret);
1987
1988         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
1989                                         WMI_VDEV_PARAM_TX_ENCAP_TYPE,
1990                                         ATH10K_HW_TXRX_NATIVE_WIFI);
1991         if (ret)
1992                 ath10k_warn("Failed to set TX encap: %d\n", ret);
1993
1994         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1995                 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
1996                 if (ret) {
1997                         ath10k_warn("Failed to create peer for AP: %d\n", ret);
1998                         goto exit;
1999                 }
2000         }
2001
2002         if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2003                 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2004                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2005                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2006                                                   param, value);
2007                 if (ret)
2008                         ath10k_warn("Failed to set RX wake policy: %d\n", ret);
2009
2010                 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2011                 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2012                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2013                                                   param, value);
2014                 if (ret)
2015                         ath10k_warn("Failed to set TX wake thresh: %d\n", ret);
2016
2017                 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2018                 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2019                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2020                                                   param, value);
2021                 if (ret)
2022                         ath10k_warn("Failed to set PSPOLL count: %d\n", ret);
2023         }
2024
2025         ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
2026         if (ret)
2027                 ath10k_warn("failed to set rts threshold for vdev %d (%d)\n",
2028                             arvif->vdev_id, ret);
2029
2030         ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
2031         if (ret)
2032                 ath10k_warn("failed to set frag threshold for vdev %d (%d)\n",
2033                             arvif->vdev_id, ret);
2034
2035         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2036                 ar->monitor_present = true;
2037
2038 exit:
2039         mutex_unlock(&ar->conf_mutex);
2040         return ret;
2041 }
2042
2043 static void ath10k_remove_interface(struct ieee80211_hw *hw,
2044                                     struct ieee80211_vif *vif)
2045 {
2046         struct ath10k *ar = hw->priv;
2047         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2048         int ret;
2049
2050         mutex_lock(&ar->conf_mutex);
2051
2052         ath10k_dbg(ATH10K_DBG_MAC, "Remove interface: id %d\n", arvif->vdev_id);
2053
2054         ar->free_vdev_map |= 1 << (arvif->vdev_id);
2055
2056         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2057                 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2058                 if (ret)
2059                         ath10k_warn("Failed to remove peer for AP: %d\n", ret);
2060
2061                 kfree(arvif->u.ap.noa_data);
2062         }
2063
2064         ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2065         if (ret)
2066                 ath10k_warn("WMI vdev delete failed: %d\n", ret);
2067
2068         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2069                 ar->monitor_present = false;
2070
2071         ath10k_peer_cleanup(ar, arvif->vdev_id);
2072
2073         mutex_unlock(&ar->conf_mutex);
2074 }
2075
2076 /*
2077  * FIXME: Has to be verified.
2078  */
2079 #define SUPPORTED_FILTERS                       \
2080         (FIF_PROMISC_IN_BSS |                   \
2081         FIF_ALLMULTI |                          \
2082         FIF_CONTROL |                           \
2083         FIF_PSPOLL |                            \
2084         FIF_OTHER_BSS |                         \
2085         FIF_BCN_PRBRESP_PROMISC |               \
2086         FIF_PROBE_REQ |                         \
2087         FIF_FCSFAIL)
2088
2089 static void ath10k_configure_filter(struct ieee80211_hw *hw,
2090                                     unsigned int changed_flags,
2091                                     unsigned int *total_flags,
2092                                     u64 multicast)
2093 {
2094         struct ath10k *ar = hw->priv;
2095         int ret;
2096
2097         mutex_lock(&ar->conf_mutex);
2098
2099         changed_flags &= SUPPORTED_FILTERS;
2100         *total_flags &= SUPPORTED_FILTERS;
2101         ar->filter_flags = *total_flags;
2102
2103         if ((ar->filter_flags & FIF_PROMISC_IN_BSS) &&
2104             !ar->monitor_enabled) {
2105                 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
2106                 if (ret)
2107                         ath10k_warn("Unable to start monitor mode\n");
2108                 else
2109                         ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode started\n");
2110         } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) &&
2111                    ar->monitor_enabled) {
2112                 ret = ath10k_monitor_stop(ar);
2113                 if (ret)
2114                         ath10k_warn("Unable to stop monitor mode\n");
2115                 else
2116                         ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode stopped\n");
2117         }
2118
2119         mutex_unlock(&ar->conf_mutex);
2120 }
2121
2122 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2123                                     struct ieee80211_vif *vif,
2124                                     struct ieee80211_bss_conf *info,
2125                                     u32 changed)
2126 {
2127         struct ath10k *ar = hw->priv;
2128         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2129         int ret = 0;
2130
2131         mutex_lock(&ar->conf_mutex);
2132
2133         if (changed & BSS_CHANGED_IBSS)
2134                 ath10k_control_ibss(arvif, info, vif->addr);
2135
2136         if (changed & BSS_CHANGED_BEACON_INT) {
2137                 arvif->beacon_interval = info->beacon_int;
2138                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2139                                                 WMI_VDEV_PARAM_BEACON_INTERVAL,
2140                                                 arvif->beacon_interval);
2141                 if (ret)
2142                         ath10k_warn("Failed to set beacon interval for VDEV: %d\n",
2143                                     arvif->vdev_id);
2144                 else
2145                         ath10k_dbg(ATH10K_DBG_MAC,
2146                                    "Beacon interval: %d set for VDEV: %d\n",
2147                                    arvif->beacon_interval, arvif->vdev_id);
2148         }
2149
2150         if (changed & BSS_CHANGED_BEACON) {
2151                 ret = ath10k_wmi_pdev_set_param(ar,
2152                                                 WMI_PDEV_PARAM_BEACON_TX_MODE,
2153                                                 WMI_BEACON_STAGGERED_MODE);
2154                 if (ret)
2155                         ath10k_warn("Failed to set beacon mode for VDEV: %d\n",
2156                                     arvif->vdev_id);
2157                 else
2158                         ath10k_dbg(ATH10K_DBG_MAC,
2159                                    "Set staggered beacon mode for VDEV: %d\n",
2160                                    arvif->vdev_id);
2161         }
2162
2163         if (changed & BSS_CHANGED_BEACON_INFO) {
2164                 arvif->dtim_period = info->dtim_period;
2165
2166                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2167                                                 WMI_VDEV_PARAM_DTIM_PERIOD,
2168                                                 arvif->dtim_period);
2169                 if (ret)
2170                         ath10k_warn("Failed to set dtim period for VDEV: %d\n",
2171                                     arvif->vdev_id);
2172                 else
2173                         ath10k_dbg(ATH10K_DBG_MAC,
2174                                    "Set dtim period: %d for VDEV: %d\n",
2175                                    arvif->dtim_period, arvif->vdev_id);
2176         }
2177
2178         if (changed & BSS_CHANGED_SSID &&
2179             vif->type == NL80211_IFTYPE_AP) {
2180                 arvif->u.ap.ssid_len = info->ssid_len;
2181                 if (info->ssid_len)
2182                         memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
2183                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
2184         }
2185
2186         if (changed & BSS_CHANGED_BSSID) {
2187                 if (!is_zero_ether_addr(info->bssid)) {
2188                         ret = ath10k_peer_create(ar, arvif->vdev_id,
2189                                                  info->bssid);
2190                         if (ret)
2191                                 ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
2192                                             info->bssid, arvif->vdev_id);
2193                         else
2194                                 ath10k_dbg(ATH10K_DBG_MAC,
2195                                            "Added peer: %pM for VDEV: %d\n",
2196                                            info->bssid, arvif->vdev_id);
2197
2198
2199                         if (vif->type == NL80211_IFTYPE_STATION) {
2200                                 /*
2201                                  * this is never erased as we it for crypto key
2202                                  * clearing; this is FW requirement
2203                                  */
2204                                 memcpy(arvif->u.sta.bssid, info->bssid,
2205                                        ETH_ALEN);
2206
2207                                 ret = ath10k_vdev_start(arvif);
2208                                 if (!ret)
2209                                         ath10k_dbg(ATH10K_DBG_MAC,
2210                                                    "VDEV: %d started with BSSID: %pM\n",
2211                                                    arvif->vdev_id, info->bssid);
2212                         }
2213
2214                         /*
2215                          * Mac80211 does not keep IBSS bssid when leaving IBSS,
2216                          * so driver need to store it. It is needed when leaving
2217                          * IBSS in order to remove BSSID peer.
2218                          */
2219                         if (vif->type == NL80211_IFTYPE_ADHOC)
2220                                 memcpy(arvif->u.ibss.bssid, info->bssid,
2221                                        ETH_ALEN);
2222                 }
2223         }
2224
2225         if (changed & BSS_CHANGED_BEACON_ENABLED)
2226                 ath10k_control_beaconing(arvif, info);
2227
2228         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2229                 u32 cts_prot;
2230                 if (info->use_cts_prot)
2231                         cts_prot = 1;
2232                 else
2233                         cts_prot = 0;
2234
2235                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2236                                                 WMI_VDEV_PARAM_ENABLE_RTSCTS,
2237                                                 cts_prot);
2238                 if (ret)
2239                         ath10k_warn("Failed to set CTS prot for VDEV: %d\n",
2240                                     arvif->vdev_id);
2241                 else
2242                         ath10k_dbg(ATH10K_DBG_MAC,
2243                                    "Set CTS prot: %d for VDEV: %d\n",
2244                                    cts_prot, arvif->vdev_id);
2245         }
2246
2247         if (changed & BSS_CHANGED_ERP_SLOT) {
2248                 u32 slottime;
2249                 if (info->use_short_slot)
2250                         slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
2251
2252                 else
2253                         slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
2254
2255                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2256                                                 WMI_VDEV_PARAM_SLOT_TIME,
2257                                                 slottime);
2258                 if (ret)
2259                         ath10k_warn("Failed to set erp slot for VDEV: %d\n",
2260                                     arvif->vdev_id);
2261                 else
2262                         ath10k_dbg(ATH10K_DBG_MAC,
2263                                    "Set slottime: %d for VDEV: %d\n",
2264                                    slottime, arvif->vdev_id);
2265         }
2266
2267         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2268                 u32 preamble;
2269                 if (info->use_short_preamble)
2270                         preamble = WMI_VDEV_PREAMBLE_SHORT;
2271                 else
2272                         preamble = WMI_VDEV_PREAMBLE_LONG;
2273
2274                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2275                                                 WMI_VDEV_PARAM_PREAMBLE,
2276                                                 preamble);
2277                 if (ret)
2278                         ath10k_warn("Failed to set preamble for VDEV: %d\n",
2279                                     arvif->vdev_id);
2280                 else
2281                         ath10k_dbg(ATH10K_DBG_MAC,
2282                                    "Set preamble: %d for VDEV: %d\n",
2283                                    preamble, arvif->vdev_id);
2284         }
2285
2286         if (changed & BSS_CHANGED_ASSOC) {
2287                 if (info->assoc)
2288                         ath10k_bss_assoc(hw, vif, info);
2289         }
2290
2291         mutex_unlock(&ar->conf_mutex);
2292 }
2293
2294 static int ath10k_hw_scan(struct ieee80211_hw *hw,
2295                           struct ieee80211_vif *vif,
2296                           struct cfg80211_scan_request *req)
2297 {
2298         struct ath10k *ar = hw->priv;
2299         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2300         struct wmi_start_scan_arg arg;
2301         int ret = 0;
2302         int i;
2303
2304         mutex_lock(&ar->conf_mutex);
2305
2306         spin_lock_bh(&ar->data_lock);
2307         if (ar->scan.in_progress) {
2308                 spin_unlock_bh(&ar->data_lock);
2309                 ret = -EBUSY;
2310                 goto exit;
2311         }
2312
2313         INIT_COMPLETION(ar->scan.started);
2314         INIT_COMPLETION(ar->scan.completed);
2315         ar->scan.in_progress = true;
2316         ar->scan.aborting = false;
2317         ar->scan.is_roc = false;
2318         ar->scan.vdev_id = arvif->vdev_id;
2319         spin_unlock_bh(&ar->data_lock);
2320
2321         memset(&arg, 0, sizeof(arg));
2322         ath10k_wmi_start_scan_init(ar, &arg);
2323         arg.vdev_id = arvif->vdev_id;
2324         arg.scan_id = ATH10K_SCAN_ID;
2325
2326         if (!req->no_cck)
2327                 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
2328
2329         if (req->ie_len) {
2330                 arg.ie_len = req->ie_len;
2331                 memcpy(arg.ie, req->ie, arg.ie_len);
2332         }
2333
2334         if (req->n_ssids) {
2335                 arg.n_ssids = req->n_ssids;
2336                 for (i = 0; i < arg.n_ssids; i++) {
2337                         arg.ssids[i].len  = req->ssids[i].ssid_len;
2338                         arg.ssids[i].ssid = req->ssids[i].ssid;
2339                 }
2340         } else {
2341                 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
2342         }
2343
2344         if (req->n_channels) {
2345                 arg.n_channels = req->n_channels;
2346                 for (i = 0; i < arg.n_channels; i++)
2347                         arg.channels[i] = req->channels[i]->center_freq;
2348         }
2349
2350         ret = ath10k_start_scan(ar, &arg);
2351         if (ret) {
2352                 ath10k_warn("could not start hw scan (%d)\n", ret);
2353                 spin_lock_bh(&ar->data_lock);
2354                 ar->scan.in_progress = false;
2355                 spin_unlock_bh(&ar->data_lock);
2356         }
2357
2358 exit:
2359         mutex_unlock(&ar->conf_mutex);
2360         return ret;
2361 }
2362
2363 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
2364                                   struct ieee80211_vif *vif)
2365 {
2366         struct ath10k *ar = hw->priv;
2367         int ret;
2368
2369         mutex_lock(&ar->conf_mutex);
2370         ret = ath10k_abort_scan(ar);
2371         if (ret) {
2372                 ath10k_warn("couldn't abort scan (%d). forcefully sending scan completion to mac80211\n",
2373                             ret);
2374                 ieee80211_scan_completed(hw, 1 /* aborted */);
2375         }
2376         mutex_unlock(&ar->conf_mutex);
2377 }
2378
2379 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2380                           struct ieee80211_vif *vif, struct ieee80211_sta *sta,
2381                           struct ieee80211_key_conf *key)
2382 {
2383         struct ath10k *ar = hw->priv;
2384         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2385         struct ath10k_peer *peer;
2386         const u8 *peer_addr;
2387         bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2388                       key->cipher == WLAN_CIPHER_SUITE_WEP104;
2389         int ret = 0;
2390
2391         if (key->keyidx > WMI_MAX_KEY_INDEX)
2392                 return -ENOSPC;
2393
2394         mutex_lock(&ar->conf_mutex);
2395
2396         if (sta)
2397                 peer_addr = sta->addr;
2398         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
2399                 peer_addr = vif->bss_conf.bssid;
2400         else
2401                 peer_addr = vif->addr;
2402
2403         key->hw_key_idx = key->keyidx;
2404
2405         /* the peer should not disappear in mid-way (unless FW goes awry) since
2406          * we already hold conf_mutex. we just make sure its there now. */
2407         spin_lock_bh(&ar->data_lock);
2408         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2409         spin_unlock_bh(&ar->data_lock);
2410
2411         if (!peer) {
2412                 if (cmd == SET_KEY) {
2413                         ath10k_warn("cannot install key for non-existent peer %pM\n",
2414                                     peer_addr);
2415                         ret = -EOPNOTSUPP;
2416                         goto exit;
2417                 } else {
2418                         /* if the peer doesn't exist there is no key to disable
2419                          * anymore */
2420                         goto exit;
2421                 }
2422         }
2423
2424         if (is_wep) {
2425                 if (cmd == SET_KEY)
2426                         arvif->wep_keys[key->keyidx] = key;
2427                 else
2428                         arvif->wep_keys[key->keyidx] = NULL;
2429
2430                 if (cmd == DISABLE_KEY)
2431                         ath10k_clear_vdev_key(arvif, key);
2432         }
2433
2434         ret = ath10k_install_key(arvif, key, cmd, peer_addr);
2435         if (ret) {
2436                 ath10k_warn("ath10k_install_key failed (%d)\n", ret);
2437                 goto exit;
2438         }
2439
2440         spin_lock_bh(&ar->data_lock);
2441         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2442         if (peer && cmd == SET_KEY)
2443                 peer->keys[key->keyidx] = key;
2444         else if (peer && cmd == DISABLE_KEY)
2445                 peer->keys[key->keyidx] = NULL;
2446         else if (peer == NULL)
2447                 /* impossible unless FW goes crazy */
2448                 ath10k_warn("peer %pM disappeared!\n", peer_addr);
2449         spin_unlock_bh(&ar->data_lock);
2450
2451 exit:
2452         mutex_unlock(&ar->conf_mutex);
2453         return ret;
2454 }
2455
2456 static int ath10k_sta_state(struct ieee80211_hw *hw,
2457                             struct ieee80211_vif *vif,
2458                             struct ieee80211_sta *sta,
2459                             enum ieee80211_sta_state old_state,
2460                             enum ieee80211_sta_state new_state)
2461 {
2462         struct ath10k *ar = hw->priv;
2463         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2464         int ret = 0;
2465
2466         mutex_lock(&ar->conf_mutex);
2467
2468         if (old_state == IEEE80211_STA_NOTEXIST &&
2469             new_state == IEEE80211_STA_NONE &&
2470             vif->type != NL80211_IFTYPE_STATION) {
2471                 /*
2472                  * New station addition.
2473                  */
2474                 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
2475                 if (ret)
2476                         ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
2477                                     sta->addr, arvif->vdev_id);
2478                 else
2479                         ath10k_dbg(ATH10K_DBG_MAC,
2480                                    "Added peer: %pM for VDEV: %d\n",
2481                                    sta->addr, arvif->vdev_id);
2482         } else if ((old_state == IEEE80211_STA_NONE &&
2483                     new_state == IEEE80211_STA_NOTEXIST)) {
2484                 /*
2485                  * Existing station deletion.
2486                  */
2487                 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
2488                 if (ret)
2489                         ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n",
2490                                     sta->addr, arvif->vdev_id);
2491                 else
2492                         ath10k_dbg(ATH10K_DBG_MAC,
2493                                    "Removed peer: %pM for VDEV: %d\n",
2494                                    sta->addr, arvif->vdev_id);
2495
2496                 if (vif->type == NL80211_IFTYPE_STATION)
2497                         ath10k_bss_disassoc(hw, vif);
2498         } else if (old_state == IEEE80211_STA_AUTH &&
2499                    new_state == IEEE80211_STA_ASSOC &&
2500                    (vif->type == NL80211_IFTYPE_AP ||
2501                     vif->type == NL80211_IFTYPE_ADHOC)) {
2502                 /*
2503                  * New association.
2504                  */
2505                 ret = ath10k_station_assoc(ar, arvif, sta);
2506                 if (ret)
2507                         ath10k_warn("Failed to associate station: %pM\n",
2508                                     sta->addr);
2509                 else
2510                         ath10k_dbg(ATH10K_DBG_MAC,
2511                                    "Station %pM moved to assoc state\n",
2512                                    sta->addr);
2513         } else if (old_state == IEEE80211_STA_ASSOC &&
2514                    new_state == IEEE80211_STA_AUTH &&
2515                    (vif->type == NL80211_IFTYPE_AP ||
2516                     vif->type == NL80211_IFTYPE_ADHOC)) {
2517                 /*
2518                  * Disassociation.
2519                  */
2520                 ret = ath10k_station_disassoc(ar, arvif, sta);
2521                 if (ret)
2522                         ath10k_warn("Failed to disassociate station: %pM\n",
2523                                     sta->addr);
2524                 else
2525                         ath10k_dbg(ATH10K_DBG_MAC,
2526                                    "Station %pM moved to disassociated state\n",
2527                                    sta->addr);
2528         }
2529
2530         mutex_unlock(&ar->conf_mutex);
2531         return ret;
2532 }
2533
2534 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
2535                                  u16 ac, bool enable)
2536 {
2537         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2538         u32 value = 0;
2539         int ret = 0;
2540
2541         lockdep_assert_held(&ar->conf_mutex);
2542
2543         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
2544                 return 0;
2545
2546         switch (ac) {
2547         case IEEE80211_AC_VO:
2548                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
2549                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
2550                 break;
2551         case IEEE80211_AC_VI:
2552                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
2553                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
2554                 break;
2555         case IEEE80211_AC_BE:
2556                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
2557                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
2558                 break;
2559         case IEEE80211_AC_BK:
2560                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
2561                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
2562                 break;
2563         }
2564
2565         if (enable)
2566                 arvif->u.sta.uapsd |= value;
2567         else
2568                 arvif->u.sta.uapsd &= ~value;
2569
2570         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2571                                           WMI_STA_PS_PARAM_UAPSD,
2572                                           arvif->u.sta.uapsd);
2573         if (ret) {
2574                 ath10k_warn("could not set uapsd params %d\n", ret);
2575                 goto exit;
2576         }
2577
2578         if (arvif->u.sta.uapsd)
2579                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
2580         else
2581                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2582
2583         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2584                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
2585                                           value);
2586         if (ret)
2587                 ath10k_warn("could not set rx wake param %d\n", ret);
2588
2589 exit:
2590         return ret;
2591 }
2592
2593 static int ath10k_conf_tx(struct ieee80211_hw *hw,
2594                           struct ieee80211_vif *vif, u16 ac,
2595                           const struct ieee80211_tx_queue_params *params)
2596 {
2597         struct ath10k *ar = hw->priv;
2598         struct wmi_wmm_params_arg *p = NULL;
2599         int ret;
2600
2601         mutex_lock(&ar->conf_mutex);
2602
2603         switch (ac) {
2604         case IEEE80211_AC_VO:
2605                 p = &ar->wmm_params.ac_vo;
2606                 break;
2607         case IEEE80211_AC_VI:
2608                 p = &ar->wmm_params.ac_vi;
2609                 break;
2610         case IEEE80211_AC_BE:
2611                 p = &ar->wmm_params.ac_be;
2612                 break;
2613         case IEEE80211_AC_BK:
2614                 p = &ar->wmm_params.ac_bk;
2615                 break;
2616         }
2617
2618         if (WARN_ON(!p)) {
2619                 ret = -EINVAL;
2620                 goto exit;
2621         }
2622
2623         p->cwmin = params->cw_min;
2624         p->cwmax = params->cw_max;
2625         p->aifs = params->aifs;
2626
2627         /*
2628          * The channel time duration programmed in the HW is in absolute
2629          * microseconds, while mac80211 gives the txop in units of
2630          * 32 microseconds.
2631          */
2632         p->txop = params->txop * 32;
2633
2634         /* FIXME: FW accepts wmm params per hw, not per vif */
2635         ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
2636         if (ret) {
2637                 ath10k_warn("could not set wmm params %d\n", ret);
2638                 goto exit;
2639         }
2640
2641         ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
2642         if (ret)
2643                 ath10k_warn("could not set sta uapsd %d\n", ret);
2644
2645 exit:
2646         mutex_unlock(&ar->conf_mutex);
2647         return ret;
2648 }
2649
2650 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
2651
2652 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
2653                                     struct ieee80211_vif *vif,
2654                                     struct ieee80211_channel *chan,
2655                                     int duration,
2656                                     enum ieee80211_roc_type type)
2657 {
2658         struct ath10k *ar = hw->priv;
2659         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2660         struct wmi_start_scan_arg arg;
2661         int ret;
2662
2663         mutex_lock(&ar->conf_mutex);
2664
2665         spin_lock_bh(&ar->data_lock);
2666         if (ar->scan.in_progress) {
2667                 spin_unlock_bh(&ar->data_lock);
2668                 ret = -EBUSY;
2669                 goto exit;
2670         }
2671
2672         INIT_COMPLETION(ar->scan.started);
2673         INIT_COMPLETION(ar->scan.completed);
2674         INIT_COMPLETION(ar->scan.on_channel);
2675         ar->scan.in_progress = true;
2676         ar->scan.aborting = false;
2677         ar->scan.is_roc = true;
2678         ar->scan.vdev_id = arvif->vdev_id;
2679         ar->scan.roc_freq = chan->center_freq;
2680         spin_unlock_bh(&ar->data_lock);
2681
2682         memset(&arg, 0, sizeof(arg));
2683         ath10k_wmi_start_scan_init(ar, &arg);
2684         arg.vdev_id = arvif->vdev_id;
2685         arg.scan_id = ATH10K_SCAN_ID;
2686         arg.n_channels = 1;
2687         arg.channels[0] = chan->center_freq;
2688         arg.dwell_time_active = duration;
2689         arg.dwell_time_passive = duration;
2690         arg.max_scan_time = 2 * duration;
2691         arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
2692         arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
2693
2694         ret = ath10k_start_scan(ar, &arg);
2695         if (ret) {
2696                 ath10k_warn("could not start roc scan (%d)\n", ret);
2697                 spin_lock_bh(&ar->data_lock);
2698                 ar->scan.in_progress = false;
2699                 spin_unlock_bh(&ar->data_lock);
2700                 goto exit;
2701         }
2702
2703         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
2704         if (ret == 0) {
2705                 ath10k_warn("could not switch to channel for roc scan\n");
2706                 ath10k_abort_scan(ar);
2707                 ret = -ETIMEDOUT;
2708                 goto exit;
2709         }
2710
2711         ret = 0;
2712 exit:
2713         mutex_unlock(&ar->conf_mutex);
2714         return ret;
2715 }
2716
2717 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
2718 {
2719         struct ath10k *ar = hw->priv;
2720
2721         mutex_lock(&ar->conf_mutex);
2722         ath10k_abort_scan(ar);
2723         mutex_unlock(&ar->conf_mutex);
2724
2725         return 0;
2726 }
2727
2728 /*
2729  * Both RTS and Fragmentation threshold are interface-specific
2730  * in ath10k, but device-specific in mac80211.
2731  */
2732 static void ath10k_set_rts_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
2733 {
2734         struct ath10k_generic_iter *ar_iter = data;
2735         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2736         u32 rts = ar_iter->ar->hw->wiphy->rts_threshold;
2737
2738         lockdep_assert_held(&arvif->ar->conf_mutex);
2739
2740         /* During HW reconfiguration mac80211 reports all interfaces that were
2741          * running until reconfiguration was started. Since FW doesn't have any
2742          * vdevs at this point we must not iterate over this interface list.
2743          * This setting will be updated upon add_interface(). */
2744         if (ar_iter->ar->state == ATH10K_STATE_RESTARTED)
2745                 return;
2746
2747         ar_iter->ret = ath10k_mac_set_rts(arvif, rts);
2748         if (ar_iter->ret)
2749                 ath10k_warn("Failed to set RTS threshold for VDEV: %d\n",
2750                             arvif->vdev_id);
2751         else
2752                 ath10k_dbg(ATH10K_DBG_MAC,
2753                            "Set RTS threshold: %d for VDEV: %d\n",
2754                            rts, arvif->vdev_id);
2755 }
2756
2757 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2758 {
2759         struct ath10k_generic_iter ar_iter;
2760         struct ath10k *ar = hw->priv;
2761
2762         memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
2763         ar_iter.ar = ar;
2764
2765         mutex_lock(&ar->conf_mutex);
2766         ieee80211_iterate_active_interfaces_atomic(
2767                 hw, IEEE80211_IFACE_ITER_NORMAL,
2768                 ath10k_set_rts_iter, &ar_iter);
2769         mutex_unlock(&ar->conf_mutex);
2770
2771         return ar_iter.ret;
2772 }
2773
2774 static void ath10k_set_frag_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
2775 {
2776         struct ath10k_generic_iter *ar_iter = data;
2777         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2778         u32 frag = ar_iter->ar->hw->wiphy->frag_threshold;
2779
2780         lockdep_assert_held(&arvif->ar->conf_mutex);
2781
2782         /* During HW reconfiguration mac80211 reports all interfaces that were
2783          * running until reconfiguration was started. Since FW doesn't have any
2784          * vdevs at this point we must not iterate over this interface list.
2785          * This setting will be updated upon add_interface(). */
2786         if (ar_iter->ar->state == ATH10K_STATE_RESTARTED)
2787                 return;
2788
2789         ar_iter->ret = ath10k_mac_set_frag(arvif, frag);
2790         if (ar_iter->ret)
2791                 ath10k_warn("Failed to set frag threshold for VDEV: %d\n",
2792                             arvif->vdev_id);
2793         else
2794                 ath10k_dbg(ATH10K_DBG_MAC,
2795                            "Set frag threshold: %d for VDEV: %d\n",
2796                            frag, arvif->vdev_id);
2797 }
2798
2799 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2800 {
2801         struct ath10k_generic_iter ar_iter;
2802         struct ath10k *ar = hw->priv;
2803
2804         memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
2805         ar_iter.ar = ar;
2806
2807         mutex_lock(&ar->conf_mutex);
2808         ieee80211_iterate_active_interfaces_atomic(
2809                 hw, IEEE80211_IFACE_ITER_NORMAL,
2810                 ath10k_set_frag_iter, &ar_iter);
2811         mutex_unlock(&ar->conf_mutex);
2812
2813         return ar_iter.ret;
2814 }
2815
2816 static void ath10k_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
2817 {
2818         struct ath10k *ar = hw->priv;
2819         bool skip;
2820         int ret;
2821
2822         /* mac80211 doesn't care if we really xmit queued frames or not
2823          * we'll collect those frames either way if we stop/delete vdevs */
2824         if (drop)
2825                 return;
2826
2827         mutex_lock(&ar->conf_mutex);
2828
2829         if (ar->state == ATH10K_STATE_WEDGED)
2830                 goto skip;
2831
2832         ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
2833                         bool empty;
2834
2835                         spin_lock_bh(&ar->htt.tx_lock);
2836                         empty = bitmap_empty(ar->htt.used_msdu_ids,
2837                                              ar->htt.max_num_pending_tx);
2838                         spin_unlock_bh(&ar->htt.tx_lock);
2839
2840                         skip = (ar->state == ATH10K_STATE_WEDGED);
2841
2842                         (empty || skip);
2843                 }), ATH10K_FLUSH_TIMEOUT_HZ);
2844
2845         if (ret <= 0 || skip)
2846                 ath10k_warn("tx not flushed\n");
2847
2848 skip:
2849         mutex_unlock(&ar->conf_mutex);
2850 }
2851
2852 /* TODO: Implement this function properly
2853  * For now it is needed to reply to Probe Requests in IBSS mode.
2854  * Propably we need this information from FW.
2855  */
2856 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
2857 {
2858         return 1;
2859 }
2860
2861 #ifdef CONFIG_PM
2862 static int ath10k_suspend(struct ieee80211_hw *hw,
2863                           struct cfg80211_wowlan *wowlan)
2864 {
2865         struct ath10k *ar = hw->priv;
2866         int ret;
2867
2868         ar->is_target_paused = false;
2869
2870         ret = ath10k_wmi_pdev_suspend_target(ar);
2871         if (ret) {
2872                 ath10k_warn("could not suspend target (%d)\n", ret);
2873                 return 1;
2874         }
2875
2876         ret = wait_event_interruptible_timeout(ar->event_queue,
2877                                                ar->is_target_paused == true,
2878                                                1 * HZ);
2879         if (ret < 0) {
2880                 ath10k_warn("suspend interrupted (%d)\n", ret);
2881                 goto resume;
2882         } else if (ret == 0) {
2883                 ath10k_warn("suspend timed out - target pause event never came\n");
2884                 goto resume;
2885         }
2886
2887         ret = ath10k_hif_suspend(ar);
2888         if (ret) {
2889                 ath10k_warn("could not suspend hif (%d)\n", ret);
2890                 goto resume;
2891         }
2892
2893         return 0;
2894 resume:
2895         ret = ath10k_wmi_pdev_resume_target(ar);
2896         if (ret)
2897                 ath10k_warn("could not resume target (%d)\n", ret);
2898         return 1;
2899 }
2900
2901 static int ath10k_resume(struct ieee80211_hw *hw)
2902 {
2903         struct ath10k *ar = hw->priv;
2904         int ret;
2905
2906         ret = ath10k_hif_resume(ar);
2907         if (ret) {
2908                 ath10k_warn("could not resume hif (%d)\n", ret);
2909                 return 1;
2910         }
2911
2912         ret = ath10k_wmi_pdev_resume_target(ar);
2913         if (ret) {
2914                 ath10k_warn("could not resume target (%d)\n", ret);
2915                 return 1;
2916         }
2917
2918         return 0;
2919 }
2920 #endif
2921
2922 static void ath10k_restart_complete(struct ieee80211_hw *hw)
2923 {
2924         struct ath10k *ar = hw->priv;
2925
2926         mutex_lock(&ar->conf_mutex);
2927
2928         /* If device failed to restart it will be in a different state, e.g.
2929          * ATH10K_STATE_WEDGED */
2930         if (ar->state == ATH10K_STATE_RESTARTED) {
2931                 ath10k_info("device successfully recovered\n");
2932                 ar->state = ATH10K_STATE_ON;
2933         }
2934
2935         mutex_unlock(&ar->conf_mutex);
2936 }
2937
2938 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
2939                              struct survey_info *survey)
2940 {
2941         struct ath10k *ar = hw->priv;
2942         struct ieee80211_supported_band *sband;
2943         struct survey_info *ar_survey = &ar->survey[idx];
2944         int ret = 0;
2945
2946         mutex_lock(&ar->conf_mutex);
2947
2948         sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
2949         if (sband && idx >= sband->n_channels) {
2950                 idx -= sband->n_channels;
2951                 sband = NULL;
2952         }
2953
2954         if (!sband)
2955                 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
2956
2957         if (!sband || idx >= sband->n_channels) {
2958                 ret = -ENOENT;
2959                 goto exit;
2960         }
2961
2962         spin_lock_bh(&ar->data_lock);
2963         memcpy(survey, ar_survey, sizeof(*survey));
2964         spin_unlock_bh(&ar->data_lock);
2965
2966         survey->channel = &sband->channels[idx];
2967
2968 exit:
2969         mutex_unlock(&ar->conf_mutex);
2970         return ret;
2971 }
2972
2973 static const struct ieee80211_ops ath10k_ops = {
2974         .tx                             = ath10k_tx,
2975         .start                          = ath10k_start,
2976         .stop                           = ath10k_stop,
2977         .config                         = ath10k_config,
2978         .add_interface                  = ath10k_add_interface,
2979         .remove_interface               = ath10k_remove_interface,
2980         .configure_filter               = ath10k_configure_filter,
2981         .bss_info_changed               = ath10k_bss_info_changed,
2982         .hw_scan                        = ath10k_hw_scan,
2983         .cancel_hw_scan                 = ath10k_cancel_hw_scan,
2984         .set_key                        = ath10k_set_key,
2985         .sta_state                      = ath10k_sta_state,
2986         .conf_tx                        = ath10k_conf_tx,
2987         .remain_on_channel              = ath10k_remain_on_channel,
2988         .cancel_remain_on_channel       = ath10k_cancel_remain_on_channel,
2989         .set_rts_threshold              = ath10k_set_rts_threshold,
2990         .set_frag_threshold             = ath10k_set_frag_threshold,
2991         .flush                          = ath10k_flush,
2992         .tx_last_beacon                 = ath10k_tx_last_beacon,
2993         .restart_complete               = ath10k_restart_complete,
2994         .get_survey                     = ath10k_get_survey,
2995 #ifdef CONFIG_PM
2996         .suspend                        = ath10k_suspend,
2997         .resume                         = ath10k_resume,
2998 #endif
2999 };
3000
3001 #define RATETAB_ENT(_rate, _rateid, _flags) { \
3002         .bitrate                = (_rate), \
3003         .flags                  = (_flags), \
3004         .hw_value               = (_rateid), \
3005 }
3006
3007 #define CHAN2G(_channel, _freq, _flags) { \
3008         .band                   = IEEE80211_BAND_2GHZ, \
3009         .hw_value               = (_channel), \
3010         .center_freq            = (_freq), \
3011         .flags                  = (_flags), \
3012         .max_antenna_gain       = 0, \
3013         .max_power              = 30, \
3014 }
3015
3016 #define CHAN5G(_channel, _freq, _flags) { \
3017         .band                   = IEEE80211_BAND_5GHZ, \
3018         .hw_value               = (_channel), \
3019         .center_freq            = (_freq), \
3020         .flags                  = (_flags), \
3021         .max_antenna_gain       = 0, \
3022         .max_power              = 30, \
3023 }
3024
3025 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
3026         CHAN2G(1, 2412, 0),
3027         CHAN2G(2, 2417, 0),
3028         CHAN2G(3, 2422, 0),
3029         CHAN2G(4, 2427, 0),
3030         CHAN2G(5, 2432, 0),
3031         CHAN2G(6, 2437, 0),
3032         CHAN2G(7, 2442, 0),
3033         CHAN2G(8, 2447, 0),
3034         CHAN2G(9, 2452, 0),
3035         CHAN2G(10, 2457, 0),
3036         CHAN2G(11, 2462, 0),
3037         CHAN2G(12, 2467, 0),
3038         CHAN2G(13, 2472, 0),
3039         CHAN2G(14, 2484, 0),
3040 };
3041
3042 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
3043         CHAN5G(36, 5180, 0),
3044         CHAN5G(40, 5200, 0),
3045         CHAN5G(44, 5220, 0),
3046         CHAN5G(48, 5240, 0),
3047         CHAN5G(52, 5260, 0),
3048         CHAN5G(56, 5280, 0),
3049         CHAN5G(60, 5300, 0),
3050         CHAN5G(64, 5320, 0),
3051         CHAN5G(100, 5500, 0),
3052         CHAN5G(104, 5520, 0),
3053         CHAN5G(108, 5540, 0),
3054         CHAN5G(112, 5560, 0),
3055         CHAN5G(116, 5580, 0),
3056         CHAN5G(120, 5600, 0),
3057         CHAN5G(124, 5620, 0),
3058         CHAN5G(128, 5640, 0),
3059         CHAN5G(132, 5660, 0),
3060         CHAN5G(136, 5680, 0),
3061         CHAN5G(140, 5700, 0),
3062         CHAN5G(149, 5745, 0),
3063         CHAN5G(153, 5765, 0),
3064         CHAN5G(157, 5785, 0),
3065         CHAN5G(161, 5805, 0),
3066         CHAN5G(165, 5825, 0),
3067 };
3068
3069 static struct ieee80211_rate ath10k_rates[] = {
3070         /* CCK */
3071         RATETAB_ENT(10,  0x82, 0),
3072         RATETAB_ENT(20,  0x84, 0),
3073         RATETAB_ENT(55,  0x8b, 0),
3074         RATETAB_ENT(110, 0x96, 0),
3075         /* OFDM */
3076         RATETAB_ENT(60,  0x0c, 0),
3077         RATETAB_ENT(90,  0x12, 0),
3078         RATETAB_ENT(120, 0x18, 0),
3079         RATETAB_ENT(180, 0x24, 0),
3080         RATETAB_ENT(240, 0x30, 0),
3081         RATETAB_ENT(360, 0x48, 0),
3082         RATETAB_ENT(480, 0x60, 0),
3083         RATETAB_ENT(540, 0x6c, 0),
3084 };
3085
3086 #define ath10k_a_rates (ath10k_rates + 4)
3087 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
3088 #define ath10k_g_rates (ath10k_rates + 0)
3089 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
3090
3091 struct ath10k *ath10k_mac_create(void)
3092 {
3093         struct ieee80211_hw *hw;
3094         struct ath10k *ar;
3095
3096         hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
3097         if (!hw)
3098                 return NULL;
3099
3100         ar = hw->priv;
3101         ar->hw = hw;
3102
3103         return ar;
3104 }
3105
3106 void ath10k_mac_destroy(struct ath10k *ar)
3107 {
3108         ieee80211_free_hw(ar->hw);
3109 }
3110
3111 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
3112         {
3113         .max    = 8,
3114         .types  = BIT(NL80211_IFTYPE_STATION)
3115                 | BIT(NL80211_IFTYPE_P2P_CLIENT)
3116         },
3117         {
3118         .max    = 3,
3119         .types  = BIT(NL80211_IFTYPE_P2P_GO)
3120         },
3121         {
3122         .max    = 7,
3123         .types  = BIT(NL80211_IFTYPE_AP)
3124         },
3125 };
3126
3127 static const struct ieee80211_iface_combination ath10k_if_comb = {
3128         .limits = ath10k_if_limits,
3129         .n_limits = ARRAY_SIZE(ath10k_if_limits),
3130         .max_interfaces = 8,
3131         .num_different_channels = 1,
3132         .beacon_int_infra_match = true,
3133 };
3134
3135 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
3136 {
3137         struct ieee80211_sta_vht_cap vht_cap = {0};
3138         u16 mcs_map;
3139         int i;
3140
3141         vht_cap.vht_supported = 1;
3142         vht_cap.cap = ar->vht_cap_info;
3143
3144         mcs_map = 0;
3145         for (i = 0; i < 8; i++) {
3146                 if (i < ar->num_rf_chains)
3147                         mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
3148                 else
3149                         mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
3150         }
3151
3152         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
3153         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
3154
3155         return vht_cap;
3156 }
3157
3158 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
3159 {
3160         int i;
3161         struct ieee80211_sta_ht_cap ht_cap = {0};
3162
3163         if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
3164                 return ht_cap;
3165
3166         ht_cap.ht_supported = 1;
3167         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3168         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
3169         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
3170         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
3171         ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
3172
3173         if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
3174                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
3175
3176         if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
3177                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
3178
3179         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
3180                 u32 smps;
3181
3182                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
3183                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
3184
3185                 ht_cap.cap |= smps;
3186         }
3187
3188         if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
3189                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
3190
3191         if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
3192                 u32 stbc;
3193
3194                 stbc   = ar->ht_cap_info;
3195                 stbc  &= WMI_HT_CAP_RX_STBC;
3196                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
3197                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
3198                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
3199
3200                 ht_cap.cap |= stbc;
3201         }
3202
3203         if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
3204                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
3205
3206         if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
3207                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
3208
3209         /* max AMSDU is implicitly taken from vht_cap_info */
3210         if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
3211                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
3212
3213         for (i = 0; i < ar->num_rf_chains; i++)
3214                 ht_cap.mcs.rx_mask[i] = 0xFF;
3215
3216         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
3217
3218         return ht_cap;
3219 }
3220
3221
3222 static void ath10k_get_arvif_iter(void *data, u8 *mac,
3223                                   struct ieee80211_vif *vif)
3224 {
3225         struct ath10k_vif_iter *arvif_iter = data;
3226         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3227
3228         if (arvif->vdev_id == arvif_iter->vdev_id)
3229                 arvif_iter->arvif = arvif;
3230 }
3231
3232 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
3233 {
3234         struct ath10k_vif_iter arvif_iter;
3235         u32 flags;
3236
3237         memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
3238         arvif_iter.vdev_id = vdev_id;
3239
3240         flags = IEEE80211_IFACE_ITER_RESUME_ALL;
3241         ieee80211_iterate_active_interfaces_atomic(ar->hw,
3242                                                    flags,
3243                                                    ath10k_get_arvif_iter,
3244                                                    &arvif_iter);
3245         if (!arvif_iter.arvif) {
3246                 ath10k_warn("No VIF found for VDEV: %d\n", vdev_id);
3247                 return NULL;
3248         }
3249
3250         return arvif_iter.arvif;
3251 }
3252
3253 int ath10k_mac_register(struct ath10k *ar)
3254 {
3255         struct ieee80211_supported_band *band;
3256         struct ieee80211_sta_vht_cap vht_cap;
3257         struct ieee80211_sta_ht_cap ht_cap;
3258         void *channels;
3259         int ret;
3260
3261         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
3262
3263         SET_IEEE80211_DEV(ar->hw, ar->dev);
3264
3265         ht_cap = ath10k_get_ht_cap(ar);
3266         vht_cap = ath10k_create_vht_cap(ar);
3267
3268         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
3269                 channels = kmemdup(ath10k_2ghz_channels,
3270                                    sizeof(ath10k_2ghz_channels),
3271                                    GFP_KERNEL);
3272                 if (!channels) {
3273                         ret = -ENOMEM;
3274                         goto err_free;
3275                 }
3276
3277                 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
3278                 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
3279                 band->channels = channels;
3280                 band->n_bitrates = ath10k_g_rates_size;
3281                 band->bitrates = ath10k_g_rates;
3282                 band->ht_cap = ht_cap;
3283
3284                 /* vht is not supported in 2.4 GHz */
3285
3286                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
3287         }
3288
3289         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
3290                 channels = kmemdup(ath10k_5ghz_channels,
3291                                    sizeof(ath10k_5ghz_channels),
3292                                    GFP_KERNEL);
3293                 if (!channels) {
3294                         ret = -ENOMEM;
3295                         goto err_free;
3296                 }
3297
3298                 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
3299                 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
3300                 band->channels = channels;
3301                 band->n_bitrates = ath10k_a_rates_size;
3302                 band->bitrates = ath10k_a_rates;
3303                 band->ht_cap = ht_cap;
3304                 band->vht_cap = vht_cap;
3305                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
3306         }
3307
3308         ar->hw->wiphy->interface_modes =
3309                 BIT(NL80211_IFTYPE_STATION) |
3310                 BIT(NL80211_IFTYPE_ADHOC) |
3311                 BIT(NL80211_IFTYPE_AP) |
3312                 BIT(NL80211_IFTYPE_P2P_CLIENT) |
3313                 BIT(NL80211_IFTYPE_P2P_GO);
3314
3315         ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3316                         IEEE80211_HW_SUPPORTS_PS |
3317                         IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
3318                         IEEE80211_HW_SUPPORTS_UAPSD |
3319                         IEEE80211_HW_MFP_CAPABLE |
3320                         IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3321                         IEEE80211_HW_HAS_RATE_CONTROL |
3322                         IEEE80211_HW_SUPPORTS_STATIC_SMPS |
3323                         IEEE80211_HW_WANT_MONITOR_VIF |
3324                         IEEE80211_HW_AP_LINK_PS;
3325
3326         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
3327                 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
3328
3329         if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
3330                 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
3331                 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
3332         }
3333
3334         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
3335         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
3336
3337         ar->hw->vif_data_size = sizeof(struct ath10k_vif);
3338
3339         ar->hw->channel_change_time = 5000;
3340         ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
3341
3342         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
3343         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
3344
3345         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
3346         /*
3347          * on LL hardware queues are managed entirely by the FW
3348          * so we only advertise to mac we can do the queues thing
3349          */
3350         ar->hw->queues = 4;
3351
3352         ar->hw->wiphy->iface_combinations = &ath10k_if_comb;
3353         ar->hw->wiphy->n_iface_combinations = 1;
3354
3355         ar->hw->netdev_features = NETIF_F_HW_CSUM;
3356
3357         ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
3358                             ath10k_reg_notifier);
3359         if (ret) {
3360                 ath10k_err("Regulatory initialization failed\n");
3361                 goto err_free;
3362         }
3363
3364         ret = ieee80211_register_hw(ar->hw);
3365         if (ret) {
3366                 ath10k_err("ieee80211 registration failed: %d\n", ret);
3367                 goto err_free;
3368         }
3369
3370         if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
3371                 ret = regulatory_hint(ar->hw->wiphy,
3372                                       ar->ath_common.regulatory.alpha2);
3373                 if (ret)
3374                         goto err_unregister;
3375         }
3376
3377         return 0;
3378
3379 err_unregister:
3380         ieee80211_unregister_hw(ar->hw);
3381 err_free:
3382         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
3383         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
3384
3385         return ret;
3386 }
3387
3388 void ath10k_mac_unregister(struct ath10k *ar)
3389 {
3390         ieee80211_unregister_hw(ar->hw);
3391
3392         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
3393         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
3394
3395         SET_IEEE80211_DEV(ar->hw, NULL);
3396 }