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