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