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