Pileus Git - ~andy/linux/blob - drivers/net/wireless/ath/ath10k/mac.c

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