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