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