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