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