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 mutex_unlock(&ar->conf_mutex); 2503 return 0; 2504 2505 err_core_stop: 2506 ath10k_core_stop(ar); 2507 2508 err_power_down: 2509 ath10k_hif_power_down(ar); 2510 2511 err_off: 2512 ar->state = ATH10K_STATE_OFF; 2513 2514 err: 2515 mutex_unlock(&ar->conf_mutex); 2516 return ret; 2517 } 2518 2519 static void ath10k_stop(struct ieee80211_hw *hw) 2520 { 2521 struct ath10k *ar = hw->priv; 2522 2523 ath10k_drain_tx(ar); 2524 2525 mutex_lock(&ar->conf_mutex); 2526 if (ar->state != ATH10K_STATE_OFF) { 2527 ath10k_halt(ar); 2528 ar->state = ATH10K_STATE_OFF; 2529 } 2530 mutex_unlock(&ar->conf_mutex); 2531 2532 cancel_work_sync(&ar->restart_work); 2533 } 2534 2535 static int ath10k_config_ps(struct ath10k *ar) 2536 { 2537 struct ath10k_vif *arvif; 2538 int ret = 0; 2539 2540 lockdep_assert_held(&ar->conf_mutex); 2541 2542 list_for_each_entry(arvif, &ar->arvifs, list) { 2543 ret = ath10k_mac_vif_setup_ps(arvif); 2544 if (ret) { 2545 ath10k_warn("failed to setup powersave: %d\n", ret); 2546 break; 2547 } 2548 } 2549 2550 return ret; 2551 } 2552 2553 static const char *chandef_get_width(enum nl80211_chan_width width) 2554 { 2555 switch (width) { 2556 case NL80211_CHAN_WIDTH_20_NOHT: 2557 return "20 (noht)"; 2558 case NL80211_CHAN_WIDTH_20: 2559 return "20"; 2560 case NL80211_CHAN_WIDTH_40: 2561 return "40"; 2562 case NL80211_CHAN_WIDTH_80: 2563 return "80"; 2564 case NL80211_CHAN_WIDTH_80P80: 2565 return "80+80"; 2566 case NL80211_CHAN_WIDTH_160: 2567 return "160"; 2568 case NL80211_CHAN_WIDTH_5: 2569 return "5"; 2570 case NL80211_CHAN_WIDTH_10: 2571 return "10"; 2572 } 2573 return "?"; 2574 } 2575 2576 static void ath10k_config_chan(struct ath10k *ar) 2577 { 2578 struct ath10k_vif *arvif; 2579 int ret; 2580 2581 lockdep_assert_held(&ar->conf_mutex); 2582 2583 ath10k_dbg(ATH10K_DBG_MAC, 2584 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n", 2585 ar->chandef.chan->center_freq, 2586 ar->chandef.center_freq1, 2587 ar->chandef.center_freq2, 2588 chandef_get_width(ar->chandef.width)); 2589 2590 /* First stop monitor interface. Some FW versions crash if there's a 2591 * lone monitor interface. */ 2592 if (ar->monitor_started) 2593 ath10k_monitor_vdev_stop(ar); 2594 2595 list_for_each_entry(arvif, &ar->arvifs, list) { 2596 if (!arvif->is_started) 2597 continue; 2598 2599 if (!arvif->is_up) 2600 continue; 2601 2602 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 2603 continue; 2604 2605 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 2606 if (ret) { 2607 ath10k_warn("failed to down vdev %d: %d\n", 2608 arvif->vdev_id, ret); 2609 continue; 2610 } 2611 } 2612 2613 /* all vdevs are downed now - attempt to restart and re-up them */ 2614 2615 list_for_each_entry(arvif, &ar->arvifs, list) { 2616 if (!arvif->is_started) 2617 continue; 2618 2619 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 2620 continue; 2621 2622 ret = ath10k_vdev_restart(arvif); 2623 if (ret) { 2624 ath10k_warn("failed to restart vdev %d: %d\n", 2625 arvif->vdev_id, ret); 2626 continue; 2627 } 2628 2629 if (!arvif->is_up) 2630 continue; 2631 2632 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 2633 arvif->bssid); 2634 if (ret) { 2635 ath10k_warn("failed to bring vdev up %d: %d\n", 2636 arvif->vdev_id, ret); 2637 continue; 2638 } 2639 } 2640 2641 if (ath10k_monitor_is_enabled(ar)) 2642 ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id); 2643 } 2644 2645 static int ath10k_config(struct ieee80211_hw *hw, u32 changed) 2646 { 2647 struct ath10k *ar = hw->priv; 2648 struct ieee80211_conf *conf = &hw->conf; 2649 int ret = 0; 2650 u32 param; 2651 2652 mutex_lock(&ar->conf_mutex); 2653 2654 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 2655 ath10k_dbg(ATH10K_DBG_MAC, 2656 "mac config channel %dMHz flags 0x%x radar %d\n", 2657 conf->chandef.chan->center_freq, 2658 conf->chandef.chan->flags, 2659 conf->radar_enabled); 2660 2661 spin_lock_bh(&ar->data_lock); 2662 ar->rx_channel = conf->chandef.chan; 2663 spin_unlock_bh(&ar->data_lock); 2664 2665 ar->radar_enabled = conf->radar_enabled; 2666 ath10k_recalc_radar_detection(ar); 2667 2668 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) { 2669 ar->chandef = conf->chandef; 2670 ath10k_config_chan(ar); 2671 } 2672 } 2673 2674 if (changed & IEEE80211_CONF_CHANGE_POWER) { 2675 ath10k_dbg(ATH10K_DBG_MAC, "mac config power %d\n", 2676 hw->conf.power_level); 2677 2678 param = ar->wmi.pdev_param->txpower_limit2g; 2679 ret = ath10k_wmi_pdev_set_param(ar, param, 2680 hw->conf.power_level * 2); 2681 if (ret) 2682 ath10k_warn("failed to set 2g txpower %d: %d\n", 2683 hw->conf.power_level, ret); 2684 2685 param = ar->wmi.pdev_param->txpower_limit5g; 2686 ret = ath10k_wmi_pdev_set_param(ar, param, 2687 hw->conf.power_level * 2); 2688 if (ret) 2689 ath10k_warn("failed to set 5g txpower %d: %d\n", 2690 hw->conf.power_level, ret); 2691 } 2692 2693 if (changed & IEEE80211_CONF_CHANGE_PS) 2694 ath10k_config_ps(ar); 2695 2696 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 2697 if (conf->flags & IEEE80211_CONF_MONITOR && !ar->monitor) { 2698 ar->monitor = true; 2699 ret = ath10k_monitor_start(ar); 2700 if (ret) { 2701 ath10k_warn("failed to start monitor (config): %d\n", 2702 ret); 2703 ar->monitor = false; 2704 } 2705 } else if (!(conf->flags & IEEE80211_CONF_MONITOR) && 2706 ar->monitor) { 2707 ar->monitor = false; 2708 ath10k_monitor_stop(ar); 2709 } 2710 } 2711 2712 mutex_unlock(&ar->conf_mutex); 2713 return ret; 2714 } 2715 2716 /* 2717 * TODO: 2718 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE, 2719 * because we will send mgmt frames without CCK. This requirement 2720 * for P2P_FIND/GO_NEG should be handled by checking CCK flag 2721 * in the TX packet. 2722 */ 2723 static int ath10k_add_interface(struct ieee80211_hw *hw, 2724 struct ieee80211_vif *vif) 2725 { 2726 struct ath10k *ar = hw->priv; 2727 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2728 enum wmi_sta_powersave_param param; 2729 int ret = 0; 2730 u32 value; 2731 int bit; 2732 u32 vdev_param; 2733 2734 mutex_lock(&ar->conf_mutex); 2735 2736 memset(arvif, 0, sizeof(*arvif)); 2737 2738 arvif->ar = ar; 2739 arvif->vif = vif; 2740 2741 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work); 2742 INIT_LIST_HEAD(&arvif->list); 2743 2744 bit = ffs(ar->free_vdev_map); 2745 if (bit == 0) { 2746 ret = -EBUSY; 2747 goto err; 2748 } 2749 2750 arvif->vdev_id = bit - 1; 2751 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 2752 2753 if (ar->p2p) 2754 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE; 2755 2756 switch (vif->type) { 2757 case NL80211_IFTYPE_UNSPECIFIED: 2758 case NL80211_IFTYPE_STATION: 2759 arvif->vdev_type = WMI_VDEV_TYPE_STA; 2760 if (vif->p2p) 2761 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT; 2762 break; 2763 case NL80211_IFTYPE_ADHOC: 2764 arvif->vdev_type = WMI_VDEV_TYPE_IBSS; 2765 break; 2766 case NL80211_IFTYPE_AP: 2767 arvif->vdev_type = WMI_VDEV_TYPE_AP; 2768 2769 if (vif->p2p) 2770 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO; 2771 break; 2772 case NL80211_IFTYPE_MONITOR: 2773 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 2774 break; 2775 default: 2776 WARN_ON(1); 2777 break; 2778 } 2779 2780 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n", 2781 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype); 2782 2783 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type, 2784 arvif->vdev_subtype, vif->addr); 2785 if (ret) { 2786 ath10k_warn("failed to create WMI vdev %i: %d\n", 2787 arvif->vdev_id, ret); 2788 goto err; 2789 } 2790 2791 ar->free_vdev_map &= ~BIT(arvif->vdev_id); 2792 list_add(&arvif->list, &ar->arvifs); 2793 2794 vdev_param = ar->wmi.vdev_param->def_keyid; 2795 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param, 2796 arvif->def_wep_key_idx); 2797 if (ret) { 2798 ath10k_warn("failed to set vdev %i default key id: %d\n", 2799 arvif->vdev_id, ret); 2800 goto err_vdev_delete; 2801 } 2802 2803 vdev_param = ar->wmi.vdev_param->tx_encap_type; 2804 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 2805 ATH10K_HW_TXRX_NATIVE_WIFI); 2806 /* 10.X firmware does not support this VDEV parameter. Do not warn */ 2807 if (ret && ret != -EOPNOTSUPP) { 2808 ath10k_warn("failed to set vdev %i TX encapsulation: %d\n", 2809 arvif->vdev_id, ret); 2810 goto err_vdev_delete; 2811 } 2812 2813 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 2814 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr); 2815 if (ret) { 2816 ath10k_warn("failed to create vdev %i peer for AP: %d\n", 2817 arvif->vdev_id, ret); 2818 goto err_vdev_delete; 2819 } 2820 2821 ret = ath10k_mac_set_kickout(arvif); 2822 if (ret) { 2823 ath10k_warn("failed to set vdev %i kickout parameters: %d\n", 2824 arvif->vdev_id, ret); 2825 goto err_peer_delete; 2826 } 2827 } 2828 2829 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) { 2830 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 2831 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 2832 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2833 param, value); 2834 if (ret) { 2835 ath10k_warn("failed to set vdev %i RX wake policy: %d\n", 2836 arvif->vdev_id, ret); 2837 goto err_peer_delete; 2838 } 2839 2840 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 2841 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 2842 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2843 param, value); 2844 if (ret) { 2845 ath10k_warn("failed to set vdev %i TX wake thresh: %d\n", 2846 arvif->vdev_id, ret); 2847 goto err_peer_delete; 2848 } 2849 2850 param = WMI_STA_PS_PARAM_PSPOLL_COUNT; 2851 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 2852 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2853 param, value); 2854 if (ret) { 2855 ath10k_warn("failed to set vdev %i PSPOLL count: %d\n", 2856 arvif->vdev_id, ret); 2857 goto err_peer_delete; 2858 } 2859 } 2860 2861 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold); 2862 if (ret) { 2863 ath10k_warn("failed to set rts threshold for vdev %d: %d\n", 2864 arvif->vdev_id, ret); 2865 goto err_peer_delete; 2866 } 2867 2868 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold); 2869 if (ret) { 2870 ath10k_warn("failed to set frag threshold for vdev %d: %d\n", 2871 arvif->vdev_id, ret); 2872 goto err_peer_delete; 2873 } 2874 2875 mutex_unlock(&ar->conf_mutex); 2876 return 0; 2877 2878 err_peer_delete: 2879 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) 2880 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr); 2881 2882 err_vdev_delete: 2883 ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 2884 ar->free_vdev_map &= ~BIT(arvif->vdev_id); 2885 list_del(&arvif->list); 2886 2887 err: 2888 mutex_unlock(&ar->conf_mutex); 2889 2890 return ret; 2891 } 2892 2893 static void ath10k_remove_interface(struct ieee80211_hw *hw, 2894 struct ieee80211_vif *vif) 2895 { 2896 struct ath10k *ar = hw->priv; 2897 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2898 int ret; 2899 2900 mutex_lock(&ar->conf_mutex); 2901 2902 cancel_work_sync(&arvif->wep_key_work); 2903 2904 spin_lock_bh(&ar->data_lock); 2905 if (arvif->beacon) { 2906 dma_unmap_single(arvif->ar->dev, 2907 ATH10K_SKB_CB(arvif->beacon)->paddr, 2908 arvif->beacon->len, DMA_TO_DEVICE); 2909 dev_kfree_skb_any(arvif->beacon); 2910 arvif->beacon = NULL; 2911 } 2912 spin_unlock_bh(&ar->data_lock); 2913 2914 ar->free_vdev_map |= 1 << (arvif->vdev_id); 2915 list_del(&arvif->list); 2916 2917 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 2918 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr); 2919 if (ret) 2920 ath10k_warn("failed to remove peer for AP vdev %i: %d\n", 2921 arvif->vdev_id, ret); 2922 2923 kfree(arvif->u.ap.noa_data); 2924 } 2925 2926 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n", 2927 arvif->vdev_id); 2928 2929 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 2930 if (ret) 2931 ath10k_warn("failed to delete WMI vdev %i: %d\n", 2932 arvif->vdev_id, ret); 2933 2934 ath10k_peer_cleanup(ar, arvif->vdev_id); 2935 2936 mutex_unlock(&ar->conf_mutex); 2937 } 2938 2939 /* 2940 * FIXME: Has to be verified. 2941 */ 2942 #define SUPPORTED_FILTERS \ 2943 (FIF_PROMISC_IN_BSS | \ 2944 FIF_ALLMULTI | \ 2945 FIF_CONTROL | \ 2946 FIF_PSPOLL | \ 2947 FIF_OTHER_BSS | \ 2948 FIF_BCN_PRBRESP_PROMISC | \ 2949 FIF_PROBE_REQ | \ 2950 FIF_FCSFAIL) 2951 2952 static void ath10k_configure_filter(struct ieee80211_hw *hw, 2953 unsigned int changed_flags, 2954 unsigned int *total_flags, 2955 u64 multicast) 2956 { 2957 struct ath10k *ar = hw->priv; 2958 int ret; 2959 2960 mutex_lock(&ar->conf_mutex); 2961 2962 changed_flags &= SUPPORTED_FILTERS; 2963 *total_flags &= SUPPORTED_FILTERS; 2964 ar->filter_flags = *total_flags; 2965 2966 if (ar->filter_flags & FIF_PROMISC_IN_BSS && !ar->promisc) { 2967 ar->promisc = true; 2968 ret = ath10k_monitor_start(ar); 2969 if (ret) { 2970 ath10k_warn("failed to start monitor (promisc): %d\n", 2971 ret); 2972 ar->promisc = false; 2973 } 2974 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) && ar->promisc) { 2975 ar->promisc = false; 2976 ath10k_monitor_stop(ar); 2977 } 2978 2979 mutex_unlock(&ar->conf_mutex); 2980 } 2981 2982 static void ath10k_bss_info_changed(struct ieee80211_hw *hw, 2983 struct ieee80211_vif *vif, 2984 struct ieee80211_bss_conf *info, 2985 u32 changed) 2986 { 2987 struct ath10k *ar = hw->priv; 2988 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2989 int ret = 0; 2990 u32 vdev_param, pdev_param; 2991 2992 mutex_lock(&ar->conf_mutex); 2993 2994 if (changed & BSS_CHANGED_IBSS) 2995 ath10k_control_ibss(arvif, info, vif->addr); 2996 2997 if (changed & BSS_CHANGED_BEACON_INT) { 2998 arvif->beacon_interval = info->beacon_int; 2999 vdev_param = ar->wmi.vdev_param->beacon_interval; 3000 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 3001 arvif->beacon_interval); 3002 ath10k_dbg(ATH10K_DBG_MAC, 3003 "mac vdev %d beacon_interval %d\n", 3004 arvif->vdev_id, arvif->beacon_interval); 3005 3006 if (ret) 3007 ath10k_warn("failed to set beacon interval for vdev %d: %i\n", 3008 arvif->vdev_id, ret); 3009 } 3010 3011 if (changed & BSS_CHANGED_BEACON) { 3012 ath10k_dbg(ATH10K_DBG_MAC, 3013 "vdev %d set beacon tx mode to staggered\n", 3014 arvif->vdev_id); 3015 3016 pdev_param = ar->wmi.pdev_param->beacon_tx_mode; 3017 ret = ath10k_wmi_pdev_set_param(ar, pdev_param, 3018 WMI_BEACON_STAGGERED_MODE); 3019 if (ret) 3020 ath10k_warn("failed to set beacon mode for vdev %d: %i\n", 3021 arvif->vdev_id, ret); 3022 } 3023 3024 if (changed & BSS_CHANGED_BEACON_INFO) { 3025 arvif->dtim_period = info->dtim_period; 3026 3027 ath10k_dbg(ATH10K_DBG_MAC, 3028 "mac vdev %d dtim_period %d\n", 3029 arvif->vdev_id, arvif->dtim_period); 3030 3031 vdev_param = ar->wmi.vdev_param->dtim_period; 3032 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 3033 arvif->dtim_period); 3034 if (ret) 3035 ath10k_warn("failed to set dtim period for vdev %d: %i\n", 3036 arvif->vdev_id, ret); 3037 } 3038 3039 if (changed & BSS_CHANGED_SSID && 3040 vif->type == NL80211_IFTYPE_AP) { 3041 arvif->u.ap.ssid_len = info->ssid_len; 3042 if (info->ssid_len) 3043 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len); 3044 arvif->u.ap.hidden_ssid = info->hidden_ssid; 3045 } 3046 3047 /* 3048 * Firmware manages AP self-peer internally so make sure to not create 3049 * it in driver. Otherwise AP self-peer deletion may timeout later. 3050 */ 3051 if (changed & BSS_CHANGED_BSSID && 3052 vif->type != NL80211_IFTYPE_AP) { 3053 if (!is_zero_ether_addr(info->bssid)) { 3054 ath10k_dbg(ATH10K_DBG_MAC, 3055 "mac vdev %d create peer %pM\n", 3056 arvif->vdev_id, info->bssid); 3057 3058 ret = ath10k_peer_create(ar, arvif->vdev_id, 3059 info->bssid); 3060 if (ret) 3061 ath10k_warn("failed to add peer %pM for vdev %d when changing bssid: %i\n", 3062 info->bssid, arvif->vdev_id, ret); 3063 3064 if (vif->type == NL80211_IFTYPE_STATION) { 3065 /* 3066 * this is never erased as we it for crypto key 3067 * clearing; this is FW requirement 3068 */ 3069 memcpy(arvif->bssid, info->bssid, ETH_ALEN); 3070 3071 ath10k_dbg(ATH10K_DBG_MAC, 3072 "mac vdev %d start %pM\n", 3073 arvif->vdev_id, info->bssid); 3074 3075 ret = ath10k_vdev_start(arvif); 3076 if (ret) { 3077 ath10k_warn("failed to start vdev %i: %d\n", 3078 arvif->vdev_id, ret); 3079 goto exit; 3080 } 3081 3082 arvif->is_started = true; 3083 } 3084 3085 /* 3086 * Mac80211 does not keep IBSS bssid when leaving IBSS, 3087 * so driver need to store it. It is needed when leaving 3088 * IBSS in order to remove BSSID peer. 3089 */ 3090 if (vif->type == NL80211_IFTYPE_ADHOC) 3091 memcpy(arvif->bssid, info->bssid, 3092 ETH_ALEN); 3093 } 3094 } 3095 3096 if (changed & BSS_CHANGED_BEACON_ENABLED) 3097 ath10k_control_beaconing(arvif, info); 3098 3099 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 3100 arvif->use_cts_prot = info->use_cts_prot; 3101 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n", 3102 arvif->vdev_id, info->use_cts_prot); 3103 3104 ret = ath10k_recalc_rtscts_prot(arvif); 3105 if (ret) 3106 ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n", 3107 arvif->vdev_id, ret); 3108 } 3109 3110 if (changed & BSS_CHANGED_ERP_SLOT) { 3111 u32 slottime; 3112 if (info->use_short_slot) 3113 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 3114 3115 else 3116 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 3117 3118 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n", 3119 arvif->vdev_id, slottime); 3120 3121 vdev_param = ar->wmi.vdev_param->slot_time; 3122 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 3123 slottime); 3124 if (ret) 3125 ath10k_warn("failed to set erp slot for vdev %d: %i\n", 3126 arvif->vdev_id, ret); 3127 } 3128 3129 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 3130 u32 preamble; 3131 if (info->use_short_preamble) 3132 preamble = WMI_VDEV_PREAMBLE_SHORT; 3133 else 3134 preamble = WMI_VDEV_PREAMBLE_LONG; 3135 3136 ath10k_dbg(ATH10K_DBG_MAC, 3137 "mac vdev %d preamble %dn", 3138 arvif->vdev_id, preamble); 3139 3140 vdev_param = ar->wmi.vdev_param->preamble; 3141 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 3142 preamble); 3143 if (ret) 3144 ath10k_warn("failed to set preamble for vdev %d: %i\n", 3145 arvif->vdev_id, ret); 3146 } 3147 3148 if (changed & BSS_CHANGED_ASSOC) { 3149 if (info->assoc) 3150 ath10k_bss_assoc(hw, vif, info); 3151 } 3152 3153 exit: 3154 mutex_unlock(&ar->conf_mutex); 3155 } 3156 3157 static int ath10k_hw_scan(struct ieee80211_hw *hw, 3158 struct ieee80211_vif *vif, 3159 struct ieee80211_scan_request *hw_req) 3160 { 3161 struct ath10k *ar = hw->priv; 3162 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3163 struct cfg80211_scan_request *req = &hw_req->req; 3164 struct wmi_start_scan_arg arg; 3165 int ret = 0; 3166 int i; 3167 3168 mutex_lock(&ar->conf_mutex); 3169 3170 spin_lock_bh(&ar->data_lock); 3171 if (ar->scan.in_progress) { 3172 spin_unlock_bh(&ar->data_lock); 3173 ret = -EBUSY; 3174 goto exit; 3175 } 3176 3177 reinit_completion(&ar->scan.started); 3178 reinit_completion(&ar->scan.completed); 3179 ar->scan.in_progress = true; 3180 ar->scan.aborting = false; 3181 ar->scan.is_roc = false; 3182 ar->scan.vdev_id = arvif->vdev_id; 3183 spin_unlock_bh(&ar->data_lock); 3184 3185 memset(&arg, 0, sizeof(arg)); 3186 ath10k_wmi_start_scan_init(ar, &arg); 3187 arg.vdev_id = arvif->vdev_id; 3188 arg.scan_id = ATH10K_SCAN_ID; 3189 3190 if (!req->no_cck) 3191 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES; 3192 3193 if (req->ie_len) { 3194 arg.ie_len = req->ie_len; 3195 memcpy(arg.ie, req->ie, arg.ie_len); 3196 } 3197 3198 if (req->n_ssids) { 3199 arg.n_ssids = req->n_ssids; 3200 for (i = 0; i < arg.n_ssids; i++) { 3201 arg.ssids[i].len = req->ssids[i].ssid_len; 3202 arg.ssids[i].ssid = req->ssids[i].ssid; 3203 } 3204 } else { 3205 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 3206 } 3207 3208 if (req->n_channels) { 3209 arg.n_channels = req->n_channels; 3210 for (i = 0; i < arg.n_channels; i++) 3211 arg.channels[i] = req->channels[i]->center_freq; 3212 } 3213 3214 ret = ath10k_start_scan(ar, &arg); 3215 if (ret) { 3216 ath10k_warn("failed to start hw scan: %d\n", ret); 3217 spin_lock_bh(&ar->data_lock); 3218 ar->scan.in_progress = false; 3219 spin_unlock_bh(&ar->data_lock); 3220 } 3221 3222 exit: 3223 mutex_unlock(&ar->conf_mutex); 3224 return ret; 3225 } 3226 3227 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw, 3228 struct ieee80211_vif *vif) 3229 { 3230 struct ath10k *ar = hw->priv; 3231 int ret; 3232 3233 mutex_lock(&ar->conf_mutex); 3234 ret = ath10k_abort_scan(ar); 3235 if (ret) { 3236 ath10k_warn("failed to abort scan: %d\n", ret); 3237 ieee80211_scan_completed(hw, 1 /* aborted */); 3238 } 3239 mutex_unlock(&ar->conf_mutex); 3240 } 3241 3242 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar, 3243 struct ath10k_vif *arvif, 3244 enum set_key_cmd cmd, 3245 struct ieee80211_key_conf *key) 3246 { 3247 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid; 3248 int ret; 3249 3250 /* 10.1 firmware branch requires default key index to be set to group 3251 * key index after installing it. Otherwise FW/HW Txes corrupted 3252 * frames with multi-vif APs. This is not required for main firmware 3253 * branch (e.g. 636). 3254 * 3255 * FIXME: This has been tested only in AP. It remains unknown if this 3256 * is required for multi-vif STA interfaces on 10.1 */ 3257 3258 if (arvif->vdev_type != WMI_VDEV_TYPE_AP) 3259 return; 3260 3261 if (key->cipher == WLAN_CIPHER_SUITE_WEP40) 3262 return; 3263 3264 if (key->cipher == WLAN_CIPHER_SUITE_WEP104) 3265 return; 3266 3267 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 3268 return; 3269 3270 if (cmd != SET_KEY) 3271 return; 3272 3273 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 3274 key->keyidx); 3275 if (ret) 3276 ath10k_warn("failed to set vdev %i group key as default key: %d\n", 3277 arvif->vdev_id, ret); 3278 } 3279 3280 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 3281 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 3282 struct ieee80211_key_conf *key) 3283 { 3284 struct ath10k *ar = hw->priv; 3285 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3286 struct ath10k_peer *peer; 3287 const u8 *peer_addr; 3288 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 || 3289 key->cipher == WLAN_CIPHER_SUITE_WEP104; 3290 int ret = 0; 3291 3292 if (key->keyidx > WMI_MAX_KEY_INDEX) 3293 return -ENOSPC; 3294 3295 mutex_lock(&ar->conf_mutex); 3296 3297 if (sta) 3298 peer_addr = sta->addr; 3299 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 3300 peer_addr = vif->bss_conf.bssid; 3301 else 3302 peer_addr = vif->addr; 3303 3304 key->hw_key_idx = key->keyidx; 3305 3306 /* the peer should not disappear in mid-way (unless FW goes awry) since 3307 * we already hold conf_mutex. we just make sure its there now. */ 3308 spin_lock_bh(&ar->data_lock); 3309 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 3310 spin_unlock_bh(&ar->data_lock); 3311 3312 if (!peer) { 3313 if (cmd == SET_KEY) { 3314 ath10k_warn("failed to install key for non-existent peer %pM\n", 3315 peer_addr); 3316 ret = -EOPNOTSUPP; 3317 goto exit; 3318 } else { 3319 /* if the peer doesn't exist there is no key to disable 3320 * anymore */ 3321 goto exit; 3322 } 3323 } 3324 3325 if (is_wep) { 3326 if (cmd == SET_KEY) 3327 arvif->wep_keys[key->keyidx] = key; 3328 else 3329 arvif->wep_keys[key->keyidx] = NULL; 3330 3331 if (cmd == DISABLE_KEY) 3332 ath10k_clear_vdev_key(arvif, key); 3333 } 3334 3335 ret = ath10k_install_key(arvif, key, cmd, peer_addr); 3336 if (ret) { 3337 ath10k_warn("failed to install key for vdev %i peer %pM: %d\n", 3338 arvif->vdev_id, peer_addr, ret); 3339 goto exit; 3340 } 3341 3342 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key); 3343 3344 spin_lock_bh(&ar->data_lock); 3345 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 3346 if (peer && cmd == SET_KEY) 3347 peer->keys[key->keyidx] = key; 3348 else if (peer && cmd == DISABLE_KEY) 3349 peer->keys[key->keyidx] = NULL; 3350 else if (peer == NULL) 3351 /* impossible unless FW goes crazy */ 3352 ath10k_warn("Peer %pM disappeared!\n", peer_addr); 3353 spin_unlock_bh(&ar->data_lock); 3354 3355 exit: 3356 mutex_unlock(&ar->conf_mutex); 3357 return ret; 3358 } 3359 3360 static void ath10k_sta_rc_update_wk(struct work_struct *wk) 3361 { 3362 struct ath10k *ar; 3363 struct ath10k_vif *arvif; 3364 struct ath10k_sta *arsta; 3365 struct ieee80211_sta *sta; 3366 u32 changed, bw, nss, smps; 3367 int err; 3368 3369 arsta = container_of(wk, struct ath10k_sta, update_wk); 3370 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 3371 arvif = arsta->arvif; 3372 ar = arvif->ar; 3373 3374 spin_lock_bh(&ar->data_lock); 3375 3376 changed = arsta->changed; 3377 arsta->changed = 0; 3378 3379 bw = arsta->bw; 3380 nss = arsta->nss; 3381 smps = arsta->smps; 3382 3383 spin_unlock_bh(&ar->data_lock); 3384 3385 mutex_lock(&ar->conf_mutex); 3386 3387 if (changed & IEEE80211_RC_BW_CHANGED) { 3388 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n", 3389 sta->addr, bw); 3390 3391 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 3392 WMI_PEER_CHAN_WIDTH, bw); 3393 if (err) 3394 ath10k_warn("failed to update STA %pM peer bw %d: %d\n", 3395 sta->addr, bw, err); 3396 } 3397 3398 if (changed & IEEE80211_RC_NSS_CHANGED) { 3399 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM nss %d\n", 3400 sta->addr, nss); 3401 3402 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 3403 WMI_PEER_NSS, nss); 3404 if (err) 3405 ath10k_warn("failed to update STA %pM nss %d: %d\n", 3406 sta->addr, nss, err); 3407 } 3408 3409 if (changed & IEEE80211_RC_SMPS_CHANGED) { 3410 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM smps %d\n", 3411 sta->addr, smps); 3412 3413 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 3414 WMI_PEER_SMPS_STATE, smps); 3415 if (err) 3416 ath10k_warn("failed to update STA %pM smps %d: %d\n", 3417 sta->addr, smps, err); 3418 } 3419 3420 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) { 3421 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM supp rates\n", 3422 sta->addr); 3423 3424 err = ath10k_station_assoc(ar, arvif, sta, true); 3425 if (err) 3426 ath10k_warn("failed to reassociate station: %pM\n", 3427 sta->addr); 3428 } 3429 3430 mutex_unlock(&ar->conf_mutex); 3431 } 3432 3433 static int ath10k_sta_state(struct ieee80211_hw *hw, 3434 struct ieee80211_vif *vif, 3435 struct ieee80211_sta *sta, 3436 enum ieee80211_sta_state old_state, 3437 enum ieee80211_sta_state new_state) 3438 { 3439 struct ath10k *ar = hw->priv; 3440 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3441 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 3442 int max_num_peers; 3443 int ret = 0; 3444 3445 if (old_state == IEEE80211_STA_NOTEXIST && 3446 new_state == IEEE80211_STA_NONE) { 3447 memset(arsta, 0, sizeof(*arsta)); 3448 arsta->arvif = arvif; 3449 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk); 3450 } 3451 3452 /* cancel must be done outside the mutex to avoid deadlock */ 3453 if ((old_state == IEEE80211_STA_NONE && 3454 new_state == IEEE80211_STA_NOTEXIST)) 3455 cancel_work_sync(&arsta->update_wk); 3456 3457 mutex_lock(&ar->conf_mutex); 3458 3459 if (old_state == IEEE80211_STA_NOTEXIST && 3460 new_state == IEEE80211_STA_NONE && 3461 vif->type != NL80211_IFTYPE_STATION) { 3462 /* 3463 * New station addition. 3464 */ 3465 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) 3466 max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1; 3467 else 3468 max_num_peers = TARGET_NUM_PEERS; 3469 3470 if (ar->num_peers >= max_num_peers) { 3471 ath10k_warn("number of peers exceeded: peers number %d (max peers %d)\n", 3472 ar->num_peers, max_num_peers); 3473 ret = -ENOBUFS; 3474 goto exit; 3475 } 3476 3477 ath10k_dbg(ATH10K_DBG_MAC, 3478 "mac vdev %d peer create %pM (new sta) num_peers %d\n", 3479 arvif->vdev_id, sta->addr, ar->num_peers); 3480 3481 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr); 3482 if (ret) 3483 ath10k_warn("failed to add peer %pM for vdev %d when adding a new sta: %i\n", 3484 sta->addr, arvif->vdev_id, ret); 3485 } else if ((old_state == IEEE80211_STA_NONE && 3486 new_state == IEEE80211_STA_NOTEXIST)) { 3487 /* 3488 * Existing station deletion. 3489 */ 3490 ath10k_dbg(ATH10K_DBG_MAC, 3491 "mac vdev %d peer delete %pM (sta gone)\n", 3492 arvif->vdev_id, sta->addr); 3493 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 3494 if (ret) 3495 ath10k_warn("failed to delete peer %pM for vdev %d: %i\n", 3496 sta->addr, arvif->vdev_id, ret); 3497 3498 if (vif->type == NL80211_IFTYPE_STATION) 3499 ath10k_bss_disassoc(hw, vif); 3500 } else if (old_state == IEEE80211_STA_AUTH && 3501 new_state == IEEE80211_STA_ASSOC && 3502 (vif->type == NL80211_IFTYPE_AP || 3503 vif->type == NL80211_IFTYPE_ADHOC)) { 3504 /* 3505 * New association. 3506 */ 3507 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n", 3508 sta->addr); 3509 3510 ret = ath10k_station_assoc(ar, arvif, sta, false); 3511 if (ret) 3512 ath10k_warn("failed to associate station %pM for vdev %i: %i\n", 3513 sta->addr, arvif->vdev_id, ret); 3514 } else if (old_state == IEEE80211_STA_ASSOC && 3515 new_state == IEEE80211_STA_AUTH && 3516 (vif->type == NL80211_IFTYPE_AP || 3517 vif->type == NL80211_IFTYPE_ADHOC)) { 3518 /* 3519 * Disassociation. 3520 */ 3521 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n", 3522 sta->addr); 3523 3524 ret = ath10k_station_disassoc(ar, arvif, sta); 3525 if (ret) 3526 ath10k_warn("failed to disassociate station: %pM vdev %i: %i\n", 3527 sta->addr, arvif->vdev_id, ret); 3528 } 3529 exit: 3530 mutex_unlock(&ar->conf_mutex); 3531 return ret; 3532 } 3533 3534 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif, 3535 u16 ac, bool enable) 3536 { 3537 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3538 u32 value = 0; 3539 int ret = 0; 3540 3541 lockdep_assert_held(&ar->conf_mutex); 3542 3543 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 3544 return 0; 3545 3546 switch (ac) { 3547 case IEEE80211_AC_VO: 3548 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 3549 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 3550 break; 3551 case IEEE80211_AC_VI: 3552 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 3553 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 3554 break; 3555 case IEEE80211_AC_BE: 3556 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 3557 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 3558 break; 3559 case IEEE80211_AC_BK: 3560 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 3561 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 3562 break; 3563 } 3564 3565 if (enable) 3566 arvif->u.sta.uapsd |= value; 3567 else 3568 arvif->u.sta.uapsd &= ~value; 3569 3570 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 3571 WMI_STA_PS_PARAM_UAPSD, 3572 arvif->u.sta.uapsd); 3573 if (ret) { 3574 ath10k_warn("failed to set uapsd params: %d\n", ret); 3575 goto exit; 3576 } 3577 3578 if (arvif->u.sta.uapsd) 3579 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 3580 else 3581 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 3582 3583 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 3584 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 3585 value); 3586 if (ret) 3587 ath10k_warn("failed to set rx wake param: %d\n", ret); 3588 3589 exit: 3590 return ret; 3591 } 3592 3593 static int ath10k_conf_tx(struct ieee80211_hw *hw, 3594 struct ieee80211_vif *vif, u16 ac, 3595 const struct ieee80211_tx_queue_params *params) 3596 { 3597 struct ath10k *ar = hw->priv; 3598 struct wmi_wmm_params_arg *p = NULL; 3599 int ret; 3600 3601 mutex_lock(&ar->conf_mutex); 3602 3603 switch (ac) { 3604 case IEEE80211_AC_VO: 3605 p = &ar->wmm_params.ac_vo; 3606 break; 3607 case IEEE80211_AC_VI: 3608 p = &ar->wmm_params.ac_vi; 3609 break; 3610 case IEEE80211_AC_BE: 3611 p = &ar->wmm_params.ac_be; 3612 break; 3613 case IEEE80211_AC_BK: 3614 p = &ar->wmm_params.ac_bk; 3615 break; 3616 } 3617 3618 if (WARN_ON(!p)) { 3619 ret = -EINVAL; 3620 goto exit; 3621 } 3622 3623 p->cwmin = params->cw_min; 3624 p->cwmax = params->cw_max; 3625 p->aifs = params->aifs; 3626 3627 /* 3628 * The channel time duration programmed in the HW is in absolute 3629 * microseconds, while mac80211 gives the txop in units of 3630 * 32 microseconds. 3631 */ 3632 p->txop = params->txop * 32; 3633 3634 /* FIXME: FW accepts wmm params per hw, not per vif */ 3635 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params); 3636 if (ret) { 3637 ath10k_warn("failed to set wmm params: %d\n", ret); 3638 goto exit; 3639 } 3640 3641 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 3642 if (ret) 3643 ath10k_warn("failed to set sta uapsd: %d\n", ret); 3644 3645 exit: 3646 mutex_unlock(&ar->conf_mutex); 3647 return ret; 3648 } 3649 3650 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ) 3651 3652 static int ath10k_remain_on_channel(struct ieee80211_hw *hw, 3653 struct ieee80211_vif *vif, 3654 struct ieee80211_channel *chan, 3655 int duration, 3656 enum ieee80211_roc_type type) 3657 { 3658 struct ath10k *ar = hw->priv; 3659 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3660 struct wmi_start_scan_arg arg; 3661 int ret; 3662 3663 mutex_lock(&ar->conf_mutex); 3664 3665 spin_lock_bh(&ar->data_lock); 3666 if (ar->scan.in_progress) { 3667 spin_unlock_bh(&ar->data_lock); 3668 ret = -EBUSY; 3669 goto exit; 3670 } 3671 3672 reinit_completion(&ar->scan.started); 3673 reinit_completion(&ar->scan.completed); 3674 reinit_completion(&ar->scan.on_channel); 3675 ar->scan.in_progress = true; 3676 ar->scan.aborting = false; 3677 ar->scan.is_roc = true; 3678 ar->scan.vdev_id = arvif->vdev_id; 3679 ar->scan.roc_freq = chan->center_freq; 3680 spin_unlock_bh(&ar->data_lock); 3681 3682 memset(&arg, 0, sizeof(arg)); 3683 ath10k_wmi_start_scan_init(ar, &arg); 3684 arg.vdev_id = arvif->vdev_id; 3685 arg.scan_id = ATH10K_SCAN_ID; 3686 arg.n_channels = 1; 3687 arg.channels[0] = chan->center_freq; 3688 arg.dwell_time_active = duration; 3689 arg.dwell_time_passive = duration; 3690 arg.max_scan_time = 2 * duration; 3691 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 3692 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ; 3693 3694 ret = ath10k_start_scan(ar, &arg); 3695 if (ret) { 3696 ath10k_warn("failed to start roc scan: %d\n", ret); 3697 spin_lock_bh(&ar->data_lock); 3698 ar->scan.in_progress = false; 3699 spin_unlock_bh(&ar->data_lock); 3700 goto exit; 3701 } 3702 3703 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ); 3704 if (ret == 0) { 3705 ath10k_warn("failed to switch to channel for roc scan\n"); 3706 ath10k_abort_scan(ar); 3707 ret = -ETIMEDOUT; 3708 goto exit; 3709 } 3710 3711 ret = 0; 3712 exit: 3713 mutex_unlock(&ar->conf_mutex); 3714 return ret; 3715 } 3716 3717 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw) 3718 { 3719 struct ath10k *ar = hw->priv; 3720 3721 mutex_lock(&ar->conf_mutex); 3722 ath10k_abort_scan(ar); 3723 mutex_unlock(&ar->conf_mutex); 3724 3725 return 0; 3726 } 3727 3728 /* 3729 * Both RTS and Fragmentation threshold are interface-specific 3730 * in ath10k, but device-specific in mac80211. 3731 */ 3732 3733 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 3734 { 3735 struct ath10k *ar = hw->priv; 3736 struct ath10k_vif *arvif; 3737 int ret = 0; 3738 3739 mutex_lock(&ar->conf_mutex); 3740 list_for_each_entry(arvif, &ar->arvifs, list) { 3741 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n", 3742 arvif->vdev_id, value); 3743 3744 ret = ath10k_mac_set_rts(arvif, value); 3745 if (ret) { 3746 ath10k_warn("failed to set rts threshold for vdev %d: %d\n", 3747 arvif->vdev_id, ret); 3748 break; 3749 } 3750 } 3751 mutex_unlock(&ar->conf_mutex); 3752 3753 return ret; 3754 } 3755 3756 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 3757 { 3758 struct ath10k *ar = hw->priv; 3759 struct ath10k_vif *arvif; 3760 int ret = 0; 3761 3762 mutex_lock(&ar->conf_mutex); 3763 list_for_each_entry(arvif, &ar->arvifs, list) { 3764 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n", 3765 arvif->vdev_id, value); 3766 3767 ret = ath10k_mac_set_rts(arvif, value); 3768 if (ret) { 3769 ath10k_warn("failed to set fragmentation threshold for vdev %d: %d\n", 3770 arvif->vdev_id, ret); 3771 break; 3772 } 3773 } 3774 mutex_unlock(&ar->conf_mutex); 3775 3776 return ret; 3777 } 3778 3779 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 3780 u32 queues, bool drop) 3781 { 3782 struct ath10k *ar = hw->priv; 3783 bool skip; 3784 int ret; 3785 3786 /* mac80211 doesn't care if we really xmit queued frames or not 3787 * we'll collect those frames either way if we stop/delete vdevs */ 3788 if (drop) 3789 return; 3790 3791 mutex_lock(&ar->conf_mutex); 3792 3793 if (ar->state == ATH10K_STATE_WEDGED) 3794 goto skip; 3795 3796 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({ 3797 bool empty; 3798 3799 spin_lock_bh(&ar->htt.tx_lock); 3800 empty = (ar->htt.num_pending_tx == 0); 3801 spin_unlock_bh(&ar->htt.tx_lock); 3802 3803 skip = (ar->state == ATH10K_STATE_WEDGED); 3804 3805 (empty || skip); 3806 }), ATH10K_FLUSH_TIMEOUT_HZ); 3807 3808 if (ret <= 0 || skip) 3809 ath10k_warn("failed to flush transmit queue (skip %i ar-state %i): %i\n", 3810 skip, ar->state, ret); 3811 3812 skip: 3813 mutex_unlock(&ar->conf_mutex); 3814 } 3815 3816 /* TODO: Implement this function properly 3817 * For now it is needed to reply to Probe Requests in IBSS mode. 3818 * Propably we need this information from FW. 3819 */ 3820 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw) 3821 { 3822 return 1; 3823 } 3824 3825 #ifdef CONFIG_PM 3826 static int ath10k_suspend(struct ieee80211_hw *hw, 3827 struct cfg80211_wowlan *wowlan) 3828 { 3829 struct ath10k *ar = hw->priv; 3830 int ret; 3831 3832 mutex_lock(&ar->conf_mutex); 3833 3834 ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND); 3835 if (ret) { 3836 if (ret == -ETIMEDOUT) 3837 goto resume; 3838 ret = 1; 3839 goto exit; 3840 } 3841 3842 ret = ath10k_hif_suspend(ar); 3843 if (ret) { 3844 ath10k_warn("failed to suspend hif: %d\n", ret); 3845 goto resume; 3846 } 3847 3848 ret = 0; 3849 goto exit; 3850 resume: 3851 ret = ath10k_wmi_pdev_resume_target(ar); 3852 if (ret) 3853 ath10k_warn("failed to resume target: %d\n", ret); 3854 3855 ret = 1; 3856 exit: 3857 mutex_unlock(&ar->conf_mutex); 3858 return ret; 3859 } 3860 3861 static int ath10k_resume(struct ieee80211_hw *hw) 3862 { 3863 struct ath10k *ar = hw->priv; 3864 int ret; 3865 3866 mutex_lock(&ar->conf_mutex); 3867 3868 ret = ath10k_hif_resume(ar); 3869 if (ret) { 3870 ath10k_warn("failed to resume hif: %d\n", ret); 3871 ret = 1; 3872 goto exit; 3873 } 3874 3875 ret = ath10k_wmi_pdev_resume_target(ar); 3876 if (ret) { 3877 ath10k_warn("failed to resume target: %d\n", ret); 3878 ret = 1; 3879 goto exit; 3880 } 3881 3882 ret = 0; 3883 exit: 3884 mutex_unlock(&ar->conf_mutex); 3885 return ret; 3886 } 3887 #endif 3888 3889 static void ath10k_restart_complete(struct ieee80211_hw *hw) 3890 { 3891 struct ath10k *ar = hw->priv; 3892 3893 mutex_lock(&ar->conf_mutex); 3894 3895 /* If device failed to restart it will be in a different state, e.g. 3896 * ATH10K_STATE_WEDGED */ 3897 if (ar->state == ATH10K_STATE_RESTARTED) { 3898 ath10k_info("device successfully recovered\n"); 3899 ar->state = ATH10K_STATE_ON; 3900 } 3901 3902 mutex_unlock(&ar->conf_mutex); 3903 } 3904 3905 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx, 3906 struct survey_info *survey) 3907 { 3908 struct ath10k *ar = hw->priv; 3909 struct ieee80211_supported_band *sband; 3910 struct survey_info *ar_survey = &ar->survey[idx]; 3911 int ret = 0; 3912 3913 mutex_lock(&ar->conf_mutex); 3914 3915 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ]; 3916 if (sband && idx >= sband->n_channels) { 3917 idx -= sband->n_channels; 3918 sband = NULL; 3919 } 3920 3921 if (!sband) 3922 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ]; 3923 3924 if (!sband || idx >= sband->n_channels) { 3925 ret = -ENOENT; 3926 goto exit; 3927 } 3928 3929 spin_lock_bh(&ar->data_lock); 3930 memcpy(survey, ar_survey, sizeof(*survey)); 3931 spin_unlock_bh(&ar->data_lock); 3932 3933 survey->channel = &sband->channels[idx]; 3934 3935 exit: 3936 mutex_unlock(&ar->conf_mutex); 3937 return ret; 3938 } 3939 3940 /* Helper table for legacy fixed_rate/bitrate_mask */ 3941 static const u8 cck_ofdm_rate[] = { 3942 /* CCK */ 3943 3, /* 1Mbps */ 3944 2, /* 2Mbps */ 3945 1, /* 5.5Mbps */ 3946 0, /* 11Mbps */ 3947 /* OFDM */ 3948 3, /* 6Mbps */ 3949 7, /* 9Mbps */ 3950 2, /* 12Mbps */ 3951 6, /* 18Mbps */ 3952 1, /* 24Mbps */ 3953 5, /* 36Mbps */ 3954 0, /* 48Mbps */ 3955 4, /* 54Mbps */ 3956 }; 3957 3958 /* Check if only one bit set */ 3959 static int ath10k_check_single_mask(u32 mask) 3960 { 3961 int bit; 3962 3963 bit = ffs(mask); 3964 if (!bit) 3965 return 0; 3966 3967 mask &= ~BIT(bit - 1); 3968 if (mask) 3969 return 2; 3970 3971 return 1; 3972 } 3973 3974 static bool 3975 ath10k_default_bitrate_mask(struct ath10k *ar, 3976 enum ieee80211_band band, 3977 const struct cfg80211_bitrate_mask *mask) 3978 { 3979 u32 legacy = 0x00ff; 3980 u8 ht = 0xff, i; 3981 u16 vht = 0x3ff; 3982 3983 switch (band) { 3984 case IEEE80211_BAND_2GHZ: 3985 legacy = 0x00fff; 3986 vht = 0; 3987 break; 3988 case IEEE80211_BAND_5GHZ: 3989 break; 3990 default: 3991 return false; 3992 } 3993 3994 if (mask->control[band].legacy != legacy) 3995 return false; 3996 3997 for (i = 0; i < ar->num_rf_chains; i++) 3998 if (mask->control[band].ht_mcs[i] != ht) 3999 return false; 4000 4001 for (i = 0; i < ar->num_rf_chains; i++) 4002 if (mask->control[band].vht_mcs[i] != vht) 4003 return false; 4004 4005 return true; 4006 } 4007 4008 static bool 4009 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask, 4010 enum ieee80211_band band, 4011 u8 *fixed_nss) 4012 { 4013 int ht_nss = 0, vht_nss = 0, i; 4014 4015 /* check legacy */ 4016 if (ath10k_check_single_mask(mask->control[band].legacy)) 4017 return false; 4018 4019 /* check HT */ 4020 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) { 4021 if (mask->control[band].ht_mcs[i] == 0xff) 4022 continue; 4023 else if (mask->control[band].ht_mcs[i] == 0x00) 4024 break; 4025 else 4026 return false; 4027 } 4028 4029 ht_nss = i; 4030 4031 /* check VHT */ 4032 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 4033 if (mask->control[band].vht_mcs[i] == 0x03ff) 4034 continue; 4035 else if (mask->control[band].vht_mcs[i] == 0x0000) 4036 break; 4037 else 4038 return false; 4039 } 4040 4041 vht_nss = i; 4042 4043 if (ht_nss > 0 && vht_nss > 0) 4044 return false; 4045 4046 if (ht_nss) 4047 *fixed_nss = ht_nss; 4048 else if (vht_nss) 4049 *fixed_nss = vht_nss; 4050 else 4051 return false; 4052 4053 return true; 4054 } 4055 4056 static bool 4057 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask, 4058 enum ieee80211_band band, 4059 enum wmi_rate_preamble *preamble) 4060 { 4061 int legacy = 0, ht = 0, vht = 0, i; 4062 4063 *preamble = WMI_RATE_PREAMBLE_OFDM; 4064 4065 /* check legacy */ 4066 legacy = ath10k_check_single_mask(mask->control[band].legacy); 4067 if (legacy > 1) 4068 return false; 4069 4070 /* check HT */ 4071 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) 4072 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]); 4073 if (ht > 1) 4074 return false; 4075 4076 /* check VHT */ 4077 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) 4078 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]); 4079 if (vht > 1) 4080 return false; 4081 4082 /* Currently we support only one fixed_rate */ 4083 if ((legacy + ht + vht) != 1) 4084 return false; 4085 4086 if (ht) 4087 *preamble = WMI_RATE_PREAMBLE_HT; 4088 else if (vht) 4089 *preamble = WMI_RATE_PREAMBLE_VHT; 4090 4091 return true; 4092 } 4093 4094 static bool 4095 ath10k_bitrate_mask_rate(const struct cfg80211_bitrate_mask *mask, 4096 enum ieee80211_band band, 4097 u8 *fixed_rate, 4098 u8 *fixed_nss) 4099 { 4100 u8 rate = 0, pream = 0, nss = 0, i; 4101 enum wmi_rate_preamble preamble; 4102 4103 /* Check if single rate correct */ 4104 if (!ath10k_bitrate_mask_correct(mask, band, &preamble)) 4105 return false; 4106 4107 pream = preamble; 4108 4109 switch (preamble) { 4110 case WMI_RATE_PREAMBLE_CCK: 4111 case WMI_RATE_PREAMBLE_OFDM: 4112 i = ffs(mask->control[band].legacy) - 1; 4113 4114 if (band == IEEE80211_BAND_2GHZ && i < 4) 4115 pream = WMI_RATE_PREAMBLE_CCK; 4116 4117 if (band == IEEE80211_BAND_5GHZ) 4118 i += 4; 4119 4120 if (i >= ARRAY_SIZE(cck_ofdm_rate)) 4121 return false; 4122 4123 rate = cck_ofdm_rate[i]; 4124 break; 4125 case WMI_RATE_PREAMBLE_HT: 4126 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) 4127 if (mask->control[band].ht_mcs[i]) 4128 break; 4129 4130 if (i == IEEE80211_HT_MCS_MASK_LEN) 4131 return false; 4132 4133 rate = ffs(mask->control[band].ht_mcs[i]) - 1; 4134 nss = i; 4135 break; 4136 case WMI_RATE_PREAMBLE_VHT: 4137 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) 4138 if (mask->control[band].vht_mcs[i]) 4139 break; 4140 4141 if (i == NL80211_VHT_NSS_MAX) 4142 return false; 4143 4144 rate = ffs(mask->control[band].vht_mcs[i]) - 1; 4145 nss = i; 4146 break; 4147 } 4148 4149 *fixed_nss = nss + 1; 4150 nss <<= 4; 4151 pream <<= 6; 4152 4153 ath10k_dbg(ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n", 4154 pream, nss, rate); 4155 4156 *fixed_rate = pream | nss | rate; 4157 4158 return true; 4159 } 4160 4161 static bool ath10k_get_fixed_rate_nss(const struct cfg80211_bitrate_mask *mask, 4162 enum ieee80211_band band, 4163 u8 *fixed_rate, 4164 u8 *fixed_nss) 4165 { 4166 /* First check full NSS mask, if we can simply limit NSS */ 4167 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss)) 4168 return true; 4169 4170 /* Next Check single rate is set */ 4171 return ath10k_bitrate_mask_rate(mask, band, fixed_rate, fixed_nss); 4172 } 4173 4174 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif, 4175 u8 fixed_rate, 4176 u8 fixed_nss, 4177 u8 force_sgi) 4178 { 4179 struct ath10k *ar = arvif->ar; 4180 u32 vdev_param; 4181 int ret = 0; 4182 4183 mutex_lock(&ar->conf_mutex); 4184 4185 if (arvif->fixed_rate == fixed_rate && 4186 arvif->fixed_nss == fixed_nss && 4187 arvif->force_sgi == force_sgi) 4188 goto exit; 4189 4190 if (fixed_rate == WMI_FIXED_RATE_NONE) 4191 ath10k_dbg(ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n"); 4192 4193 if (force_sgi) 4194 ath10k_dbg(ATH10K_DBG_MAC, "mac force sgi\n"); 4195 4196 vdev_param = ar->wmi.vdev_param->fixed_rate; 4197 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 4198 vdev_param, fixed_rate); 4199 if (ret) { 4200 ath10k_warn("failed to set fixed rate param 0x%02x: %d\n", 4201 fixed_rate, ret); 4202 ret = -EINVAL; 4203 goto exit; 4204 } 4205 4206 arvif->fixed_rate = fixed_rate; 4207 4208 vdev_param = ar->wmi.vdev_param->nss; 4209 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 4210 vdev_param, fixed_nss); 4211 4212 if (ret) { 4213 ath10k_warn("failed to set fixed nss param %d: %d\n", 4214 fixed_nss, ret); 4215 ret = -EINVAL; 4216 goto exit; 4217 } 4218 4219 arvif->fixed_nss = fixed_nss; 4220 4221 vdev_param = ar->wmi.vdev_param->sgi; 4222 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 4223 force_sgi); 4224 4225 if (ret) { 4226 ath10k_warn("failed to set sgi param %d: %d\n", 4227 force_sgi, ret); 4228 ret = -EINVAL; 4229 goto exit; 4230 } 4231 4232 arvif->force_sgi = force_sgi; 4233 4234 exit: 4235 mutex_unlock(&ar->conf_mutex); 4236 return ret; 4237 } 4238 4239 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw, 4240 struct ieee80211_vif *vif, 4241 const struct cfg80211_bitrate_mask *mask) 4242 { 4243 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 4244 struct ath10k *ar = arvif->ar; 4245 enum ieee80211_band band = ar->hw->conf.chandef.chan->band; 4246 u8 fixed_rate = WMI_FIXED_RATE_NONE; 4247 u8 fixed_nss = ar->num_rf_chains; 4248 u8 force_sgi; 4249 4250 force_sgi = mask->control[band].gi; 4251 if (force_sgi == NL80211_TXRATE_FORCE_LGI) 4252 return -EINVAL; 4253 4254 if (!ath10k_default_bitrate_mask(ar, band, mask)) { 4255 if (!ath10k_get_fixed_rate_nss(mask, band, 4256 &fixed_rate, 4257 &fixed_nss)) 4258 return -EINVAL; 4259 } 4260 4261 if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) { 4262 ath10k_warn("failed to force SGI usage for default rate settings\n"); 4263 return -EINVAL; 4264 } 4265 4266 return ath10k_set_fixed_rate_param(arvif, fixed_rate, 4267 fixed_nss, force_sgi); 4268 } 4269 4270 static void ath10k_sta_rc_update(struct ieee80211_hw *hw, 4271 struct ieee80211_vif *vif, 4272 struct ieee80211_sta *sta, 4273 u32 changed) 4274 { 4275 struct ath10k *ar = hw->priv; 4276 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 4277 u32 bw, smps; 4278 4279 spin_lock_bh(&ar->data_lock); 4280 4281 ath10k_dbg(ATH10K_DBG_MAC, 4282 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 4283 sta->addr, changed, sta->bandwidth, sta->rx_nss, 4284 sta->smps_mode); 4285 4286 if (changed & IEEE80211_RC_BW_CHANGED) { 4287 bw = WMI_PEER_CHWIDTH_20MHZ; 4288 4289 switch (sta->bandwidth) { 4290 case IEEE80211_STA_RX_BW_20: 4291 bw = WMI_PEER_CHWIDTH_20MHZ; 4292 break; 4293 case IEEE80211_STA_RX_BW_40: 4294 bw = WMI_PEER_CHWIDTH_40MHZ; 4295 break; 4296 case IEEE80211_STA_RX_BW_80: 4297 bw = WMI_PEER_CHWIDTH_80MHZ; 4298 break; 4299 case IEEE80211_STA_RX_BW_160: 4300 ath10k_warn("Invalid bandwith %d in rc update for %pM\n", 4301 sta->bandwidth, sta->addr); 4302 bw = WMI_PEER_CHWIDTH_20MHZ; 4303 break; 4304 } 4305 4306 arsta->bw = bw; 4307 } 4308 4309 if (changed & IEEE80211_RC_NSS_CHANGED) 4310 arsta->nss = sta->rx_nss; 4311 4312 if (changed & IEEE80211_RC_SMPS_CHANGED) { 4313 smps = WMI_PEER_SMPS_PS_NONE; 4314 4315 switch (sta->smps_mode) { 4316 case IEEE80211_SMPS_AUTOMATIC: 4317 case IEEE80211_SMPS_OFF: 4318 smps = WMI_PEER_SMPS_PS_NONE; 4319 break; 4320 case IEEE80211_SMPS_STATIC: 4321 smps = WMI_PEER_SMPS_STATIC; 4322 break; 4323 case IEEE80211_SMPS_DYNAMIC: 4324 smps = WMI_PEER_SMPS_DYNAMIC; 4325 break; 4326 case IEEE80211_SMPS_NUM_MODES: 4327 ath10k_warn("Invalid smps %d in sta rc update for %pM\n", 4328 sta->smps_mode, sta->addr); 4329 smps = WMI_PEER_SMPS_PS_NONE; 4330 break; 4331 } 4332 4333 arsta->smps = smps; 4334 } 4335 4336 arsta->changed |= changed; 4337 4338 spin_unlock_bh(&ar->data_lock); 4339 4340 ieee80211_queue_work(hw, &arsta->update_wk); 4341 } 4342 4343 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 4344 { 4345 /* 4346 * FIXME: Return 0 for time being. Need to figure out whether FW 4347 * has the API to fetch 64-bit local TSF 4348 */ 4349 4350 return 0; 4351 } 4352 4353 static int ath10k_ampdu_action(struct ieee80211_hw *hw, 4354 struct ieee80211_vif *vif, 4355 enum ieee80211_ampdu_mlme_action action, 4356 struct ieee80211_sta *sta, u16 tid, u16 *ssn, 4357 u8 buf_size) 4358 { 4359 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 4360 4361 ath10k_dbg(ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n", 4362 arvif->vdev_id, sta->addr, tid, action); 4363 4364 switch (action) { 4365 case IEEE80211_AMPDU_RX_START: 4366 case IEEE80211_AMPDU_RX_STOP: 4367 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session 4368 * creation/removal. Do we need to verify this? 4369 */ 4370 return 0; 4371 case IEEE80211_AMPDU_TX_START: 4372 case IEEE80211_AMPDU_TX_STOP_CONT: 4373 case IEEE80211_AMPDU_TX_STOP_FLUSH: 4374 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 4375 case IEEE80211_AMPDU_TX_OPERATIONAL: 4376 /* Firmware offloads Tx aggregation entirely so deny mac80211 4377 * Tx aggregation requests. 4378 */ 4379 return -EOPNOTSUPP; 4380 } 4381 4382 return -EINVAL; 4383 } 4384 4385 static const struct ieee80211_ops ath10k_ops = { 4386 .tx = ath10k_tx, 4387 .start = ath10k_start, 4388 .stop = ath10k_stop, 4389 .config = ath10k_config, 4390 .add_interface = ath10k_add_interface, 4391 .remove_interface = ath10k_remove_interface, 4392 .configure_filter = ath10k_configure_filter, 4393 .bss_info_changed = ath10k_bss_info_changed, 4394 .hw_scan = ath10k_hw_scan, 4395 .cancel_hw_scan = ath10k_cancel_hw_scan, 4396 .set_key = ath10k_set_key, 4397 .sta_state = ath10k_sta_state, 4398 .conf_tx = ath10k_conf_tx, 4399 .remain_on_channel = ath10k_remain_on_channel, 4400 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel, 4401 .set_rts_threshold = ath10k_set_rts_threshold, 4402 .set_frag_threshold = ath10k_set_frag_threshold, 4403 .flush = ath10k_flush, 4404 .tx_last_beacon = ath10k_tx_last_beacon, 4405 .set_antenna = ath10k_set_antenna, 4406 .get_antenna = ath10k_get_antenna, 4407 .restart_complete = ath10k_restart_complete, 4408 .get_survey = ath10k_get_survey, 4409 .set_bitrate_mask = ath10k_set_bitrate_mask, 4410 .sta_rc_update = ath10k_sta_rc_update, 4411 .get_tsf = ath10k_get_tsf, 4412 .ampdu_action = ath10k_ampdu_action, 4413 #ifdef CONFIG_PM 4414 .suspend = ath10k_suspend, 4415 .resume = ath10k_resume, 4416 #endif 4417 }; 4418 4419 #define RATETAB_ENT(_rate, _rateid, _flags) { \ 4420 .bitrate = (_rate), \ 4421 .flags = (_flags), \ 4422 .hw_value = (_rateid), \ 4423 } 4424 4425 #define CHAN2G(_channel, _freq, _flags) { \ 4426 .band = IEEE80211_BAND_2GHZ, \ 4427 .hw_value = (_channel), \ 4428 .center_freq = (_freq), \ 4429 .flags = (_flags), \ 4430 .max_antenna_gain = 0, \ 4431 .max_power = 30, \ 4432 } 4433 4434 #define CHAN5G(_channel, _freq, _flags) { \ 4435 .band = IEEE80211_BAND_5GHZ, \ 4436 .hw_value = (_channel), \ 4437 .center_freq = (_freq), \ 4438 .flags = (_flags), \ 4439 .max_antenna_gain = 0, \ 4440 .max_power = 30, \ 4441 } 4442 4443 static const struct ieee80211_channel ath10k_2ghz_channels[] = { 4444 CHAN2G(1, 2412, 0), 4445 CHAN2G(2, 2417, 0), 4446 CHAN2G(3, 2422, 0), 4447 CHAN2G(4, 2427, 0), 4448 CHAN2G(5, 2432, 0), 4449 CHAN2G(6, 2437, 0), 4450 CHAN2G(7, 2442, 0), 4451 CHAN2G(8, 2447, 0), 4452 CHAN2G(9, 2452, 0), 4453 CHAN2G(10, 2457, 0), 4454 CHAN2G(11, 2462, 0), 4455 CHAN2G(12, 2467, 0), 4456 CHAN2G(13, 2472, 0), 4457 CHAN2G(14, 2484, 0), 4458 }; 4459 4460 static const struct ieee80211_channel ath10k_5ghz_channels[] = { 4461 CHAN5G(36, 5180, 0), 4462 CHAN5G(40, 5200, 0), 4463 CHAN5G(44, 5220, 0), 4464 CHAN5G(48, 5240, 0), 4465 CHAN5G(52, 5260, 0), 4466 CHAN5G(56, 5280, 0), 4467 CHAN5G(60, 5300, 0), 4468 CHAN5G(64, 5320, 0), 4469 CHAN5G(100, 5500, 0), 4470 CHAN5G(104, 5520, 0), 4471 CHAN5G(108, 5540, 0), 4472 CHAN5G(112, 5560, 0), 4473 CHAN5G(116, 5580, 0), 4474 CHAN5G(120, 5600, 0), 4475 CHAN5G(124, 5620, 0), 4476 CHAN5G(128, 5640, 0), 4477 CHAN5G(132, 5660, 0), 4478 CHAN5G(136, 5680, 0), 4479 CHAN5G(140, 5700, 0), 4480 CHAN5G(149, 5745, 0), 4481 CHAN5G(153, 5765, 0), 4482 CHAN5G(157, 5785, 0), 4483 CHAN5G(161, 5805, 0), 4484 CHAN5G(165, 5825, 0), 4485 }; 4486 4487 static struct ieee80211_rate ath10k_rates[] = { 4488 /* CCK */ 4489 RATETAB_ENT(10, 0x82, 0), 4490 RATETAB_ENT(20, 0x84, 0), 4491 RATETAB_ENT(55, 0x8b, 0), 4492 RATETAB_ENT(110, 0x96, 0), 4493 /* OFDM */ 4494 RATETAB_ENT(60, 0x0c, 0), 4495 RATETAB_ENT(90, 0x12, 0), 4496 RATETAB_ENT(120, 0x18, 0), 4497 RATETAB_ENT(180, 0x24, 0), 4498 RATETAB_ENT(240, 0x30, 0), 4499 RATETAB_ENT(360, 0x48, 0), 4500 RATETAB_ENT(480, 0x60, 0), 4501 RATETAB_ENT(540, 0x6c, 0), 4502 }; 4503 4504 #define ath10k_a_rates (ath10k_rates + 4) 4505 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4) 4506 #define ath10k_g_rates (ath10k_rates + 0) 4507 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates)) 4508 4509 struct ath10k *ath10k_mac_create(void) 4510 { 4511 struct ieee80211_hw *hw; 4512 struct ath10k *ar; 4513 4514 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops); 4515 if (!hw) 4516 return NULL; 4517 4518 ar = hw->priv; 4519 ar->hw = hw; 4520 4521 return ar; 4522 } 4523 4524 void ath10k_mac_destroy(struct ath10k *ar) 4525 { 4526 ieee80211_free_hw(ar->hw); 4527 } 4528 4529 static const struct ieee80211_iface_limit ath10k_if_limits[] = { 4530 { 4531 .max = 8, 4532 .types = BIT(NL80211_IFTYPE_STATION) 4533 | BIT(NL80211_IFTYPE_P2P_CLIENT) 4534 }, 4535 { 4536 .max = 3, 4537 .types = BIT(NL80211_IFTYPE_P2P_GO) 4538 }, 4539 { 4540 .max = 7, 4541 .types = BIT(NL80211_IFTYPE_AP) 4542 }, 4543 }; 4544 4545 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = { 4546 { 4547 .max = 8, 4548 .types = BIT(NL80211_IFTYPE_AP) 4549 }, 4550 }; 4551 4552 static const struct ieee80211_iface_combination ath10k_if_comb[] = { 4553 { 4554 .limits = ath10k_if_limits, 4555 .n_limits = ARRAY_SIZE(ath10k_if_limits), 4556 .max_interfaces = 8, 4557 .num_different_channels = 1, 4558 .beacon_int_infra_match = true, 4559 }, 4560 }; 4561 4562 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = { 4563 { 4564 .limits = ath10k_10x_if_limits, 4565 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits), 4566 .max_interfaces = 8, 4567 .num_different_channels = 1, 4568 .beacon_int_infra_match = true, 4569 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 4570 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 4571 BIT(NL80211_CHAN_WIDTH_20) | 4572 BIT(NL80211_CHAN_WIDTH_40) | 4573 BIT(NL80211_CHAN_WIDTH_80), 4574 #endif 4575 }, 4576 }; 4577 4578 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar) 4579 { 4580 struct ieee80211_sta_vht_cap vht_cap = {0}; 4581 u16 mcs_map; 4582 int i; 4583 4584 vht_cap.vht_supported = 1; 4585 vht_cap.cap = ar->vht_cap_info; 4586 4587 mcs_map = 0; 4588 for (i = 0; i < 8; i++) { 4589 if (i < ar->num_rf_chains) 4590 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2); 4591 else 4592 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2); 4593 } 4594 4595 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map); 4596 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map); 4597 4598 return vht_cap; 4599 } 4600 4601 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar) 4602 { 4603 int i; 4604 struct ieee80211_sta_ht_cap ht_cap = {0}; 4605 4606 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED)) 4607 return ht_cap; 4608 4609 ht_cap.ht_supported = 1; 4610 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 4611 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8; 4612 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 4613 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 4614 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT; 4615 4616 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI) 4617 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 4618 4619 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI) 4620 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 4621 4622 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) { 4623 u32 smps; 4624 4625 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 4626 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 4627 4628 ht_cap.cap |= smps; 4629 } 4630 4631 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC) 4632 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 4633 4634 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) { 4635 u32 stbc; 4636 4637 stbc = ar->ht_cap_info; 4638 stbc &= WMI_HT_CAP_RX_STBC; 4639 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 4640 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 4641 stbc &= IEEE80211_HT_CAP_RX_STBC; 4642 4643 ht_cap.cap |= stbc; 4644 } 4645 4646 if (ar->ht_cap_info & WMI_HT_CAP_LDPC) 4647 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 4648 4649 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT) 4650 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 4651 4652 /* max AMSDU is implicitly taken from vht_cap_info */ 4653 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 4654 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 4655 4656 for (i = 0; i < ar->num_rf_chains; i++) 4657 ht_cap.mcs.rx_mask[i] = 0xFF; 4658 4659 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 4660 4661 return ht_cap; 4662 } 4663 4664 4665 static void ath10k_get_arvif_iter(void *data, u8 *mac, 4666 struct ieee80211_vif *vif) 4667 { 4668 struct ath10k_vif_iter *arvif_iter = data; 4669 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 4670 4671 if (arvif->vdev_id == arvif_iter->vdev_id) 4672 arvif_iter->arvif = arvif; 4673 } 4674 4675 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id) 4676 { 4677 struct ath10k_vif_iter arvif_iter; 4678 u32 flags; 4679 4680 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter)); 4681 arvif_iter.vdev_id = vdev_id; 4682 4683 flags = IEEE80211_IFACE_ITER_RESUME_ALL; 4684 ieee80211_iterate_active_interfaces_atomic(ar->hw, 4685 flags, 4686 ath10k_get_arvif_iter, 4687 &arvif_iter); 4688 if (!arvif_iter.arvif) { 4689 ath10k_warn("No VIF found for vdev %d\n", vdev_id); 4690 return NULL; 4691 } 4692 4693 return arvif_iter.arvif; 4694 } 4695 4696 int ath10k_mac_register(struct ath10k *ar) 4697 { 4698 struct ieee80211_supported_band *band; 4699 struct ieee80211_sta_vht_cap vht_cap; 4700 struct ieee80211_sta_ht_cap ht_cap; 4701 void *channels; 4702 int ret; 4703 4704 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 4705 4706 SET_IEEE80211_DEV(ar->hw, ar->dev); 4707 4708 ht_cap = ath10k_get_ht_cap(ar); 4709 vht_cap = ath10k_create_vht_cap(ar); 4710 4711 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) { 4712 channels = kmemdup(ath10k_2ghz_channels, 4713 sizeof(ath10k_2ghz_channels), 4714 GFP_KERNEL); 4715 if (!channels) { 4716 ret = -ENOMEM; 4717 goto err_free; 4718 } 4719 4720 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ]; 4721 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels); 4722 band->channels = channels; 4723 band->n_bitrates = ath10k_g_rates_size; 4724 band->bitrates = ath10k_g_rates; 4725 band->ht_cap = ht_cap; 4726 4727 /* vht is not supported in 2.4 GHz */ 4728 4729 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band; 4730 } 4731 4732 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) { 4733 channels = kmemdup(ath10k_5ghz_channels, 4734 sizeof(ath10k_5ghz_channels), 4735 GFP_KERNEL); 4736 if (!channels) { 4737 ret = -ENOMEM; 4738 goto err_free; 4739 } 4740 4741 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ]; 4742 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels); 4743 band->channels = channels; 4744 band->n_bitrates = ath10k_a_rates_size; 4745 band->bitrates = ath10k_a_rates; 4746 band->ht_cap = ht_cap; 4747 band->vht_cap = vht_cap; 4748 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band; 4749 } 4750 4751 ar->hw->wiphy->interface_modes = 4752 BIT(NL80211_IFTYPE_STATION) | 4753 BIT(NL80211_IFTYPE_AP); 4754 4755 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) { 4756 /* TODO: Have to deal with 2x2 chips if/when the come out. */ 4757 ar->supp_tx_chainmask = TARGET_10X_TX_CHAIN_MASK; 4758 ar->supp_rx_chainmask = TARGET_10X_RX_CHAIN_MASK; 4759 } else { 4760 ar->supp_tx_chainmask = TARGET_TX_CHAIN_MASK; 4761 ar->supp_rx_chainmask = TARGET_RX_CHAIN_MASK; 4762 } 4763 4764 ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask; 4765 ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask; 4766 4767 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features)) 4768 ar->hw->wiphy->interface_modes |= 4769 BIT(NL80211_IFTYPE_P2P_CLIENT) | 4770 BIT(NL80211_IFTYPE_P2P_GO); 4771 4772 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM | 4773 IEEE80211_HW_SUPPORTS_PS | 4774 IEEE80211_HW_SUPPORTS_DYNAMIC_PS | 4775 IEEE80211_HW_SUPPORTS_UAPSD | 4776 IEEE80211_HW_MFP_CAPABLE | 4777 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 4778 IEEE80211_HW_HAS_RATE_CONTROL | 4779 IEEE80211_HW_SUPPORTS_STATIC_SMPS | 4780 IEEE80211_HW_AP_LINK_PS | 4781 IEEE80211_HW_SPECTRUM_MGMT; 4782 4783 /* MSDU can have HTT TX fragment pushed in front. The additional 4 4784 * bytes is used for padding/alignment if necessary. */ 4785 ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4; 4786 4787 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 4788 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS; 4789 4790 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) { 4791 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION; 4792 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW; 4793 } 4794 4795 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 4796 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 4797 4798 ar->hw->vif_data_size = sizeof(struct ath10k_vif); 4799 ar->hw->sta_data_size = sizeof(struct ath10k_sta); 4800 4801 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL; 4802 4803 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 4804 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 4805 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 4806 4807 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 4808 /* 4809 * on LL hardware queues are managed entirely by the FW 4810 * so we only advertise to mac we can do the queues thing 4811 */ 4812 ar->hw->queues = 4; 4813 4814 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) { 4815 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb; 4816 ar->hw->wiphy->n_iface_combinations = 4817 ARRAY_SIZE(ath10k_10x_if_comb); 4818 } else { 4819 ar->hw->wiphy->iface_combinations = ath10k_if_comb; 4820 ar->hw->wiphy->n_iface_combinations = 4821 ARRAY_SIZE(ath10k_if_comb); 4822 4823 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC); 4824 } 4825 4826 ar->hw->netdev_features = NETIF_F_HW_CSUM; 4827 4828 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) { 4829 /* Init ath dfs pattern detector */ 4830 ar->ath_common.debug_mask = ATH_DBG_DFS; 4831 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common, 4832 NL80211_DFS_UNSET); 4833 4834 if (!ar->dfs_detector) 4835 ath10k_warn("failed to initialise DFS pattern detector\n"); 4836 } 4837 4838 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy, 4839 ath10k_reg_notifier); 4840 if (ret) { 4841 ath10k_err("failed to initialise regulatory: %i\n", ret); 4842 goto err_free; 4843 } 4844 4845 ret = ieee80211_register_hw(ar->hw); 4846 if (ret) { 4847 ath10k_err("failed to register ieee80211: %d\n", ret); 4848 goto err_free; 4849 } 4850 4851 if (!ath_is_world_regd(&ar->ath_common.regulatory)) { 4852 ret = regulatory_hint(ar->hw->wiphy, 4853 ar->ath_common.regulatory.alpha2); 4854 if (ret) 4855 goto err_unregister; 4856 } 4857 4858 return 0; 4859 4860 err_unregister: 4861 ieee80211_unregister_hw(ar->hw); 4862 err_free: 4863 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels); 4864 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels); 4865 4866 return ret; 4867 } 4868 4869 void ath10k_mac_unregister(struct ath10k *ar) 4870 { 4871 ieee80211_unregister_hw(ar->hw); 4872 4873 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) 4874 ar->dfs_detector->exit(ar->dfs_detector); 4875 4876 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels); 4877 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels); 4878 4879 SET_IEEE80211_DEV(ar->hw, NULL); 4880 } 4881