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 INIT_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 return ret; 327 328 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr); 329 if (ret) 330 return ret; 331 332 return 0; 333 } 334 335 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value) 336 { 337 if (value != 0xFFFFFFFF) 338 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold, 339 ATH10K_RTS_MAX); 340 341 return ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, 342 WMI_VDEV_PARAM_RTS_THRESHOLD, 343 value); 344 } 345 346 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value) 347 { 348 if (value != 0xFFFFFFFF) 349 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold, 350 ATH10K_FRAGMT_THRESHOLD_MIN, 351 ATH10K_FRAGMT_THRESHOLD_MAX); 352 353 return ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, 354 WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD, 355 value); 356 } 357 358 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr) 359 { 360 int ret; 361 362 lockdep_assert_held(&ar->conf_mutex); 363 364 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr); 365 if (ret) 366 return ret; 367 368 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr); 369 if (ret) 370 return ret; 371 372 return 0; 373 } 374 375 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id) 376 { 377 struct ath10k_peer *peer, *tmp; 378 379 lockdep_assert_held(&ar->conf_mutex); 380 381 spin_lock_bh(&ar->data_lock); 382 list_for_each_entry_safe(peer, tmp, &ar->peers, list) { 383 if (peer->vdev_id != vdev_id) 384 continue; 385 386 ath10k_warn("removing stale peer %pM from vdev_id %d\n", 387 peer->addr, vdev_id); 388 389 list_del(&peer->list); 390 kfree(peer); 391 } 392 spin_unlock_bh(&ar->data_lock); 393 } 394 395 static void ath10k_peer_cleanup_all(struct ath10k *ar) 396 { 397 struct ath10k_peer *peer, *tmp; 398 399 lockdep_assert_held(&ar->conf_mutex); 400 401 spin_lock_bh(&ar->data_lock); 402 list_for_each_entry_safe(peer, tmp, &ar->peers, list) { 403 list_del(&peer->list); 404 kfree(peer); 405 } 406 spin_unlock_bh(&ar->data_lock); 407 } 408 409 /************************/ 410 /* Interface management */ 411 /************************/ 412 413 static inline int ath10k_vdev_setup_sync(struct ath10k *ar) 414 { 415 int ret; 416 417 lockdep_assert_held(&ar->conf_mutex); 418 419 ret = wait_for_completion_timeout(&ar->vdev_setup_done, 420 ATH10K_VDEV_SETUP_TIMEOUT_HZ); 421 if (ret == 0) 422 return -ETIMEDOUT; 423 424 return 0; 425 } 426 427 static int ath10k_vdev_start(struct ath10k_vif *arvif) 428 { 429 struct ath10k *ar = arvif->ar; 430 struct ieee80211_conf *conf = &ar->hw->conf; 431 struct ieee80211_channel *channel = conf->chandef.chan; 432 struct wmi_vdev_start_request_arg arg = {}; 433 int ret = 0; 434 435 lockdep_assert_held(&ar->conf_mutex); 436 437 INIT_COMPLETION(ar->vdev_setup_done); 438 439 arg.vdev_id = arvif->vdev_id; 440 arg.dtim_period = arvif->dtim_period; 441 arg.bcn_intval = arvif->beacon_interval; 442 443 arg.channel.freq = channel->center_freq; 444 445 arg.channel.band_center_freq1 = conf->chandef.center_freq1; 446 447 arg.channel.mode = chan_to_phymode(&conf->chandef); 448 449 arg.channel.min_power = channel->max_power * 3; 450 arg.channel.max_power = channel->max_power * 4; 451 arg.channel.max_reg_power = channel->max_reg_power * 4; 452 arg.channel.max_antenna_gain = channel->max_antenna_gain; 453 454 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 455 arg.ssid = arvif->u.ap.ssid; 456 arg.ssid_len = arvif->u.ap.ssid_len; 457 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 458 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 459 arg.ssid = arvif->vif->bss_conf.ssid; 460 arg.ssid_len = arvif->vif->bss_conf.ssid_len; 461 } 462 463 ret = ath10k_wmi_vdev_start(ar, &arg); 464 if (ret) { 465 ath10k_warn("WMI vdev start failed: ret %d\n", ret); 466 return ret; 467 } 468 469 ret = ath10k_vdev_setup_sync(ar); 470 if (ret) { 471 ath10k_warn("vdev setup failed %d\n", ret); 472 return ret; 473 } 474 475 return ret; 476 } 477 478 static int ath10k_vdev_stop(struct ath10k_vif *arvif) 479 { 480 struct ath10k *ar = arvif->ar; 481 int ret; 482 483 lockdep_assert_held(&ar->conf_mutex); 484 485 INIT_COMPLETION(ar->vdev_setup_done); 486 487 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id); 488 if (ret) { 489 ath10k_warn("WMI vdev stop failed: ret %d\n", ret); 490 return ret; 491 } 492 493 ret = ath10k_vdev_setup_sync(ar); 494 if (ret) { 495 ath10k_warn("vdev setup failed %d\n", ret); 496 return ret; 497 } 498 499 return ret; 500 } 501 502 static int ath10k_monitor_start(struct ath10k *ar, int vdev_id) 503 { 504 struct ieee80211_channel *channel = ar->hw->conf.chandef.chan; 505 struct wmi_vdev_start_request_arg arg = {}; 506 enum nl80211_channel_type type; 507 int ret = 0; 508 509 lockdep_assert_held(&ar->conf_mutex); 510 511 type = cfg80211_get_chandef_type(&ar->hw->conf.chandef); 512 513 arg.vdev_id = vdev_id; 514 arg.channel.freq = channel->center_freq; 515 arg.channel.band_center_freq1 = ar->hw->conf.chandef.center_freq1; 516 517 /* TODO setup this dynamically, what in case we 518 don't have any vifs? */ 519 arg.channel.mode = chan_to_phymode(&ar->hw->conf.chandef); 520 521 arg.channel.min_power = channel->max_power * 3; 522 arg.channel.max_power = channel->max_power * 4; 523 arg.channel.max_reg_power = channel->max_reg_power * 4; 524 arg.channel.max_antenna_gain = channel->max_antenna_gain; 525 526 ret = ath10k_wmi_vdev_start(ar, &arg); 527 if (ret) { 528 ath10k_warn("Monitor vdev start failed: ret %d\n", ret); 529 return ret; 530 } 531 532 ret = ath10k_vdev_setup_sync(ar); 533 if (ret) { 534 ath10k_warn("Monitor vdev setup failed %d\n", ret); 535 return ret; 536 } 537 538 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr); 539 if (ret) { 540 ath10k_warn("Monitor vdev up failed: %d\n", ret); 541 goto vdev_stop; 542 } 543 544 ar->monitor_vdev_id = vdev_id; 545 ar->monitor_enabled = true; 546 547 return 0; 548 549 vdev_stop: 550 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id); 551 if (ret) 552 ath10k_warn("Monitor vdev stop failed: %d\n", ret); 553 554 return ret; 555 } 556 557 static int ath10k_monitor_stop(struct ath10k *ar) 558 { 559 int ret = 0; 560 561 lockdep_assert_held(&ar->conf_mutex); 562 563 /* For some reasons, ath10k_wmi_vdev_down() here couse 564 * often ath10k_wmi_vdev_stop() to fail. Next we could 565 * not run monitor vdev and driver reload 566 * required. Don't see such problems we skip 567 * ath10k_wmi_vdev_down() here. 568 */ 569 570 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id); 571 if (ret) 572 ath10k_warn("Monitor vdev stop failed: %d\n", ret); 573 574 ret = ath10k_vdev_setup_sync(ar); 575 if (ret) 576 ath10k_warn("Monitor_down sync failed: %d\n", ret); 577 578 ar->monitor_enabled = false; 579 return ret; 580 } 581 582 static int ath10k_monitor_create(struct ath10k *ar) 583 { 584 int bit, ret = 0; 585 586 lockdep_assert_held(&ar->conf_mutex); 587 588 if (ar->monitor_present) { 589 ath10k_warn("Monitor mode already enabled\n"); 590 return 0; 591 } 592 593 bit = ffs(ar->free_vdev_map); 594 if (bit == 0) { 595 ath10k_warn("No free VDEV slots\n"); 596 return -ENOMEM; 597 } 598 599 ar->monitor_vdev_id = bit - 1; 600 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id); 601 602 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id, 603 WMI_VDEV_TYPE_MONITOR, 604 0, ar->mac_addr); 605 if (ret) { 606 ath10k_warn("WMI vdev monitor create failed: ret %d\n", ret); 607 goto vdev_fail; 608 } 609 610 ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface created, vdev id: %d\n", 611 ar->monitor_vdev_id); 612 613 ar->monitor_present = true; 614 return 0; 615 616 vdev_fail: 617 /* 618 * Restore the ID to the global map. 619 */ 620 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id); 621 return ret; 622 } 623 624 static int ath10k_monitor_destroy(struct ath10k *ar) 625 { 626 int ret = 0; 627 628 lockdep_assert_held(&ar->conf_mutex); 629 630 if (!ar->monitor_present) 631 return 0; 632 633 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id); 634 if (ret) { 635 ath10k_warn("WMI vdev monitor delete failed: %d\n", ret); 636 return ret; 637 } 638 639 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id); 640 ar->monitor_present = false; 641 642 ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface destroyed, vdev id: %d\n", 643 ar->monitor_vdev_id); 644 return ret; 645 } 646 647 static void ath10k_control_beaconing(struct ath10k_vif *arvif, 648 struct ieee80211_bss_conf *info) 649 { 650 int ret = 0; 651 652 lockdep_assert_held(&arvif->ar->conf_mutex); 653 654 if (!info->enable_beacon) { 655 ath10k_vdev_stop(arvif); 656 return; 657 } 658 659 arvif->tx_seq_no = 0x1000; 660 661 ret = ath10k_vdev_start(arvif); 662 if (ret) 663 return; 664 665 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, 0, info->bssid); 666 if (ret) { 667 ath10k_warn("Failed to bring up VDEV: %d\n", 668 arvif->vdev_id); 669 return; 670 } 671 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d up\n", arvif->vdev_id); 672 } 673 674 static void ath10k_control_ibss(struct ath10k_vif *arvif, 675 struct ieee80211_bss_conf *info, 676 const u8 self_peer[ETH_ALEN]) 677 { 678 int ret = 0; 679 680 lockdep_assert_held(&arvif->ar->conf_mutex); 681 682 if (!info->ibss_joined) { 683 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer); 684 if (ret) 685 ath10k_warn("Failed to delete IBSS self peer:%pM for VDEV:%d ret:%d\n", 686 self_peer, arvif->vdev_id, ret); 687 688 if (is_zero_ether_addr(arvif->u.ibss.bssid)) 689 return; 690 691 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, 692 arvif->u.ibss.bssid); 693 if (ret) { 694 ath10k_warn("Failed to delete IBSS BSSID peer:%pM for VDEV:%d ret:%d\n", 695 arvif->u.ibss.bssid, arvif->vdev_id, ret); 696 return; 697 } 698 699 memset(arvif->u.ibss.bssid, 0, ETH_ALEN); 700 701 return; 702 } 703 704 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer); 705 if (ret) { 706 ath10k_warn("Failed to create IBSS self peer:%pM for VDEV:%d ret:%d\n", 707 self_peer, arvif->vdev_id, ret); 708 return; 709 } 710 711 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, 712 WMI_VDEV_PARAM_ATIM_WINDOW, 713 ATH10K_DEFAULT_ATIM); 714 if (ret) 715 ath10k_warn("Failed to set IBSS ATIM for VDEV:%d ret:%d\n", 716 arvif->vdev_id, ret); 717 } 718 719 /* 720 * Review this when mac80211 gains per-interface powersave support. 721 */ 722 static void ath10k_ps_iter(void *data, u8 *mac, struct ieee80211_vif *vif) 723 { 724 struct ath10k_generic_iter *ar_iter = data; 725 struct ieee80211_conf *conf = &ar_iter->ar->hw->conf; 726 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 727 enum wmi_sta_powersave_param param; 728 enum wmi_sta_ps_mode psmode; 729 int ret; 730 731 lockdep_assert_held(&arvif->ar->conf_mutex); 732 733 if (vif->type != NL80211_IFTYPE_STATION) 734 return; 735 736 if (conf->flags & IEEE80211_CONF_PS) { 737 psmode = WMI_STA_PS_MODE_ENABLED; 738 param = WMI_STA_PS_PARAM_INACTIVITY_TIME; 739 740 ret = ath10k_wmi_set_sta_ps_param(ar_iter->ar, 741 arvif->vdev_id, 742 param, 743 conf->dynamic_ps_timeout); 744 if (ret) { 745 ath10k_warn("Failed to set inactivity time for VDEV: %d\n", 746 arvif->vdev_id); 747 return; 748 } 749 750 ar_iter->ret = ret; 751 } else { 752 psmode = WMI_STA_PS_MODE_DISABLED; 753 } 754 755 ar_iter->ret = ath10k_wmi_set_psmode(ar_iter->ar, arvif->vdev_id, 756 psmode); 757 if (ar_iter->ret) 758 ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n", 759 psmode, arvif->vdev_id); 760 else 761 ath10k_dbg(ATH10K_DBG_MAC, "Set PS Mode: %d for VDEV: %d\n", 762 psmode, arvif->vdev_id); 763 } 764 765 /**********************/ 766 /* Station management */ 767 /**********************/ 768 769 static void ath10k_peer_assoc_h_basic(struct ath10k *ar, 770 struct ath10k_vif *arvif, 771 struct ieee80211_sta *sta, 772 struct ieee80211_bss_conf *bss_conf, 773 struct wmi_peer_assoc_complete_arg *arg) 774 { 775 lockdep_assert_held(&ar->conf_mutex); 776 777 memcpy(arg->addr, sta->addr, ETH_ALEN); 778 arg->vdev_id = arvif->vdev_id; 779 arg->peer_aid = sta->aid; 780 arg->peer_flags |= WMI_PEER_AUTH; 781 782 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 783 /* 784 * Seems FW have problems with Power Save in STA 785 * mode when we setup this parameter to high (eg. 5). 786 * Often we see that FW don't send NULL (with clean P flags) 787 * frame even there is info about buffered frames in beacons. 788 * Sometimes we have to wait more than 10 seconds before FW 789 * will wakeup. Often sending one ping from AP to our device 790 * just fail (more than 50%). 791 * 792 * Seems setting this FW parameter to 1 couse FW 793 * will check every beacon and will wakup immediately 794 * after detection buffered data. 795 */ 796 arg->peer_listen_intval = 1; 797 else 798 arg->peer_listen_intval = ar->hw->conf.listen_interval; 799 800 arg->peer_num_spatial_streams = 1; 801 802 /* 803 * The assoc capabilities are available only in managed mode. 804 */ 805 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf) 806 arg->peer_caps = bss_conf->assoc_capability; 807 } 808 809 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar, 810 struct ath10k_vif *arvif, 811 struct wmi_peer_assoc_complete_arg *arg) 812 { 813 struct ieee80211_vif *vif = arvif->vif; 814 struct ieee80211_bss_conf *info = &vif->bss_conf; 815 struct cfg80211_bss *bss; 816 const u8 *rsnie = NULL; 817 const u8 *wpaie = NULL; 818 819 lockdep_assert_held(&ar->conf_mutex); 820 821 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan, 822 info->bssid, NULL, 0, 0, 0); 823 if (bss) { 824 const struct cfg80211_bss_ies *ies; 825 826 rcu_read_lock(); 827 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN); 828 829 ies = rcu_dereference(bss->ies); 830 831 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, 832 WLAN_OUI_TYPE_MICROSOFT_WPA, 833 ies->data, 834 ies->len); 835 rcu_read_unlock(); 836 cfg80211_put_bss(ar->hw->wiphy, bss); 837 } 838 839 /* FIXME: base on RSN IE/WPA IE is a correct idea? */ 840 if (rsnie || wpaie) { 841 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__); 842 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY; 843 } 844 845 if (wpaie) { 846 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__); 847 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY; 848 } 849 } 850 851 static void ath10k_peer_assoc_h_rates(struct ath10k *ar, 852 struct ieee80211_sta *sta, 853 struct wmi_peer_assoc_complete_arg *arg) 854 { 855 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates; 856 const struct ieee80211_supported_band *sband; 857 const struct ieee80211_rate *rates; 858 u32 ratemask; 859 int i; 860 861 lockdep_assert_held(&ar->conf_mutex); 862 863 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band]; 864 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band]; 865 rates = sband->bitrates; 866 867 rateset->num_rates = 0; 868 869 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) { 870 if (!(ratemask & 1)) 871 continue; 872 873 rateset->rates[rateset->num_rates] = rates->hw_value; 874 rateset->num_rates++; 875 } 876 } 877 878 static void ath10k_peer_assoc_h_ht(struct ath10k *ar, 879 struct ieee80211_sta *sta, 880 struct wmi_peer_assoc_complete_arg *arg) 881 { 882 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap; 883 int smps; 884 int i, n; 885 886 lockdep_assert_held(&ar->conf_mutex); 887 888 if (!ht_cap->ht_supported) 889 return; 890 891 arg->peer_flags |= WMI_PEER_HT; 892 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + 893 ht_cap->ampdu_factor)) - 1; 894 895 arg->peer_mpdu_density = 896 ath10k_parse_mpdudensity(ht_cap->ampdu_density); 897 898 arg->peer_ht_caps = ht_cap->cap; 899 arg->peer_rate_caps |= WMI_RC_HT_FLAG; 900 901 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING) 902 arg->peer_flags |= WMI_PEER_LDPC; 903 904 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) { 905 arg->peer_flags |= WMI_PEER_40MHZ; 906 arg->peer_rate_caps |= WMI_RC_CW40_FLAG; 907 } 908 909 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20) 910 arg->peer_rate_caps |= WMI_RC_SGI_FLAG; 911 912 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40) 913 arg->peer_rate_caps |= WMI_RC_SGI_FLAG; 914 915 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) { 916 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG; 917 arg->peer_flags |= WMI_PEER_STBC; 918 } 919 920 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) { 921 u32 stbc; 922 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC; 923 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT; 924 stbc = stbc << WMI_RC_RX_STBC_FLAG_S; 925 arg->peer_rate_caps |= stbc; 926 arg->peer_flags |= WMI_PEER_STBC; 927 } 928 929 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 930 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 931 932 if (smps == WLAN_HT_CAP_SM_PS_STATIC) { 933 arg->peer_flags |= WMI_PEER_SPATIAL_MUX; 934 arg->peer_flags |= WMI_PEER_STATIC_MIMOPS; 935 } else if (smps == WLAN_HT_CAP_SM_PS_DYNAMIC) { 936 arg->peer_flags |= WMI_PEER_SPATIAL_MUX; 937 arg->peer_flags |= WMI_PEER_DYN_MIMOPS; 938 } 939 940 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2]) 941 arg->peer_rate_caps |= WMI_RC_TS_FLAG; 942 else if (ht_cap->mcs.rx_mask[1]) 943 arg->peer_rate_caps |= WMI_RC_DS_FLAG; 944 945 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++) 946 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8)) 947 arg->peer_ht_rates.rates[n++] = i; 948 949 arg->peer_ht_rates.num_rates = n; 950 arg->peer_num_spatial_streams = max((n+7) / 8, 1); 951 952 ath10k_dbg(ATH10K_DBG_MAC, "mcs cnt %d nss %d\n", 953 arg->peer_ht_rates.num_rates, 954 arg->peer_num_spatial_streams); 955 } 956 957 static void ath10k_peer_assoc_h_qos_ap(struct ath10k *ar, 958 struct ath10k_vif *arvif, 959 struct ieee80211_sta *sta, 960 struct ieee80211_bss_conf *bss_conf, 961 struct wmi_peer_assoc_complete_arg *arg) 962 { 963 u32 uapsd = 0; 964 u32 max_sp = 0; 965 966 lockdep_assert_held(&ar->conf_mutex); 967 968 if (sta->wme) 969 arg->peer_flags |= WMI_PEER_QOS; 970 971 if (sta->wme && sta->uapsd_queues) { 972 ath10k_dbg(ATH10K_DBG_MAC, "uapsd_queues: 0x%X, max_sp: %d\n", 973 sta->uapsd_queues, sta->max_sp); 974 975 arg->peer_flags |= WMI_PEER_APSD; 976 arg->peer_flags |= WMI_RC_UAPSD_FLAG; 977 978 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) 979 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN | 980 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN; 981 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) 982 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN | 983 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN; 984 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) 985 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN | 986 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN; 987 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) 988 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN | 989 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN; 990 991 992 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP) 993 max_sp = sta->max_sp; 994 995 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, 996 sta->addr, 997 WMI_AP_PS_PEER_PARAM_UAPSD, 998 uapsd); 999 1000 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, 1001 sta->addr, 1002 WMI_AP_PS_PEER_PARAM_MAX_SP, 1003 max_sp); 1004 1005 /* TODO setup this based on STA listen interval and 1006 beacon interval. Currently we don't know 1007 sta->listen_interval - mac80211 patch required. 1008 Currently use 10 seconds */ 1009 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, 1010 sta->addr, 1011 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME, 1012 10); 1013 } 1014 } 1015 1016 static void ath10k_peer_assoc_h_qos_sta(struct ath10k *ar, 1017 struct ath10k_vif *arvif, 1018 struct ieee80211_sta *sta, 1019 struct ieee80211_bss_conf *bss_conf, 1020 struct wmi_peer_assoc_complete_arg *arg) 1021 { 1022 if (bss_conf->qos) 1023 arg->peer_flags |= WMI_PEER_QOS; 1024 } 1025 1026 static void ath10k_peer_assoc_h_vht(struct ath10k *ar, 1027 struct ieee80211_sta *sta, 1028 struct wmi_peer_assoc_complete_arg *arg) 1029 { 1030 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap; 1031 1032 if (!vht_cap->vht_supported) 1033 return; 1034 1035 arg->peer_flags |= WMI_PEER_VHT; 1036 1037 arg->peer_vht_caps = vht_cap->cap; 1038 1039 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 1040 arg->peer_flags |= WMI_PEER_80MHZ; 1041 1042 arg->peer_vht_rates.rx_max_rate = 1043 __le16_to_cpu(vht_cap->vht_mcs.rx_highest); 1044 arg->peer_vht_rates.rx_mcs_set = 1045 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map); 1046 arg->peer_vht_rates.tx_max_rate = 1047 __le16_to_cpu(vht_cap->vht_mcs.tx_highest); 1048 arg->peer_vht_rates.tx_mcs_set = 1049 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map); 1050 1051 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer\n"); 1052 } 1053 1054 static void ath10k_peer_assoc_h_qos(struct ath10k *ar, 1055 struct ath10k_vif *arvif, 1056 struct ieee80211_sta *sta, 1057 struct ieee80211_bss_conf *bss_conf, 1058 struct wmi_peer_assoc_complete_arg *arg) 1059 { 1060 switch (arvif->vdev_type) { 1061 case WMI_VDEV_TYPE_AP: 1062 ath10k_peer_assoc_h_qos_ap(ar, arvif, sta, bss_conf, arg); 1063 break; 1064 case WMI_VDEV_TYPE_STA: 1065 ath10k_peer_assoc_h_qos_sta(ar, arvif, sta, bss_conf, arg); 1066 break; 1067 default: 1068 break; 1069 } 1070 } 1071 1072 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar, 1073 struct ath10k_vif *arvif, 1074 struct ieee80211_sta *sta, 1075 struct wmi_peer_assoc_complete_arg *arg) 1076 { 1077 enum wmi_phy_mode phymode = MODE_UNKNOWN; 1078 1079 /* FIXME: add VHT */ 1080 1081 switch (ar->hw->conf.chandef.chan->band) { 1082 case IEEE80211_BAND_2GHZ: 1083 if (sta->ht_cap.ht_supported) { 1084 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 1085 phymode = MODE_11NG_HT40; 1086 else 1087 phymode = MODE_11NG_HT20; 1088 } else { 1089 phymode = MODE_11G; 1090 } 1091 1092 break; 1093 case IEEE80211_BAND_5GHZ: 1094 if (sta->ht_cap.ht_supported) { 1095 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 1096 phymode = MODE_11NA_HT40; 1097 else 1098 phymode = MODE_11NA_HT20; 1099 } else { 1100 phymode = MODE_11A; 1101 } 1102 1103 break; 1104 default: 1105 break; 1106 } 1107 1108 arg->peer_phymode = phymode; 1109 WARN_ON(phymode == MODE_UNKNOWN); 1110 } 1111 1112 static int ath10k_peer_assoc(struct ath10k *ar, 1113 struct ath10k_vif *arvif, 1114 struct ieee80211_sta *sta, 1115 struct ieee80211_bss_conf *bss_conf) 1116 { 1117 struct wmi_peer_assoc_complete_arg arg; 1118 1119 lockdep_assert_held(&ar->conf_mutex); 1120 1121 memset(&arg, 0, sizeof(struct wmi_peer_assoc_complete_arg)); 1122 1123 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, &arg); 1124 ath10k_peer_assoc_h_crypto(ar, arvif, &arg); 1125 ath10k_peer_assoc_h_rates(ar, sta, &arg); 1126 ath10k_peer_assoc_h_ht(ar, sta, &arg); 1127 ath10k_peer_assoc_h_vht(ar, sta, &arg); 1128 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, &arg); 1129 ath10k_peer_assoc_h_phymode(ar, arvif, sta, &arg); 1130 1131 return ath10k_wmi_peer_assoc(ar, &arg); 1132 } 1133 1134 /* can be called only in mac80211 callbacks due to `key_count` usage */ 1135 static void ath10k_bss_assoc(struct ieee80211_hw *hw, 1136 struct ieee80211_vif *vif, 1137 struct ieee80211_bss_conf *bss_conf) 1138 { 1139 struct ath10k *ar = hw->priv; 1140 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1141 struct ieee80211_sta *ap_sta; 1142 int ret; 1143 1144 lockdep_assert_held(&ar->conf_mutex); 1145 1146 rcu_read_lock(); 1147 1148 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid); 1149 if (!ap_sta) { 1150 ath10k_warn("Failed to find station entry for %pM\n", 1151 bss_conf->bssid); 1152 rcu_read_unlock(); 1153 return; 1154 } 1155 1156 ret = ath10k_peer_assoc(ar, arvif, ap_sta, bss_conf); 1157 if (ret) { 1158 ath10k_warn("Peer assoc failed for %pM\n", bss_conf->bssid); 1159 rcu_read_unlock(); 1160 return; 1161 } 1162 1163 rcu_read_unlock(); 1164 1165 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, bss_conf->aid, 1166 bss_conf->bssid); 1167 if (ret) 1168 ath10k_warn("VDEV: %d up failed: ret %d\n", 1169 arvif->vdev_id, ret); 1170 else 1171 ath10k_dbg(ATH10K_DBG_MAC, 1172 "VDEV: %d associated, BSSID: %pM, AID: %d\n", 1173 arvif->vdev_id, bss_conf->bssid, bss_conf->aid); 1174 } 1175 1176 /* 1177 * FIXME: flush TIDs 1178 */ 1179 static void ath10k_bss_disassoc(struct ieee80211_hw *hw, 1180 struct ieee80211_vif *vif) 1181 { 1182 struct ath10k *ar = hw->priv; 1183 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1184 int ret; 1185 1186 lockdep_assert_held(&ar->conf_mutex); 1187 1188 /* 1189 * For some reason, calling VDEV-DOWN before VDEV-STOP 1190 * makes the FW to send frames via HTT after disassociation. 1191 * No idea why this happens, even though VDEV-DOWN is supposed 1192 * to be analogous to link down, so just stop the VDEV. 1193 */ 1194 ret = ath10k_vdev_stop(arvif); 1195 if (!ret) 1196 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d stopped\n", 1197 arvif->vdev_id); 1198 1199 /* 1200 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and 1201 * report beacons from previously associated network through HTT. 1202 * This in turn would spam mac80211 WARN_ON if we bring down all 1203 * interfaces as it expects there is no rx when no interface is 1204 * running. 1205 */ 1206 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 1207 if (ret) 1208 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d ath10k_wmi_vdev_down failed (%d)\n", 1209 arvif->vdev_id, ret); 1210 1211 ath10k_wmi_flush_tx(ar); 1212 1213 arvif->def_wep_key_index = 0; 1214 } 1215 1216 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif, 1217 struct ieee80211_sta *sta) 1218 { 1219 int ret = 0; 1220 1221 lockdep_assert_held(&ar->conf_mutex); 1222 1223 ret = ath10k_peer_assoc(ar, arvif, sta, NULL); 1224 if (ret) { 1225 ath10k_warn("WMI peer assoc failed for %pM\n", sta->addr); 1226 return ret; 1227 } 1228 1229 ret = ath10k_install_peer_wep_keys(arvif, sta->addr); 1230 if (ret) { 1231 ath10k_warn("could not install peer wep keys (%d)\n", ret); 1232 return ret; 1233 } 1234 1235 return ret; 1236 } 1237 1238 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif, 1239 struct ieee80211_sta *sta) 1240 { 1241 int ret = 0; 1242 1243 lockdep_assert_held(&ar->conf_mutex); 1244 1245 ret = ath10k_clear_peer_keys(arvif, sta->addr); 1246 if (ret) { 1247 ath10k_warn("could not clear all peer wep keys (%d)\n", ret); 1248 return ret; 1249 } 1250 1251 return ret; 1252 } 1253 1254 /**************/ 1255 /* Regulatory */ 1256 /**************/ 1257 1258 static int ath10k_update_channel_list(struct ath10k *ar) 1259 { 1260 struct ieee80211_hw *hw = ar->hw; 1261 struct ieee80211_supported_band **bands; 1262 enum ieee80211_band band; 1263 struct ieee80211_channel *channel; 1264 struct wmi_scan_chan_list_arg arg = {0}; 1265 struct wmi_channel_arg *ch; 1266 bool passive; 1267 int len; 1268 int ret; 1269 int i; 1270 1271 lockdep_assert_held(&ar->conf_mutex); 1272 1273 bands = hw->wiphy->bands; 1274 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 1275 if (!bands[band]) 1276 continue; 1277 1278 for (i = 0; i < bands[band]->n_channels; i++) { 1279 if (bands[band]->channels[i].flags & 1280 IEEE80211_CHAN_DISABLED) 1281 continue; 1282 1283 arg.n_channels++; 1284 } 1285 } 1286 1287 len = sizeof(struct wmi_channel_arg) * arg.n_channels; 1288 arg.channels = kzalloc(len, GFP_KERNEL); 1289 if (!arg.channels) 1290 return -ENOMEM; 1291 1292 ch = arg.channels; 1293 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 1294 if (!bands[band]) 1295 continue; 1296 1297 for (i = 0; i < bands[band]->n_channels; i++) { 1298 channel = &bands[band]->channels[i]; 1299 1300 if (channel->flags & IEEE80211_CHAN_DISABLED) 1301 continue; 1302 1303 ch->allow_ht = true; 1304 1305 /* FIXME: when should we really allow VHT? */ 1306 ch->allow_vht = true; 1307 1308 ch->allow_ibss = 1309 !(channel->flags & IEEE80211_CHAN_NO_IBSS); 1310 1311 ch->ht40plus = 1312 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS); 1313 1314 passive = channel->flags & IEEE80211_CHAN_PASSIVE_SCAN; 1315 ch->passive = passive; 1316 1317 ch->freq = channel->center_freq; 1318 ch->min_power = channel->max_power * 3; 1319 ch->max_power = channel->max_power * 4; 1320 ch->max_reg_power = channel->max_reg_power * 4; 1321 ch->max_antenna_gain = channel->max_antenna_gain; 1322 ch->reg_class_id = 0; /* FIXME */ 1323 1324 /* FIXME: why use only legacy modes, why not any 1325 * HT/VHT modes? Would that even make any 1326 * difference? */ 1327 if (channel->band == IEEE80211_BAND_2GHZ) 1328 ch->mode = MODE_11G; 1329 else 1330 ch->mode = MODE_11A; 1331 1332 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN)) 1333 continue; 1334 1335 ath10k_dbg(ATH10K_DBG_WMI, 1336 "%s: [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n", 1337 __func__, ch - arg.channels, arg.n_channels, 1338 ch->freq, ch->max_power, ch->max_reg_power, 1339 ch->max_antenna_gain, ch->mode); 1340 1341 ch++; 1342 } 1343 } 1344 1345 ret = ath10k_wmi_scan_chan_list(ar, &arg); 1346 kfree(arg.channels); 1347 1348 return ret; 1349 } 1350 1351 static void ath10k_regd_update(struct ath10k *ar) 1352 { 1353 struct reg_dmn_pair_mapping *regpair; 1354 int ret; 1355 1356 lockdep_assert_held(&ar->conf_mutex); 1357 1358 ret = ath10k_update_channel_list(ar); 1359 if (ret) 1360 ath10k_warn("could not update channel list (%d)\n", ret); 1361 1362 regpair = ar->ath_common.regulatory.regpair; 1363 1364 /* Target allows setting up per-band regdomain but ath_common provides 1365 * a combined one only */ 1366 ret = ath10k_wmi_pdev_set_regdomain(ar, 1367 regpair->regDmnEnum, 1368 regpair->regDmnEnum, /* 2ghz */ 1369 regpair->regDmnEnum, /* 5ghz */ 1370 regpair->reg_2ghz_ctl, 1371 regpair->reg_5ghz_ctl); 1372 if (ret) 1373 ath10k_warn("could not set pdev regdomain (%d)\n", ret); 1374 } 1375 1376 static void ath10k_reg_notifier(struct wiphy *wiphy, 1377 struct regulatory_request *request) 1378 { 1379 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 1380 struct ath10k *ar = hw->priv; 1381 1382 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory); 1383 1384 mutex_lock(&ar->conf_mutex); 1385 if (ar->state == ATH10K_STATE_ON) 1386 ath10k_regd_update(ar); 1387 mutex_unlock(&ar->conf_mutex); 1388 } 1389 1390 /***************/ 1391 /* TX handlers */ 1392 /***************/ 1393 1394 /* 1395 * Frames sent to the FW have to be in "Native Wifi" format. 1396 * Strip the QoS field from the 802.11 header. 1397 */ 1398 static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw, 1399 struct ieee80211_tx_control *control, 1400 struct sk_buff *skb) 1401 { 1402 struct ieee80211_hdr *hdr = (void *)skb->data; 1403 u8 *qos_ctl; 1404 1405 if (!ieee80211_is_data_qos(hdr->frame_control)) 1406 return; 1407 1408 qos_ctl = ieee80211_get_qos_ctl(hdr); 1409 memmove(skb->data + IEEE80211_QOS_CTL_LEN, 1410 skb->data, (void *)qos_ctl - (void *)skb->data); 1411 skb_pull(skb, IEEE80211_QOS_CTL_LEN); 1412 } 1413 1414 static void ath10k_tx_h_update_wep_key(struct sk_buff *skb) 1415 { 1416 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1417 struct ieee80211_vif *vif = info->control.vif; 1418 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1419 struct ath10k *ar = arvif->ar; 1420 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1421 struct ieee80211_key_conf *key = info->control.hw_key; 1422 int ret; 1423 1424 /* TODO AP mode should be implemented */ 1425 if (vif->type != NL80211_IFTYPE_STATION) 1426 return; 1427 1428 if (!ieee80211_has_protected(hdr->frame_control)) 1429 return; 1430 1431 if (!key) 1432 return; 1433 1434 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 && 1435 key->cipher != WLAN_CIPHER_SUITE_WEP104) 1436 return; 1437 1438 if (key->keyidx == arvif->def_wep_key_index) 1439 return; 1440 1441 ath10k_dbg(ATH10K_DBG_MAC, "new wep keyidx will be %d\n", key->keyidx); 1442 1443 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 1444 WMI_VDEV_PARAM_DEF_KEYID, 1445 key->keyidx); 1446 if (ret) { 1447 ath10k_warn("could not update wep keyidx (%d)\n", ret); 1448 return; 1449 } 1450 1451 arvif->def_wep_key_index = key->keyidx; 1452 } 1453 1454 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb) 1455 { 1456 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1457 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1458 struct ieee80211_vif *vif = info->control.vif; 1459 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1460 1461 /* This is case only for P2P_GO */ 1462 if (arvif->vdev_type != WMI_VDEV_TYPE_AP || 1463 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO) 1464 return; 1465 1466 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) { 1467 spin_lock_bh(&ar->data_lock); 1468 if (arvif->u.ap.noa_data) 1469 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len, 1470 GFP_ATOMIC)) 1471 memcpy(skb_put(skb, arvif->u.ap.noa_len), 1472 arvif->u.ap.noa_data, 1473 arvif->u.ap.noa_len); 1474 spin_unlock_bh(&ar->data_lock); 1475 } 1476 } 1477 1478 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb) 1479 { 1480 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1481 int ret; 1482 1483 if (ieee80211_is_mgmt(hdr->frame_control)) 1484 ret = ath10k_htt_mgmt_tx(&ar->htt, skb); 1485 else if (ieee80211_is_nullfunc(hdr->frame_control)) 1486 /* FW does not report tx status properly for NullFunc frames 1487 * unless they are sent through mgmt tx path. mac80211 sends 1488 * those frames when it detects link/beacon loss and depends on 1489 * the tx status to be correct. */ 1490 ret = ath10k_htt_mgmt_tx(&ar->htt, skb); 1491 else 1492 ret = ath10k_htt_tx(&ar->htt, skb); 1493 1494 if (ret) { 1495 ath10k_warn("tx failed (%d). dropping packet.\n", ret); 1496 ieee80211_free_txskb(ar->hw, skb); 1497 } 1498 } 1499 1500 void ath10k_offchan_tx_purge(struct ath10k *ar) 1501 { 1502 struct sk_buff *skb; 1503 1504 for (;;) { 1505 skb = skb_dequeue(&ar->offchan_tx_queue); 1506 if (!skb) 1507 break; 1508 1509 ieee80211_free_txskb(ar->hw, skb); 1510 } 1511 } 1512 1513 void ath10k_offchan_tx_work(struct work_struct *work) 1514 { 1515 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work); 1516 struct ath10k_peer *peer; 1517 struct ieee80211_hdr *hdr; 1518 struct sk_buff *skb; 1519 const u8 *peer_addr; 1520 int vdev_id; 1521 int ret; 1522 1523 /* FW requirement: We must create a peer before FW will send out 1524 * an offchannel frame. Otherwise the frame will be stuck and 1525 * never transmitted. We delete the peer upon tx completion. 1526 * It is unlikely that a peer for offchannel tx will already be 1527 * present. However it may be in some rare cases so account for that. 1528 * Otherwise we might remove a legitimate peer and break stuff. */ 1529 1530 for (;;) { 1531 skb = skb_dequeue(&ar->offchan_tx_queue); 1532 if (!skb) 1533 break; 1534 1535 mutex_lock(&ar->conf_mutex); 1536 1537 ath10k_dbg(ATH10K_DBG_MAC, "processing offchannel skb %p\n", 1538 skb); 1539 1540 hdr = (struct ieee80211_hdr *)skb->data; 1541 peer_addr = ieee80211_get_DA(hdr); 1542 vdev_id = ATH10K_SKB_CB(skb)->htt.vdev_id; 1543 1544 spin_lock_bh(&ar->data_lock); 1545 peer = ath10k_peer_find(ar, vdev_id, peer_addr); 1546 spin_unlock_bh(&ar->data_lock); 1547 1548 if (peer) 1549 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n", 1550 peer_addr, vdev_id); 1551 1552 if (!peer) { 1553 ret = ath10k_peer_create(ar, vdev_id, peer_addr); 1554 if (ret) 1555 ath10k_warn("peer %pM on vdev %d not created (%d)\n", 1556 peer_addr, vdev_id, ret); 1557 } 1558 1559 spin_lock_bh(&ar->data_lock); 1560 INIT_COMPLETION(ar->offchan_tx_completed); 1561 ar->offchan_tx_skb = skb; 1562 spin_unlock_bh(&ar->data_lock); 1563 1564 ath10k_tx_htt(ar, skb); 1565 1566 ret = wait_for_completion_timeout(&ar->offchan_tx_completed, 1567 3 * HZ); 1568 if (ret <= 0) 1569 ath10k_warn("timed out waiting for offchannel skb %p\n", 1570 skb); 1571 1572 if (!peer) { 1573 ret = ath10k_peer_delete(ar, vdev_id, peer_addr); 1574 if (ret) 1575 ath10k_warn("peer %pM on vdev %d not deleted (%d)\n", 1576 peer_addr, vdev_id, ret); 1577 } 1578 1579 mutex_unlock(&ar->conf_mutex); 1580 } 1581 } 1582 1583 /************/ 1584 /* Scanning */ 1585 /************/ 1586 1587 /* 1588 * This gets called if we dont get a heart-beat during scan. 1589 * This may indicate the FW has hung and we need to abort the 1590 * scan manually to prevent cancel_hw_scan() from deadlocking 1591 */ 1592 void ath10k_reset_scan(unsigned long ptr) 1593 { 1594 struct ath10k *ar = (struct ath10k *)ptr; 1595 1596 spin_lock_bh(&ar->data_lock); 1597 if (!ar->scan.in_progress) { 1598 spin_unlock_bh(&ar->data_lock); 1599 return; 1600 } 1601 1602 ath10k_warn("scan timeout. resetting. fw issue?\n"); 1603 1604 if (ar->scan.is_roc) 1605 ieee80211_remain_on_channel_expired(ar->hw); 1606 else 1607 ieee80211_scan_completed(ar->hw, 1 /* aborted */); 1608 1609 ar->scan.in_progress = false; 1610 complete_all(&ar->scan.completed); 1611 spin_unlock_bh(&ar->data_lock); 1612 } 1613 1614 static int ath10k_abort_scan(struct ath10k *ar) 1615 { 1616 struct wmi_stop_scan_arg arg = { 1617 .req_id = 1, /* FIXME */ 1618 .req_type = WMI_SCAN_STOP_ONE, 1619 .u.scan_id = ATH10K_SCAN_ID, 1620 }; 1621 int ret; 1622 1623 lockdep_assert_held(&ar->conf_mutex); 1624 1625 del_timer_sync(&ar->scan.timeout); 1626 1627 spin_lock_bh(&ar->data_lock); 1628 if (!ar->scan.in_progress) { 1629 spin_unlock_bh(&ar->data_lock); 1630 return 0; 1631 } 1632 1633 ar->scan.aborting = true; 1634 spin_unlock_bh(&ar->data_lock); 1635 1636 ret = ath10k_wmi_stop_scan(ar, &arg); 1637 if (ret) { 1638 ath10k_warn("could not submit wmi stop scan (%d)\n", ret); 1639 spin_lock_bh(&ar->data_lock); 1640 ar->scan.in_progress = false; 1641 ath10k_offchan_tx_purge(ar); 1642 spin_unlock_bh(&ar->data_lock); 1643 return -EIO; 1644 } 1645 1646 ath10k_wmi_flush_tx(ar); 1647 1648 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ); 1649 if (ret == 0) 1650 ath10k_warn("timed out while waiting for scan to stop\n"); 1651 1652 /* scan completion may be done right after we timeout here, so let's 1653 * check the in_progress and tell mac80211 scan is completed. if we 1654 * don't do that and FW fails to send us scan completion indication 1655 * then userspace won't be able to scan anymore */ 1656 ret = 0; 1657 1658 spin_lock_bh(&ar->data_lock); 1659 if (ar->scan.in_progress) { 1660 ath10k_warn("could not stop scan. its still in progress\n"); 1661 ar->scan.in_progress = false; 1662 ath10k_offchan_tx_purge(ar); 1663 ret = -ETIMEDOUT; 1664 } 1665 spin_unlock_bh(&ar->data_lock); 1666 1667 return ret; 1668 } 1669 1670 static int ath10k_start_scan(struct ath10k *ar, 1671 const struct wmi_start_scan_arg *arg) 1672 { 1673 int ret; 1674 1675 lockdep_assert_held(&ar->conf_mutex); 1676 1677 ret = ath10k_wmi_start_scan(ar, arg); 1678 if (ret) 1679 return ret; 1680 1681 /* make sure we submit the command so the completion 1682 * timeout makes sense */ 1683 ath10k_wmi_flush_tx(ar); 1684 1685 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ); 1686 if (ret == 0) { 1687 ath10k_abort_scan(ar); 1688 return ret; 1689 } 1690 1691 /* the scan can complete earlier, before we even 1692 * start the timer. in that case the timer handler 1693 * checks ar->scan.in_progress and bails out if its 1694 * false. Add a 200ms margin to account event/command 1695 * processing. */ 1696 mod_timer(&ar->scan.timeout, jiffies + 1697 msecs_to_jiffies(arg->max_scan_time+200)); 1698 return 0; 1699 } 1700 1701 /**********************/ 1702 /* mac80211 callbacks */ 1703 /**********************/ 1704 1705 static void ath10k_tx(struct ieee80211_hw *hw, 1706 struct ieee80211_tx_control *control, 1707 struct sk_buff *skb) 1708 { 1709 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1710 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1711 struct ath10k *ar = hw->priv; 1712 struct ath10k_vif *arvif = NULL; 1713 u32 vdev_id = 0; 1714 u8 tid; 1715 1716 if (info->control.vif) { 1717 arvif = ath10k_vif_to_arvif(info->control.vif); 1718 vdev_id = arvif->vdev_id; 1719 } else if (ar->monitor_enabled) { 1720 vdev_id = ar->monitor_vdev_id; 1721 } 1722 1723 /* We should disable CCK RATE due to P2P */ 1724 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE) 1725 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n"); 1726 1727 /* we must calculate tid before we apply qos workaround 1728 * as we'd lose the qos control field */ 1729 tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST; 1730 if (ieee80211_is_data_qos(hdr->frame_control) && 1731 is_unicast_ether_addr(ieee80211_get_DA(hdr))) { 1732 u8 *qc = ieee80211_get_qos_ctl(hdr); 1733 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK; 1734 } 1735 1736 /* it makes no sense to process injected frames like that */ 1737 if (info->control.vif && 1738 info->control.vif->type != NL80211_IFTYPE_MONITOR) { 1739 ath10k_tx_h_qos_workaround(hw, control, skb); 1740 ath10k_tx_h_update_wep_key(skb); 1741 ath10k_tx_h_add_p2p_noa_ie(ar, skb); 1742 ath10k_tx_h_seq_no(skb); 1743 } 1744 1745 memset(ATH10K_SKB_CB(skb), 0, sizeof(*ATH10K_SKB_CB(skb))); 1746 ATH10K_SKB_CB(skb)->htt.vdev_id = vdev_id; 1747 ATH10K_SKB_CB(skb)->htt.tid = tid; 1748 1749 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) { 1750 spin_lock_bh(&ar->data_lock); 1751 ATH10K_SKB_CB(skb)->htt.is_offchan = true; 1752 ATH10K_SKB_CB(skb)->htt.vdev_id = ar->scan.vdev_id; 1753 spin_unlock_bh(&ar->data_lock); 1754 1755 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb); 1756 1757 skb_queue_tail(&ar->offchan_tx_queue, skb); 1758 ieee80211_queue_work(hw, &ar->offchan_tx_work); 1759 return; 1760 } 1761 1762 ath10k_tx_htt(ar, skb); 1763 } 1764 1765 /* 1766 * Initialize various parameters with default vaules. 1767 */ 1768 void ath10k_halt(struct ath10k *ar) 1769 { 1770 lockdep_assert_held(&ar->conf_mutex); 1771 1772 del_timer_sync(&ar->scan.timeout); 1773 ath10k_offchan_tx_purge(ar); 1774 ath10k_peer_cleanup_all(ar); 1775 ath10k_core_stop(ar); 1776 ath10k_hif_power_down(ar); 1777 1778 spin_lock_bh(&ar->data_lock); 1779 if (ar->scan.in_progress) { 1780 del_timer(&ar->scan.timeout); 1781 ar->scan.in_progress = false; 1782 ieee80211_scan_completed(ar->hw, true); 1783 } 1784 spin_unlock_bh(&ar->data_lock); 1785 } 1786 1787 static int ath10k_start(struct ieee80211_hw *hw) 1788 { 1789 struct ath10k *ar = hw->priv; 1790 int ret = 0; 1791 1792 mutex_lock(&ar->conf_mutex); 1793 1794 if (ar->state != ATH10K_STATE_OFF && 1795 ar->state != ATH10K_STATE_RESTARTING) { 1796 ret = -EINVAL; 1797 goto exit; 1798 } 1799 1800 ret = ath10k_hif_power_up(ar); 1801 if (ret) { 1802 ath10k_err("could not init hif (%d)\n", ret); 1803 ar->state = ATH10K_STATE_OFF; 1804 goto exit; 1805 } 1806 1807 ret = ath10k_core_start(ar); 1808 if (ret) { 1809 ath10k_err("could not init core (%d)\n", ret); 1810 ath10k_hif_power_down(ar); 1811 ar->state = ATH10K_STATE_OFF; 1812 goto exit; 1813 } 1814 1815 if (ar->state == ATH10K_STATE_OFF) 1816 ar->state = ATH10K_STATE_ON; 1817 else if (ar->state == ATH10K_STATE_RESTARTING) 1818 ar->state = ATH10K_STATE_RESTARTED; 1819 1820 ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 1); 1821 if (ret) 1822 ath10k_warn("could not enable WMI_PDEV_PARAM_PMF_QOS (%d)\n", 1823 ret); 1824 1825 ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 0); 1826 if (ret) 1827 ath10k_warn("could not init WMI_PDEV_PARAM_DYNAMIC_BW (%d)\n", 1828 ret); 1829 1830 ath10k_regd_update(ar); 1831 1832 exit: 1833 mutex_unlock(&ar->conf_mutex); 1834 return 0; 1835 } 1836 1837 static void ath10k_stop(struct ieee80211_hw *hw) 1838 { 1839 struct ath10k *ar = hw->priv; 1840 1841 mutex_lock(&ar->conf_mutex); 1842 if (ar->state == ATH10K_STATE_ON || 1843 ar->state == ATH10K_STATE_RESTARTED || 1844 ar->state == ATH10K_STATE_WEDGED) 1845 ath10k_halt(ar); 1846 1847 ar->state = ATH10K_STATE_OFF; 1848 mutex_unlock(&ar->conf_mutex); 1849 1850 cancel_work_sync(&ar->offchan_tx_work); 1851 cancel_work_sync(&ar->restart_work); 1852 } 1853 1854 static void ath10k_config_ps(struct ath10k *ar) 1855 { 1856 struct ath10k_generic_iter ar_iter; 1857 1858 lockdep_assert_held(&ar->conf_mutex); 1859 1860 /* During HW reconfiguration mac80211 reports all interfaces that were 1861 * running until reconfiguration was started. Since FW doesn't have any 1862 * vdevs at this point we must not iterate over this interface list. 1863 * This setting will be updated upon add_interface(). */ 1864 if (ar->state == ATH10K_STATE_RESTARTED) 1865 return; 1866 1867 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter)); 1868 ar_iter.ar = ar; 1869 1870 ieee80211_iterate_active_interfaces_atomic( 1871 ar->hw, IEEE80211_IFACE_ITER_NORMAL, 1872 ath10k_ps_iter, &ar_iter); 1873 1874 if (ar_iter.ret) 1875 ath10k_warn("failed to set ps config (%d)\n", ar_iter.ret); 1876 } 1877 1878 static int ath10k_config(struct ieee80211_hw *hw, u32 changed) 1879 { 1880 struct ath10k *ar = hw->priv; 1881 struct ieee80211_conf *conf = &hw->conf; 1882 int ret = 0; 1883 1884 mutex_lock(&ar->conf_mutex); 1885 1886 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 1887 ath10k_dbg(ATH10K_DBG_MAC, "Config channel %d mhz\n", 1888 conf->chandef.chan->center_freq); 1889 spin_lock_bh(&ar->data_lock); 1890 ar->rx_channel = conf->chandef.chan; 1891 spin_unlock_bh(&ar->data_lock); 1892 } 1893 1894 if (changed & IEEE80211_CONF_CHANGE_PS) 1895 ath10k_config_ps(ar); 1896 1897 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 1898 if (conf->flags & IEEE80211_CONF_MONITOR) 1899 ret = ath10k_monitor_create(ar); 1900 else 1901 ret = ath10k_monitor_destroy(ar); 1902 } 1903 1904 ath10k_wmi_flush_tx(ar); 1905 mutex_unlock(&ar->conf_mutex); 1906 return ret; 1907 } 1908 1909 /* 1910 * TODO: 1911 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE, 1912 * because we will send mgmt frames without CCK. This requirement 1913 * for P2P_FIND/GO_NEG should be handled by checking CCK flag 1914 * in the TX packet. 1915 */ 1916 static int ath10k_add_interface(struct ieee80211_hw *hw, 1917 struct ieee80211_vif *vif) 1918 { 1919 struct ath10k *ar = hw->priv; 1920 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1921 enum wmi_sta_powersave_param param; 1922 int ret = 0; 1923 u32 value; 1924 int bit; 1925 1926 mutex_lock(&ar->conf_mutex); 1927 1928 memset(arvif, 0, sizeof(*arvif)); 1929 1930 arvif->ar = ar; 1931 arvif->vif = vif; 1932 1933 if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) { 1934 ath10k_warn("Only one monitor interface allowed\n"); 1935 ret = -EBUSY; 1936 goto exit; 1937 } 1938 1939 bit = ffs(ar->free_vdev_map); 1940 if (bit == 0) { 1941 ret = -EBUSY; 1942 goto exit; 1943 } 1944 1945 arvif->vdev_id = bit - 1; 1946 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 1947 ar->free_vdev_map &= ~(1 << arvif->vdev_id); 1948 1949 if (ar->p2p) 1950 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE; 1951 1952 switch (vif->type) { 1953 case NL80211_IFTYPE_UNSPECIFIED: 1954 case NL80211_IFTYPE_STATION: 1955 arvif->vdev_type = WMI_VDEV_TYPE_STA; 1956 if (vif->p2p) 1957 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT; 1958 break; 1959 case NL80211_IFTYPE_ADHOC: 1960 arvif->vdev_type = WMI_VDEV_TYPE_IBSS; 1961 break; 1962 case NL80211_IFTYPE_AP: 1963 arvif->vdev_type = WMI_VDEV_TYPE_AP; 1964 1965 if (vif->p2p) 1966 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO; 1967 break; 1968 case NL80211_IFTYPE_MONITOR: 1969 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 1970 break; 1971 default: 1972 WARN_ON(1); 1973 break; 1974 } 1975 1976 ath10k_dbg(ATH10K_DBG_MAC, "Add interface: id %d type %d subtype %d\n", 1977 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype); 1978 1979 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type, 1980 arvif->vdev_subtype, vif->addr); 1981 if (ret) { 1982 ath10k_warn("WMI vdev create failed: ret %d\n", ret); 1983 goto exit; 1984 } 1985 1986 ret = ath10k_wmi_vdev_set_param(ar, 0, WMI_VDEV_PARAM_DEF_KEYID, 1987 arvif->def_wep_key_index); 1988 if (ret) 1989 ath10k_warn("Failed to set default keyid: %d\n", ret); 1990 1991 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 1992 WMI_VDEV_PARAM_TX_ENCAP_TYPE, 1993 ATH10K_HW_TXRX_NATIVE_WIFI); 1994 if (ret) 1995 ath10k_warn("Failed to set TX encap: %d\n", ret); 1996 1997 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 1998 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr); 1999 if (ret) { 2000 ath10k_warn("Failed to create peer for AP: %d\n", ret); 2001 goto exit; 2002 } 2003 } 2004 2005 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) { 2006 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 2007 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 2008 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2009 param, value); 2010 if (ret) 2011 ath10k_warn("Failed to set RX wake policy: %d\n", ret); 2012 2013 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 2014 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 2015 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2016 param, value); 2017 if (ret) 2018 ath10k_warn("Failed to set TX wake thresh: %d\n", ret); 2019 2020 param = WMI_STA_PS_PARAM_PSPOLL_COUNT; 2021 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 2022 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2023 param, value); 2024 if (ret) 2025 ath10k_warn("Failed to set PSPOLL count: %d\n", ret); 2026 } 2027 2028 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold); 2029 if (ret) 2030 ath10k_warn("failed to set rts threshold for vdev %d (%d)\n", 2031 arvif->vdev_id, ret); 2032 2033 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold); 2034 if (ret) 2035 ath10k_warn("failed to set frag threshold for vdev %d (%d)\n", 2036 arvif->vdev_id, ret); 2037 2038 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 2039 ar->monitor_present = true; 2040 2041 exit: 2042 mutex_unlock(&ar->conf_mutex); 2043 return ret; 2044 } 2045 2046 static void ath10k_remove_interface(struct ieee80211_hw *hw, 2047 struct ieee80211_vif *vif) 2048 { 2049 struct ath10k *ar = hw->priv; 2050 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2051 int ret; 2052 2053 mutex_lock(&ar->conf_mutex); 2054 2055 ath10k_dbg(ATH10K_DBG_MAC, "Remove interface: id %d\n", arvif->vdev_id); 2056 2057 ar->free_vdev_map |= 1 << (arvif->vdev_id); 2058 2059 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 2060 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr); 2061 if (ret) 2062 ath10k_warn("Failed to remove peer for AP: %d\n", ret); 2063 2064 kfree(arvif->u.ap.noa_data); 2065 } 2066 2067 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 2068 if (ret) 2069 ath10k_warn("WMI vdev delete failed: %d\n", ret); 2070 2071 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 2072 ar->monitor_present = false; 2073 2074 ath10k_peer_cleanup(ar, arvif->vdev_id); 2075 2076 mutex_unlock(&ar->conf_mutex); 2077 } 2078 2079 /* 2080 * FIXME: Has to be verified. 2081 */ 2082 #define SUPPORTED_FILTERS \ 2083 (FIF_PROMISC_IN_BSS | \ 2084 FIF_ALLMULTI | \ 2085 FIF_CONTROL | \ 2086 FIF_PSPOLL | \ 2087 FIF_OTHER_BSS | \ 2088 FIF_BCN_PRBRESP_PROMISC | \ 2089 FIF_PROBE_REQ | \ 2090 FIF_FCSFAIL) 2091 2092 static void ath10k_configure_filter(struct ieee80211_hw *hw, 2093 unsigned int changed_flags, 2094 unsigned int *total_flags, 2095 u64 multicast) 2096 { 2097 struct ath10k *ar = hw->priv; 2098 int ret; 2099 2100 mutex_lock(&ar->conf_mutex); 2101 2102 changed_flags &= SUPPORTED_FILTERS; 2103 *total_flags &= SUPPORTED_FILTERS; 2104 ar->filter_flags = *total_flags; 2105 2106 if ((ar->filter_flags & FIF_PROMISC_IN_BSS) && 2107 !ar->monitor_enabled) { 2108 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id); 2109 if (ret) 2110 ath10k_warn("Unable to start monitor mode\n"); 2111 else 2112 ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode started\n"); 2113 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) && 2114 ar->monitor_enabled) { 2115 ret = ath10k_monitor_stop(ar); 2116 if (ret) 2117 ath10k_warn("Unable to stop monitor mode\n"); 2118 else 2119 ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode stopped\n"); 2120 } 2121 2122 mutex_unlock(&ar->conf_mutex); 2123 } 2124 2125 static void ath10k_bss_info_changed(struct ieee80211_hw *hw, 2126 struct ieee80211_vif *vif, 2127 struct ieee80211_bss_conf *info, 2128 u32 changed) 2129 { 2130 struct ath10k *ar = hw->priv; 2131 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2132 int ret = 0; 2133 2134 mutex_lock(&ar->conf_mutex); 2135 2136 if (changed & BSS_CHANGED_IBSS) 2137 ath10k_control_ibss(arvif, info, vif->addr); 2138 2139 if (changed & BSS_CHANGED_BEACON_INT) { 2140 arvif->beacon_interval = info->beacon_int; 2141 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 2142 WMI_VDEV_PARAM_BEACON_INTERVAL, 2143 arvif->beacon_interval); 2144 if (ret) 2145 ath10k_warn("Failed to set beacon interval for VDEV: %d\n", 2146 arvif->vdev_id); 2147 else 2148 ath10k_dbg(ATH10K_DBG_MAC, 2149 "Beacon interval: %d set for VDEV: %d\n", 2150 arvif->beacon_interval, arvif->vdev_id); 2151 } 2152 2153 if (changed & BSS_CHANGED_BEACON) { 2154 ret = ath10k_wmi_pdev_set_param(ar, 2155 WMI_PDEV_PARAM_BEACON_TX_MODE, 2156 WMI_BEACON_STAGGERED_MODE); 2157 if (ret) 2158 ath10k_warn("Failed to set beacon mode for VDEV: %d\n", 2159 arvif->vdev_id); 2160 else 2161 ath10k_dbg(ATH10K_DBG_MAC, 2162 "Set staggered beacon mode for VDEV: %d\n", 2163 arvif->vdev_id); 2164 } 2165 2166 if (changed & BSS_CHANGED_BEACON_INFO) { 2167 arvif->dtim_period = info->dtim_period; 2168 2169 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 2170 WMI_VDEV_PARAM_DTIM_PERIOD, 2171 arvif->dtim_period); 2172 if (ret) 2173 ath10k_warn("Failed to set dtim period for VDEV: %d\n", 2174 arvif->vdev_id); 2175 else 2176 ath10k_dbg(ATH10K_DBG_MAC, 2177 "Set dtim period: %d for VDEV: %d\n", 2178 arvif->dtim_period, arvif->vdev_id); 2179 } 2180 2181 if (changed & BSS_CHANGED_SSID && 2182 vif->type == NL80211_IFTYPE_AP) { 2183 arvif->u.ap.ssid_len = info->ssid_len; 2184 if (info->ssid_len) 2185 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len); 2186 arvif->u.ap.hidden_ssid = info->hidden_ssid; 2187 } 2188 2189 if (changed & BSS_CHANGED_BSSID) { 2190 if (!is_zero_ether_addr(info->bssid)) { 2191 ret = ath10k_peer_create(ar, arvif->vdev_id, 2192 info->bssid); 2193 if (ret) 2194 ath10k_warn("Failed to add peer: %pM for VDEV: %d\n", 2195 info->bssid, arvif->vdev_id); 2196 else 2197 ath10k_dbg(ATH10K_DBG_MAC, 2198 "Added peer: %pM for VDEV: %d\n", 2199 info->bssid, arvif->vdev_id); 2200 2201 2202 if (vif->type == NL80211_IFTYPE_STATION) { 2203 /* 2204 * this is never erased as we it for crypto key 2205 * clearing; this is FW requirement 2206 */ 2207 memcpy(arvif->u.sta.bssid, info->bssid, 2208 ETH_ALEN); 2209 2210 ret = ath10k_vdev_start(arvif); 2211 if (!ret) 2212 ath10k_dbg(ATH10K_DBG_MAC, 2213 "VDEV: %d started with BSSID: %pM\n", 2214 arvif->vdev_id, info->bssid); 2215 } 2216 2217 /* 2218 * Mac80211 does not keep IBSS bssid when leaving IBSS, 2219 * so driver need to store it. It is needed when leaving 2220 * IBSS in order to remove BSSID peer. 2221 */ 2222 if (vif->type == NL80211_IFTYPE_ADHOC) 2223 memcpy(arvif->u.ibss.bssid, info->bssid, 2224 ETH_ALEN); 2225 } 2226 } 2227 2228 if (changed & BSS_CHANGED_BEACON_ENABLED) 2229 ath10k_control_beaconing(arvif, info); 2230 2231 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 2232 u32 cts_prot; 2233 if (info->use_cts_prot) 2234 cts_prot = 1; 2235 else 2236 cts_prot = 0; 2237 2238 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 2239 WMI_VDEV_PARAM_ENABLE_RTSCTS, 2240 cts_prot); 2241 if (ret) 2242 ath10k_warn("Failed to set CTS prot for VDEV: %d\n", 2243 arvif->vdev_id); 2244 else 2245 ath10k_dbg(ATH10K_DBG_MAC, 2246 "Set CTS prot: %d for VDEV: %d\n", 2247 cts_prot, arvif->vdev_id); 2248 } 2249 2250 if (changed & BSS_CHANGED_ERP_SLOT) { 2251 u32 slottime; 2252 if (info->use_short_slot) 2253 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 2254 2255 else 2256 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 2257 2258 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 2259 WMI_VDEV_PARAM_SLOT_TIME, 2260 slottime); 2261 if (ret) 2262 ath10k_warn("Failed to set erp slot for VDEV: %d\n", 2263 arvif->vdev_id); 2264 else 2265 ath10k_dbg(ATH10K_DBG_MAC, 2266 "Set slottime: %d for VDEV: %d\n", 2267 slottime, arvif->vdev_id); 2268 } 2269 2270 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 2271 u32 preamble; 2272 if (info->use_short_preamble) 2273 preamble = WMI_VDEV_PREAMBLE_SHORT; 2274 else 2275 preamble = WMI_VDEV_PREAMBLE_LONG; 2276 2277 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 2278 WMI_VDEV_PARAM_PREAMBLE, 2279 preamble); 2280 if (ret) 2281 ath10k_warn("Failed to set preamble for VDEV: %d\n", 2282 arvif->vdev_id); 2283 else 2284 ath10k_dbg(ATH10K_DBG_MAC, 2285 "Set preamble: %d for VDEV: %d\n", 2286 preamble, arvif->vdev_id); 2287 } 2288 2289 if (changed & BSS_CHANGED_ASSOC) { 2290 if (info->assoc) 2291 ath10k_bss_assoc(hw, vif, info); 2292 } 2293 2294 mutex_unlock(&ar->conf_mutex); 2295 } 2296 2297 static int ath10k_hw_scan(struct ieee80211_hw *hw, 2298 struct ieee80211_vif *vif, 2299 struct cfg80211_scan_request *req) 2300 { 2301 struct ath10k *ar = hw->priv; 2302 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2303 struct wmi_start_scan_arg arg; 2304 int ret = 0; 2305 int i; 2306 2307 mutex_lock(&ar->conf_mutex); 2308 2309 spin_lock_bh(&ar->data_lock); 2310 if (ar->scan.in_progress) { 2311 spin_unlock_bh(&ar->data_lock); 2312 ret = -EBUSY; 2313 goto exit; 2314 } 2315 2316 INIT_COMPLETION(ar->scan.started); 2317 INIT_COMPLETION(ar->scan.completed); 2318 ar->scan.in_progress = true; 2319 ar->scan.aborting = false; 2320 ar->scan.is_roc = false; 2321 ar->scan.vdev_id = arvif->vdev_id; 2322 spin_unlock_bh(&ar->data_lock); 2323 2324 memset(&arg, 0, sizeof(arg)); 2325 ath10k_wmi_start_scan_init(ar, &arg); 2326 arg.vdev_id = arvif->vdev_id; 2327 arg.scan_id = ATH10K_SCAN_ID; 2328 2329 if (!req->no_cck) 2330 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES; 2331 2332 if (req->ie_len) { 2333 arg.ie_len = req->ie_len; 2334 memcpy(arg.ie, req->ie, arg.ie_len); 2335 } 2336 2337 if (req->n_ssids) { 2338 arg.n_ssids = req->n_ssids; 2339 for (i = 0; i < arg.n_ssids; i++) { 2340 arg.ssids[i].len = req->ssids[i].ssid_len; 2341 arg.ssids[i].ssid = req->ssids[i].ssid; 2342 } 2343 } else { 2344 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 2345 } 2346 2347 if (req->n_channels) { 2348 arg.n_channels = req->n_channels; 2349 for (i = 0; i < arg.n_channels; i++) 2350 arg.channels[i] = req->channels[i]->center_freq; 2351 } 2352 2353 ret = ath10k_start_scan(ar, &arg); 2354 if (ret) { 2355 ath10k_warn("could not start hw scan (%d)\n", ret); 2356 spin_lock_bh(&ar->data_lock); 2357 ar->scan.in_progress = false; 2358 spin_unlock_bh(&ar->data_lock); 2359 } 2360 2361 exit: 2362 mutex_unlock(&ar->conf_mutex); 2363 return ret; 2364 } 2365 2366 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw, 2367 struct ieee80211_vif *vif) 2368 { 2369 struct ath10k *ar = hw->priv; 2370 int ret; 2371 2372 mutex_lock(&ar->conf_mutex); 2373 ret = ath10k_abort_scan(ar); 2374 if (ret) { 2375 ath10k_warn("couldn't abort scan (%d). forcefully sending scan completion to mac80211\n", 2376 ret); 2377 ieee80211_scan_completed(hw, 1 /* aborted */); 2378 } 2379 mutex_unlock(&ar->conf_mutex); 2380 } 2381 2382 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 2383 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 2384 struct ieee80211_key_conf *key) 2385 { 2386 struct ath10k *ar = hw->priv; 2387 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2388 struct ath10k_peer *peer; 2389 const u8 *peer_addr; 2390 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 || 2391 key->cipher == WLAN_CIPHER_SUITE_WEP104; 2392 int ret = 0; 2393 2394 if (key->keyidx > WMI_MAX_KEY_INDEX) 2395 return -ENOSPC; 2396 2397 mutex_lock(&ar->conf_mutex); 2398 2399 if (sta) 2400 peer_addr = sta->addr; 2401 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 2402 peer_addr = vif->bss_conf.bssid; 2403 else 2404 peer_addr = vif->addr; 2405 2406 key->hw_key_idx = key->keyidx; 2407 2408 /* the peer should not disappear in mid-way (unless FW goes awry) since 2409 * we already hold conf_mutex. we just make sure its there now. */ 2410 spin_lock_bh(&ar->data_lock); 2411 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 2412 spin_unlock_bh(&ar->data_lock); 2413 2414 if (!peer) { 2415 if (cmd == SET_KEY) { 2416 ath10k_warn("cannot install key for non-existent peer %pM\n", 2417 peer_addr); 2418 ret = -EOPNOTSUPP; 2419 goto exit; 2420 } else { 2421 /* if the peer doesn't exist there is no key to disable 2422 * anymore */ 2423 goto exit; 2424 } 2425 } 2426 2427 if (is_wep) { 2428 if (cmd == SET_KEY) 2429 arvif->wep_keys[key->keyidx] = key; 2430 else 2431 arvif->wep_keys[key->keyidx] = NULL; 2432 2433 if (cmd == DISABLE_KEY) 2434 ath10k_clear_vdev_key(arvif, key); 2435 } 2436 2437 ret = ath10k_install_key(arvif, key, cmd, peer_addr); 2438 if (ret) { 2439 ath10k_warn("ath10k_install_key failed (%d)\n", ret); 2440 goto exit; 2441 } 2442 2443 spin_lock_bh(&ar->data_lock); 2444 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 2445 if (peer && cmd == SET_KEY) 2446 peer->keys[key->keyidx] = key; 2447 else if (peer && cmd == DISABLE_KEY) 2448 peer->keys[key->keyidx] = NULL; 2449 else if (peer == NULL) 2450 /* impossible unless FW goes crazy */ 2451 ath10k_warn("peer %pM disappeared!\n", peer_addr); 2452 spin_unlock_bh(&ar->data_lock); 2453 2454 exit: 2455 mutex_unlock(&ar->conf_mutex); 2456 return ret; 2457 } 2458 2459 static int ath10k_sta_state(struct ieee80211_hw *hw, 2460 struct ieee80211_vif *vif, 2461 struct ieee80211_sta *sta, 2462 enum ieee80211_sta_state old_state, 2463 enum ieee80211_sta_state new_state) 2464 { 2465 struct ath10k *ar = hw->priv; 2466 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2467 int ret = 0; 2468 2469 mutex_lock(&ar->conf_mutex); 2470 2471 if (old_state == IEEE80211_STA_NOTEXIST && 2472 new_state == IEEE80211_STA_NONE && 2473 vif->type != NL80211_IFTYPE_STATION) { 2474 /* 2475 * New station addition. 2476 */ 2477 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr); 2478 if (ret) 2479 ath10k_warn("Failed to add peer: %pM for VDEV: %d\n", 2480 sta->addr, arvif->vdev_id); 2481 else 2482 ath10k_dbg(ATH10K_DBG_MAC, 2483 "Added peer: %pM for VDEV: %d\n", 2484 sta->addr, arvif->vdev_id); 2485 } else if ((old_state == IEEE80211_STA_NONE && 2486 new_state == IEEE80211_STA_NOTEXIST)) { 2487 /* 2488 * Existing station deletion. 2489 */ 2490 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 2491 if (ret) 2492 ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n", 2493 sta->addr, arvif->vdev_id); 2494 else 2495 ath10k_dbg(ATH10K_DBG_MAC, 2496 "Removed peer: %pM for VDEV: %d\n", 2497 sta->addr, arvif->vdev_id); 2498 2499 if (vif->type == NL80211_IFTYPE_STATION) 2500 ath10k_bss_disassoc(hw, vif); 2501 } else if (old_state == IEEE80211_STA_AUTH && 2502 new_state == IEEE80211_STA_ASSOC && 2503 (vif->type == NL80211_IFTYPE_AP || 2504 vif->type == NL80211_IFTYPE_ADHOC)) { 2505 /* 2506 * New association. 2507 */ 2508 ret = ath10k_station_assoc(ar, arvif, sta); 2509 if (ret) 2510 ath10k_warn("Failed to associate station: %pM\n", 2511 sta->addr); 2512 else 2513 ath10k_dbg(ATH10K_DBG_MAC, 2514 "Station %pM moved to assoc state\n", 2515 sta->addr); 2516 } else if (old_state == IEEE80211_STA_ASSOC && 2517 new_state == IEEE80211_STA_AUTH && 2518 (vif->type == NL80211_IFTYPE_AP || 2519 vif->type == NL80211_IFTYPE_ADHOC)) { 2520 /* 2521 * Disassociation. 2522 */ 2523 ret = ath10k_station_disassoc(ar, arvif, sta); 2524 if (ret) 2525 ath10k_warn("Failed to disassociate station: %pM\n", 2526 sta->addr); 2527 else 2528 ath10k_dbg(ATH10K_DBG_MAC, 2529 "Station %pM moved to disassociated state\n", 2530 sta->addr); 2531 } 2532 2533 mutex_unlock(&ar->conf_mutex); 2534 return ret; 2535 } 2536 2537 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif, 2538 u16 ac, bool enable) 2539 { 2540 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2541 u32 value = 0; 2542 int ret = 0; 2543 2544 lockdep_assert_held(&ar->conf_mutex); 2545 2546 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 2547 return 0; 2548 2549 switch (ac) { 2550 case IEEE80211_AC_VO: 2551 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 2552 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 2553 break; 2554 case IEEE80211_AC_VI: 2555 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 2556 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 2557 break; 2558 case IEEE80211_AC_BE: 2559 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 2560 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 2561 break; 2562 case IEEE80211_AC_BK: 2563 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 2564 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 2565 break; 2566 } 2567 2568 if (enable) 2569 arvif->u.sta.uapsd |= value; 2570 else 2571 arvif->u.sta.uapsd &= ~value; 2572 2573 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2574 WMI_STA_PS_PARAM_UAPSD, 2575 arvif->u.sta.uapsd); 2576 if (ret) { 2577 ath10k_warn("could not set uapsd params %d\n", ret); 2578 goto exit; 2579 } 2580 2581 if (arvif->u.sta.uapsd) 2582 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 2583 else 2584 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 2585 2586 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2587 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 2588 value); 2589 if (ret) 2590 ath10k_warn("could not set rx wake param %d\n", ret); 2591 2592 exit: 2593 return ret; 2594 } 2595 2596 static int ath10k_conf_tx(struct ieee80211_hw *hw, 2597 struct ieee80211_vif *vif, u16 ac, 2598 const struct ieee80211_tx_queue_params *params) 2599 { 2600 struct ath10k *ar = hw->priv; 2601 struct wmi_wmm_params_arg *p = NULL; 2602 int ret; 2603 2604 mutex_lock(&ar->conf_mutex); 2605 2606 switch (ac) { 2607 case IEEE80211_AC_VO: 2608 p = &ar->wmm_params.ac_vo; 2609 break; 2610 case IEEE80211_AC_VI: 2611 p = &ar->wmm_params.ac_vi; 2612 break; 2613 case IEEE80211_AC_BE: 2614 p = &ar->wmm_params.ac_be; 2615 break; 2616 case IEEE80211_AC_BK: 2617 p = &ar->wmm_params.ac_bk; 2618 break; 2619 } 2620 2621 if (WARN_ON(!p)) { 2622 ret = -EINVAL; 2623 goto exit; 2624 } 2625 2626 p->cwmin = params->cw_min; 2627 p->cwmax = params->cw_max; 2628 p->aifs = params->aifs; 2629 2630 /* 2631 * The channel time duration programmed in the HW is in absolute 2632 * microseconds, while mac80211 gives the txop in units of 2633 * 32 microseconds. 2634 */ 2635 p->txop = params->txop * 32; 2636 2637 /* FIXME: FW accepts wmm params per hw, not per vif */ 2638 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params); 2639 if (ret) { 2640 ath10k_warn("could not set wmm params %d\n", ret); 2641 goto exit; 2642 } 2643 2644 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 2645 if (ret) 2646 ath10k_warn("could not set sta uapsd %d\n", ret); 2647 2648 exit: 2649 mutex_unlock(&ar->conf_mutex); 2650 return ret; 2651 } 2652 2653 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ) 2654 2655 static int ath10k_remain_on_channel(struct ieee80211_hw *hw, 2656 struct ieee80211_vif *vif, 2657 struct ieee80211_channel *chan, 2658 int duration, 2659 enum ieee80211_roc_type type) 2660 { 2661 struct ath10k *ar = hw->priv; 2662 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2663 struct wmi_start_scan_arg arg; 2664 int ret; 2665 2666 mutex_lock(&ar->conf_mutex); 2667 2668 spin_lock_bh(&ar->data_lock); 2669 if (ar->scan.in_progress) { 2670 spin_unlock_bh(&ar->data_lock); 2671 ret = -EBUSY; 2672 goto exit; 2673 } 2674 2675 INIT_COMPLETION(ar->scan.started); 2676 INIT_COMPLETION(ar->scan.completed); 2677 INIT_COMPLETION(ar->scan.on_channel); 2678 ar->scan.in_progress = true; 2679 ar->scan.aborting = false; 2680 ar->scan.is_roc = true; 2681 ar->scan.vdev_id = arvif->vdev_id; 2682 ar->scan.roc_freq = chan->center_freq; 2683 spin_unlock_bh(&ar->data_lock); 2684 2685 memset(&arg, 0, sizeof(arg)); 2686 ath10k_wmi_start_scan_init(ar, &arg); 2687 arg.vdev_id = arvif->vdev_id; 2688 arg.scan_id = ATH10K_SCAN_ID; 2689 arg.n_channels = 1; 2690 arg.channels[0] = chan->center_freq; 2691 arg.dwell_time_active = duration; 2692 arg.dwell_time_passive = duration; 2693 arg.max_scan_time = 2 * duration; 2694 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 2695 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ; 2696 2697 ret = ath10k_start_scan(ar, &arg); 2698 if (ret) { 2699 ath10k_warn("could not start roc scan (%d)\n", ret); 2700 spin_lock_bh(&ar->data_lock); 2701 ar->scan.in_progress = false; 2702 spin_unlock_bh(&ar->data_lock); 2703 goto exit; 2704 } 2705 2706 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ); 2707 if (ret == 0) { 2708 ath10k_warn("could not switch to channel for roc scan\n"); 2709 ath10k_abort_scan(ar); 2710 ret = -ETIMEDOUT; 2711 goto exit; 2712 } 2713 2714 ret = 0; 2715 exit: 2716 mutex_unlock(&ar->conf_mutex); 2717 return ret; 2718 } 2719 2720 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw) 2721 { 2722 struct ath10k *ar = hw->priv; 2723 2724 mutex_lock(&ar->conf_mutex); 2725 ath10k_abort_scan(ar); 2726 mutex_unlock(&ar->conf_mutex); 2727 2728 return 0; 2729 } 2730 2731 /* 2732 * Both RTS and Fragmentation threshold are interface-specific 2733 * in ath10k, but device-specific in mac80211. 2734 */ 2735 static void ath10k_set_rts_iter(void *data, u8 *mac, struct ieee80211_vif *vif) 2736 { 2737 struct ath10k_generic_iter *ar_iter = data; 2738 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2739 u32 rts = ar_iter->ar->hw->wiphy->rts_threshold; 2740 2741 lockdep_assert_held(&arvif->ar->conf_mutex); 2742 2743 /* During HW reconfiguration mac80211 reports all interfaces that were 2744 * running until reconfiguration was started. Since FW doesn't have any 2745 * vdevs at this point we must not iterate over this interface list. 2746 * This setting will be updated upon add_interface(). */ 2747 if (ar_iter->ar->state == ATH10K_STATE_RESTARTED) 2748 return; 2749 2750 ar_iter->ret = ath10k_mac_set_rts(arvif, rts); 2751 if (ar_iter->ret) 2752 ath10k_warn("Failed to set RTS threshold for VDEV: %d\n", 2753 arvif->vdev_id); 2754 else 2755 ath10k_dbg(ATH10K_DBG_MAC, 2756 "Set RTS threshold: %d for VDEV: %d\n", 2757 rts, arvif->vdev_id); 2758 } 2759 2760 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 2761 { 2762 struct ath10k_generic_iter ar_iter; 2763 struct ath10k *ar = hw->priv; 2764 2765 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter)); 2766 ar_iter.ar = ar; 2767 2768 mutex_lock(&ar->conf_mutex); 2769 ieee80211_iterate_active_interfaces_atomic( 2770 hw, IEEE80211_IFACE_ITER_NORMAL, 2771 ath10k_set_rts_iter, &ar_iter); 2772 mutex_unlock(&ar->conf_mutex); 2773 2774 return ar_iter.ret; 2775 } 2776 2777 static void ath10k_set_frag_iter(void *data, u8 *mac, struct ieee80211_vif *vif) 2778 { 2779 struct ath10k_generic_iter *ar_iter = data; 2780 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2781 u32 frag = ar_iter->ar->hw->wiphy->frag_threshold; 2782 2783 lockdep_assert_held(&arvif->ar->conf_mutex); 2784 2785 /* During HW reconfiguration mac80211 reports all interfaces that were 2786 * running until reconfiguration was started. Since FW doesn't have any 2787 * vdevs at this point we must not iterate over this interface list. 2788 * This setting will be updated upon add_interface(). */ 2789 if (ar_iter->ar->state == ATH10K_STATE_RESTARTED) 2790 return; 2791 2792 ar_iter->ret = ath10k_mac_set_frag(arvif, frag); 2793 if (ar_iter->ret) 2794 ath10k_warn("Failed to set frag threshold for VDEV: %d\n", 2795 arvif->vdev_id); 2796 else 2797 ath10k_dbg(ATH10K_DBG_MAC, 2798 "Set frag threshold: %d for VDEV: %d\n", 2799 frag, arvif->vdev_id); 2800 } 2801 2802 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 2803 { 2804 struct ath10k_generic_iter ar_iter; 2805 struct ath10k *ar = hw->priv; 2806 2807 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter)); 2808 ar_iter.ar = ar; 2809 2810 mutex_lock(&ar->conf_mutex); 2811 ieee80211_iterate_active_interfaces_atomic( 2812 hw, IEEE80211_IFACE_ITER_NORMAL, 2813 ath10k_set_frag_iter, &ar_iter); 2814 mutex_unlock(&ar->conf_mutex); 2815 2816 return ar_iter.ret; 2817 } 2818 2819 static void ath10k_flush(struct ieee80211_hw *hw, u32 queues, bool drop) 2820 { 2821 struct ath10k *ar = hw->priv; 2822 bool skip; 2823 int ret; 2824 2825 /* mac80211 doesn't care if we really xmit queued frames or not 2826 * we'll collect those frames either way if we stop/delete vdevs */ 2827 if (drop) 2828 return; 2829 2830 mutex_lock(&ar->conf_mutex); 2831 2832 if (ar->state == ATH10K_STATE_WEDGED) 2833 goto skip; 2834 2835 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({ 2836 bool empty; 2837 2838 spin_lock_bh(&ar->htt.tx_lock); 2839 empty = bitmap_empty(ar->htt.used_msdu_ids, 2840 ar->htt.max_num_pending_tx); 2841 spin_unlock_bh(&ar->htt.tx_lock); 2842 2843 skip = (ar->state == ATH10K_STATE_WEDGED); 2844 2845 (empty || skip); 2846 }), ATH10K_FLUSH_TIMEOUT_HZ); 2847 2848 if (ret <= 0 || skip) 2849 ath10k_warn("tx not flushed\n"); 2850 2851 skip: 2852 mutex_unlock(&ar->conf_mutex); 2853 } 2854 2855 /* TODO: Implement this function properly 2856 * For now it is needed to reply to Probe Requests in IBSS mode. 2857 * Propably we need this information from FW. 2858 */ 2859 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw) 2860 { 2861 return 1; 2862 } 2863 2864 #ifdef CONFIG_PM 2865 static int ath10k_suspend(struct ieee80211_hw *hw, 2866 struct cfg80211_wowlan *wowlan) 2867 { 2868 struct ath10k *ar = hw->priv; 2869 int ret; 2870 2871 ar->is_target_paused = false; 2872 2873 ret = ath10k_wmi_pdev_suspend_target(ar); 2874 if (ret) { 2875 ath10k_warn("could not suspend target (%d)\n", ret); 2876 return 1; 2877 } 2878 2879 ret = wait_event_interruptible_timeout(ar->event_queue, 2880 ar->is_target_paused == true, 2881 1 * HZ); 2882 if (ret < 0) { 2883 ath10k_warn("suspend interrupted (%d)\n", ret); 2884 goto resume; 2885 } else if (ret == 0) { 2886 ath10k_warn("suspend timed out - target pause event never came\n"); 2887 goto resume; 2888 } 2889 2890 ret = ath10k_hif_suspend(ar); 2891 if (ret) { 2892 ath10k_warn("could not suspend hif (%d)\n", ret); 2893 goto resume; 2894 } 2895 2896 return 0; 2897 resume: 2898 ret = ath10k_wmi_pdev_resume_target(ar); 2899 if (ret) 2900 ath10k_warn("could not resume target (%d)\n", ret); 2901 return 1; 2902 } 2903 2904 static int ath10k_resume(struct ieee80211_hw *hw) 2905 { 2906 struct ath10k *ar = hw->priv; 2907 int ret; 2908 2909 ret = ath10k_hif_resume(ar); 2910 if (ret) { 2911 ath10k_warn("could not resume hif (%d)\n", ret); 2912 return 1; 2913 } 2914 2915 ret = ath10k_wmi_pdev_resume_target(ar); 2916 if (ret) { 2917 ath10k_warn("could not resume target (%d)\n", ret); 2918 return 1; 2919 } 2920 2921 return 0; 2922 } 2923 #endif 2924 2925 static void ath10k_restart_complete(struct ieee80211_hw *hw) 2926 { 2927 struct ath10k *ar = hw->priv; 2928 2929 mutex_lock(&ar->conf_mutex); 2930 2931 /* If device failed to restart it will be in a different state, e.g. 2932 * ATH10K_STATE_WEDGED */ 2933 if (ar->state == ATH10K_STATE_RESTARTED) { 2934 ath10k_info("device successfully recovered\n"); 2935 ar->state = ATH10K_STATE_ON; 2936 } 2937 2938 mutex_unlock(&ar->conf_mutex); 2939 } 2940 2941 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx, 2942 struct survey_info *survey) 2943 { 2944 struct ath10k *ar = hw->priv; 2945 struct ieee80211_supported_band *sband; 2946 struct survey_info *ar_survey = &ar->survey[idx]; 2947 int ret = 0; 2948 2949 mutex_lock(&ar->conf_mutex); 2950 2951 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ]; 2952 if (sband && idx >= sband->n_channels) { 2953 idx -= sband->n_channels; 2954 sband = NULL; 2955 } 2956 2957 if (!sband) 2958 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ]; 2959 2960 if (!sband || idx >= sband->n_channels) { 2961 ret = -ENOENT; 2962 goto exit; 2963 } 2964 2965 spin_lock_bh(&ar->data_lock); 2966 memcpy(survey, ar_survey, sizeof(*survey)); 2967 spin_unlock_bh(&ar->data_lock); 2968 2969 survey->channel = &sband->channels[idx]; 2970 2971 exit: 2972 mutex_unlock(&ar->conf_mutex); 2973 return ret; 2974 } 2975 2976 static const struct ieee80211_ops ath10k_ops = { 2977 .tx = ath10k_tx, 2978 .start = ath10k_start, 2979 .stop = ath10k_stop, 2980 .config = ath10k_config, 2981 .add_interface = ath10k_add_interface, 2982 .remove_interface = ath10k_remove_interface, 2983 .configure_filter = ath10k_configure_filter, 2984 .bss_info_changed = ath10k_bss_info_changed, 2985 .hw_scan = ath10k_hw_scan, 2986 .cancel_hw_scan = ath10k_cancel_hw_scan, 2987 .set_key = ath10k_set_key, 2988 .sta_state = ath10k_sta_state, 2989 .conf_tx = ath10k_conf_tx, 2990 .remain_on_channel = ath10k_remain_on_channel, 2991 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel, 2992 .set_rts_threshold = ath10k_set_rts_threshold, 2993 .set_frag_threshold = ath10k_set_frag_threshold, 2994 .flush = ath10k_flush, 2995 .tx_last_beacon = ath10k_tx_last_beacon, 2996 .restart_complete = ath10k_restart_complete, 2997 .get_survey = ath10k_get_survey, 2998 #ifdef CONFIG_PM 2999 .suspend = ath10k_suspend, 3000 .resume = ath10k_resume, 3001 #endif 3002 }; 3003 3004 #define RATETAB_ENT(_rate, _rateid, _flags) { \ 3005 .bitrate = (_rate), \ 3006 .flags = (_flags), \ 3007 .hw_value = (_rateid), \ 3008 } 3009 3010 #define CHAN2G(_channel, _freq, _flags) { \ 3011 .band = IEEE80211_BAND_2GHZ, \ 3012 .hw_value = (_channel), \ 3013 .center_freq = (_freq), \ 3014 .flags = (_flags), \ 3015 .max_antenna_gain = 0, \ 3016 .max_power = 30, \ 3017 } 3018 3019 #define CHAN5G(_channel, _freq, _flags) { \ 3020 .band = IEEE80211_BAND_5GHZ, \ 3021 .hw_value = (_channel), \ 3022 .center_freq = (_freq), \ 3023 .flags = (_flags), \ 3024 .max_antenna_gain = 0, \ 3025 .max_power = 30, \ 3026 } 3027 3028 static const struct ieee80211_channel ath10k_2ghz_channels[] = { 3029 CHAN2G(1, 2412, 0), 3030 CHAN2G(2, 2417, 0), 3031 CHAN2G(3, 2422, 0), 3032 CHAN2G(4, 2427, 0), 3033 CHAN2G(5, 2432, 0), 3034 CHAN2G(6, 2437, 0), 3035 CHAN2G(7, 2442, 0), 3036 CHAN2G(8, 2447, 0), 3037 CHAN2G(9, 2452, 0), 3038 CHAN2G(10, 2457, 0), 3039 CHAN2G(11, 2462, 0), 3040 CHAN2G(12, 2467, 0), 3041 CHAN2G(13, 2472, 0), 3042 CHAN2G(14, 2484, 0), 3043 }; 3044 3045 static const struct ieee80211_channel ath10k_5ghz_channels[] = { 3046 CHAN5G(36, 5180, 0), 3047 CHAN5G(40, 5200, 0), 3048 CHAN5G(44, 5220, 0), 3049 CHAN5G(48, 5240, 0), 3050 CHAN5G(52, 5260, 0), 3051 CHAN5G(56, 5280, 0), 3052 CHAN5G(60, 5300, 0), 3053 CHAN5G(64, 5320, 0), 3054 CHAN5G(100, 5500, 0), 3055 CHAN5G(104, 5520, 0), 3056 CHAN5G(108, 5540, 0), 3057 CHAN5G(112, 5560, 0), 3058 CHAN5G(116, 5580, 0), 3059 CHAN5G(120, 5600, 0), 3060 CHAN5G(124, 5620, 0), 3061 CHAN5G(128, 5640, 0), 3062 CHAN5G(132, 5660, 0), 3063 CHAN5G(136, 5680, 0), 3064 CHAN5G(140, 5700, 0), 3065 CHAN5G(149, 5745, 0), 3066 CHAN5G(153, 5765, 0), 3067 CHAN5G(157, 5785, 0), 3068 CHAN5G(161, 5805, 0), 3069 CHAN5G(165, 5825, 0), 3070 }; 3071 3072 static struct ieee80211_rate ath10k_rates[] = { 3073 /* CCK */ 3074 RATETAB_ENT(10, 0x82, 0), 3075 RATETAB_ENT(20, 0x84, 0), 3076 RATETAB_ENT(55, 0x8b, 0), 3077 RATETAB_ENT(110, 0x96, 0), 3078 /* OFDM */ 3079 RATETAB_ENT(60, 0x0c, 0), 3080 RATETAB_ENT(90, 0x12, 0), 3081 RATETAB_ENT(120, 0x18, 0), 3082 RATETAB_ENT(180, 0x24, 0), 3083 RATETAB_ENT(240, 0x30, 0), 3084 RATETAB_ENT(360, 0x48, 0), 3085 RATETAB_ENT(480, 0x60, 0), 3086 RATETAB_ENT(540, 0x6c, 0), 3087 }; 3088 3089 #define ath10k_a_rates (ath10k_rates + 4) 3090 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4) 3091 #define ath10k_g_rates (ath10k_rates + 0) 3092 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates)) 3093 3094 struct ath10k *ath10k_mac_create(void) 3095 { 3096 struct ieee80211_hw *hw; 3097 struct ath10k *ar; 3098 3099 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops); 3100 if (!hw) 3101 return NULL; 3102 3103 ar = hw->priv; 3104 ar->hw = hw; 3105 3106 return ar; 3107 } 3108 3109 void ath10k_mac_destroy(struct ath10k *ar) 3110 { 3111 ieee80211_free_hw(ar->hw); 3112 } 3113 3114 static const struct ieee80211_iface_limit ath10k_if_limits[] = { 3115 { 3116 .max = 8, 3117 .types = BIT(NL80211_IFTYPE_STATION) 3118 | BIT(NL80211_IFTYPE_P2P_CLIENT) 3119 }, 3120 { 3121 .max = 3, 3122 .types = BIT(NL80211_IFTYPE_P2P_GO) 3123 }, 3124 { 3125 .max = 7, 3126 .types = BIT(NL80211_IFTYPE_AP) 3127 }, 3128 }; 3129 3130 static const struct ieee80211_iface_combination ath10k_if_comb = { 3131 .limits = ath10k_if_limits, 3132 .n_limits = ARRAY_SIZE(ath10k_if_limits), 3133 .max_interfaces = 8, 3134 .num_different_channels = 1, 3135 .beacon_int_infra_match = true, 3136 }; 3137 3138 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar) 3139 { 3140 struct ieee80211_sta_vht_cap vht_cap = {0}; 3141 u16 mcs_map; 3142 int i; 3143 3144 vht_cap.vht_supported = 1; 3145 vht_cap.cap = ar->vht_cap_info; 3146 3147 mcs_map = 0; 3148 for (i = 0; i < 8; i++) { 3149 if (i < ar->num_rf_chains) 3150 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2); 3151 else 3152 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2); 3153 } 3154 3155 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map); 3156 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map); 3157 3158 return vht_cap; 3159 } 3160 3161 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar) 3162 { 3163 int i; 3164 struct ieee80211_sta_ht_cap ht_cap = {0}; 3165 3166 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED)) 3167 return ht_cap; 3168 3169 ht_cap.ht_supported = 1; 3170 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 3171 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8; 3172 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 3173 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 3174 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT; 3175 3176 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI) 3177 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 3178 3179 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI) 3180 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 3181 3182 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) { 3183 u32 smps; 3184 3185 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 3186 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 3187 3188 ht_cap.cap |= smps; 3189 } 3190 3191 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC) 3192 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 3193 3194 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) { 3195 u32 stbc; 3196 3197 stbc = ar->ht_cap_info; 3198 stbc &= WMI_HT_CAP_RX_STBC; 3199 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 3200 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 3201 stbc &= IEEE80211_HT_CAP_RX_STBC; 3202 3203 ht_cap.cap |= stbc; 3204 } 3205 3206 if (ar->ht_cap_info & WMI_HT_CAP_LDPC) 3207 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 3208 3209 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT) 3210 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 3211 3212 /* max AMSDU is implicitly taken from vht_cap_info */ 3213 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 3214 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 3215 3216 for (i = 0; i < ar->num_rf_chains; i++) 3217 ht_cap.mcs.rx_mask[i] = 0xFF; 3218 3219 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 3220 3221 return ht_cap; 3222 } 3223 3224 3225 static void ath10k_get_arvif_iter(void *data, u8 *mac, 3226 struct ieee80211_vif *vif) 3227 { 3228 struct ath10k_vif_iter *arvif_iter = data; 3229 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3230 3231 if (arvif->vdev_id == arvif_iter->vdev_id) 3232 arvif_iter->arvif = arvif; 3233 } 3234 3235 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id) 3236 { 3237 struct ath10k_vif_iter arvif_iter; 3238 u32 flags; 3239 3240 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter)); 3241 arvif_iter.vdev_id = vdev_id; 3242 3243 flags = IEEE80211_IFACE_ITER_RESUME_ALL; 3244 ieee80211_iterate_active_interfaces_atomic(ar->hw, 3245 flags, 3246 ath10k_get_arvif_iter, 3247 &arvif_iter); 3248 if (!arvif_iter.arvif) { 3249 ath10k_warn("No VIF found for VDEV: %d\n", vdev_id); 3250 return NULL; 3251 } 3252 3253 return arvif_iter.arvif; 3254 } 3255 3256 int ath10k_mac_register(struct ath10k *ar) 3257 { 3258 struct ieee80211_supported_band *band; 3259 struct ieee80211_sta_vht_cap vht_cap; 3260 struct ieee80211_sta_ht_cap ht_cap; 3261 void *channels; 3262 int ret; 3263 3264 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 3265 3266 SET_IEEE80211_DEV(ar->hw, ar->dev); 3267 3268 ht_cap = ath10k_get_ht_cap(ar); 3269 vht_cap = ath10k_create_vht_cap(ar); 3270 3271 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) { 3272 channels = kmemdup(ath10k_2ghz_channels, 3273 sizeof(ath10k_2ghz_channels), 3274 GFP_KERNEL); 3275 if (!channels) { 3276 ret = -ENOMEM; 3277 goto err_free; 3278 } 3279 3280 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ]; 3281 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels); 3282 band->channels = channels; 3283 band->n_bitrates = ath10k_g_rates_size; 3284 band->bitrates = ath10k_g_rates; 3285 band->ht_cap = ht_cap; 3286 3287 /* vht is not supported in 2.4 GHz */ 3288 3289 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band; 3290 } 3291 3292 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) { 3293 channels = kmemdup(ath10k_5ghz_channels, 3294 sizeof(ath10k_5ghz_channels), 3295 GFP_KERNEL); 3296 if (!channels) { 3297 ret = -ENOMEM; 3298 goto err_free; 3299 } 3300 3301 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ]; 3302 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels); 3303 band->channels = channels; 3304 band->n_bitrates = ath10k_a_rates_size; 3305 band->bitrates = ath10k_a_rates; 3306 band->ht_cap = ht_cap; 3307 band->vht_cap = vht_cap; 3308 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band; 3309 } 3310 3311 ar->hw->wiphy->interface_modes = 3312 BIT(NL80211_IFTYPE_STATION) | 3313 BIT(NL80211_IFTYPE_ADHOC) | 3314 BIT(NL80211_IFTYPE_AP) | 3315 BIT(NL80211_IFTYPE_P2P_CLIENT) | 3316 BIT(NL80211_IFTYPE_P2P_GO); 3317 3318 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM | 3319 IEEE80211_HW_SUPPORTS_PS | 3320 IEEE80211_HW_SUPPORTS_DYNAMIC_PS | 3321 IEEE80211_HW_SUPPORTS_UAPSD | 3322 IEEE80211_HW_MFP_CAPABLE | 3323 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 3324 IEEE80211_HW_HAS_RATE_CONTROL | 3325 IEEE80211_HW_SUPPORTS_STATIC_SMPS | 3326 IEEE80211_HW_WANT_MONITOR_VIF | 3327 IEEE80211_HW_AP_LINK_PS; 3328 3329 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 3330 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS; 3331 3332 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) { 3333 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION; 3334 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW; 3335 } 3336 3337 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 3338 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 3339 3340 ar->hw->vif_data_size = sizeof(struct ath10k_vif); 3341 3342 ar->hw->channel_change_time = 5000; 3343 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL; 3344 3345 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 3346 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 3347 3348 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 3349 /* 3350 * on LL hardware queues are managed entirely by the FW 3351 * so we only advertise to mac we can do the queues thing 3352 */ 3353 ar->hw->queues = 4; 3354 3355 ar->hw->wiphy->iface_combinations = &ath10k_if_comb; 3356 ar->hw->wiphy->n_iface_combinations = 1; 3357 3358 ar->hw->netdev_features = NETIF_F_HW_CSUM; 3359 3360 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy, 3361 ath10k_reg_notifier); 3362 if (ret) { 3363 ath10k_err("Regulatory initialization failed\n"); 3364 goto err_free; 3365 } 3366 3367 ret = ieee80211_register_hw(ar->hw); 3368 if (ret) { 3369 ath10k_err("ieee80211 registration failed: %d\n", ret); 3370 goto err_free; 3371 } 3372 3373 if (!ath_is_world_regd(&ar->ath_common.regulatory)) { 3374 ret = regulatory_hint(ar->hw->wiphy, 3375 ar->ath_common.regulatory.alpha2); 3376 if (ret) 3377 goto err_unregister; 3378 } 3379 3380 return 0; 3381 3382 err_unregister: 3383 ieee80211_unregister_hw(ar->hw); 3384 err_free: 3385 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels); 3386 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels); 3387 3388 return ret; 3389 } 3390 3391 void ath10k_mac_unregister(struct ath10k *ar) 3392 { 3393 ieee80211_unregister_hw(ar->hw); 3394 3395 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels); 3396 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels); 3397 3398 SET_IEEE80211_DEV(ar->hw, NULL); 3399 } 3400