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