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