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