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