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