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

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