1 /* 2 * Copyright (c) 2005-2011 Atheros Communications Inc. 3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 #include "mac.h" 19 20 #include <net/mac80211.h> 21 #include <linux/etherdevice.h> 22 23 #include "hif.h" 24 #include "core.h" 25 #include "debug.h" 26 #include "wmi.h" 27 #include "htt.h" 28 #include "txrx.h" 29 #include "testmode.h" 30 #include "wmi.h" 31 #include "wmi-tlv.h" 32 #include "wmi-ops.h" 33 #include "wow.h" 34 35 /*********/ 36 /* Rates */ 37 /*********/ 38 39 static struct ieee80211_rate ath10k_rates[] = { 40 { .bitrate = 10, 41 .hw_value = ATH10K_HW_RATE_CCK_LP_1M }, 42 { .bitrate = 20, 43 .hw_value = ATH10K_HW_RATE_CCK_LP_2M, 44 .hw_value_short = ATH10K_HW_RATE_CCK_SP_2M, 45 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 46 { .bitrate = 55, 47 .hw_value = ATH10K_HW_RATE_CCK_LP_5_5M, 48 .hw_value_short = ATH10K_HW_RATE_CCK_SP_5_5M, 49 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 50 { .bitrate = 110, 51 .hw_value = ATH10K_HW_RATE_CCK_LP_11M, 52 .hw_value_short = ATH10K_HW_RATE_CCK_SP_11M, 53 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 54 55 { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M }, 56 { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M }, 57 { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M }, 58 { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M }, 59 { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M }, 60 { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M }, 61 { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M }, 62 { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M }, 63 }; 64 65 #define ATH10K_MAC_FIRST_OFDM_RATE_IDX 4 66 67 #define ath10k_a_rates (ath10k_rates + ATH10K_MAC_FIRST_OFDM_RATE_IDX) 68 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - \ 69 ATH10K_MAC_FIRST_OFDM_RATE_IDX) 70 #define ath10k_g_rates (ath10k_rates + 0) 71 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates)) 72 73 static bool ath10k_mac_bitrate_is_cck(int bitrate) 74 { 75 switch (bitrate) { 76 case 10: 77 case 20: 78 case 55: 79 case 110: 80 return true; 81 } 82 83 return false; 84 } 85 86 static u8 ath10k_mac_bitrate_to_rate(int bitrate) 87 { 88 return DIV_ROUND_UP(bitrate, 5) | 89 (ath10k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0); 90 } 91 92 u8 ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband, 93 u8 hw_rate) 94 { 95 const struct ieee80211_rate *rate; 96 int i; 97 98 for (i = 0; i < sband->n_bitrates; i++) { 99 rate = &sband->bitrates[i]; 100 101 if (rate->hw_value == hw_rate) 102 return i; 103 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE && 104 rate->hw_value_short == hw_rate) 105 return i; 106 } 107 108 return 0; 109 } 110 111 u8 ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband, 112 u32 bitrate) 113 { 114 int i; 115 116 for (i = 0; i < sband->n_bitrates; i++) 117 if (sband->bitrates[i].bitrate == bitrate) 118 return i; 119 120 return 0; 121 } 122 123 static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss) 124 { 125 switch ((mcs_map >> (2 * nss)) & 0x3) { 126 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1; 127 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1; 128 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1; 129 } 130 return 0; 131 } 132 133 static u32 134 ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN]) 135 { 136 int nss; 137 138 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--) 139 if (ht_mcs_mask[nss]) 140 return nss + 1; 141 142 return 1; 143 } 144 145 static u32 146 ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX]) 147 { 148 int nss; 149 150 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--) 151 if (vht_mcs_mask[nss]) 152 return nss + 1; 153 154 return 1; 155 } 156 157 /**********/ 158 /* Crypto */ 159 /**********/ 160 161 static int ath10k_send_key(struct ath10k_vif *arvif, 162 struct ieee80211_key_conf *key, 163 enum set_key_cmd cmd, 164 const u8 *macaddr, u32 flags) 165 { 166 struct ath10k *ar = arvif->ar; 167 struct wmi_vdev_install_key_arg arg = { 168 .vdev_id = arvif->vdev_id, 169 .key_idx = key->keyidx, 170 .key_len = key->keylen, 171 .key_data = key->key, 172 .key_flags = flags, 173 .macaddr = macaddr, 174 }; 175 176 lockdep_assert_held(&arvif->ar->conf_mutex); 177 178 switch (key->cipher) { 179 case WLAN_CIPHER_SUITE_CCMP: 180 arg.key_cipher = WMI_CIPHER_AES_CCM; 181 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT; 182 break; 183 case WLAN_CIPHER_SUITE_TKIP: 184 arg.key_cipher = WMI_CIPHER_TKIP; 185 arg.key_txmic_len = 8; 186 arg.key_rxmic_len = 8; 187 break; 188 case WLAN_CIPHER_SUITE_WEP40: 189 case WLAN_CIPHER_SUITE_WEP104: 190 arg.key_cipher = WMI_CIPHER_WEP; 191 break; 192 case WLAN_CIPHER_SUITE_AES_CMAC: 193 WARN_ON(1); 194 return -EINVAL; 195 default: 196 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher); 197 return -EOPNOTSUPP; 198 } 199 200 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) 201 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 202 203 if (cmd == DISABLE_KEY) { 204 arg.key_cipher = WMI_CIPHER_NONE; 205 arg.key_data = NULL; 206 } 207 208 return ath10k_wmi_vdev_install_key(arvif->ar, &arg); 209 } 210 211 static int ath10k_install_key(struct ath10k_vif *arvif, 212 struct ieee80211_key_conf *key, 213 enum set_key_cmd cmd, 214 const u8 *macaddr, u32 flags) 215 { 216 struct ath10k *ar = arvif->ar; 217 int ret; 218 unsigned long time_left; 219 220 lockdep_assert_held(&ar->conf_mutex); 221 222 reinit_completion(&ar->install_key_done); 223 224 if (arvif->nohwcrypt) 225 return 1; 226 227 ret = ath10k_send_key(arvif, key, cmd, macaddr, flags); 228 if (ret) 229 return ret; 230 231 time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ); 232 if (time_left == 0) 233 return -ETIMEDOUT; 234 235 return 0; 236 } 237 238 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif, 239 const u8 *addr) 240 { 241 struct ath10k *ar = arvif->ar; 242 struct ath10k_peer *peer; 243 int ret; 244 int i; 245 u32 flags; 246 247 lockdep_assert_held(&ar->conf_mutex); 248 249 if (WARN_ON(arvif->vif->type != NL80211_IFTYPE_AP && 250 arvif->vif->type != NL80211_IFTYPE_ADHOC)) 251 return -EINVAL; 252 253 spin_lock_bh(&ar->data_lock); 254 peer = ath10k_peer_find(ar, arvif->vdev_id, addr); 255 spin_unlock_bh(&ar->data_lock); 256 257 if (!peer) 258 return -ENOENT; 259 260 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) { 261 if (arvif->wep_keys[i] == NULL) 262 continue; 263 264 switch (arvif->vif->type) { 265 case NL80211_IFTYPE_AP: 266 flags = WMI_KEY_PAIRWISE; 267 268 if (arvif->def_wep_key_idx == i) 269 flags |= WMI_KEY_TX_USAGE; 270 271 ret = ath10k_install_key(arvif, arvif->wep_keys[i], 272 SET_KEY, addr, flags); 273 if (ret < 0) 274 return ret; 275 break; 276 case NL80211_IFTYPE_ADHOC: 277 ret = ath10k_install_key(arvif, arvif->wep_keys[i], 278 SET_KEY, addr, 279 WMI_KEY_PAIRWISE); 280 if (ret < 0) 281 return ret; 282 283 ret = ath10k_install_key(arvif, arvif->wep_keys[i], 284 SET_KEY, addr, WMI_KEY_GROUP); 285 if (ret < 0) 286 return ret; 287 break; 288 default: 289 WARN_ON(1); 290 return -EINVAL; 291 } 292 293 spin_lock_bh(&ar->data_lock); 294 peer->keys[i] = arvif->wep_keys[i]; 295 spin_unlock_bh(&ar->data_lock); 296 } 297 298 /* In some cases (notably with static WEP IBSS with multiple keys) 299 * multicast Tx becomes broken. Both pairwise and groupwise keys are 300 * installed already. Using WMI_KEY_TX_USAGE in different combinations 301 * didn't seem help. Using def_keyid vdev parameter seems to be 302 * effective so use that. 303 * 304 * FIXME: Revisit. Perhaps this can be done in a less hacky way. 305 */ 306 if (arvif->vif->type != NL80211_IFTYPE_ADHOC) 307 return 0; 308 309 if (arvif->def_wep_key_idx == -1) 310 return 0; 311 312 ret = ath10k_wmi_vdev_set_param(arvif->ar, 313 arvif->vdev_id, 314 arvif->ar->wmi.vdev_param->def_keyid, 315 arvif->def_wep_key_idx); 316 if (ret) { 317 ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n", 318 arvif->vdev_id, ret); 319 return ret; 320 } 321 322 return 0; 323 } 324 325 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif, 326 const u8 *addr) 327 { 328 struct ath10k *ar = arvif->ar; 329 struct ath10k_peer *peer; 330 int first_errno = 0; 331 int ret; 332 int i; 333 u32 flags = 0; 334 335 lockdep_assert_held(&ar->conf_mutex); 336 337 spin_lock_bh(&ar->data_lock); 338 peer = ath10k_peer_find(ar, arvif->vdev_id, addr); 339 spin_unlock_bh(&ar->data_lock); 340 341 if (!peer) 342 return -ENOENT; 343 344 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 345 if (peer->keys[i] == NULL) 346 continue; 347 348 /* key flags are not required to delete the key */ 349 ret = ath10k_install_key(arvif, peer->keys[i], 350 DISABLE_KEY, addr, flags); 351 if (ret < 0 && first_errno == 0) 352 first_errno = ret; 353 354 if (ret < 0) 355 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n", 356 i, ret); 357 358 spin_lock_bh(&ar->data_lock); 359 peer->keys[i] = NULL; 360 spin_unlock_bh(&ar->data_lock); 361 } 362 363 return first_errno; 364 } 365 366 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr, 367 u8 keyidx) 368 { 369 struct ath10k_peer *peer; 370 int i; 371 372 lockdep_assert_held(&ar->data_lock); 373 374 /* We don't know which vdev this peer belongs to, 375 * since WMI doesn't give us that information. 376 * 377 * FIXME: multi-bss needs to be handled. 378 */ 379 peer = ath10k_peer_find(ar, 0, addr); 380 if (!peer) 381 return false; 382 383 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 384 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx) 385 return true; 386 } 387 388 return false; 389 } 390 391 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif, 392 struct ieee80211_key_conf *key) 393 { 394 struct ath10k *ar = arvif->ar; 395 struct ath10k_peer *peer; 396 u8 addr[ETH_ALEN]; 397 int first_errno = 0; 398 int ret; 399 int i; 400 u32 flags = 0; 401 402 lockdep_assert_held(&ar->conf_mutex); 403 404 for (;;) { 405 /* since ath10k_install_key we can't hold data_lock all the 406 * time, so we try to remove the keys incrementally */ 407 spin_lock_bh(&ar->data_lock); 408 i = 0; 409 list_for_each_entry(peer, &ar->peers, list) { 410 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 411 if (peer->keys[i] == key) { 412 ether_addr_copy(addr, peer->addr); 413 peer->keys[i] = NULL; 414 break; 415 } 416 } 417 418 if (i < ARRAY_SIZE(peer->keys)) 419 break; 420 } 421 spin_unlock_bh(&ar->data_lock); 422 423 if (i == ARRAY_SIZE(peer->keys)) 424 break; 425 /* key flags are not required to delete the key */ 426 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags); 427 if (ret < 0 && first_errno == 0) 428 first_errno = ret; 429 430 if (ret) 431 ath10k_warn(ar, "failed to remove key for %pM: %d\n", 432 addr, ret); 433 } 434 435 return first_errno; 436 } 437 438 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif, 439 struct ieee80211_key_conf *key) 440 { 441 struct ath10k *ar = arvif->ar; 442 struct ath10k_peer *peer; 443 int ret; 444 445 lockdep_assert_held(&ar->conf_mutex); 446 447 list_for_each_entry(peer, &ar->peers, list) { 448 if (!memcmp(peer->addr, arvif->vif->addr, ETH_ALEN)) 449 continue; 450 451 if (!memcmp(peer->addr, arvif->bssid, ETH_ALEN)) 452 continue; 453 454 if (peer->keys[key->keyidx] == key) 455 continue; 456 457 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n", 458 arvif->vdev_id, key->keyidx); 459 460 ret = ath10k_install_peer_wep_keys(arvif, peer->addr); 461 if (ret) { 462 ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n", 463 arvif->vdev_id, peer->addr, ret); 464 return ret; 465 } 466 } 467 468 return 0; 469 } 470 471 /*********************/ 472 /* General utilities */ 473 /*********************/ 474 475 static inline enum wmi_phy_mode 476 chan_to_phymode(const struct cfg80211_chan_def *chandef) 477 { 478 enum wmi_phy_mode phymode = MODE_UNKNOWN; 479 480 switch (chandef->chan->band) { 481 case IEEE80211_BAND_2GHZ: 482 switch (chandef->width) { 483 case NL80211_CHAN_WIDTH_20_NOHT: 484 if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM) 485 phymode = MODE_11B; 486 else 487 phymode = MODE_11G; 488 break; 489 case NL80211_CHAN_WIDTH_20: 490 phymode = MODE_11NG_HT20; 491 break; 492 case NL80211_CHAN_WIDTH_40: 493 phymode = MODE_11NG_HT40; 494 break; 495 case NL80211_CHAN_WIDTH_5: 496 case NL80211_CHAN_WIDTH_10: 497 case NL80211_CHAN_WIDTH_80: 498 case NL80211_CHAN_WIDTH_80P80: 499 case NL80211_CHAN_WIDTH_160: 500 phymode = MODE_UNKNOWN; 501 break; 502 } 503 break; 504 case IEEE80211_BAND_5GHZ: 505 switch (chandef->width) { 506 case NL80211_CHAN_WIDTH_20_NOHT: 507 phymode = MODE_11A; 508 break; 509 case NL80211_CHAN_WIDTH_20: 510 phymode = MODE_11NA_HT20; 511 break; 512 case NL80211_CHAN_WIDTH_40: 513 phymode = MODE_11NA_HT40; 514 break; 515 case NL80211_CHAN_WIDTH_80: 516 phymode = MODE_11AC_VHT80; 517 break; 518 case NL80211_CHAN_WIDTH_5: 519 case NL80211_CHAN_WIDTH_10: 520 case NL80211_CHAN_WIDTH_80P80: 521 case NL80211_CHAN_WIDTH_160: 522 phymode = MODE_UNKNOWN; 523 break; 524 } 525 break; 526 default: 527 break; 528 } 529 530 WARN_ON(phymode == MODE_UNKNOWN); 531 return phymode; 532 } 533 534 static u8 ath10k_parse_mpdudensity(u8 mpdudensity) 535 { 536 /* 537 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing": 538 * 0 for no restriction 539 * 1 for 1/4 us 540 * 2 for 1/2 us 541 * 3 for 1 us 542 * 4 for 2 us 543 * 5 for 4 us 544 * 6 for 8 us 545 * 7 for 16 us 546 */ 547 switch (mpdudensity) { 548 case 0: 549 return 0; 550 case 1: 551 case 2: 552 case 3: 553 /* Our lower layer calculations limit our precision to 554 1 microsecond */ 555 return 1; 556 case 4: 557 return 2; 558 case 5: 559 return 4; 560 case 6: 561 return 8; 562 case 7: 563 return 16; 564 default: 565 return 0; 566 } 567 } 568 569 int ath10k_mac_vif_chan(struct ieee80211_vif *vif, 570 struct cfg80211_chan_def *def) 571 { 572 struct ieee80211_chanctx_conf *conf; 573 574 rcu_read_lock(); 575 conf = rcu_dereference(vif->chanctx_conf); 576 if (!conf) { 577 rcu_read_unlock(); 578 return -ENOENT; 579 } 580 581 *def = conf->def; 582 rcu_read_unlock(); 583 584 return 0; 585 } 586 587 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw, 588 struct ieee80211_chanctx_conf *conf, 589 void *data) 590 { 591 int *num = data; 592 593 (*num)++; 594 } 595 596 static int ath10k_mac_num_chanctxs(struct ath10k *ar) 597 { 598 int num = 0; 599 600 ieee80211_iter_chan_contexts_atomic(ar->hw, 601 ath10k_mac_num_chanctxs_iter, 602 &num); 603 604 return num; 605 } 606 607 static void 608 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw, 609 struct ieee80211_chanctx_conf *conf, 610 void *data) 611 { 612 struct cfg80211_chan_def **def = data; 613 614 *def = &conf->def; 615 } 616 617 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr, 618 enum wmi_peer_type peer_type) 619 { 620 struct ath10k_vif *arvif; 621 int num_peers = 0; 622 int ret; 623 624 lockdep_assert_held(&ar->conf_mutex); 625 626 num_peers = ar->num_peers; 627 628 /* Each vdev consumes a peer entry as well */ 629 list_for_each_entry(arvif, &ar->arvifs, list) 630 num_peers++; 631 632 if (num_peers >= ar->max_num_peers) 633 return -ENOBUFS; 634 635 ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type); 636 if (ret) { 637 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n", 638 addr, vdev_id, ret); 639 return ret; 640 } 641 642 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr); 643 if (ret) { 644 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n", 645 addr, vdev_id, ret); 646 return ret; 647 } 648 649 ar->num_peers++; 650 651 return 0; 652 } 653 654 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif) 655 { 656 struct ath10k *ar = arvif->ar; 657 u32 param; 658 int ret; 659 660 param = ar->wmi.pdev_param->sta_kickout_th; 661 ret = ath10k_wmi_pdev_set_param(ar, param, 662 ATH10K_KICKOUT_THRESHOLD); 663 if (ret) { 664 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n", 665 arvif->vdev_id, ret); 666 return ret; 667 } 668 669 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs; 670 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, 671 ATH10K_KEEPALIVE_MIN_IDLE); 672 if (ret) { 673 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n", 674 arvif->vdev_id, ret); 675 return ret; 676 } 677 678 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs; 679 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, 680 ATH10K_KEEPALIVE_MAX_IDLE); 681 if (ret) { 682 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n", 683 arvif->vdev_id, ret); 684 return ret; 685 } 686 687 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs; 688 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, 689 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE); 690 if (ret) { 691 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n", 692 arvif->vdev_id, ret); 693 return ret; 694 } 695 696 return 0; 697 } 698 699 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value) 700 { 701 struct ath10k *ar = arvif->ar; 702 u32 vdev_param; 703 704 vdev_param = ar->wmi.vdev_param->rts_threshold; 705 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value); 706 } 707 708 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr) 709 { 710 int ret; 711 712 lockdep_assert_held(&ar->conf_mutex); 713 714 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr); 715 if (ret) 716 return ret; 717 718 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr); 719 if (ret) 720 return ret; 721 722 ar->num_peers--; 723 724 return 0; 725 } 726 727 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id) 728 { 729 struct ath10k_peer *peer, *tmp; 730 731 lockdep_assert_held(&ar->conf_mutex); 732 733 spin_lock_bh(&ar->data_lock); 734 list_for_each_entry_safe(peer, tmp, &ar->peers, list) { 735 if (peer->vdev_id != vdev_id) 736 continue; 737 738 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n", 739 peer->addr, vdev_id); 740 741 list_del(&peer->list); 742 kfree(peer); 743 ar->num_peers--; 744 } 745 spin_unlock_bh(&ar->data_lock); 746 } 747 748 static void ath10k_peer_cleanup_all(struct ath10k *ar) 749 { 750 struct ath10k_peer *peer, *tmp; 751 752 lockdep_assert_held(&ar->conf_mutex); 753 754 spin_lock_bh(&ar->data_lock); 755 list_for_each_entry_safe(peer, tmp, &ar->peers, list) { 756 list_del(&peer->list); 757 kfree(peer); 758 } 759 spin_unlock_bh(&ar->data_lock); 760 761 ar->num_peers = 0; 762 ar->num_stations = 0; 763 } 764 765 static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id, 766 struct ieee80211_sta *sta, 767 enum wmi_tdls_peer_state state) 768 { 769 int ret; 770 struct wmi_tdls_peer_update_cmd_arg arg = {}; 771 struct wmi_tdls_peer_capab_arg cap = {}; 772 struct wmi_channel_arg chan_arg = {}; 773 774 lockdep_assert_held(&ar->conf_mutex); 775 776 arg.vdev_id = vdev_id; 777 arg.peer_state = state; 778 ether_addr_copy(arg.addr, sta->addr); 779 780 cap.peer_max_sp = sta->max_sp; 781 cap.peer_uapsd_queues = sta->uapsd_queues; 782 783 if (state == WMI_TDLS_PEER_STATE_CONNECTED && 784 !sta->tdls_initiator) 785 cap.is_peer_responder = 1; 786 787 ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg); 788 if (ret) { 789 ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n", 790 arg.addr, vdev_id, ret); 791 return ret; 792 } 793 794 return 0; 795 } 796 797 /************************/ 798 /* Interface management */ 799 /************************/ 800 801 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif) 802 { 803 struct ath10k *ar = arvif->ar; 804 805 lockdep_assert_held(&ar->data_lock); 806 807 if (!arvif->beacon) 808 return; 809 810 if (!arvif->beacon_buf) 811 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr, 812 arvif->beacon->len, DMA_TO_DEVICE); 813 814 if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED && 815 arvif->beacon_state != ATH10K_BEACON_SENT)) 816 return; 817 818 dev_kfree_skb_any(arvif->beacon); 819 820 arvif->beacon = NULL; 821 arvif->beacon_state = ATH10K_BEACON_SCHEDULED; 822 } 823 824 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif) 825 { 826 struct ath10k *ar = arvif->ar; 827 828 lockdep_assert_held(&ar->data_lock); 829 830 ath10k_mac_vif_beacon_free(arvif); 831 832 if (arvif->beacon_buf) { 833 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN, 834 arvif->beacon_buf, arvif->beacon_paddr); 835 arvif->beacon_buf = NULL; 836 } 837 } 838 839 static inline int ath10k_vdev_setup_sync(struct ath10k *ar) 840 { 841 unsigned long time_left; 842 843 lockdep_assert_held(&ar->conf_mutex); 844 845 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags)) 846 return -ESHUTDOWN; 847 848 time_left = wait_for_completion_timeout(&ar->vdev_setup_done, 849 ATH10K_VDEV_SETUP_TIMEOUT_HZ); 850 if (time_left == 0) 851 return -ETIMEDOUT; 852 853 return 0; 854 } 855 856 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id) 857 { 858 struct cfg80211_chan_def *chandef = NULL; 859 struct ieee80211_channel *channel = NULL; 860 struct wmi_vdev_start_request_arg arg = {}; 861 int ret = 0; 862 863 lockdep_assert_held(&ar->conf_mutex); 864 865 ieee80211_iter_chan_contexts_atomic(ar->hw, 866 ath10k_mac_get_any_chandef_iter, 867 &chandef); 868 if (WARN_ON_ONCE(!chandef)) 869 return -ENOENT; 870 871 channel = chandef->chan; 872 873 arg.vdev_id = vdev_id; 874 arg.channel.freq = channel->center_freq; 875 arg.channel.band_center_freq1 = chandef->center_freq1; 876 877 /* TODO setup this dynamically, what in case we 878 don't have any vifs? */ 879 arg.channel.mode = chan_to_phymode(chandef); 880 arg.channel.chan_radar = 881 !!(channel->flags & IEEE80211_CHAN_RADAR); 882 883 arg.channel.min_power = 0; 884 arg.channel.max_power = channel->max_power * 2; 885 arg.channel.max_reg_power = channel->max_reg_power * 2; 886 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2; 887 888 reinit_completion(&ar->vdev_setup_done); 889 890 ret = ath10k_wmi_vdev_start(ar, &arg); 891 if (ret) { 892 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n", 893 vdev_id, ret); 894 return ret; 895 } 896 897 ret = ath10k_vdev_setup_sync(ar); 898 if (ret) { 899 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n", 900 vdev_id, ret); 901 return ret; 902 } 903 904 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr); 905 if (ret) { 906 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n", 907 vdev_id, ret); 908 goto vdev_stop; 909 } 910 911 ar->monitor_vdev_id = vdev_id; 912 913 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n", 914 ar->monitor_vdev_id); 915 return 0; 916 917 vdev_stop: 918 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id); 919 if (ret) 920 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n", 921 ar->monitor_vdev_id, ret); 922 923 return ret; 924 } 925 926 static int ath10k_monitor_vdev_stop(struct ath10k *ar) 927 { 928 int ret = 0; 929 930 lockdep_assert_held(&ar->conf_mutex); 931 932 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id); 933 if (ret) 934 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n", 935 ar->monitor_vdev_id, ret); 936 937 reinit_completion(&ar->vdev_setup_done); 938 939 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id); 940 if (ret) 941 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n", 942 ar->monitor_vdev_id, ret); 943 944 ret = ath10k_vdev_setup_sync(ar); 945 if (ret) 946 ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n", 947 ar->monitor_vdev_id, ret); 948 949 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n", 950 ar->monitor_vdev_id); 951 return ret; 952 } 953 954 static int ath10k_monitor_vdev_create(struct ath10k *ar) 955 { 956 int bit, ret = 0; 957 958 lockdep_assert_held(&ar->conf_mutex); 959 960 if (ar->free_vdev_map == 0) { 961 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n"); 962 return -ENOMEM; 963 } 964 965 bit = __ffs64(ar->free_vdev_map); 966 967 ar->monitor_vdev_id = bit; 968 969 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id, 970 WMI_VDEV_TYPE_MONITOR, 971 0, ar->mac_addr); 972 if (ret) { 973 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n", 974 ar->monitor_vdev_id, ret); 975 return ret; 976 } 977 978 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id); 979 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n", 980 ar->monitor_vdev_id); 981 982 return 0; 983 } 984 985 static int ath10k_monitor_vdev_delete(struct ath10k *ar) 986 { 987 int ret = 0; 988 989 lockdep_assert_held(&ar->conf_mutex); 990 991 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id); 992 if (ret) { 993 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n", 994 ar->monitor_vdev_id, ret); 995 return ret; 996 } 997 998 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id; 999 1000 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n", 1001 ar->monitor_vdev_id); 1002 return ret; 1003 } 1004 1005 static int ath10k_monitor_start(struct ath10k *ar) 1006 { 1007 int ret; 1008 1009 lockdep_assert_held(&ar->conf_mutex); 1010 1011 ret = ath10k_monitor_vdev_create(ar); 1012 if (ret) { 1013 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret); 1014 return ret; 1015 } 1016 1017 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id); 1018 if (ret) { 1019 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret); 1020 ath10k_monitor_vdev_delete(ar); 1021 return ret; 1022 } 1023 1024 ar->monitor_started = true; 1025 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n"); 1026 1027 return 0; 1028 } 1029 1030 static int ath10k_monitor_stop(struct ath10k *ar) 1031 { 1032 int ret; 1033 1034 lockdep_assert_held(&ar->conf_mutex); 1035 1036 ret = ath10k_monitor_vdev_stop(ar); 1037 if (ret) { 1038 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret); 1039 return ret; 1040 } 1041 1042 ret = ath10k_monitor_vdev_delete(ar); 1043 if (ret) { 1044 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret); 1045 return ret; 1046 } 1047 1048 ar->monitor_started = false; 1049 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n"); 1050 1051 return 0; 1052 } 1053 1054 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar) 1055 { 1056 int num_ctx; 1057 1058 /* At least one chanctx is required to derive a channel to start 1059 * monitor vdev on. 1060 */ 1061 num_ctx = ath10k_mac_num_chanctxs(ar); 1062 if (num_ctx == 0) 1063 return false; 1064 1065 /* If there's already an existing special monitor interface then don't 1066 * bother creating another monitor vdev. 1067 */ 1068 if (ar->monitor_arvif) 1069 return false; 1070 1071 return ar->monitor || 1072 ar->filter_flags & FIF_OTHER_BSS || 1073 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 1074 } 1075 1076 static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k *ar) 1077 { 1078 int num_ctx; 1079 1080 num_ctx = ath10k_mac_num_chanctxs(ar); 1081 1082 /* FIXME: Current interface combinations and cfg80211/mac80211 code 1083 * shouldn't allow this but make sure to prevent handling the following 1084 * case anyway since multi-channel DFS hasn't been tested at all. 1085 */ 1086 if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags) && num_ctx > 1) 1087 return false; 1088 1089 return true; 1090 } 1091 1092 static int ath10k_monitor_recalc(struct ath10k *ar) 1093 { 1094 bool needed; 1095 bool allowed; 1096 int ret; 1097 1098 lockdep_assert_held(&ar->conf_mutex); 1099 1100 needed = ath10k_mac_monitor_vdev_is_needed(ar); 1101 allowed = ath10k_mac_monitor_vdev_is_allowed(ar); 1102 1103 ath10k_dbg(ar, ATH10K_DBG_MAC, 1104 "mac monitor recalc started? %d needed? %d allowed? %d\n", 1105 ar->monitor_started, needed, allowed); 1106 1107 if (WARN_ON(needed && !allowed)) { 1108 if (ar->monitor_started) { 1109 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopping disallowed monitor\n"); 1110 1111 ret = ath10k_monitor_stop(ar); 1112 if (ret) 1113 ath10k_warn(ar, "failed to stop disallowed monitor: %d\n", 1114 ret); 1115 /* not serious */ 1116 } 1117 1118 return -EPERM; 1119 } 1120 1121 if (needed == ar->monitor_started) 1122 return 0; 1123 1124 if (needed) 1125 return ath10k_monitor_start(ar); 1126 else 1127 return ath10k_monitor_stop(ar); 1128 } 1129 1130 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif) 1131 { 1132 struct ath10k *ar = arvif->ar; 1133 u32 vdev_param, rts_cts = 0; 1134 1135 lockdep_assert_held(&ar->conf_mutex); 1136 1137 vdev_param = ar->wmi.vdev_param->enable_rtscts; 1138 1139 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET); 1140 1141 if (arvif->num_legacy_stations > 0) 1142 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES, 1143 WMI_RTSCTS_PROFILE); 1144 else 1145 rts_cts |= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES, 1146 WMI_RTSCTS_PROFILE); 1147 1148 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 1149 rts_cts); 1150 } 1151 1152 static int ath10k_start_cac(struct ath10k *ar) 1153 { 1154 int ret; 1155 1156 lockdep_assert_held(&ar->conf_mutex); 1157 1158 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 1159 1160 ret = ath10k_monitor_recalc(ar); 1161 if (ret) { 1162 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret); 1163 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 1164 return ret; 1165 } 1166 1167 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n", 1168 ar->monitor_vdev_id); 1169 1170 return 0; 1171 } 1172 1173 static int ath10k_stop_cac(struct ath10k *ar) 1174 { 1175 lockdep_assert_held(&ar->conf_mutex); 1176 1177 /* CAC is not running - do nothing */ 1178 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags)) 1179 return 0; 1180 1181 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 1182 ath10k_monitor_stop(ar); 1183 1184 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n"); 1185 1186 return 0; 1187 } 1188 1189 static void ath10k_mac_has_radar_iter(struct ieee80211_hw *hw, 1190 struct ieee80211_chanctx_conf *conf, 1191 void *data) 1192 { 1193 bool *ret = data; 1194 1195 if (!*ret && conf->radar_enabled) 1196 *ret = true; 1197 } 1198 1199 static bool ath10k_mac_has_radar_enabled(struct ath10k *ar) 1200 { 1201 bool has_radar = false; 1202 1203 ieee80211_iter_chan_contexts_atomic(ar->hw, 1204 ath10k_mac_has_radar_iter, 1205 &has_radar); 1206 1207 return has_radar; 1208 } 1209 1210 static void ath10k_recalc_radar_detection(struct ath10k *ar) 1211 { 1212 int ret; 1213 1214 lockdep_assert_held(&ar->conf_mutex); 1215 1216 ath10k_stop_cac(ar); 1217 1218 if (!ath10k_mac_has_radar_enabled(ar)) 1219 return; 1220 1221 if (ar->num_started_vdevs > 0) 1222 return; 1223 1224 ret = ath10k_start_cac(ar); 1225 if (ret) { 1226 /* 1227 * Not possible to start CAC on current channel so starting 1228 * radiation is not allowed, make this channel DFS_UNAVAILABLE 1229 * by indicating that radar was detected. 1230 */ 1231 ath10k_warn(ar, "failed to start CAC: %d\n", ret); 1232 ieee80211_radar_detected(ar->hw); 1233 } 1234 } 1235 1236 static int ath10k_vdev_stop(struct ath10k_vif *arvif) 1237 { 1238 struct ath10k *ar = arvif->ar; 1239 int ret; 1240 1241 lockdep_assert_held(&ar->conf_mutex); 1242 1243 reinit_completion(&ar->vdev_setup_done); 1244 1245 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id); 1246 if (ret) { 1247 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n", 1248 arvif->vdev_id, ret); 1249 return ret; 1250 } 1251 1252 ret = ath10k_vdev_setup_sync(ar); 1253 if (ret) { 1254 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n", 1255 arvif->vdev_id, ret); 1256 return ret; 1257 } 1258 1259 WARN_ON(ar->num_started_vdevs == 0); 1260 1261 if (ar->num_started_vdevs != 0) { 1262 ar->num_started_vdevs--; 1263 ath10k_recalc_radar_detection(ar); 1264 } 1265 1266 return ret; 1267 } 1268 1269 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif, 1270 const struct cfg80211_chan_def *chandef, 1271 bool restart) 1272 { 1273 struct ath10k *ar = arvif->ar; 1274 struct wmi_vdev_start_request_arg arg = {}; 1275 int ret = 0; 1276 1277 lockdep_assert_held(&ar->conf_mutex); 1278 1279 reinit_completion(&ar->vdev_setup_done); 1280 1281 arg.vdev_id = arvif->vdev_id; 1282 arg.dtim_period = arvif->dtim_period; 1283 arg.bcn_intval = arvif->beacon_interval; 1284 1285 arg.channel.freq = chandef->chan->center_freq; 1286 arg.channel.band_center_freq1 = chandef->center_freq1; 1287 arg.channel.mode = chan_to_phymode(chandef); 1288 1289 arg.channel.min_power = 0; 1290 arg.channel.max_power = chandef->chan->max_power * 2; 1291 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2; 1292 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2; 1293 1294 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 1295 arg.ssid = arvif->u.ap.ssid; 1296 arg.ssid_len = arvif->u.ap.ssid_len; 1297 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 1298 1299 /* For now allow DFS for AP mode */ 1300 arg.channel.chan_radar = 1301 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR); 1302 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 1303 arg.ssid = arvif->vif->bss_conf.ssid; 1304 arg.ssid_len = arvif->vif->bss_conf.ssid_len; 1305 } 1306 1307 ath10k_dbg(ar, ATH10K_DBG_MAC, 1308 "mac vdev %d start center_freq %d phymode %s\n", 1309 arg.vdev_id, arg.channel.freq, 1310 ath10k_wmi_phymode_str(arg.channel.mode)); 1311 1312 if (restart) 1313 ret = ath10k_wmi_vdev_restart(ar, &arg); 1314 else 1315 ret = ath10k_wmi_vdev_start(ar, &arg); 1316 1317 if (ret) { 1318 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n", 1319 arg.vdev_id, ret); 1320 return ret; 1321 } 1322 1323 ret = ath10k_vdev_setup_sync(ar); 1324 if (ret) { 1325 ath10k_warn(ar, 1326 "failed to synchronize setup for vdev %i restart %d: %d\n", 1327 arg.vdev_id, restart, ret); 1328 return ret; 1329 } 1330 1331 ar->num_started_vdevs++; 1332 ath10k_recalc_radar_detection(ar); 1333 1334 return ret; 1335 } 1336 1337 static int ath10k_vdev_start(struct ath10k_vif *arvif, 1338 const struct cfg80211_chan_def *def) 1339 { 1340 return ath10k_vdev_start_restart(arvif, def, false); 1341 } 1342 1343 static int ath10k_vdev_restart(struct ath10k_vif *arvif, 1344 const struct cfg80211_chan_def *def) 1345 { 1346 return ath10k_vdev_start_restart(arvif, def, true); 1347 } 1348 1349 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif, 1350 struct sk_buff *bcn) 1351 { 1352 struct ath10k *ar = arvif->ar; 1353 struct ieee80211_mgmt *mgmt; 1354 const u8 *p2p_ie; 1355 int ret; 1356 1357 if (arvif->vdev_type != WMI_VDEV_TYPE_AP) 1358 return 0; 1359 1360 if (arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO) 1361 return 0; 1362 1363 mgmt = (void *)bcn->data; 1364 p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P, 1365 mgmt->u.beacon.variable, 1366 bcn->len - (mgmt->u.beacon.variable - 1367 bcn->data)); 1368 if (!p2p_ie) 1369 return -ENOENT; 1370 1371 ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie); 1372 if (ret) { 1373 ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n", 1374 arvif->vdev_id, ret); 1375 return ret; 1376 } 1377 1378 return 0; 1379 } 1380 1381 static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui, 1382 u8 oui_type, size_t ie_offset) 1383 { 1384 size_t len; 1385 const u8 *next; 1386 const u8 *end; 1387 u8 *ie; 1388 1389 if (WARN_ON(skb->len < ie_offset)) 1390 return -EINVAL; 1391 1392 ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type, 1393 skb->data + ie_offset, 1394 skb->len - ie_offset); 1395 if (!ie) 1396 return -ENOENT; 1397 1398 len = ie[1] + 2; 1399 end = skb->data + skb->len; 1400 next = ie + len; 1401 1402 if (WARN_ON(next > end)) 1403 return -EINVAL; 1404 1405 memmove(ie, next, end - next); 1406 skb_trim(skb, skb->len - len); 1407 1408 return 0; 1409 } 1410 1411 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif) 1412 { 1413 struct ath10k *ar = arvif->ar; 1414 struct ieee80211_hw *hw = ar->hw; 1415 struct ieee80211_vif *vif = arvif->vif; 1416 struct ieee80211_mutable_offsets offs = {}; 1417 struct sk_buff *bcn; 1418 int ret; 1419 1420 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) 1421 return 0; 1422 1423 if (arvif->vdev_type != WMI_VDEV_TYPE_AP && 1424 arvif->vdev_type != WMI_VDEV_TYPE_IBSS) 1425 return 0; 1426 1427 bcn = ieee80211_beacon_get_template(hw, vif, &offs); 1428 if (!bcn) { 1429 ath10k_warn(ar, "failed to get beacon template from mac80211\n"); 1430 return -EPERM; 1431 } 1432 1433 ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn); 1434 if (ret) { 1435 ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret); 1436 kfree_skb(bcn); 1437 return ret; 1438 } 1439 1440 /* P2P IE is inserted by firmware automatically (as configured above) 1441 * so remove it from the base beacon template to avoid duplicate P2P 1442 * IEs in beacon frames. 1443 */ 1444 ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P, 1445 offsetof(struct ieee80211_mgmt, 1446 u.beacon.variable)); 1447 1448 ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0, 1449 0, NULL, 0); 1450 kfree_skb(bcn); 1451 1452 if (ret) { 1453 ath10k_warn(ar, "failed to submit beacon template command: %d\n", 1454 ret); 1455 return ret; 1456 } 1457 1458 return 0; 1459 } 1460 1461 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif) 1462 { 1463 struct ath10k *ar = arvif->ar; 1464 struct ieee80211_hw *hw = ar->hw; 1465 struct ieee80211_vif *vif = arvif->vif; 1466 struct sk_buff *prb; 1467 int ret; 1468 1469 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) 1470 return 0; 1471 1472 if (arvif->vdev_type != WMI_VDEV_TYPE_AP) 1473 return 0; 1474 1475 prb = ieee80211_proberesp_get(hw, vif); 1476 if (!prb) { 1477 ath10k_warn(ar, "failed to get probe resp template from mac80211\n"); 1478 return -EPERM; 1479 } 1480 1481 ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb); 1482 kfree_skb(prb); 1483 1484 if (ret) { 1485 ath10k_warn(ar, "failed to submit probe resp template command: %d\n", 1486 ret); 1487 return ret; 1488 } 1489 1490 return 0; 1491 } 1492 1493 static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif *arvif) 1494 { 1495 struct ath10k *ar = arvif->ar; 1496 struct cfg80211_chan_def def; 1497 int ret; 1498 1499 /* When originally vdev is started during assign_vif_chanctx() some 1500 * information is missing, notably SSID. Firmware revisions with beacon 1501 * offloading require the SSID to be provided during vdev (re)start to 1502 * handle hidden SSID properly. 1503 * 1504 * Vdev restart must be done after vdev has been both started and 1505 * upped. Otherwise some firmware revisions (at least 10.2) fail to 1506 * deliver vdev restart response event causing timeouts during vdev 1507 * syncing in ath10k. 1508 * 1509 * Note: The vdev down/up and template reinstallation could be skipped 1510 * since only wmi-tlv firmware are known to have beacon offload and 1511 * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart 1512 * response delivery. It's probably more robust to keep it as is. 1513 */ 1514 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) 1515 return 0; 1516 1517 if (WARN_ON(!arvif->is_started)) 1518 return -EINVAL; 1519 1520 if (WARN_ON(!arvif->is_up)) 1521 return -EINVAL; 1522 1523 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def))) 1524 return -EINVAL; 1525 1526 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 1527 if (ret) { 1528 ath10k_warn(ar, "failed to bring down ap vdev %i: %d\n", 1529 arvif->vdev_id, ret); 1530 return ret; 1531 } 1532 1533 /* Vdev down reset beacon & presp templates. Reinstall them. Otherwise 1534 * firmware will crash upon vdev up. 1535 */ 1536 1537 ret = ath10k_mac_setup_bcn_tmpl(arvif); 1538 if (ret) { 1539 ath10k_warn(ar, "failed to update beacon template: %d\n", ret); 1540 return ret; 1541 } 1542 1543 ret = ath10k_mac_setup_prb_tmpl(arvif); 1544 if (ret) { 1545 ath10k_warn(ar, "failed to update presp template: %d\n", ret); 1546 return ret; 1547 } 1548 1549 ret = ath10k_vdev_restart(arvif, &def); 1550 if (ret) { 1551 ath10k_warn(ar, "failed to restart ap vdev %i: %d\n", 1552 arvif->vdev_id, ret); 1553 return ret; 1554 } 1555 1556 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 1557 arvif->bssid); 1558 if (ret) { 1559 ath10k_warn(ar, "failed to bring up ap vdev %i: %d\n", 1560 arvif->vdev_id, ret); 1561 return ret; 1562 } 1563 1564 return 0; 1565 } 1566 1567 static void ath10k_control_beaconing(struct ath10k_vif *arvif, 1568 struct ieee80211_bss_conf *info) 1569 { 1570 struct ath10k *ar = arvif->ar; 1571 int ret = 0; 1572 1573 lockdep_assert_held(&arvif->ar->conf_mutex); 1574 1575 if (!info->enable_beacon) { 1576 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 1577 if (ret) 1578 ath10k_warn(ar, "failed to down vdev_id %i: %d\n", 1579 arvif->vdev_id, ret); 1580 1581 arvif->is_up = false; 1582 1583 spin_lock_bh(&arvif->ar->data_lock); 1584 ath10k_mac_vif_beacon_free(arvif); 1585 spin_unlock_bh(&arvif->ar->data_lock); 1586 1587 return; 1588 } 1589 1590 arvif->tx_seq_no = 0x1000; 1591 1592 arvif->aid = 0; 1593 ether_addr_copy(arvif->bssid, info->bssid); 1594 1595 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 1596 arvif->bssid); 1597 if (ret) { 1598 ath10k_warn(ar, "failed to bring up vdev %d: %i\n", 1599 arvif->vdev_id, ret); 1600 return; 1601 } 1602 1603 arvif->is_up = true; 1604 1605 ret = ath10k_mac_vif_fix_hidden_ssid(arvif); 1606 if (ret) { 1607 ath10k_warn(ar, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n", 1608 arvif->vdev_id, ret); 1609 return; 1610 } 1611 1612 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id); 1613 } 1614 1615 static void ath10k_control_ibss(struct ath10k_vif *arvif, 1616 struct ieee80211_bss_conf *info, 1617 const u8 self_peer[ETH_ALEN]) 1618 { 1619 struct ath10k *ar = arvif->ar; 1620 u32 vdev_param; 1621 int ret = 0; 1622 1623 lockdep_assert_held(&arvif->ar->conf_mutex); 1624 1625 if (!info->ibss_joined) { 1626 if (is_zero_ether_addr(arvif->bssid)) 1627 return; 1628 1629 eth_zero_addr(arvif->bssid); 1630 1631 return; 1632 } 1633 1634 vdev_param = arvif->ar->wmi.vdev_param->atim_window; 1635 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param, 1636 ATH10K_DEFAULT_ATIM); 1637 if (ret) 1638 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n", 1639 arvif->vdev_id, ret); 1640 } 1641 1642 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif) 1643 { 1644 struct ath10k *ar = arvif->ar; 1645 u32 param; 1646 u32 value; 1647 int ret; 1648 1649 lockdep_assert_held(&arvif->ar->conf_mutex); 1650 1651 if (arvif->u.sta.uapsd) 1652 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER; 1653 else 1654 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 1655 1656 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 1657 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value); 1658 if (ret) { 1659 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n", 1660 value, arvif->vdev_id, ret); 1661 return ret; 1662 } 1663 1664 return 0; 1665 } 1666 1667 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif) 1668 { 1669 struct ath10k *ar = arvif->ar; 1670 u32 param; 1671 u32 value; 1672 int ret; 1673 1674 lockdep_assert_held(&arvif->ar->conf_mutex); 1675 1676 if (arvif->u.sta.uapsd) 1677 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD; 1678 else 1679 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 1680 1681 param = WMI_STA_PS_PARAM_PSPOLL_COUNT; 1682 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 1683 param, value); 1684 if (ret) { 1685 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n", 1686 value, arvif->vdev_id, ret); 1687 return ret; 1688 } 1689 1690 return 0; 1691 } 1692 1693 static int ath10k_mac_num_vifs_started(struct ath10k *ar) 1694 { 1695 struct ath10k_vif *arvif; 1696 int num = 0; 1697 1698 lockdep_assert_held(&ar->conf_mutex); 1699 1700 list_for_each_entry(arvif, &ar->arvifs, list) 1701 if (arvif->is_started) 1702 num++; 1703 1704 return num; 1705 } 1706 1707 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif) 1708 { 1709 struct ath10k *ar = arvif->ar; 1710 struct ieee80211_vif *vif = arvif->vif; 1711 struct ieee80211_conf *conf = &ar->hw->conf; 1712 enum wmi_sta_powersave_param param; 1713 enum wmi_sta_ps_mode psmode; 1714 int ret; 1715 int ps_timeout; 1716 bool enable_ps; 1717 1718 lockdep_assert_held(&arvif->ar->conf_mutex); 1719 1720 if (arvif->vif->type != NL80211_IFTYPE_STATION) 1721 return 0; 1722 1723 enable_ps = arvif->ps; 1724 1725 if (enable_ps && ath10k_mac_num_vifs_started(ar) > 1 && 1726 !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT, 1727 ar->fw_features)) { 1728 ath10k_warn(ar, "refusing to enable ps on vdev %i: not supported by fw\n", 1729 arvif->vdev_id); 1730 enable_ps = false; 1731 } 1732 1733 if (!arvif->is_started) { 1734 /* mac80211 can update vif powersave state while disconnected. 1735 * Firmware doesn't behave nicely and consumes more power than 1736 * necessary if PS is disabled on a non-started vdev. Hence 1737 * force-enable PS for non-running vdevs. 1738 */ 1739 psmode = WMI_STA_PS_MODE_ENABLED; 1740 } else if (enable_ps) { 1741 psmode = WMI_STA_PS_MODE_ENABLED; 1742 param = WMI_STA_PS_PARAM_INACTIVITY_TIME; 1743 1744 ps_timeout = conf->dynamic_ps_timeout; 1745 if (ps_timeout == 0) { 1746 /* Firmware doesn't like 0 */ 1747 ps_timeout = ieee80211_tu_to_usec( 1748 vif->bss_conf.beacon_int) / 1000; 1749 } 1750 1751 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, 1752 ps_timeout); 1753 if (ret) { 1754 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n", 1755 arvif->vdev_id, ret); 1756 return ret; 1757 } 1758 } else { 1759 psmode = WMI_STA_PS_MODE_DISABLED; 1760 } 1761 1762 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n", 1763 arvif->vdev_id, psmode ? "enable" : "disable"); 1764 1765 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode); 1766 if (ret) { 1767 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n", 1768 psmode, arvif->vdev_id, ret); 1769 return ret; 1770 } 1771 1772 return 0; 1773 } 1774 1775 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif) 1776 { 1777 struct ath10k *ar = arvif->ar; 1778 struct wmi_sta_keepalive_arg arg = {}; 1779 int ret; 1780 1781 lockdep_assert_held(&arvif->ar->conf_mutex); 1782 1783 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 1784 return 0; 1785 1786 if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map)) 1787 return 0; 1788 1789 /* Some firmware revisions have a bug and ignore the `enabled` field. 1790 * Instead use the interval to disable the keepalive. 1791 */ 1792 arg.vdev_id = arvif->vdev_id; 1793 arg.enabled = 1; 1794 arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME; 1795 arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE; 1796 1797 ret = ath10k_wmi_sta_keepalive(ar, &arg); 1798 if (ret) { 1799 ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n", 1800 arvif->vdev_id, ret); 1801 return ret; 1802 } 1803 1804 return 0; 1805 } 1806 1807 static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif *arvif) 1808 { 1809 struct ath10k *ar = arvif->ar; 1810 struct ieee80211_vif *vif = arvif->vif; 1811 int ret; 1812 1813 lockdep_assert_held(&arvif->ar->conf_mutex); 1814 1815 if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))) 1816 return; 1817 1818 if (arvif->vdev_type != WMI_VDEV_TYPE_AP) 1819 return; 1820 1821 if (!vif->csa_active) 1822 return; 1823 1824 if (!arvif->is_up) 1825 return; 1826 1827 if (!ieee80211_csa_is_complete(vif)) { 1828 ieee80211_csa_update_counter(vif); 1829 1830 ret = ath10k_mac_setup_bcn_tmpl(arvif); 1831 if (ret) 1832 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n", 1833 ret); 1834 1835 ret = ath10k_mac_setup_prb_tmpl(arvif); 1836 if (ret) 1837 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n", 1838 ret); 1839 } else { 1840 ieee80211_csa_finish(vif); 1841 } 1842 } 1843 1844 static void ath10k_mac_vif_ap_csa_work(struct work_struct *work) 1845 { 1846 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif, 1847 ap_csa_work); 1848 struct ath10k *ar = arvif->ar; 1849 1850 mutex_lock(&ar->conf_mutex); 1851 ath10k_mac_vif_ap_csa_count_down(arvif); 1852 mutex_unlock(&ar->conf_mutex); 1853 } 1854 1855 static void ath10k_mac_handle_beacon_iter(void *data, u8 *mac, 1856 struct ieee80211_vif *vif) 1857 { 1858 struct sk_buff *skb = data; 1859 struct ieee80211_mgmt *mgmt = (void *)skb->data; 1860 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1861 1862 if (vif->type != NL80211_IFTYPE_STATION) 1863 return; 1864 1865 if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid)) 1866 return; 1867 1868 cancel_delayed_work(&arvif->connection_loss_work); 1869 } 1870 1871 void ath10k_mac_handle_beacon(struct ath10k *ar, struct sk_buff *skb) 1872 { 1873 ieee80211_iterate_active_interfaces_atomic(ar->hw, 1874 IEEE80211_IFACE_ITER_NORMAL, 1875 ath10k_mac_handle_beacon_iter, 1876 skb); 1877 } 1878 1879 static void ath10k_mac_handle_beacon_miss_iter(void *data, u8 *mac, 1880 struct ieee80211_vif *vif) 1881 { 1882 u32 *vdev_id = data; 1883 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1884 struct ath10k *ar = arvif->ar; 1885 struct ieee80211_hw *hw = ar->hw; 1886 1887 if (arvif->vdev_id != *vdev_id) 1888 return; 1889 1890 if (!arvif->is_up) 1891 return; 1892 1893 ieee80211_beacon_loss(vif); 1894 1895 /* Firmware doesn't report beacon loss events repeatedly. If AP probe 1896 * (done by mac80211) succeeds but beacons do not resume then it 1897 * doesn't make sense to continue operation. Queue connection loss work 1898 * which can be cancelled when beacon is received. 1899 */ 1900 ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work, 1901 ATH10K_CONNECTION_LOSS_HZ); 1902 } 1903 1904 void ath10k_mac_handle_beacon_miss(struct ath10k *ar, u32 vdev_id) 1905 { 1906 ieee80211_iterate_active_interfaces_atomic(ar->hw, 1907 IEEE80211_IFACE_ITER_NORMAL, 1908 ath10k_mac_handle_beacon_miss_iter, 1909 &vdev_id); 1910 } 1911 1912 static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct *work) 1913 { 1914 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif, 1915 connection_loss_work.work); 1916 struct ieee80211_vif *vif = arvif->vif; 1917 1918 if (!arvif->is_up) 1919 return; 1920 1921 ieee80211_connection_loss(vif); 1922 } 1923 1924 /**********************/ 1925 /* Station management */ 1926 /**********************/ 1927 1928 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar, 1929 struct ieee80211_vif *vif) 1930 { 1931 /* Some firmware revisions have unstable STA powersave when listen 1932 * interval is set too high (e.g. 5). The symptoms are firmware doesn't 1933 * generate NullFunc frames properly even if buffered frames have been 1934 * indicated in Beacon TIM. Firmware would seldom wake up to pull 1935 * buffered frames. Often pinging the device from AP would simply fail. 1936 * 1937 * As a workaround set it to 1. 1938 */ 1939 if (vif->type == NL80211_IFTYPE_STATION) 1940 return 1; 1941 1942 return ar->hw->conf.listen_interval; 1943 } 1944 1945 static void ath10k_peer_assoc_h_basic(struct ath10k *ar, 1946 struct ieee80211_vif *vif, 1947 struct ieee80211_sta *sta, 1948 struct wmi_peer_assoc_complete_arg *arg) 1949 { 1950 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1951 u32 aid; 1952 1953 lockdep_assert_held(&ar->conf_mutex); 1954 1955 if (vif->type == NL80211_IFTYPE_STATION) 1956 aid = vif->bss_conf.aid; 1957 else 1958 aid = sta->aid; 1959 1960 ether_addr_copy(arg->addr, sta->addr); 1961 arg->vdev_id = arvif->vdev_id; 1962 arg->peer_aid = aid; 1963 arg->peer_flags |= WMI_PEER_AUTH; 1964 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif); 1965 arg->peer_num_spatial_streams = 1; 1966 arg->peer_caps = vif->bss_conf.assoc_capability; 1967 } 1968 1969 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar, 1970 struct ieee80211_vif *vif, 1971 struct wmi_peer_assoc_complete_arg *arg) 1972 { 1973 struct ieee80211_bss_conf *info = &vif->bss_conf; 1974 struct cfg80211_chan_def def; 1975 struct cfg80211_bss *bss; 1976 const u8 *rsnie = NULL; 1977 const u8 *wpaie = NULL; 1978 1979 lockdep_assert_held(&ar->conf_mutex); 1980 1981 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 1982 return; 1983 1984 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0, 1985 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY); 1986 if (bss) { 1987 const struct cfg80211_bss_ies *ies; 1988 1989 rcu_read_lock(); 1990 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN); 1991 1992 ies = rcu_dereference(bss->ies); 1993 1994 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, 1995 WLAN_OUI_TYPE_MICROSOFT_WPA, 1996 ies->data, 1997 ies->len); 1998 rcu_read_unlock(); 1999 cfg80211_put_bss(ar->hw->wiphy, bss); 2000 } 2001 2002 /* FIXME: base on RSN IE/WPA IE is a correct idea? */ 2003 if (rsnie || wpaie) { 2004 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__); 2005 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY; 2006 } 2007 2008 if (wpaie) { 2009 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__); 2010 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY; 2011 } 2012 } 2013 2014 static void ath10k_peer_assoc_h_rates(struct ath10k *ar, 2015 struct ieee80211_vif *vif, 2016 struct ieee80211_sta *sta, 2017 struct wmi_peer_assoc_complete_arg *arg) 2018 { 2019 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2020 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates; 2021 struct cfg80211_chan_def def; 2022 const struct ieee80211_supported_band *sband; 2023 const struct ieee80211_rate *rates; 2024 enum ieee80211_band band; 2025 u32 ratemask; 2026 u8 rate; 2027 int i; 2028 2029 lockdep_assert_held(&ar->conf_mutex); 2030 2031 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 2032 return; 2033 2034 band = def.chan->band; 2035 sband = ar->hw->wiphy->bands[band]; 2036 ratemask = sta->supp_rates[band]; 2037 ratemask &= arvif->bitrate_mask.control[band].legacy; 2038 rates = sband->bitrates; 2039 2040 rateset->num_rates = 0; 2041 2042 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) { 2043 if (!(ratemask & 1)) 2044 continue; 2045 2046 rate = ath10k_mac_bitrate_to_rate(rates->bitrate); 2047 rateset->rates[rateset->num_rates] = rate; 2048 rateset->num_rates++; 2049 } 2050 } 2051 2052 static bool 2053 ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN]) 2054 { 2055 int nss; 2056 2057 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++) 2058 if (ht_mcs_mask[nss]) 2059 return false; 2060 2061 return true; 2062 } 2063 2064 static bool 2065 ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX]) 2066 { 2067 int nss; 2068 2069 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) 2070 if (vht_mcs_mask[nss]) 2071 return false; 2072 2073 return true; 2074 } 2075 2076 static void ath10k_peer_assoc_h_ht(struct ath10k *ar, 2077 struct ieee80211_vif *vif, 2078 struct ieee80211_sta *sta, 2079 struct wmi_peer_assoc_complete_arg *arg) 2080 { 2081 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap; 2082 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2083 struct cfg80211_chan_def def; 2084 enum ieee80211_band band; 2085 const u8 *ht_mcs_mask; 2086 const u16 *vht_mcs_mask; 2087 int i, n; 2088 u8 max_nss; 2089 u32 stbc; 2090 2091 lockdep_assert_held(&ar->conf_mutex); 2092 2093 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 2094 return; 2095 2096 if (!ht_cap->ht_supported) 2097 return; 2098 2099 band = def.chan->band; 2100 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 2101 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 2102 2103 if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask) && 2104 ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) 2105 return; 2106 2107 arg->peer_flags |= WMI_PEER_HT; 2108 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + 2109 ht_cap->ampdu_factor)) - 1; 2110 2111 arg->peer_mpdu_density = 2112 ath10k_parse_mpdudensity(ht_cap->ampdu_density); 2113 2114 arg->peer_ht_caps = ht_cap->cap; 2115 arg->peer_rate_caps |= WMI_RC_HT_FLAG; 2116 2117 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING) 2118 arg->peer_flags |= WMI_PEER_LDPC; 2119 2120 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) { 2121 arg->peer_flags |= WMI_PEER_40MHZ; 2122 arg->peer_rate_caps |= WMI_RC_CW40_FLAG; 2123 } 2124 2125 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) { 2126 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20) 2127 arg->peer_rate_caps |= WMI_RC_SGI_FLAG; 2128 2129 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40) 2130 arg->peer_rate_caps |= WMI_RC_SGI_FLAG; 2131 } 2132 2133 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) { 2134 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG; 2135 arg->peer_flags |= WMI_PEER_STBC; 2136 } 2137 2138 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) { 2139 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC; 2140 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT; 2141 stbc = stbc << WMI_RC_RX_STBC_FLAG_S; 2142 arg->peer_rate_caps |= stbc; 2143 arg->peer_flags |= WMI_PEER_STBC; 2144 } 2145 2146 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2]) 2147 arg->peer_rate_caps |= WMI_RC_TS_FLAG; 2148 else if (ht_cap->mcs.rx_mask[1]) 2149 arg->peer_rate_caps |= WMI_RC_DS_FLAG; 2150 2151 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++) 2152 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) && 2153 (ht_mcs_mask[i / 8] & BIT(i % 8))) { 2154 max_nss = (i / 8) + 1; 2155 arg->peer_ht_rates.rates[n++] = i; 2156 } 2157 2158 /* 2159 * This is a workaround for HT-enabled STAs which break the spec 2160 * and have no HT capabilities RX mask (no HT RX MCS map). 2161 * 2162 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS), 2163 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs. 2164 * 2165 * Firmware asserts if such situation occurs. 2166 */ 2167 if (n == 0) { 2168 arg->peer_ht_rates.num_rates = 8; 2169 for (i = 0; i < arg->peer_ht_rates.num_rates; i++) 2170 arg->peer_ht_rates.rates[i] = i; 2171 } else { 2172 arg->peer_ht_rates.num_rates = n; 2173 arg->peer_num_spatial_streams = min(sta->rx_nss, max_nss); 2174 } 2175 2176 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n", 2177 arg->addr, 2178 arg->peer_ht_rates.num_rates, 2179 arg->peer_num_spatial_streams); 2180 } 2181 2182 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar, 2183 struct ath10k_vif *arvif, 2184 struct ieee80211_sta *sta) 2185 { 2186 u32 uapsd = 0; 2187 u32 max_sp = 0; 2188 int ret = 0; 2189 2190 lockdep_assert_held(&ar->conf_mutex); 2191 2192 if (sta->wme && sta->uapsd_queues) { 2193 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n", 2194 sta->uapsd_queues, sta->max_sp); 2195 2196 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) 2197 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN | 2198 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN; 2199 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) 2200 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN | 2201 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN; 2202 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) 2203 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN | 2204 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN; 2205 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) 2206 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN | 2207 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN; 2208 2209 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP) 2210 max_sp = sta->max_sp; 2211 2212 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, 2213 sta->addr, 2214 WMI_AP_PS_PEER_PARAM_UAPSD, 2215 uapsd); 2216 if (ret) { 2217 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n", 2218 arvif->vdev_id, ret); 2219 return ret; 2220 } 2221 2222 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, 2223 sta->addr, 2224 WMI_AP_PS_PEER_PARAM_MAX_SP, 2225 max_sp); 2226 if (ret) { 2227 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n", 2228 arvif->vdev_id, ret); 2229 return ret; 2230 } 2231 2232 /* TODO setup this based on STA listen interval and 2233 beacon interval. Currently we don't know 2234 sta->listen_interval - mac80211 patch required. 2235 Currently use 10 seconds */ 2236 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr, 2237 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME, 2238 10); 2239 if (ret) { 2240 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n", 2241 arvif->vdev_id, ret); 2242 return ret; 2243 } 2244 } 2245 2246 return 0; 2247 } 2248 2249 static u16 2250 ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set, 2251 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX]) 2252 { 2253 int idx_limit; 2254 int nss; 2255 u16 mcs_map; 2256 u16 mcs; 2257 2258 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) { 2259 mcs_map = ath10k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) & 2260 vht_mcs_limit[nss]; 2261 2262 if (mcs_map) 2263 idx_limit = fls(mcs_map) - 1; 2264 else 2265 idx_limit = -1; 2266 2267 switch (idx_limit) { 2268 case 0: /* fall through */ 2269 case 1: /* fall through */ 2270 case 2: /* fall through */ 2271 case 3: /* fall through */ 2272 case 4: /* fall through */ 2273 case 5: /* fall through */ 2274 case 6: /* fall through */ 2275 default: 2276 /* see ath10k_mac_can_set_bitrate_mask() */ 2277 WARN_ON(1); 2278 /* fall through */ 2279 case -1: 2280 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED; 2281 break; 2282 case 7: 2283 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7; 2284 break; 2285 case 8: 2286 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8; 2287 break; 2288 case 9: 2289 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9; 2290 break; 2291 } 2292 2293 tx_mcs_set &= ~(0x3 << (nss * 2)); 2294 tx_mcs_set |= mcs << (nss * 2); 2295 } 2296 2297 return tx_mcs_set; 2298 } 2299 2300 static void ath10k_peer_assoc_h_vht(struct ath10k *ar, 2301 struct ieee80211_vif *vif, 2302 struct ieee80211_sta *sta, 2303 struct wmi_peer_assoc_complete_arg *arg) 2304 { 2305 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap; 2306 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2307 struct cfg80211_chan_def def; 2308 enum ieee80211_band band; 2309 const u16 *vht_mcs_mask; 2310 u8 ampdu_factor; 2311 2312 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 2313 return; 2314 2315 if (!vht_cap->vht_supported) 2316 return; 2317 2318 band = def.chan->band; 2319 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 2320 2321 if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) 2322 return; 2323 2324 arg->peer_flags |= WMI_PEER_VHT; 2325 2326 if (def.chan->band == IEEE80211_BAND_2GHZ) 2327 arg->peer_flags |= WMI_PEER_VHT_2G; 2328 2329 arg->peer_vht_caps = vht_cap->cap; 2330 2331 ampdu_factor = (vht_cap->cap & 2332 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >> 2333 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT; 2334 2335 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to 2336 * zero in VHT IE. Using it would result in degraded throughput. 2337 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep 2338 * it if VHT max_mpdu is smaller. */ 2339 arg->peer_max_mpdu = max(arg->peer_max_mpdu, 2340 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR + 2341 ampdu_factor)) - 1); 2342 2343 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 2344 arg->peer_flags |= WMI_PEER_80MHZ; 2345 2346 arg->peer_vht_rates.rx_max_rate = 2347 __le16_to_cpu(vht_cap->vht_mcs.rx_highest); 2348 arg->peer_vht_rates.rx_mcs_set = 2349 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map); 2350 arg->peer_vht_rates.tx_max_rate = 2351 __le16_to_cpu(vht_cap->vht_mcs.tx_highest); 2352 arg->peer_vht_rates.tx_mcs_set = ath10k_peer_assoc_h_vht_limit( 2353 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask); 2354 2355 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n", 2356 sta->addr, arg->peer_max_mpdu, arg->peer_flags); 2357 } 2358 2359 static void ath10k_peer_assoc_h_qos(struct ath10k *ar, 2360 struct ieee80211_vif *vif, 2361 struct ieee80211_sta *sta, 2362 struct wmi_peer_assoc_complete_arg *arg) 2363 { 2364 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2365 2366 switch (arvif->vdev_type) { 2367 case WMI_VDEV_TYPE_AP: 2368 if (sta->wme) 2369 arg->peer_flags |= WMI_PEER_QOS; 2370 2371 if (sta->wme && sta->uapsd_queues) { 2372 arg->peer_flags |= WMI_PEER_APSD; 2373 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG; 2374 } 2375 break; 2376 case WMI_VDEV_TYPE_STA: 2377 if (vif->bss_conf.qos) 2378 arg->peer_flags |= WMI_PEER_QOS; 2379 break; 2380 case WMI_VDEV_TYPE_IBSS: 2381 if (sta->wme) 2382 arg->peer_flags |= WMI_PEER_QOS; 2383 break; 2384 default: 2385 break; 2386 } 2387 2388 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n", 2389 sta->addr, !!(arg->peer_flags & WMI_PEER_QOS)); 2390 } 2391 2392 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta) 2393 { 2394 return sta->supp_rates[IEEE80211_BAND_2GHZ] >> 2395 ATH10K_MAC_FIRST_OFDM_RATE_IDX; 2396 } 2397 2398 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar, 2399 struct ieee80211_vif *vif, 2400 struct ieee80211_sta *sta, 2401 struct wmi_peer_assoc_complete_arg *arg) 2402 { 2403 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2404 struct cfg80211_chan_def def; 2405 enum ieee80211_band band; 2406 const u8 *ht_mcs_mask; 2407 const u16 *vht_mcs_mask; 2408 enum wmi_phy_mode phymode = MODE_UNKNOWN; 2409 2410 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 2411 return; 2412 2413 band = def.chan->band; 2414 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 2415 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 2416 2417 switch (band) { 2418 case IEEE80211_BAND_2GHZ: 2419 if (sta->vht_cap.vht_supported && 2420 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2421 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2422 phymode = MODE_11AC_VHT40; 2423 else 2424 phymode = MODE_11AC_VHT20; 2425 } else if (sta->ht_cap.ht_supported && 2426 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2427 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2428 phymode = MODE_11NG_HT40; 2429 else 2430 phymode = MODE_11NG_HT20; 2431 } else if (ath10k_mac_sta_has_ofdm_only(sta)) { 2432 phymode = MODE_11G; 2433 } else { 2434 phymode = MODE_11B; 2435 } 2436 2437 break; 2438 case IEEE80211_BAND_5GHZ: 2439 /* 2440 * Check VHT first. 2441 */ 2442 if (sta->vht_cap.vht_supported && 2443 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2444 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 2445 phymode = MODE_11AC_VHT80; 2446 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2447 phymode = MODE_11AC_VHT40; 2448 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20) 2449 phymode = MODE_11AC_VHT20; 2450 } else if (sta->ht_cap.ht_supported && 2451 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2452 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) 2453 phymode = MODE_11NA_HT40; 2454 else 2455 phymode = MODE_11NA_HT20; 2456 } else { 2457 phymode = MODE_11A; 2458 } 2459 2460 break; 2461 default: 2462 break; 2463 } 2464 2465 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n", 2466 sta->addr, ath10k_wmi_phymode_str(phymode)); 2467 2468 arg->peer_phymode = phymode; 2469 WARN_ON(phymode == MODE_UNKNOWN); 2470 } 2471 2472 static int ath10k_peer_assoc_prepare(struct ath10k *ar, 2473 struct ieee80211_vif *vif, 2474 struct ieee80211_sta *sta, 2475 struct wmi_peer_assoc_complete_arg *arg) 2476 { 2477 lockdep_assert_held(&ar->conf_mutex); 2478 2479 memset(arg, 0, sizeof(*arg)); 2480 2481 ath10k_peer_assoc_h_basic(ar, vif, sta, arg); 2482 ath10k_peer_assoc_h_crypto(ar, vif, arg); 2483 ath10k_peer_assoc_h_rates(ar, vif, sta, arg); 2484 ath10k_peer_assoc_h_ht(ar, vif, sta, arg); 2485 ath10k_peer_assoc_h_vht(ar, vif, sta, arg); 2486 ath10k_peer_assoc_h_qos(ar, vif, sta, arg); 2487 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg); 2488 2489 return 0; 2490 } 2491 2492 static const u32 ath10k_smps_map[] = { 2493 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC, 2494 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC, 2495 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE, 2496 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE, 2497 }; 2498 2499 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif, 2500 const u8 *addr, 2501 const struct ieee80211_sta_ht_cap *ht_cap) 2502 { 2503 int smps; 2504 2505 if (!ht_cap->ht_supported) 2506 return 0; 2507 2508 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 2509 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 2510 2511 if (smps >= ARRAY_SIZE(ath10k_smps_map)) 2512 return -EINVAL; 2513 2514 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr, 2515 WMI_PEER_SMPS_STATE, 2516 ath10k_smps_map[smps]); 2517 } 2518 2519 static int ath10k_mac_vif_recalc_txbf(struct ath10k *ar, 2520 struct ieee80211_vif *vif, 2521 struct ieee80211_sta_vht_cap vht_cap) 2522 { 2523 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2524 int ret; 2525 u32 param; 2526 u32 value; 2527 2528 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_AFTER_ASSOC) 2529 return 0; 2530 2531 if (!(ar->vht_cap_info & 2532 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 2533 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE | 2534 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 2535 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))) 2536 return 0; 2537 2538 param = ar->wmi.vdev_param->txbf; 2539 value = 0; 2540 2541 if (WARN_ON(param == WMI_VDEV_PARAM_UNSUPPORTED)) 2542 return 0; 2543 2544 /* The following logic is correct. If a remote STA advertises support 2545 * for being a beamformer then we should enable us being a beamformee. 2546 */ 2547 2548 if (ar->vht_cap_info & 2549 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 2550 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) { 2551 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) 2552 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 2553 2554 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) 2555 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE; 2556 } 2557 2558 if (ar->vht_cap_info & 2559 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 2560 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) { 2561 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) 2562 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 2563 2564 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) 2565 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER; 2566 } 2567 2568 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFEE) 2569 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 2570 2571 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFER) 2572 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 2573 2574 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, value); 2575 if (ret) { 2576 ath10k_warn(ar, "failed to submit vdev param txbf 0x%x: %d\n", 2577 value, ret); 2578 return ret; 2579 } 2580 2581 return 0; 2582 } 2583 2584 /* can be called only in mac80211 callbacks due to `key_count` usage */ 2585 static void ath10k_bss_assoc(struct ieee80211_hw *hw, 2586 struct ieee80211_vif *vif, 2587 struct ieee80211_bss_conf *bss_conf) 2588 { 2589 struct ath10k *ar = hw->priv; 2590 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2591 struct ieee80211_sta_ht_cap ht_cap; 2592 struct ieee80211_sta_vht_cap vht_cap; 2593 struct wmi_peer_assoc_complete_arg peer_arg; 2594 struct ieee80211_sta *ap_sta; 2595 int ret; 2596 2597 lockdep_assert_held(&ar->conf_mutex); 2598 2599 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n", 2600 arvif->vdev_id, arvif->bssid, arvif->aid); 2601 2602 rcu_read_lock(); 2603 2604 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid); 2605 if (!ap_sta) { 2606 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n", 2607 bss_conf->bssid, arvif->vdev_id); 2608 rcu_read_unlock(); 2609 return; 2610 } 2611 2612 /* ap_sta must be accessed only within rcu section which must be left 2613 * before calling ath10k_setup_peer_smps() which might sleep. */ 2614 ht_cap = ap_sta->ht_cap; 2615 vht_cap = ap_sta->vht_cap; 2616 2617 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg); 2618 if (ret) { 2619 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n", 2620 bss_conf->bssid, arvif->vdev_id, ret); 2621 rcu_read_unlock(); 2622 return; 2623 } 2624 2625 rcu_read_unlock(); 2626 2627 ret = ath10k_wmi_peer_assoc(ar, &peer_arg); 2628 if (ret) { 2629 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n", 2630 bss_conf->bssid, arvif->vdev_id, ret); 2631 return; 2632 } 2633 2634 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap); 2635 if (ret) { 2636 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n", 2637 arvif->vdev_id, ret); 2638 return; 2639 } 2640 2641 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap); 2642 if (ret) { 2643 ath10k_warn(ar, "failed to recalc txbf for vdev %i on bss %pM: %d\n", 2644 arvif->vdev_id, bss_conf->bssid, ret); 2645 return; 2646 } 2647 2648 ath10k_dbg(ar, ATH10K_DBG_MAC, 2649 "mac vdev %d up (associated) bssid %pM aid %d\n", 2650 arvif->vdev_id, bss_conf->bssid, bss_conf->aid); 2651 2652 WARN_ON(arvif->is_up); 2653 2654 arvif->aid = bss_conf->aid; 2655 ether_addr_copy(arvif->bssid, bss_conf->bssid); 2656 2657 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid); 2658 if (ret) { 2659 ath10k_warn(ar, "failed to set vdev %d up: %d\n", 2660 arvif->vdev_id, ret); 2661 return; 2662 } 2663 2664 arvif->is_up = true; 2665 2666 /* Workaround: Some firmware revisions (tested with qca6174 2667 * WLAN.RM.2.0-00073) have buggy powersave state machine and must be 2668 * poked with peer param command. 2669 */ 2670 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid, 2671 WMI_PEER_DUMMY_VAR, 1); 2672 if (ret) { 2673 ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n", 2674 arvif->bssid, arvif->vdev_id, ret); 2675 return; 2676 } 2677 } 2678 2679 static void ath10k_bss_disassoc(struct ieee80211_hw *hw, 2680 struct ieee80211_vif *vif) 2681 { 2682 struct ath10k *ar = hw->priv; 2683 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2684 struct ieee80211_sta_vht_cap vht_cap = {}; 2685 int ret; 2686 2687 lockdep_assert_held(&ar->conf_mutex); 2688 2689 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n", 2690 arvif->vdev_id, arvif->bssid); 2691 2692 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 2693 if (ret) 2694 ath10k_warn(ar, "faield to down vdev %i: %d\n", 2695 arvif->vdev_id, ret); 2696 2697 arvif->def_wep_key_idx = -1; 2698 2699 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap); 2700 if (ret) { 2701 ath10k_warn(ar, "failed to recalc txbf for vdev %i: %d\n", 2702 arvif->vdev_id, ret); 2703 return; 2704 } 2705 2706 arvif->is_up = false; 2707 2708 cancel_delayed_work_sync(&arvif->connection_loss_work); 2709 } 2710 2711 static int ath10k_station_assoc(struct ath10k *ar, 2712 struct ieee80211_vif *vif, 2713 struct ieee80211_sta *sta, 2714 bool reassoc) 2715 { 2716 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2717 struct wmi_peer_assoc_complete_arg peer_arg; 2718 int ret = 0; 2719 2720 lockdep_assert_held(&ar->conf_mutex); 2721 2722 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg); 2723 if (ret) { 2724 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n", 2725 sta->addr, arvif->vdev_id, ret); 2726 return ret; 2727 } 2728 2729 ret = ath10k_wmi_peer_assoc(ar, &peer_arg); 2730 if (ret) { 2731 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n", 2732 sta->addr, arvif->vdev_id, ret); 2733 return ret; 2734 } 2735 2736 /* Re-assoc is run only to update supported rates for given station. It 2737 * doesn't make much sense to reconfigure the peer completely. 2738 */ 2739 if (!reassoc) { 2740 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr, 2741 &sta->ht_cap); 2742 if (ret) { 2743 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n", 2744 arvif->vdev_id, ret); 2745 return ret; 2746 } 2747 2748 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta); 2749 if (ret) { 2750 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n", 2751 sta->addr, arvif->vdev_id, ret); 2752 return ret; 2753 } 2754 2755 if (!sta->wme) { 2756 arvif->num_legacy_stations++; 2757 ret = ath10k_recalc_rtscts_prot(arvif); 2758 if (ret) { 2759 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n", 2760 arvif->vdev_id, ret); 2761 return ret; 2762 } 2763 } 2764 2765 /* Plumb cached keys only for static WEP */ 2766 if (arvif->def_wep_key_idx != -1) { 2767 ret = ath10k_install_peer_wep_keys(arvif, sta->addr); 2768 if (ret) { 2769 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n", 2770 arvif->vdev_id, ret); 2771 return ret; 2772 } 2773 } 2774 } 2775 2776 return ret; 2777 } 2778 2779 static int ath10k_station_disassoc(struct ath10k *ar, 2780 struct ieee80211_vif *vif, 2781 struct ieee80211_sta *sta) 2782 { 2783 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2784 int ret = 0; 2785 2786 lockdep_assert_held(&ar->conf_mutex); 2787 2788 if (!sta->wme) { 2789 arvif->num_legacy_stations--; 2790 ret = ath10k_recalc_rtscts_prot(arvif); 2791 if (ret) { 2792 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n", 2793 arvif->vdev_id, ret); 2794 return ret; 2795 } 2796 } 2797 2798 ret = ath10k_clear_peer_keys(arvif, sta->addr); 2799 if (ret) { 2800 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n", 2801 arvif->vdev_id, ret); 2802 return ret; 2803 } 2804 2805 return ret; 2806 } 2807 2808 /**************/ 2809 /* Regulatory */ 2810 /**************/ 2811 2812 static int ath10k_update_channel_list(struct ath10k *ar) 2813 { 2814 struct ieee80211_hw *hw = ar->hw; 2815 struct ieee80211_supported_band **bands; 2816 enum ieee80211_band band; 2817 struct ieee80211_channel *channel; 2818 struct wmi_scan_chan_list_arg arg = {0}; 2819 struct wmi_channel_arg *ch; 2820 bool passive; 2821 int len; 2822 int ret; 2823 int i; 2824 2825 lockdep_assert_held(&ar->conf_mutex); 2826 2827 bands = hw->wiphy->bands; 2828 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 2829 if (!bands[band]) 2830 continue; 2831 2832 for (i = 0; i < bands[band]->n_channels; i++) { 2833 if (bands[band]->channels[i].flags & 2834 IEEE80211_CHAN_DISABLED) 2835 continue; 2836 2837 arg.n_channels++; 2838 } 2839 } 2840 2841 len = sizeof(struct wmi_channel_arg) * arg.n_channels; 2842 arg.channels = kzalloc(len, GFP_KERNEL); 2843 if (!arg.channels) 2844 return -ENOMEM; 2845 2846 ch = arg.channels; 2847 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 2848 if (!bands[band]) 2849 continue; 2850 2851 for (i = 0; i < bands[band]->n_channels; i++) { 2852 channel = &bands[band]->channels[i]; 2853 2854 if (channel->flags & IEEE80211_CHAN_DISABLED) 2855 continue; 2856 2857 ch->allow_ht = true; 2858 2859 /* FIXME: when should we really allow VHT? */ 2860 ch->allow_vht = true; 2861 2862 ch->allow_ibss = 2863 !(channel->flags & IEEE80211_CHAN_NO_IR); 2864 2865 ch->ht40plus = 2866 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS); 2867 2868 ch->chan_radar = 2869 !!(channel->flags & IEEE80211_CHAN_RADAR); 2870 2871 passive = channel->flags & IEEE80211_CHAN_NO_IR; 2872 ch->passive = passive; 2873 2874 ch->freq = channel->center_freq; 2875 ch->band_center_freq1 = channel->center_freq; 2876 ch->min_power = 0; 2877 ch->max_power = channel->max_power * 2; 2878 ch->max_reg_power = channel->max_reg_power * 2; 2879 ch->max_antenna_gain = channel->max_antenna_gain * 2; 2880 ch->reg_class_id = 0; /* FIXME */ 2881 2882 /* FIXME: why use only legacy modes, why not any 2883 * HT/VHT modes? Would that even make any 2884 * difference? */ 2885 if (channel->band == IEEE80211_BAND_2GHZ) 2886 ch->mode = MODE_11G; 2887 else 2888 ch->mode = MODE_11A; 2889 2890 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN)) 2891 continue; 2892 2893 ath10k_dbg(ar, ATH10K_DBG_WMI, 2894 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n", 2895 ch - arg.channels, arg.n_channels, 2896 ch->freq, ch->max_power, ch->max_reg_power, 2897 ch->max_antenna_gain, ch->mode); 2898 2899 ch++; 2900 } 2901 } 2902 2903 ret = ath10k_wmi_scan_chan_list(ar, &arg); 2904 kfree(arg.channels); 2905 2906 return ret; 2907 } 2908 2909 static enum wmi_dfs_region 2910 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region) 2911 { 2912 switch (dfs_region) { 2913 case NL80211_DFS_UNSET: 2914 return WMI_UNINIT_DFS_DOMAIN; 2915 case NL80211_DFS_FCC: 2916 return WMI_FCC_DFS_DOMAIN; 2917 case NL80211_DFS_ETSI: 2918 return WMI_ETSI_DFS_DOMAIN; 2919 case NL80211_DFS_JP: 2920 return WMI_MKK4_DFS_DOMAIN; 2921 } 2922 return WMI_UNINIT_DFS_DOMAIN; 2923 } 2924 2925 static void ath10k_regd_update(struct ath10k *ar) 2926 { 2927 struct reg_dmn_pair_mapping *regpair; 2928 int ret; 2929 enum wmi_dfs_region wmi_dfs_reg; 2930 enum nl80211_dfs_regions nl_dfs_reg; 2931 2932 lockdep_assert_held(&ar->conf_mutex); 2933 2934 ret = ath10k_update_channel_list(ar); 2935 if (ret) 2936 ath10k_warn(ar, "failed to update channel list: %d\n", ret); 2937 2938 regpair = ar->ath_common.regulatory.regpair; 2939 2940 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) { 2941 nl_dfs_reg = ar->dfs_detector->region; 2942 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg); 2943 } else { 2944 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN; 2945 } 2946 2947 /* Target allows setting up per-band regdomain but ath_common provides 2948 * a combined one only */ 2949 ret = ath10k_wmi_pdev_set_regdomain(ar, 2950 regpair->reg_domain, 2951 regpair->reg_domain, /* 2ghz */ 2952 regpair->reg_domain, /* 5ghz */ 2953 regpair->reg_2ghz_ctl, 2954 regpair->reg_5ghz_ctl, 2955 wmi_dfs_reg); 2956 if (ret) 2957 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret); 2958 } 2959 2960 static void ath10k_reg_notifier(struct wiphy *wiphy, 2961 struct regulatory_request *request) 2962 { 2963 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 2964 struct ath10k *ar = hw->priv; 2965 bool result; 2966 2967 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory); 2968 2969 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) { 2970 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n", 2971 request->dfs_region); 2972 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector, 2973 request->dfs_region); 2974 if (!result) 2975 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n", 2976 request->dfs_region); 2977 } 2978 2979 mutex_lock(&ar->conf_mutex); 2980 if (ar->state == ATH10K_STATE_ON) 2981 ath10k_regd_update(ar); 2982 mutex_unlock(&ar->conf_mutex); 2983 } 2984 2985 /***************/ 2986 /* TX handlers */ 2987 /***************/ 2988 2989 void ath10k_mac_tx_lock(struct ath10k *ar, int reason) 2990 { 2991 lockdep_assert_held(&ar->htt.tx_lock); 2992 2993 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX); 2994 ar->tx_paused |= BIT(reason); 2995 ieee80211_stop_queues(ar->hw); 2996 } 2997 2998 static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac, 2999 struct ieee80211_vif *vif) 3000 { 3001 struct ath10k *ar = data; 3002 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3003 3004 if (arvif->tx_paused) 3005 return; 3006 3007 ieee80211_wake_queue(ar->hw, arvif->vdev_id); 3008 } 3009 3010 void ath10k_mac_tx_unlock(struct ath10k *ar, int reason) 3011 { 3012 lockdep_assert_held(&ar->htt.tx_lock); 3013 3014 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX); 3015 ar->tx_paused &= ~BIT(reason); 3016 3017 if (ar->tx_paused) 3018 return; 3019 3020 ieee80211_iterate_active_interfaces_atomic(ar->hw, 3021 IEEE80211_IFACE_ITER_RESUME_ALL, 3022 ath10k_mac_tx_unlock_iter, 3023 ar); 3024 3025 ieee80211_wake_queue(ar->hw, ar->hw->offchannel_tx_hw_queue); 3026 } 3027 3028 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason) 3029 { 3030 struct ath10k *ar = arvif->ar; 3031 3032 lockdep_assert_held(&ar->htt.tx_lock); 3033 3034 WARN_ON(reason >= BITS_PER_LONG); 3035 arvif->tx_paused |= BIT(reason); 3036 ieee80211_stop_queue(ar->hw, arvif->vdev_id); 3037 } 3038 3039 void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason) 3040 { 3041 struct ath10k *ar = arvif->ar; 3042 3043 lockdep_assert_held(&ar->htt.tx_lock); 3044 3045 WARN_ON(reason >= BITS_PER_LONG); 3046 arvif->tx_paused &= ~BIT(reason); 3047 3048 if (ar->tx_paused) 3049 return; 3050 3051 if (arvif->tx_paused) 3052 return; 3053 3054 ieee80211_wake_queue(ar->hw, arvif->vdev_id); 3055 } 3056 3057 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif, 3058 enum wmi_tlv_tx_pause_id pause_id, 3059 enum wmi_tlv_tx_pause_action action) 3060 { 3061 struct ath10k *ar = arvif->ar; 3062 3063 lockdep_assert_held(&ar->htt.tx_lock); 3064 3065 switch (action) { 3066 case WMI_TLV_TX_PAUSE_ACTION_STOP: 3067 ath10k_mac_vif_tx_lock(arvif, pause_id); 3068 break; 3069 case WMI_TLV_TX_PAUSE_ACTION_WAKE: 3070 ath10k_mac_vif_tx_unlock(arvif, pause_id); 3071 break; 3072 default: 3073 ath10k_warn(ar, "received unknown tx pause action %d on vdev %i, ignoring\n", 3074 action, arvif->vdev_id); 3075 break; 3076 } 3077 } 3078 3079 struct ath10k_mac_tx_pause { 3080 u32 vdev_id; 3081 enum wmi_tlv_tx_pause_id pause_id; 3082 enum wmi_tlv_tx_pause_action action; 3083 }; 3084 3085 static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac, 3086 struct ieee80211_vif *vif) 3087 { 3088 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3089 struct ath10k_mac_tx_pause *arg = data; 3090 3091 if (arvif->vdev_id != arg->vdev_id) 3092 return; 3093 3094 ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action); 3095 } 3096 3097 void ath10k_mac_handle_tx_pause_vdev(struct ath10k *ar, u32 vdev_id, 3098 enum wmi_tlv_tx_pause_id pause_id, 3099 enum wmi_tlv_tx_pause_action action) 3100 { 3101 struct ath10k_mac_tx_pause arg = { 3102 .vdev_id = vdev_id, 3103 .pause_id = pause_id, 3104 .action = action, 3105 }; 3106 3107 spin_lock_bh(&ar->htt.tx_lock); 3108 ieee80211_iterate_active_interfaces_atomic(ar->hw, 3109 IEEE80211_IFACE_ITER_RESUME_ALL, 3110 ath10k_mac_handle_tx_pause_iter, 3111 &arg); 3112 spin_unlock_bh(&ar->htt.tx_lock); 3113 } 3114 3115 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr) 3116 { 3117 if (ieee80211_is_mgmt(hdr->frame_control)) 3118 return HTT_DATA_TX_EXT_TID_MGMT; 3119 3120 if (!ieee80211_is_data_qos(hdr->frame_control)) 3121 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST; 3122 3123 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr))) 3124 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST; 3125 3126 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK; 3127 } 3128 3129 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar, struct ieee80211_vif *vif) 3130 { 3131 if (vif) 3132 return ath10k_vif_to_arvif(vif)->vdev_id; 3133 3134 if (ar->monitor_started) 3135 return ar->monitor_vdev_id; 3136 3137 ath10k_warn(ar, "failed to resolve vdev id\n"); 3138 return 0; 3139 } 3140 3141 static enum ath10k_hw_txrx_mode 3142 ath10k_tx_h_get_txmode(struct ath10k *ar, struct ieee80211_vif *vif, 3143 struct ieee80211_sta *sta, struct sk_buff *skb) 3144 { 3145 const struct ieee80211_hdr *hdr = (void *)skb->data; 3146 __le16 fc = hdr->frame_control; 3147 3148 if (!vif || vif->type == NL80211_IFTYPE_MONITOR) 3149 return ATH10K_HW_TXRX_RAW; 3150 3151 if (ieee80211_is_mgmt(fc)) 3152 return ATH10K_HW_TXRX_MGMT; 3153 3154 /* Workaround: 3155 * 3156 * NullFunc frames are mostly used to ping if a client or AP are still 3157 * reachable and responsive. This implies tx status reports must be 3158 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can 3159 * come to a conclusion that the other end disappeared and tear down 3160 * BSS connection or it can never disconnect from BSS/client (which is 3161 * the case). 3162 * 3163 * Firmware with HTT older than 3.0 delivers incorrect tx status for 3164 * NullFunc frames to driver. However there's a HTT Mgmt Tx command 3165 * which seems to deliver correct tx reports for NullFunc frames. The 3166 * downside of using it is it ignores client powersave state so it can 3167 * end up disconnecting sleeping clients in AP mode. It should fix STA 3168 * mode though because AP don't sleep. 3169 */ 3170 if (ar->htt.target_version_major < 3 && 3171 (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) && 3172 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, ar->fw_features)) 3173 return ATH10K_HW_TXRX_MGMT; 3174 3175 /* Workaround: 3176 * 3177 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for 3178 * NativeWifi txmode - it selects AP key instead of peer key. It seems 3179 * to work with Ethernet txmode so use it. 3180 * 3181 * FIXME: Check if raw mode works with TDLS. 3182 */ 3183 if (ieee80211_is_data_present(fc) && sta && sta->tdls) 3184 return ATH10K_HW_TXRX_ETHERNET; 3185 3186 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) 3187 return ATH10K_HW_TXRX_RAW; 3188 3189 return ATH10K_HW_TXRX_NATIVE_WIFI; 3190 } 3191 3192 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif, 3193 struct sk_buff *skb) { 3194 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 3195 const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT | 3196 IEEE80211_TX_CTL_INJECTED; 3197 if ((info->flags & mask) == mask) 3198 return false; 3199 if (vif) 3200 return !ath10k_vif_to_arvif(vif)->nohwcrypt; 3201 return true; 3202 } 3203 3204 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS 3205 * Control in the header. 3206 */ 3207 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb) 3208 { 3209 struct ieee80211_hdr *hdr = (void *)skb->data; 3210 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb); 3211 u8 *qos_ctl; 3212 3213 if (!ieee80211_is_data_qos(hdr->frame_control)) 3214 return; 3215 3216 qos_ctl = ieee80211_get_qos_ctl(hdr); 3217 memmove(skb->data + IEEE80211_QOS_CTL_LEN, 3218 skb->data, (void *)qos_ctl - (void *)skb->data); 3219 skb_pull(skb, IEEE80211_QOS_CTL_LEN); 3220 3221 /* Some firmware revisions don't handle sending QoS NullFunc well. 3222 * These frames are mainly used for CQM purposes so it doesn't really 3223 * matter whether QoS NullFunc or NullFunc are sent. 3224 */ 3225 hdr = (void *)skb->data; 3226 if (ieee80211_is_qos_nullfunc(hdr->frame_control)) 3227 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST; 3228 3229 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA); 3230 } 3231 3232 static void ath10k_tx_h_8023(struct sk_buff *skb) 3233 { 3234 struct ieee80211_hdr *hdr; 3235 struct rfc1042_hdr *rfc1042; 3236 struct ethhdr *eth; 3237 size_t hdrlen; 3238 u8 da[ETH_ALEN]; 3239 u8 sa[ETH_ALEN]; 3240 __be16 type; 3241 3242 hdr = (void *)skb->data; 3243 hdrlen = ieee80211_hdrlen(hdr->frame_control); 3244 rfc1042 = (void *)skb->data + hdrlen; 3245 3246 ether_addr_copy(da, ieee80211_get_DA(hdr)); 3247 ether_addr_copy(sa, ieee80211_get_SA(hdr)); 3248 type = rfc1042->snap_type; 3249 3250 skb_pull(skb, hdrlen + sizeof(*rfc1042)); 3251 skb_push(skb, sizeof(*eth)); 3252 3253 eth = (void *)skb->data; 3254 ether_addr_copy(eth->h_dest, da); 3255 ether_addr_copy(eth->h_source, sa); 3256 eth->h_proto = type; 3257 } 3258 3259 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, 3260 struct ieee80211_vif *vif, 3261 struct sk_buff *skb) 3262 { 3263 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 3264 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3265 3266 /* This is case only for P2P_GO */ 3267 if (arvif->vdev_type != WMI_VDEV_TYPE_AP || 3268 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO) 3269 return; 3270 3271 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) { 3272 spin_lock_bh(&ar->data_lock); 3273 if (arvif->u.ap.noa_data) 3274 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len, 3275 GFP_ATOMIC)) 3276 memcpy(skb_put(skb, arvif->u.ap.noa_len), 3277 arvif->u.ap.noa_data, 3278 arvif->u.ap.noa_len); 3279 spin_unlock_bh(&ar->data_lock); 3280 } 3281 } 3282 3283 static bool ath10k_mac_need_offchan_tx_work(struct ath10k *ar) 3284 { 3285 /* FIXME: Not really sure since when the behaviour changed. At some 3286 * point new firmware stopped requiring creation of peer entries for 3287 * offchannel tx (and actually creating them causes issues with wmi-htc 3288 * tx credit replenishment and reliability). Assuming it's at least 3.4 3289 * because that's when the `freq` was introduced to TX_FRM HTT command. 3290 */ 3291 return !(ar->htt.target_version_major >= 3 && 3292 ar->htt.target_version_minor >= 4); 3293 } 3294 3295 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb) 3296 { 3297 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue; 3298 int ret = 0; 3299 3300 spin_lock_bh(&ar->data_lock); 3301 3302 if (skb_queue_len(q) == ATH10K_MAX_NUM_MGMT_PENDING) { 3303 ath10k_warn(ar, "wmi mgmt tx queue is full\n"); 3304 ret = -ENOSPC; 3305 goto unlock; 3306 } 3307 3308 __skb_queue_tail(q, skb); 3309 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work); 3310 3311 unlock: 3312 spin_unlock_bh(&ar->data_lock); 3313 3314 return ret; 3315 } 3316 3317 static void ath10k_mac_tx(struct ath10k *ar, struct sk_buff *skb) 3318 { 3319 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb); 3320 struct ath10k_htt *htt = &ar->htt; 3321 int ret = 0; 3322 3323 switch (cb->txmode) { 3324 case ATH10K_HW_TXRX_RAW: 3325 case ATH10K_HW_TXRX_NATIVE_WIFI: 3326 case ATH10K_HW_TXRX_ETHERNET: 3327 ret = ath10k_htt_tx(htt, skb); 3328 break; 3329 case ATH10K_HW_TXRX_MGMT: 3330 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, 3331 ar->fw_features)) 3332 ret = ath10k_mac_tx_wmi_mgmt(ar, skb); 3333 else if (ar->htt.target_version_major >= 3) 3334 ret = ath10k_htt_tx(htt, skb); 3335 else 3336 ret = ath10k_htt_mgmt_tx(htt, skb); 3337 break; 3338 } 3339 3340 if (ret) { 3341 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n", 3342 ret); 3343 ieee80211_free_txskb(ar->hw, skb); 3344 } 3345 } 3346 3347 void ath10k_offchan_tx_purge(struct ath10k *ar) 3348 { 3349 struct sk_buff *skb; 3350 3351 for (;;) { 3352 skb = skb_dequeue(&ar->offchan_tx_queue); 3353 if (!skb) 3354 break; 3355 3356 ieee80211_free_txskb(ar->hw, skb); 3357 } 3358 } 3359 3360 void ath10k_offchan_tx_work(struct work_struct *work) 3361 { 3362 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work); 3363 struct ath10k_peer *peer; 3364 struct ieee80211_hdr *hdr; 3365 struct sk_buff *skb; 3366 const u8 *peer_addr; 3367 int vdev_id; 3368 int ret; 3369 unsigned long time_left; 3370 bool tmp_peer_created = false; 3371 3372 /* FW requirement: We must create a peer before FW will send out 3373 * an offchannel frame. Otherwise the frame will be stuck and 3374 * never transmitted. We delete the peer upon tx completion. 3375 * It is unlikely that a peer for offchannel tx will already be 3376 * present. However it may be in some rare cases so account for that. 3377 * Otherwise we might remove a legitimate peer and break stuff. */ 3378 3379 for (;;) { 3380 skb = skb_dequeue(&ar->offchan_tx_queue); 3381 if (!skb) 3382 break; 3383 3384 mutex_lock(&ar->conf_mutex); 3385 3386 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n", 3387 skb); 3388 3389 hdr = (struct ieee80211_hdr *)skb->data; 3390 peer_addr = ieee80211_get_DA(hdr); 3391 vdev_id = ATH10K_SKB_CB(skb)->vdev_id; 3392 3393 spin_lock_bh(&ar->data_lock); 3394 peer = ath10k_peer_find(ar, vdev_id, peer_addr); 3395 spin_unlock_bh(&ar->data_lock); 3396 3397 if (peer) 3398 /* FIXME: should this use ath10k_warn()? */ 3399 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n", 3400 peer_addr, vdev_id); 3401 3402 if (!peer) { 3403 ret = ath10k_peer_create(ar, vdev_id, peer_addr, 3404 WMI_PEER_TYPE_DEFAULT); 3405 if (ret) 3406 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n", 3407 peer_addr, vdev_id, ret); 3408 tmp_peer_created = (ret == 0); 3409 } 3410 3411 spin_lock_bh(&ar->data_lock); 3412 reinit_completion(&ar->offchan_tx_completed); 3413 ar->offchan_tx_skb = skb; 3414 spin_unlock_bh(&ar->data_lock); 3415 3416 ath10k_mac_tx(ar, skb); 3417 3418 time_left = 3419 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ); 3420 if (time_left == 0) 3421 ath10k_warn(ar, "timed out waiting for offchannel skb %p\n", 3422 skb); 3423 3424 if (!peer && tmp_peer_created) { 3425 ret = ath10k_peer_delete(ar, vdev_id, peer_addr); 3426 if (ret) 3427 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n", 3428 peer_addr, vdev_id, ret); 3429 } 3430 3431 mutex_unlock(&ar->conf_mutex); 3432 } 3433 } 3434 3435 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar) 3436 { 3437 struct sk_buff *skb; 3438 3439 for (;;) { 3440 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue); 3441 if (!skb) 3442 break; 3443 3444 ieee80211_free_txskb(ar->hw, skb); 3445 } 3446 } 3447 3448 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work) 3449 { 3450 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work); 3451 struct sk_buff *skb; 3452 int ret; 3453 3454 for (;;) { 3455 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue); 3456 if (!skb) 3457 break; 3458 3459 ret = ath10k_wmi_mgmt_tx(ar, skb); 3460 if (ret) { 3461 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n", 3462 ret); 3463 ieee80211_free_txskb(ar->hw, skb); 3464 } 3465 } 3466 } 3467 3468 /************/ 3469 /* Scanning */ 3470 /************/ 3471 3472 void __ath10k_scan_finish(struct ath10k *ar) 3473 { 3474 lockdep_assert_held(&ar->data_lock); 3475 3476 switch (ar->scan.state) { 3477 case ATH10K_SCAN_IDLE: 3478 break; 3479 case ATH10K_SCAN_RUNNING: 3480 case ATH10K_SCAN_ABORTING: 3481 if (!ar->scan.is_roc) 3482 ieee80211_scan_completed(ar->hw, 3483 (ar->scan.state == 3484 ATH10K_SCAN_ABORTING)); 3485 else if (ar->scan.roc_notify) 3486 ieee80211_remain_on_channel_expired(ar->hw); 3487 /* fall through */ 3488 case ATH10K_SCAN_STARTING: 3489 ar->scan.state = ATH10K_SCAN_IDLE; 3490 ar->scan_channel = NULL; 3491 ath10k_offchan_tx_purge(ar); 3492 cancel_delayed_work(&ar->scan.timeout); 3493 complete_all(&ar->scan.completed); 3494 break; 3495 } 3496 } 3497 3498 void ath10k_scan_finish(struct ath10k *ar) 3499 { 3500 spin_lock_bh(&ar->data_lock); 3501 __ath10k_scan_finish(ar); 3502 spin_unlock_bh(&ar->data_lock); 3503 } 3504 3505 static int ath10k_scan_stop(struct ath10k *ar) 3506 { 3507 struct wmi_stop_scan_arg arg = { 3508 .req_id = 1, /* FIXME */ 3509 .req_type = WMI_SCAN_STOP_ONE, 3510 .u.scan_id = ATH10K_SCAN_ID, 3511 }; 3512 int ret; 3513 3514 lockdep_assert_held(&ar->conf_mutex); 3515 3516 ret = ath10k_wmi_stop_scan(ar, &arg); 3517 if (ret) { 3518 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret); 3519 goto out; 3520 } 3521 3522 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ); 3523 if (ret == 0) { 3524 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n"); 3525 ret = -ETIMEDOUT; 3526 } else if (ret > 0) { 3527 ret = 0; 3528 } 3529 3530 out: 3531 /* Scan state should be updated upon scan completion but in case 3532 * firmware fails to deliver the event (for whatever reason) it is 3533 * desired to clean up scan state anyway. Firmware may have just 3534 * dropped the scan completion event delivery due to transport pipe 3535 * being overflown with data and/or it can recover on its own before 3536 * next scan request is submitted. 3537 */ 3538 spin_lock_bh(&ar->data_lock); 3539 if (ar->scan.state != ATH10K_SCAN_IDLE) 3540 __ath10k_scan_finish(ar); 3541 spin_unlock_bh(&ar->data_lock); 3542 3543 return ret; 3544 } 3545 3546 static void ath10k_scan_abort(struct ath10k *ar) 3547 { 3548 int ret; 3549 3550 lockdep_assert_held(&ar->conf_mutex); 3551 3552 spin_lock_bh(&ar->data_lock); 3553 3554 switch (ar->scan.state) { 3555 case ATH10K_SCAN_IDLE: 3556 /* This can happen if timeout worker kicked in and called 3557 * abortion while scan completion was being processed. 3558 */ 3559 break; 3560 case ATH10K_SCAN_STARTING: 3561 case ATH10K_SCAN_ABORTING: 3562 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n", 3563 ath10k_scan_state_str(ar->scan.state), 3564 ar->scan.state); 3565 break; 3566 case ATH10K_SCAN_RUNNING: 3567 ar->scan.state = ATH10K_SCAN_ABORTING; 3568 spin_unlock_bh(&ar->data_lock); 3569 3570 ret = ath10k_scan_stop(ar); 3571 if (ret) 3572 ath10k_warn(ar, "failed to abort scan: %d\n", ret); 3573 3574 spin_lock_bh(&ar->data_lock); 3575 break; 3576 } 3577 3578 spin_unlock_bh(&ar->data_lock); 3579 } 3580 3581 void ath10k_scan_timeout_work(struct work_struct *work) 3582 { 3583 struct ath10k *ar = container_of(work, struct ath10k, 3584 scan.timeout.work); 3585 3586 mutex_lock(&ar->conf_mutex); 3587 ath10k_scan_abort(ar); 3588 mutex_unlock(&ar->conf_mutex); 3589 } 3590 3591 static int ath10k_start_scan(struct ath10k *ar, 3592 const struct wmi_start_scan_arg *arg) 3593 { 3594 int ret; 3595 3596 lockdep_assert_held(&ar->conf_mutex); 3597 3598 ret = ath10k_wmi_start_scan(ar, arg); 3599 if (ret) 3600 return ret; 3601 3602 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ); 3603 if (ret == 0) { 3604 ret = ath10k_scan_stop(ar); 3605 if (ret) 3606 ath10k_warn(ar, "failed to stop scan: %d\n", ret); 3607 3608 return -ETIMEDOUT; 3609 } 3610 3611 /* If we failed to start the scan, return error code at 3612 * this point. This is probably due to some issue in the 3613 * firmware, but no need to wedge the driver due to that... 3614 */ 3615 spin_lock_bh(&ar->data_lock); 3616 if (ar->scan.state == ATH10K_SCAN_IDLE) { 3617 spin_unlock_bh(&ar->data_lock); 3618 return -EINVAL; 3619 } 3620 spin_unlock_bh(&ar->data_lock); 3621 3622 return 0; 3623 } 3624 3625 /**********************/ 3626 /* mac80211 callbacks */ 3627 /**********************/ 3628 3629 static void ath10k_tx(struct ieee80211_hw *hw, 3630 struct ieee80211_tx_control *control, 3631 struct sk_buff *skb) 3632 { 3633 struct ath10k *ar = hw->priv; 3634 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 3635 struct ieee80211_vif *vif = info->control.vif; 3636 struct ieee80211_sta *sta = control->sta; 3637 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 3638 __le16 fc = hdr->frame_control; 3639 3640 /* We should disable CCK RATE due to P2P */ 3641 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE) 3642 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n"); 3643 3644 ATH10K_SKB_CB(skb)->htt.is_offchan = false; 3645 ATH10K_SKB_CB(skb)->htt.freq = 0; 3646 ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr); 3647 ATH10K_SKB_CB(skb)->htt.nohwcrypt = !ath10k_tx_h_use_hwcrypto(vif, skb); 3648 ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, vif); 3649 ATH10K_SKB_CB(skb)->txmode = ath10k_tx_h_get_txmode(ar, vif, sta, skb); 3650 ATH10K_SKB_CB(skb)->is_protected = ieee80211_has_protected(fc); 3651 3652 switch (ATH10K_SKB_CB(skb)->txmode) { 3653 case ATH10K_HW_TXRX_MGMT: 3654 case ATH10K_HW_TXRX_NATIVE_WIFI: 3655 ath10k_tx_h_nwifi(hw, skb); 3656 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb); 3657 ath10k_tx_h_seq_no(vif, skb); 3658 break; 3659 case ATH10K_HW_TXRX_ETHERNET: 3660 ath10k_tx_h_8023(skb); 3661 break; 3662 case ATH10K_HW_TXRX_RAW: 3663 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) { 3664 WARN_ON_ONCE(1); 3665 ieee80211_free_txskb(hw, skb); 3666 return; 3667 } 3668 } 3669 3670 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) { 3671 spin_lock_bh(&ar->data_lock); 3672 ATH10K_SKB_CB(skb)->htt.freq = ar->scan.roc_freq; 3673 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id; 3674 spin_unlock_bh(&ar->data_lock); 3675 3676 if (ath10k_mac_need_offchan_tx_work(ar)) { 3677 ATH10K_SKB_CB(skb)->htt.freq = 0; 3678 ATH10K_SKB_CB(skb)->htt.is_offchan = true; 3679 3680 ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n", 3681 skb); 3682 3683 skb_queue_tail(&ar->offchan_tx_queue, skb); 3684 ieee80211_queue_work(hw, &ar->offchan_tx_work); 3685 return; 3686 } 3687 } 3688 3689 ath10k_mac_tx(ar, skb); 3690 } 3691 3692 /* Must not be called with conf_mutex held as workers can use that also. */ 3693 void ath10k_drain_tx(struct ath10k *ar) 3694 { 3695 /* make sure rcu-protected mac80211 tx path itself is drained */ 3696 synchronize_net(); 3697 3698 ath10k_offchan_tx_purge(ar); 3699 ath10k_mgmt_over_wmi_tx_purge(ar); 3700 3701 cancel_work_sync(&ar->offchan_tx_work); 3702 cancel_work_sync(&ar->wmi_mgmt_tx_work); 3703 } 3704 3705 void ath10k_halt(struct ath10k *ar) 3706 { 3707 struct ath10k_vif *arvif; 3708 3709 lockdep_assert_held(&ar->conf_mutex); 3710 3711 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 3712 ar->filter_flags = 0; 3713 ar->monitor = false; 3714 ar->monitor_arvif = NULL; 3715 3716 if (ar->monitor_started) 3717 ath10k_monitor_stop(ar); 3718 3719 ar->monitor_started = false; 3720 ar->tx_paused = 0; 3721 3722 ath10k_scan_finish(ar); 3723 ath10k_peer_cleanup_all(ar); 3724 ath10k_core_stop(ar); 3725 ath10k_hif_power_down(ar); 3726 3727 spin_lock_bh(&ar->data_lock); 3728 list_for_each_entry(arvif, &ar->arvifs, list) 3729 ath10k_mac_vif_beacon_cleanup(arvif); 3730 spin_unlock_bh(&ar->data_lock); 3731 } 3732 3733 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 3734 { 3735 struct ath10k *ar = hw->priv; 3736 3737 mutex_lock(&ar->conf_mutex); 3738 3739 *tx_ant = ar->cfg_tx_chainmask; 3740 *rx_ant = ar->cfg_rx_chainmask; 3741 3742 mutex_unlock(&ar->conf_mutex); 3743 3744 return 0; 3745 } 3746 3747 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg) 3748 { 3749 /* It is not clear that allowing gaps in chainmask 3750 * is helpful. Probably it will not do what user 3751 * is hoping for, so warn in that case. 3752 */ 3753 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0) 3754 return; 3755 3756 ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n", 3757 dbg, cm); 3758 } 3759 3760 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar) 3761 { 3762 int nsts = ar->vht_cap_info; 3763 3764 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 3765 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 3766 3767 /* If firmware does not deliver to host number of space-time 3768 * streams supported, assume it support up to 4 BF STS and return 3769 * the value for VHT CAP: nsts-1) 3770 */ 3771 if (nsts == 0) 3772 return 3; 3773 3774 return nsts; 3775 } 3776 3777 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar) 3778 { 3779 int sound_dim = ar->vht_cap_info; 3780 3781 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 3782 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 3783 3784 /* If the sounding dimension is not advertised by the firmware, 3785 * let's use a default value of 1 3786 */ 3787 if (sound_dim == 0) 3788 return 1; 3789 3790 return sound_dim; 3791 } 3792 3793 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar) 3794 { 3795 struct ieee80211_sta_vht_cap vht_cap = {0}; 3796 u16 mcs_map; 3797 u32 val; 3798 int i; 3799 3800 vht_cap.vht_supported = 1; 3801 vht_cap.cap = ar->vht_cap_info; 3802 3803 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 3804 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) { 3805 val = ath10k_mac_get_vht_cap_bf_sts(ar); 3806 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 3807 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 3808 3809 vht_cap.cap |= val; 3810 } 3811 3812 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 3813 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) { 3814 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar); 3815 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 3816 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 3817 3818 vht_cap.cap |= val; 3819 } 3820 3821 mcs_map = 0; 3822 for (i = 0; i < 8; i++) { 3823 if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i))) 3824 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 3825 else 3826 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 3827 } 3828 3829 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map); 3830 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map); 3831 3832 return vht_cap; 3833 } 3834 3835 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar) 3836 { 3837 int i; 3838 struct ieee80211_sta_ht_cap ht_cap = {0}; 3839 3840 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED)) 3841 return ht_cap; 3842 3843 ht_cap.ht_supported = 1; 3844 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 3845 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8; 3846 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 3847 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 3848 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT; 3849 3850 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI) 3851 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 3852 3853 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI) 3854 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 3855 3856 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) { 3857 u32 smps; 3858 3859 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 3860 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 3861 3862 ht_cap.cap |= smps; 3863 } 3864 3865 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC) 3866 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 3867 3868 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) { 3869 u32 stbc; 3870 3871 stbc = ar->ht_cap_info; 3872 stbc &= WMI_HT_CAP_RX_STBC; 3873 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 3874 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 3875 stbc &= IEEE80211_HT_CAP_RX_STBC; 3876 3877 ht_cap.cap |= stbc; 3878 } 3879 3880 if (ar->ht_cap_info & WMI_HT_CAP_LDPC) 3881 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 3882 3883 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT) 3884 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 3885 3886 /* max AMSDU is implicitly taken from vht_cap_info */ 3887 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 3888 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 3889 3890 for (i = 0; i < ar->num_rf_chains; i++) { 3891 if (ar->cfg_rx_chainmask & BIT(i)) 3892 ht_cap.mcs.rx_mask[i] = 0xFF; 3893 } 3894 3895 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 3896 3897 return ht_cap; 3898 } 3899 3900 static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar) 3901 { 3902 struct ieee80211_supported_band *band; 3903 struct ieee80211_sta_vht_cap vht_cap; 3904 struct ieee80211_sta_ht_cap ht_cap; 3905 3906 ht_cap = ath10k_get_ht_cap(ar); 3907 vht_cap = ath10k_create_vht_cap(ar); 3908 3909 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) { 3910 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ]; 3911 band->ht_cap = ht_cap; 3912 3913 /* Enable the VHT support at 2.4 GHz */ 3914 band->vht_cap = vht_cap; 3915 } 3916 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) { 3917 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ]; 3918 band->ht_cap = ht_cap; 3919 band->vht_cap = vht_cap; 3920 } 3921 } 3922 3923 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant) 3924 { 3925 int ret; 3926 3927 lockdep_assert_held(&ar->conf_mutex); 3928 3929 ath10k_check_chain_mask(ar, tx_ant, "tx"); 3930 ath10k_check_chain_mask(ar, rx_ant, "rx"); 3931 3932 ar->cfg_tx_chainmask = tx_ant; 3933 ar->cfg_rx_chainmask = rx_ant; 3934 3935 if ((ar->state != ATH10K_STATE_ON) && 3936 (ar->state != ATH10K_STATE_RESTARTED)) 3937 return 0; 3938 3939 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask, 3940 tx_ant); 3941 if (ret) { 3942 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n", 3943 ret, tx_ant); 3944 return ret; 3945 } 3946 3947 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask, 3948 rx_ant); 3949 if (ret) { 3950 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n", 3951 ret, rx_ant); 3952 return ret; 3953 } 3954 3955 /* Reload HT/VHT capability */ 3956 ath10k_mac_setup_ht_vht_cap(ar); 3957 3958 return 0; 3959 } 3960 3961 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 3962 { 3963 struct ath10k *ar = hw->priv; 3964 int ret; 3965 3966 mutex_lock(&ar->conf_mutex); 3967 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant); 3968 mutex_unlock(&ar->conf_mutex); 3969 return ret; 3970 } 3971 3972 static int ath10k_start(struct ieee80211_hw *hw) 3973 { 3974 struct ath10k *ar = hw->priv; 3975 u32 burst_enable; 3976 int ret = 0; 3977 3978 /* 3979 * This makes sense only when restarting hw. It is harmless to call 3980 * uncoditionally. This is necessary to make sure no HTT/WMI tx 3981 * commands will be submitted while restarting. 3982 */ 3983 ath10k_drain_tx(ar); 3984 3985 mutex_lock(&ar->conf_mutex); 3986 3987 switch (ar->state) { 3988 case ATH10K_STATE_OFF: 3989 ar->state = ATH10K_STATE_ON; 3990 break; 3991 case ATH10K_STATE_RESTARTING: 3992 ath10k_halt(ar); 3993 ar->state = ATH10K_STATE_RESTARTED; 3994 break; 3995 case ATH10K_STATE_ON: 3996 case ATH10K_STATE_RESTARTED: 3997 case ATH10K_STATE_WEDGED: 3998 WARN_ON(1); 3999 ret = -EINVAL; 4000 goto err; 4001 case ATH10K_STATE_UTF: 4002 ret = -EBUSY; 4003 goto err; 4004 } 4005 4006 ret = ath10k_hif_power_up(ar); 4007 if (ret) { 4008 ath10k_err(ar, "Could not init hif: %d\n", ret); 4009 goto err_off; 4010 } 4011 4012 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL); 4013 if (ret) { 4014 ath10k_err(ar, "Could not init core: %d\n", ret); 4015 goto err_power_down; 4016 } 4017 4018 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1); 4019 if (ret) { 4020 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret); 4021 goto err_core_stop; 4022 } 4023 4024 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1); 4025 if (ret) { 4026 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret); 4027 goto err_core_stop; 4028 } 4029 4030 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) { 4031 ret = ath10k_wmi_adaptive_qcs(ar, true); 4032 if (ret) { 4033 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n", 4034 ret); 4035 goto err_core_stop; 4036 } 4037 } 4038 4039 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) { 4040 burst_enable = ar->wmi.pdev_param->burst_enable; 4041 ret = ath10k_wmi_pdev_set_param(ar, burst_enable, 0); 4042 if (ret) { 4043 ath10k_warn(ar, "failed to disable burst: %d\n", ret); 4044 goto err_core_stop; 4045 } 4046 } 4047 4048 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask); 4049 4050 /* 4051 * By default FW set ARP frames ac to voice (6). In that case ARP 4052 * exchange is not working properly for UAPSD enabled AP. ARP requests 4053 * which arrives with access category 0 are processed by network stack 4054 * and send back with access category 0, but FW changes access category 4055 * to 6. Set ARP frames access category to best effort (0) solves 4056 * this problem. 4057 */ 4058 4059 ret = ath10k_wmi_pdev_set_param(ar, 4060 ar->wmi.pdev_param->arp_ac_override, 0); 4061 if (ret) { 4062 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n", 4063 ret); 4064 goto err_core_stop; 4065 } 4066 4067 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA, 4068 ar->fw_features)) { 4069 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1, 4070 WMI_CCA_DETECT_LEVEL_AUTO, 4071 WMI_CCA_DETECT_MARGIN_AUTO); 4072 if (ret) { 4073 ath10k_warn(ar, "failed to enable adaptive cca: %d\n", 4074 ret); 4075 goto err_core_stop; 4076 } 4077 } 4078 4079 ret = ath10k_wmi_pdev_set_param(ar, 4080 ar->wmi.pdev_param->ani_enable, 1); 4081 if (ret) { 4082 ath10k_warn(ar, "failed to enable ani by default: %d\n", 4083 ret); 4084 goto err_core_stop; 4085 } 4086 4087 ar->ani_enabled = true; 4088 4089 ar->num_started_vdevs = 0; 4090 ath10k_regd_update(ar); 4091 4092 ath10k_spectral_start(ar); 4093 ath10k_thermal_set_throttling(ar); 4094 4095 mutex_unlock(&ar->conf_mutex); 4096 return 0; 4097 4098 err_core_stop: 4099 ath10k_core_stop(ar); 4100 4101 err_power_down: 4102 ath10k_hif_power_down(ar); 4103 4104 err_off: 4105 ar->state = ATH10K_STATE_OFF; 4106 4107 err: 4108 mutex_unlock(&ar->conf_mutex); 4109 return ret; 4110 } 4111 4112 static void ath10k_stop(struct ieee80211_hw *hw) 4113 { 4114 struct ath10k *ar = hw->priv; 4115 4116 ath10k_drain_tx(ar); 4117 4118 mutex_lock(&ar->conf_mutex); 4119 if (ar->state != ATH10K_STATE_OFF) { 4120 ath10k_halt(ar); 4121 ar->state = ATH10K_STATE_OFF; 4122 } 4123 mutex_unlock(&ar->conf_mutex); 4124 4125 cancel_delayed_work_sync(&ar->scan.timeout); 4126 cancel_work_sync(&ar->restart_work); 4127 } 4128 4129 static int ath10k_config_ps(struct ath10k *ar) 4130 { 4131 struct ath10k_vif *arvif; 4132 int ret = 0; 4133 4134 lockdep_assert_held(&ar->conf_mutex); 4135 4136 list_for_each_entry(arvif, &ar->arvifs, list) { 4137 ret = ath10k_mac_vif_setup_ps(arvif); 4138 if (ret) { 4139 ath10k_warn(ar, "failed to setup powersave: %d\n", ret); 4140 break; 4141 } 4142 } 4143 4144 return ret; 4145 } 4146 4147 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower) 4148 { 4149 int ret; 4150 u32 param; 4151 4152 lockdep_assert_held(&ar->conf_mutex); 4153 4154 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower); 4155 4156 param = ar->wmi.pdev_param->txpower_limit2g; 4157 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2); 4158 if (ret) { 4159 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n", 4160 txpower, ret); 4161 return ret; 4162 } 4163 4164 param = ar->wmi.pdev_param->txpower_limit5g; 4165 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2); 4166 if (ret) { 4167 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n", 4168 txpower, ret); 4169 return ret; 4170 } 4171 4172 return 0; 4173 } 4174 4175 static int ath10k_mac_txpower_recalc(struct ath10k *ar) 4176 { 4177 struct ath10k_vif *arvif; 4178 int ret, txpower = -1; 4179 4180 lockdep_assert_held(&ar->conf_mutex); 4181 4182 list_for_each_entry(arvif, &ar->arvifs, list) { 4183 WARN_ON(arvif->txpower < 0); 4184 4185 if (txpower == -1) 4186 txpower = arvif->txpower; 4187 else 4188 txpower = min(txpower, arvif->txpower); 4189 } 4190 4191 if (WARN_ON(txpower == -1)) 4192 return -EINVAL; 4193 4194 ret = ath10k_mac_txpower_setup(ar, txpower); 4195 if (ret) { 4196 ath10k_warn(ar, "failed to setup tx power %d: %d\n", 4197 txpower, ret); 4198 return ret; 4199 } 4200 4201 return 0; 4202 } 4203 4204 static int ath10k_config(struct ieee80211_hw *hw, u32 changed) 4205 { 4206 struct ath10k *ar = hw->priv; 4207 struct ieee80211_conf *conf = &hw->conf; 4208 int ret = 0; 4209 4210 mutex_lock(&ar->conf_mutex); 4211 4212 if (changed & IEEE80211_CONF_CHANGE_PS) 4213 ath10k_config_ps(ar); 4214 4215 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 4216 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR; 4217 ret = ath10k_monitor_recalc(ar); 4218 if (ret) 4219 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 4220 } 4221 4222 mutex_unlock(&ar->conf_mutex); 4223 return ret; 4224 } 4225 4226 static u32 get_nss_from_chainmask(u16 chain_mask) 4227 { 4228 if ((chain_mask & 0xf) == 0xf) 4229 return 4; 4230 else if ((chain_mask & 0x7) == 0x7) 4231 return 3; 4232 else if ((chain_mask & 0x3) == 0x3) 4233 return 2; 4234 return 1; 4235 } 4236 4237 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif) 4238 { 4239 u32 value = 0; 4240 struct ath10k *ar = arvif->ar; 4241 int nsts; 4242 int sound_dim; 4243 4244 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC) 4245 return 0; 4246 4247 nsts = ath10k_mac_get_vht_cap_bf_sts(ar); 4248 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 4249 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) 4250 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET); 4251 4252 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar); 4253 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 4254 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) 4255 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET); 4256 4257 if (!value) 4258 return 0; 4259 4260 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) 4261 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 4262 4263 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) 4264 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER | 4265 WMI_VDEV_PARAM_TXBF_SU_TX_BFER); 4266 4267 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) 4268 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 4269 4270 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) 4271 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE | 4272 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE); 4273 4274 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 4275 ar->wmi.vdev_param->txbf, value); 4276 } 4277 4278 /* 4279 * TODO: 4280 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE, 4281 * because we will send mgmt frames without CCK. This requirement 4282 * for P2P_FIND/GO_NEG should be handled by checking CCK flag 4283 * in the TX packet. 4284 */ 4285 static int ath10k_add_interface(struct ieee80211_hw *hw, 4286 struct ieee80211_vif *vif) 4287 { 4288 struct ath10k *ar = hw->priv; 4289 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 4290 enum wmi_sta_powersave_param param; 4291 int ret = 0; 4292 u32 value; 4293 int bit; 4294 int i; 4295 u32 vdev_param; 4296 4297 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 4298 4299 mutex_lock(&ar->conf_mutex); 4300 4301 memset(arvif, 0, sizeof(*arvif)); 4302 4303 arvif->ar = ar; 4304 arvif->vif = vif; 4305 4306 INIT_LIST_HEAD(&arvif->list); 4307 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work); 4308 INIT_DELAYED_WORK(&arvif->connection_loss_work, 4309 ath10k_mac_vif_sta_connection_loss_work); 4310 4311 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) { 4312 arvif->bitrate_mask.control[i].legacy = 0xffffffff; 4313 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff, 4314 sizeof(arvif->bitrate_mask.control[i].ht_mcs)); 4315 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff, 4316 sizeof(arvif->bitrate_mask.control[i].vht_mcs)); 4317 } 4318 4319 if (ar->num_peers >= ar->max_num_peers) { 4320 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n"); 4321 ret = -ENOBUFS; 4322 goto err; 4323 } 4324 4325 if (ar->free_vdev_map == 0) { 4326 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n"); 4327 ret = -EBUSY; 4328 goto err; 4329 } 4330 bit = __ffs64(ar->free_vdev_map); 4331 4332 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n", 4333 bit, ar->free_vdev_map); 4334 4335 arvif->vdev_id = bit; 4336 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 4337 4338 switch (vif->type) { 4339 case NL80211_IFTYPE_P2P_DEVICE: 4340 arvif->vdev_type = WMI_VDEV_TYPE_STA; 4341 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE; 4342 break; 4343 case NL80211_IFTYPE_UNSPECIFIED: 4344 case NL80211_IFTYPE_STATION: 4345 arvif->vdev_type = WMI_VDEV_TYPE_STA; 4346 if (vif->p2p) 4347 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT; 4348 break; 4349 case NL80211_IFTYPE_ADHOC: 4350 arvif->vdev_type = WMI_VDEV_TYPE_IBSS; 4351 break; 4352 case NL80211_IFTYPE_MESH_POINT: 4353 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) { 4354 ret = -EINVAL; 4355 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n"); 4356 goto err; 4357 } 4358 arvif->vdev_type = WMI_VDEV_TYPE_AP; 4359 break; 4360 case NL80211_IFTYPE_AP: 4361 arvif->vdev_type = WMI_VDEV_TYPE_AP; 4362 4363 if (vif->p2p) 4364 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO; 4365 break; 4366 case NL80211_IFTYPE_MONITOR: 4367 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 4368 break; 4369 default: 4370 WARN_ON(1); 4371 break; 4372 } 4373 4374 /* Using vdev_id as queue number will make it very easy to do per-vif 4375 * tx queue locking. This shouldn't wrap due to interface combinations 4376 * but do a modulo for correctness sake and prevent using offchannel tx 4377 * queues for regular vif tx. 4378 */ 4379 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1); 4380 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 4381 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1); 4382 4383 /* Some firmware revisions don't wait for beacon tx completion before 4384 * sending another SWBA event. This could lead to hardware using old 4385 * (freed) beacon data in some cases, e.g. tx credit starvation 4386 * combined with missed TBTT. This is very very rare. 4387 * 4388 * On non-IOMMU-enabled hosts this could be a possible security issue 4389 * because hw could beacon some random data on the air. On 4390 * IOMMU-enabled hosts DMAR faults would occur in most cases and target 4391 * device would crash. 4392 * 4393 * Since there are no beacon tx completions (implicit nor explicit) 4394 * propagated to host the only workaround for this is to allocate a 4395 * DMA-coherent buffer for a lifetime of a vif and use it for all 4396 * beacon tx commands. Worst case for this approach is some beacons may 4397 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap. 4398 */ 4399 if (vif->type == NL80211_IFTYPE_ADHOC || 4400 vif->type == NL80211_IFTYPE_MESH_POINT || 4401 vif->type == NL80211_IFTYPE_AP) { 4402 arvif->beacon_buf = dma_zalloc_coherent(ar->dev, 4403 IEEE80211_MAX_FRAME_LEN, 4404 &arvif->beacon_paddr, 4405 GFP_ATOMIC); 4406 if (!arvif->beacon_buf) { 4407 ret = -ENOMEM; 4408 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n", 4409 ret); 4410 goto err; 4411 } 4412 } 4413 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags)) 4414 arvif->nohwcrypt = true; 4415 4416 if (arvif->nohwcrypt && 4417 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) { 4418 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n"); 4419 goto err; 4420 } 4421 4422 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n", 4423 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype, 4424 arvif->beacon_buf ? "single-buf" : "per-skb"); 4425 4426 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type, 4427 arvif->vdev_subtype, vif->addr); 4428 if (ret) { 4429 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n", 4430 arvif->vdev_id, ret); 4431 goto err; 4432 } 4433 4434 ar->free_vdev_map &= ~(1LL << arvif->vdev_id); 4435 list_add(&arvif->list, &ar->arvifs); 4436 4437 /* It makes no sense to have firmware do keepalives. mac80211 already 4438 * takes care of this with idle connection polling. 4439 */ 4440 ret = ath10k_mac_vif_disable_keepalive(arvif); 4441 if (ret) { 4442 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n", 4443 arvif->vdev_id, ret); 4444 goto err_vdev_delete; 4445 } 4446 4447 arvif->def_wep_key_idx = -1; 4448 4449 vdev_param = ar->wmi.vdev_param->tx_encap_type; 4450 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 4451 ATH10K_HW_TXRX_NATIVE_WIFI); 4452 /* 10.X firmware does not support this VDEV parameter. Do not warn */ 4453 if (ret && ret != -EOPNOTSUPP) { 4454 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n", 4455 arvif->vdev_id, ret); 4456 goto err_vdev_delete; 4457 } 4458 4459 if (ar->cfg_tx_chainmask) { 4460 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask); 4461 4462 vdev_param = ar->wmi.vdev_param->nss; 4463 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 4464 nss); 4465 if (ret) { 4466 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n", 4467 arvif->vdev_id, ar->cfg_tx_chainmask, nss, 4468 ret); 4469 goto err_vdev_delete; 4470 } 4471 } 4472 4473 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 4474 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 4475 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr, 4476 WMI_PEER_TYPE_DEFAULT); 4477 if (ret) { 4478 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n", 4479 arvif->vdev_id, ret); 4480 goto err_vdev_delete; 4481 } 4482 } 4483 4484 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 4485 ret = ath10k_mac_set_kickout(arvif); 4486 if (ret) { 4487 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n", 4488 arvif->vdev_id, ret); 4489 goto err_peer_delete; 4490 } 4491 } 4492 4493 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) { 4494 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 4495 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 4496 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 4497 param, value); 4498 if (ret) { 4499 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n", 4500 arvif->vdev_id, ret); 4501 goto err_peer_delete; 4502 } 4503 4504 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif); 4505 if (ret) { 4506 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n", 4507 arvif->vdev_id, ret); 4508 goto err_peer_delete; 4509 } 4510 4511 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif); 4512 if (ret) { 4513 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n", 4514 arvif->vdev_id, ret); 4515 goto err_peer_delete; 4516 } 4517 } 4518 4519 ret = ath10k_mac_set_txbf_conf(arvif); 4520 if (ret) { 4521 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n", 4522 arvif->vdev_id, ret); 4523 goto err_peer_delete; 4524 } 4525 4526 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold); 4527 if (ret) { 4528 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n", 4529 arvif->vdev_id, ret); 4530 goto err_peer_delete; 4531 } 4532 4533 arvif->txpower = vif->bss_conf.txpower; 4534 ret = ath10k_mac_txpower_recalc(ar); 4535 if (ret) { 4536 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret); 4537 goto err_peer_delete; 4538 } 4539 4540 if (vif->type == NL80211_IFTYPE_MONITOR) { 4541 ar->monitor_arvif = arvif; 4542 ret = ath10k_monitor_recalc(ar); 4543 if (ret) { 4544 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 4545 goto err_peer_delete; 4546 } 4547 } 4548 4549 spin_lock_bh(&ar->htt.tx_lock); 4550 if (!ar->tx_paused) 4551 ieee80211_wake_queue(ar->hw, arvif->vdev_id); 4552 spin_unlock_bh(&ar->htt.tx_lock); 4553 4554 mutex_unlock(&ar->conf_mutex); 4555 return 0; 4556 4557 err_peer_delete: 4558 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 4559 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) 4560 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr); 4561 4562 err_vdev_delete: 4563 ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 4564 ar->free_vdev_map |= 1LL << arvif->vdev_id; 4565 list_del(&arvif->list); 4566 4567 err: 4568 if (arvif->beacon_buf) { 4569 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN, 4570 arvif->beacon_buf, arvif->beacon_paddr); 4571 arvif->beacon_buf = NULL; 4572 } 4573 4574 mutex_unlock(&ar->conf_mutex); 4575 4576 return ret; 4577 } 4578 4579 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif) 4580 { 4581 int i; 4582 4583 for (i = 0; i < BITS_PER_LONG; i++) 4584 ath10k_mac_vif_tx_unlock(arvif, i); 4585 } 4586 4587 static void ath10k_remove_interface(struct ieee80211_hw *hw, 4588 struct ieee80211_vif *vif) 4589 { 4590 struct ath10k *ar = hw->priv; 4591 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 4592 int ret; 4593 4594 cancel_work_sync(&arvif->ap_csa_work); 4595 cancel_delayed_work_sync(&arvif->connection_loss_work); 4596 4597 mutex_lock(&ar->conf_mutex); 4598 4599 spin_lock_bh(&ar->data_lock); 4600 ath10k_mac_vif_beacon_cleanup(arvif); 4601 spin_unlock_bh(&ar->data_lock); 4602 4603 ret = ath10k_spectral_vif_stop(arvif); 4604 if (ret) 4605 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n", 4606 arvif->vdev_id, ret); 4607 4608 ar->free_vdev_map |= 1LL << arvif->vdev_id; 4609 list_del(&arvif->list); 4610 4611 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 4612 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 4613 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id, 4614 vif->addr); 4615 if (ret) 4616 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n", 4617 arvif->vdev_id, ret); 4618 4619 kfree(arvif->u.ap.noa_data); 4620 } 4621 4622 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n", 4623 arvif->vdev_id); 4624 4625 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 4626 if (ret) 4627 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n", 4628 arvif->vdev_id, ret); 4629 4630 /* Some firmware revisions don't notify host about self-peer removal 4631 * until after associated vdev is deleted. 4632 */ 4633 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 4634 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 4635 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id, 4636 vif->addr); 4637 if (ret) 4638 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n", 4639 arvif->vdev_id, ret); 4640 4641 spin_lock_bh(&ar->data_lock); 4642 ar->num_peers--; 4643 spin_unlock_bh(&ar->data_lock); 4644 } 4645 4646 ath10k_peer_cleanup(ar, arvif->vdev_id); 4647 4648 if (vif->type == NL80211_IFTYPE_MONITOR) { 4649 ar->monitor_arvif = NULL; 4650 ret = ath10k_monitor_recalc(ar); 4651 if (ret) 4652 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 4653 } 4654 4655 spin_lock_bh(&ar->htt.tx_lock); 4656 ath10k_mac_vif_tx_unlock_all(arvif); 4657 spin_unlock_bh(&ar->htt.tx_lock); 4658 4659 mutex_unlock(&ar->conf_mutex); 4660 } 4661 4662 /* 4663 * FIXME: Has to be verified. 4664 */ 4665 #define SUPPORTED_FILTERS \ 4666 (FIF_ALLMULTI | \ 4667 FIF_CONTROL | \ 4668 FIF_PSPOLL | \ 4669 FIF_OTHER_BSS | \ 4670 FIF_BCN_PRBRESP_PROMISC | \ 4671 FIF_PROBE_REQ | \ 4672 FIF_FCSFAIL) 4673 4674 static void ath10k_configure_filter(struct ieee80211_hw *hw, 4675 unsigned int changed_flags, 4676 unsigned int *total_flags, 4677 u64 multicast) 4678 { 4679 struct ath10k *ar = hw->priv; 4680 int ret; 4681 4682 mutex_lock(&ar->conf_mutex); 4683 4684 changed_flags &= SUPPORTED_FILTERS; 4685 *total_flags &= SUPPORTED_FILTERS; 4686 ar->filter_flags = *total_flags; 4687 4688 ret = ath10k_monitor_recalc(ar); 4689 if (ret) 4690 ath10k_warn(ar, "failed to recalc montior: %d\n", ret); 4691 4692 mutex_unlock(&ar->conf_mutex); 4693 } 4694 4695 static void ath10k_bss_info_changed(struct ieee80211_hw *hw, 4696 struct ieee80211_vif *vif, 4697 struct ieee80211_bss_conf *info, 4698 u32 changed) 4699 { 4700 struct ath10k *ar = hw->priv; 4701 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 4702 int ret = 0; 4703 u32 vdev_param, pdev_param, slottime, preamble; 4704 4705 mutex_lock(&ar->conf_mutex); 4706 4707 if (changed & BSS_CHANGED_IBSS) 4708 ath10k_control_ibss(arvif, info, vif->addr); 4709 4710 if (changed & BSS_CHANGED_BEACON_INT) { 4711 arvif->beacon_interval = info->beacon_int; 4712 vdev_param = ar->wmi.vdev_param->beacon_interval; 4713 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 4714 arvif->beacon_interval); 4715 ath10k_dbg(ar, ATH10K_DBG_MAC, 4716 "mac vdev %d beacon_interval %d\n", 4717 arvif->vdev_id, arvif->beacon_interval); 4718 4719 if (ret) 4720 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n", 4721 arvif->vdev_id, ret); 4722 } 4723 4724 if (changed & BSS_CHANGED_BEACON) { 4725 ath10k_dbg(ar, ATH10K_DBG_MAC, 4726 "vdev %d set beacon tx mode to staggered\n", 4727 arvif->vdev_id); 4728 4729 pdev_param = ar->wmi.pdev_param->beacon_tx_mode; 4730 ret = ath10k_wmi_pdev_set_param(ar, pdev_param, 4731 WMI_BEACON_STAGGERED_MODE); 4732 if (ret) 4733 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n", 4734 arvif->vdev_id, ret); 4735 4736 ret = ath10k_mac_setup_bcn_tmpl(arvif); 4737 if (ret) 4738 ath10k_warn(ar, "failed to update beacon template: %d\n", 4739 ret); 4740 4741 if (ieee80211_vif_is_mesh(vif)) { 4742 /* mesh doesn't use SSID but firmware needs it */ 4743 strncpy(arvif->u.ap.ssid, "mesh", 4744 sizeof(arvif->u.ap.ssid)); 4745 arvif->u.ap.ssid_len = 4; 4746 } 4747 } 4748 4749 if (changed & BSS_CHANGED_AP_PROBE_RESP) { 4750 ret = ath10k_mac_setup_prb_tmpl(arvif); 4751 if (ret) 4752 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n", 4753 arvif->vdev_id, ret); 4754 } 4755 4756 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) { 4757 arvif->dtim_period = info->dtim_period; 4758 4759 ath10k_dbg(ar, ATH10K_DBG_MAC, 4760 "mac vdev %d dtim_period %d\n", 4761 arvif->vdev_id, arvif->dtim_period); 4762 4763 vdev_param = ar->wmi.vdev_param->dtim_period; 4764 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 4765 arvif->dtim_period); 4766 if (ret) 4767 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n", 4768 arvif->vdev_id, ret); 4769 } 4770 4771 if (changed & BSS_CHANGED_SSID && 4772 vif->type == NL80211_IFTYPE_AP) { 4773 arvif->u.ap.ssid_len = info->ssid_len; 4774 if (info->ssid_len) 4775 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len); 4776 arvif->u.ap.hidden_ssid = info->hidden_ssid; 4777 } 4778 4779 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid)) 4780 ether_addr_copy(arvif->bssid, info->bssid); 4781 4782 if (changed & BSS_CHANGED_BEACON_ENABLED) 4783 ath10k_control_beaconing(arvif, info); 4784 4785 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 4786 arvif->use_cts_prot = info->use_cts_prot; 4787 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n", 4788 arvif->vdev_id, info->use_cts_prot); 4789 4790 ret = ath10k_recalc_rtscts_prot(arvif); 4791 if (ret) 4792 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n", 4793 arvif->vdev_id, ret); 4794 4795 vdev_param = ar->wmi.vdev_param->protection_mode; 4796 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 4797 info->use_cts_prot ? 1 : 0); 4798 if (ret) 4799 ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n", 4800 info->use_cts_prot, arvif->vdev_id, ret); 4801 } 4802 4803 if (changed & BSS_CHANGED_ERP_SLOT) { 4804 if (info->use_short_slot) 4805 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 4806 4807 else 4808 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 4809 4810 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n", 4811 arvif->vdev_id, slottime); 4812 4813 vdev_param = ar->wmi.vdev_param->slot_time; 4814 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 4815 slottime); 4816 if (ret) 4817 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n", 4818 arvif->vdev_id, ret); 4819 } 4820 4821 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 4822 if (info->use_short_preamble) 4823 preamble = WMI_VDEV_PREAMBLE_SHORT; 4824 else 4825 preamble = WMI_VDEV_PREAMBLE_LONG; 4826 4827 ath10k_dbg(ar, ATH10K_DBG_MAC, 4828 "mac vdev %d preamble %dn", 4829 arvif->vdev_id, preamble); 4830 4831 vdev_param = ar->wmi.vdev_param->preamble; 4832 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 4833 preamble); 4834 if (ret) 4835 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n", 4836 arvif->vdev_id, ret); 4837 } 4838 4839 if (changed & BSS_CHANGED_ASSOC) { 4840 if (info->assoc) { 4841 /* Workaround: Make sure monitor vdev is not running 4842 * when associating to prevent some firmware revisions 4843 * (e.g. 10.1 and 10.2) from crashing. 4844 */ 4845 if (ar->monitor_started) 4846 ath10k_monitor_stop(ar); 4847 ath10k_bss_assoc(hw, vif, info); 4848 ath10k_monitor_recalc(ar); 4849 } else { 4850 ath10k_bss_disassoc(hw, vif); 4851 } 4852 } 4853 4854 if (changed & BSS_CHANGED_TXPOWER) { 4855 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n", 4856 arvif->vdev_id, info->txpower); 4857 4858 arvif->txpower = info->txpower; 4859 ret = ath10k_mac_txpower_recalc(ar); 4860 if (ret) 4861 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret); 4862 } 4863 4864 if (changed & BSS_CHANGED_PS) { 4865 arvif->ps = vif->bss_conf.ps; 4866 4867 ret = ath10k_config_ps(ar); 4868 if (ret) 4869 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n", 4870 arvif->vdev_id, ret); 4871 } 4872 4873 mutex_unlock(&ar->conf_mutex); 4874 } 4875 4876 static int ath10k_hw_scan(struct ieee80211_hw *hw, 4877 struct ieee80211_vif *vif, 4878 struct ieee80211_scan_request *hw_req) 4879 { 4880 struct ath10k *ar = hw->priv; 4881 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 4882 struct cfg80211_scan_request *req = &hw_req->req; 4883 struct wmi_start_scan_arg arg; 4884 int ret = 0; 4885 int i; 4886 4887 mutex_lock(&ar->conf_mutex); 4888 4889 spin_lock_bh(&ar->data_lock); 4890 switch (ar->scan.state) { 4891 case ATH10K_SCAN_IDLE: 4892 reinit_completion(&ar->scan.started); 4893 reinit_completion(&ar->scan.completed); 4894 ar->scan.state = ATH10K_SCAN_STARTING; 4895 ar->scan.is_roc = false; 4896 ar->scan.vdev_id = arvif->vdev_id; 4897 ret = 0; 4898 break; 4899 case ATH10K_SCAN_STARTING: 4900 case ATH10K_SCAN_RUNNING: 4901 case ATH10K_SCAN_ABORTING: 4902 ret = -EBUSY; 4903 break; 4904 } 4905 spin_unlock_bh(&ar->data_lock); 4906 4907 if (ret) 4908 goto exit; 4909 4910 memset(&arg, 0, sizeof(arg)); 4911 ath10k_wmi_start_scan_init(ar, &arg); 4912 arg.vdev_id = arvif->vdev_id; 4913 arg.scan_id = ATH10K_SCAN_ID; 4914 4915 if (req->ie_len) { 4916 arg.ie_len = req->ie_len; 4917 memcpy(arg.ie, req->ie, arg.ie_len); 4918 } 4919 4920 if (req->n_ssids) { 4921 arg.n_ssids = req->n_ssids; 4922 for (i = 0; i < arg.n_ssids; i++) { 4923 arg.ssids[i].len = req->ssids[i].ssid_len; 4924 arg.ssids[i].ssid = req->ssids[i].ssid; 4925 } 4926 } else { 4927 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 4928 } 4929 4930 if (req->n_channels) { 4931 arg.n_channels = req->n_channels; 4932 for (i = 0; i < arg.n_channels; i++) 4933 arg.channels[i] = req->channels[i]->center_freq; 4934 } 4935 4936 ret = ath10k_start_scan(ar, &arg); 4937 if (ret) { 4938 ath10k_warn(ar, "failed to start hw scan: %d\n", ret); 4939 spin_lock_bh(&ar->data_lock); 4940 ar->scan.state = ATH10K_SCAN_IDLE; 4941 spin_unlock_bh(&ar->data_lock); 4942 } 4943 4944 /* Add a 200ms margin to account for event/command processing */ 4945 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 4946 msecs_to_jiffies(arg.max_scan_time + 4947 200)); 4948 4949 exit: 4950 mutex_unlock(&ar->conf_mutex); 4951 return ret; 4952 } 4953 4954 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw, 4955 struct ieee80211_vif *vif) 4956 { 4957 struct ath10k *ar = hw->priv; 4958 4959 mutex_lock(&ar->conf_mutex); 4960 ath10k_scan_abort(ar); 4961 mutex_unlock(&ar->conf_mutex); 4962 4963 cancel_delayed_work_sync(&ar->scan.timeout); 4964 } 4965 4966 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar, 4967 struct ath10k_vif *arvif, 4968 enum set_key_cmd cmd, 4969 struct ieee80211_key_conf *key) 4970 { 4971 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid; 4972 int ret; 4973 4974 /* 10.1 firmware branch requires default key index to be set to group 4975 * key index after installing it. Otherwise FW/HW Txes corrupted 4976 * frames with multi-vif APs. This is not required for main firmware 4977 * branch (e.g. 636). 4978 * 4979 * This is also needed for 636 fw for IBSS-RSN to work more reliably. 4980 * 4981 * FIXME: It remains unknown if this is required for multi-vif STA 4982 * interfaces on 10.1. 4983 */ 4984 4985 if (arvif->vdev_type != WMI_VDEV_TYPE_AP && 4986 arvif->vdev_type != WMI_VDEV_TYPE_IBSS) 4987 return; 4988 4989 if (key->cipher == WLAN_CIPHER_SUITE_WEP40) 4990 return; 4991 4992 if (key->cipher == WLAN_CIPHER_SUITE_WEP104) 4993 return; 4994 4995 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 4996 return; 4997 4998 if (cmd != SET_KEY) 4999 return; 5000 5001 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5002 key->keyidx); 5003 if (ret) 5004 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n", 5005 arvif->vdev_id, ret); 5006 } 5007 5008 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 5009 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 5010 struct ieee80211_key_conf *key) 5011 { 5012 struct ath10k *ar = hw->priv; 5013 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 5014 struct ath10k_peer *peer; 5015 const u8 *peer_addr; 5016 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 || 5017 key->cipher == WLAN_CIPHER_SUITE_WEP104; 5018 int ret = 0; 5019 int ret2; 5020 u32 flags = 0; 5021 u32 flags2; 5022 5023 /* this one needs to be done in software */ 5024 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC) 5025 return 1; 5026 5027 if (arvif->nohwcrypt) 5028 return 1; 5029 5030 if (key->keyidx > WMI_MAX_KEY_INDEX) 5031 return -ENOSPC; 5032 5033 mutex_lock(&ar->conf_mutex); 5034 5035 if (sta) 5036 peer_addr = sta->addr; 5037 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 5038 peer_addr = vif->bss_conf.bssid; 5039 else 5040 peer_addr = vif->addr; 5041 5042 key->hw_key_idx = key->keyidx; 5043 5044 if (is_wep) { 5045 if (cmd == SET_KEY) 5046 arvif->wep_keys[key->keyidx] = key; 5047 else 5048 arvif->wep_keys[key->keyidx] = NULL; 5049 } 5050 5051 /* the peer should not disappear in mid-way (unless FW goes awry) since 5052 * we already hold conf_mutex. we just make sure its there now. */ 5053 spin_lock_bh(&ar->data_lock); 5054 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 5055 spin_unlock_bh(&ar->data_lock); 5056 5057 if (!peer) { 5058 if (cmd == SET_KEY) { 5059 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n", 5060 peer_addr); 5061 ret = -EOPNOTSUPP; 5062 goto exit; 5063 } else { 5064 /* if the peer doesn't exist there is no key to disable 5065 * anymore */ 5066 goto exit; 5067 } 5068 } 5069 5070 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 5071 flags |= WMI_KEY_PAIRWISE; 5072 else 5073 flags |= WMI_KEY_GROUP; 5074 5075 if (is_wep) { 5076 if (cmd == DISABLE_KEY) 5077 ath10k_clear_vdev_key(arvif, key); 5078 5079 /* When WEP keys are uploaded it's possible that there are 5080 * stations associated already (e.g. when merging) without any 5081 * keys. Static WEP needs an explicit per-peer key upload. 5082 */ 5083 if (vif->type == NL80211_IFTYPE_ADHOC && 5084 cmd == SET_KEY) 5085 ath10k_mac_vif_update_wep_key(arvif, key); 5086 5087 /* 802.1x never sets the def_wep_key_idx so each set_key() 5088 * call changes default tx key. 5089 * 5090 * Static WEP sets def_wep_key_idx via .set_default_unicast_key 5091 * after first set_key(). 5092 */ 5093 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1) 5094 flags |= WMI_KEY_TX_USAGE; 5095 } 5096 5097 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags); 5098 if (ret) { 5099 WARN_ON(ret > 0); 5100 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n", 5101 arvif->vdev_id, peer_addr, ret); 5102 goto exit; 5103 } 5104 5105 /* mac80211 sets static WEP keys as groupwise while firmware requires 5106 * them to be installed twice as both pairwise and groupwise. 5107 */ 5108 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) { 5109 flags2 = flags; 5110 flags2 &= ~WMI_KEY_GROUP; 5111 flags2 |= WMI_KEY_PAIRWISE; 5112 5113 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2); 5114 if (ret) { 5115 WARN_ON(ret > 0); 5116 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n", 5117 arvif->vdev_id, peer_addr, ret); 5118 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY, 5119 peer_addr, flags); 5120 if (ret2) { 5121 WARN_ON(ret2 > 0); 5122 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n", 5123 arvif->vdev_id, peer_addr, ret2); 5124 } 5125 goto exit; 5126 } 5127 } 5128 5129 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key); 5130 5131 spin_lock_bh(&ar->data_lock); 5132 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 5133 if (peer && cmd == SET_KEY) 5134 peer->keys[key->keyidx] = key; 5135 else if (peer && cmd == DISABLE_KEY) 5136 peer->keys[key->keyidx] = NULL; 5137 else if (peer == NULL) 5138 /* impossible unless FW goes crazy */ 5139 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr); 5140 spin_unlock_bh(&ar->data_lock); 5141 5142 exit: 5143 mutex_unlock(&ar->conf_mutex); 5144 return ret; 5145 } 5146 5147 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw, 5148 struct ieee80211_vif *vif, 5149 int keyidx) 5150 { 5151 struct ath10k *ar = hw->priv; 5152 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 5153 int ret; 5154 5155 mutex_lock(&arvif->ar->conf_mutex); 5156 5157 if (arvif->ar->state != ATH10K_STATE_ON) 5158 goto unlock; 5159 5160 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n", 5161 arvif->vdev_id, keyidx); 5162 5163 ret = ath10k_wmi_vdev_set_param(arvif->ar, 5164 arvif->vdev_id, 5165 arvif->ar->wmi.vdev_param->def_keyid, 5166 keyidx); 5167 5168 if (ret) { 5169 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n", 5170 arvif->vdev_id, 5171 ret); 5172 goto unlock; 5173 } 5174 5175 arvif->def_wep_key_idx = keyidx; 5176 5177 unlock: 5178 mutex_unlock(&arvif->ar->conf_mutex); 5179 } 5180 5181 static void ath10k_sta_rc_update_wk(struct work_struct *wk) 5182 { 5183 struct ath10k *ar; 5184 struct ath10k_vif *arvif; 5185 struct ath10k_sta *arsta; 5186 struct ieee80211_sta *sta; 5187 struct cfg80211_chan_def def; 5188 enum ieee80211_band band; 5189 const u8 *ht_mcs_mask; 5190 const u16 *vht_mcs_mask; 5191 u32 changed, bw, nss, smps; 5192 int err; 5193 5194 arsta = container_of(wk, struct ath10k_sta, update_wk); 5195 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 5196 arvif = arsta->arvif; 5197 ar = arvif->ar; 5198 5199 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def))) 5200 return; 5201 5202 band = def.chan->band; 5203 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 5204 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 5205 5206 spin_lock_bh(&ar->data_lock); 5207 5208 changed = arsta->changed; 5209 arsta->changed = 0; 5210 5211 bw = arsta->bw; 5212 nss = arsta->nss; 5213 smps = arsta->smps; 5214 5215 spin_unlock_bh(&ar->data_lock); 5216 5217 mutex_lock(&ar->conf_mutex); 5218 5219 nss = max_t(u32, 1, nss); 5220 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask), 5221 ath10k_mac_max_vht_nss(vht_mcs_mask))); 5222 5223 if (changed & IEEE80211_RC_BW_CHANGED) { 5224 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n", 5225 sta->addr, bw); 5226 5227 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 5228 WMI_PEER_CHAN_WIDTH, bw); 5229 if (err) 5230 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n", 5231 sta->addr, bw, err); 5232 } 5233 5234 if (changed & IEEE80211_RC_NSS_CHANGED) { 5235 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n", 5236 sta->addr, nss); 5237 5238 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 5239 WMI_PEER_NSS, nss); 5240 if (err) 5241 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n", 5242 sta->addr, nss, err); 5243 } 5244 5245 if (changed & IEEE80211_RC_SMPS_CHANGED) { 5246 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n", 5247 sta->addr, smps); 5248 5249 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 5250 WMI_PEER_SMPS_STATE, smps); 5251 if (err) 5252 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n", 5253 sta->addr, smps, err); 5254 } 5255 5256 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED || 5257 changed & IEEE80211_RC_NSS_CHANGED) { 5258 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n", 5259 sta->addr); 5260 5261 err = ath10k_station_assoc(ar, arvif->vif, sta, true); 5262 if (err) 5263 ath10k_warn(ar, "failed to reassociate station: %pM\n", 5264 sta->addr); 5265 } 5266 5267 mutex_unlock(&ar->conf_mutex); 5268 } 5269 5270 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif, 5271 struct ieee80211_sta *sta) 5272 { 5273 struct ath10k *ar = arvif->ar; 5274 5275 lockdep_assert_held(&ar->conf_mutex); 5276 5277 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 5278 return 0; 5279 5280 if (ar->num_stations >= ar->max_num_stations) 5281 return -ENOBUFS; 5282 5283 ar->num_stations++; 5284 5285 return 0; 5286 } 5287 5288 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif, 5289 struct ieee80211_sta *sta) 5290 { 5291 struct ath10k *ar = arvif->ar; 5292 5293 lockdep_assert_held(&ar->conf_mutex); 5294 5295 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 5296 return; 5297 5298 ar->num_stations--; 5299 } 5300 5301 struct ath10k_mac_tdls_iter_data { 5302 u32 num_tdls_stations; 5303 struct ieee80211_vif *curr_vif; 5304 }; 5305 5306 static void ath10k_mac_tdls_vif_stations_count_iter(void *data, 5307 struct ieee80211_sta *sta) 5308 { 5309 struct ath10k_mac_tdls_iter_data *iter_data = data; 5310 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 5311 struct ieee80211_vif *sta_vif = arsta->arvif->vif; 5312 5313 if (sta->tdls && sta_vif == iter_data->curr_vif) 5314 iter_data->num_tdls_stations++; 5315 } 5316 5317 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw, 5318 struct ieee80211_vif *vif) 5319 { 5320 struct ath10k_mac_tdls_iter_data data = {}; 5321 5322 data.curr_vif = vif; 5323 5324 ieee80211_iterate_stations_atomic(hw, 5325 ath10k_mac_tdls_vif_stations_count_iter, 5326 &data); 5327 return data.num_tdls_stations; 5328 } 5329 5330 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac, 5331 struct ieee80211_vif *vif) 5332 { 5333 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 5334 int *num_tdls_vifs = data; 5335 5336 if (vif->type != NL80211_IFTYPE_STATION) 5337 return; 5338 5339 if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0) 5340 (*num_tdls_vifs)++; 5341 } 5342 5343 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw) 5344 { 5345 int num_tdls_vifs = 0; 5346 5347 ieee80211_iterate_active_interfaces_atomic(hw, 5348 IEEE80211_IFACE_ITER_NORMAL, 5349 ath10k_mac_tdls_vifs_count_iter, 5350 &num_tdls_vifs); 5351 return num_tdls_vifs; 5352 } 5353 5354 static int ath10k_sta_state(struct ieee80211_hw *hw, 5355 struct ieee80211_vif *vif, 5356 struct ieee80211_sta *sta, 5357 enum ieee80211_sta_state old_state, 5358 enum ieee80211_sta_state new_state) 5359 { 5360 struct ath10k *ar = hw->priv; 5361 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 5362 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 5363 int ret = 0; 5364 5365 if (old_state == IEEE80211_STA_NOTEXIST && 5366 new_state == IEEE80211_STA_NONE) { 5367 memset(arsta, 0, sizeof(*arsta)); 5368 arsta->arvif = arvif; 5369 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk); 5370 } 5371 5372 /* cancel must be done outside the mutex to avoid deadlock */ 5373 if ((old_state == IEEE80211_STA_NONE && 5374 new_state == IEEE80211_STA_NOTEXIST)) 5375 cancel_work_sync(&arsta->update_wk); 5376 5377 mutex_lock(&ar->conf_mutex); 5378 5379 if (old_state == IEEE80211_STA_NOTEXIST && 5380 new_state == IEEE80211_STA_NONE) { 5381 /* 5382 * New station addition. 5383 */ 5384 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT; 5385 u32 num_tdls_stations; 5386 u32 num_tdls_vifs; 5387 5388 ath10k_dbg(ar, ATH10K_DBG_MAC, 5389 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n", 5390 arvif->vdev_id, sta->addr, 5391 ar->num_stations + 1, ar->max_num_stations, 5392 ar->num_peers + 1, ar->max_num_peers); 5393 5394 ret = ath10k_mac_inc_num_stations(arvif, sta); 5395 if (ret) { 5396 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n", 5397 ar->max_num_stations); 5398 goto exit; 5399 } 5400 5401 if (sta->tdls) 5402 peer_type = WMI_PEER_TYPE_TDLS; 5403 5404 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr, 5405 peer_type); 5406 if (ret) { 5407 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n", 5408 sta->addr, arvif->vdev_id, ret); 5409 ath10k_mac_dec_num_stations(arvif, sta); 5410 goto exit; 5411 } 5412 5413 if (!sta->tdls) 5414 goto exit; 5415 5416 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif); 5417 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw); 5418 5419 if (num_tdls_vifs >= ar->max_num_tdls_vdevs && 5420 num_tdls_stations == 0) { 5421 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n", 5422 arvif->vdev_id, ar->max_num_tdls_vdevs); 5423 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 5424 ath10k_mac_dec_num_stations(arvif, sta); 5425 ret = -ENOBUFS; 5426 goto exit; 5427 } 5428 5429 if (num_tdls_stations == 0) { 5430 /* This is the first tdls peer in current vif */ 5431 enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE; 5432 5433 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id, 5434 state); 5435 if (ret) { 5436 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n", 5437 arvif->vdev_id, ret); 5438 ath10k_peer_delete(ar, arvif->vdev_id, 5439 sta->addr); 5440 ath10k_mac_dec_num_stations(arvif, sta); 5441 goto exit; 5442 } 5443 } 5444 5445 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta, 5446 WMI_TDLS_PEER_STATE_PEERING); 5447 if (ret) { 5448 ath10k_warn(ar, 5449 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n", 5450 sta->addr, arvif->vdev_id, ret); 5451 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 5452 ath10k_mac_dec_num_stations(arvif, sta); 5453 5454 if (num_tdls_stations != 0) 5455 goto exit; 5456 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id, 5457 WMI_TDLS_DISABLE); 5458 } 5459 } else if ((old_state == IEEE80211_STA_NONE && 5460 new_state == IEEE80211_STA_NOTEXIST)) { 5461 /* 5462 * Existing station deletion. 5463 */ 5464 ath10k_dbg(ar, ATH10K_DBG_MAC, 5465 "mac vdev %d peer delete %pM (sta gone)\n", 5466 arvif->vdev_id, sta->addr); 5467 5468 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 5469 if (ret) 5470 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n", 5471 sta->addr, arvif->vdev_id, ret); 5472 5473 ath10k_mac_dec_num_stations(arvif, sta); 5474 5475 if (!sta->tdls) 5476 goto exit; 5477 5478 if (ath10k_mac_tdls_vif_stations_count(hw, vif)) 5479 goto exit; 5480 5481 /* This was the last tdls peer in current vif */ 5482 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id, 5483 WMI_TDLS_DISABLE); 5484 if (ret) { 5485 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n", 5486 arvif->vdev_id, ret); 5487 } 5488 } else if (old_state == IEEE80211_STA_AUTH && 5489 new_state == IEEE80211_STA_ASSOC && 5490 (vif->type == NL80211_IFTYPE_AP || 5491 vif->type == NL80211_IFTYPE_MESH_POINT || 5492 vif->type == NL80211_IFTYPE_ADHOC)) { 5493 /* 5494 * New association. 5495 */ 5496 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n", 5497 sta->addr); 5498 5499 ret = ath10k_station_assoc(ar, vif, sta, false); 5500 if (ret) 5501 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n", 5502 sta->addr, arvif->vdev_id, ret); 5503 } else if (old_state == IEEE80211_STA_ASSOC && 5504 new_state == IEEE80211_STA_AUTHORIZED && 5505 sta->tdls) { 5506 /* 5507 * Tdls station authorized. 5508 */ 5509 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n", 5510 sta->addr); 5511 5512 ret = ath10k_station_assoc(ar, vif, sta, false); 5513 if (ret) { 5514 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n", 5515 sta->addr, arvif->vdev_id, ret); 5516 goto exit; 5517 } 5518 5519 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta, 5520 WMI_TDLS_PEER_STATE_CONNECTED); 5521 if (ret) 5522 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n", 5523 sta->addr, arvif->vdev_id, ret); 5524 } else if (old_state == IEEE80211_STA_ASSOC && 5525 new_state == IEEE80211_STA_AUTH && 5526 (vif->type == NL80211_IFTYPE_AP || 5527 vif->type == NL80211_IFTYPE_MESH_POINT || 5528 vif->type == NL80211_IFTYPE_ADHOC)) { 5529 /* 5530 * Disassociation. 5531 */ 5532 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n", 5533 sta->addr); 5534 5535 ret = ath10k_station_disassoc(ar, vif, sta); 5536 if (ret) 5537 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n", 5538 sta->addr, arvif->vdev_id, ret); 5539 } 5540 exit: 5541 mutex_unlock(&ar->conf_mutex); 5542 return ret; 5543 } 5544 5545 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif, 5546 u16 ac, bool enable) 5547 { 5548 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 5549 struct wmi_sta_uapsd_auto_trig_arg arg = {}; 5550 u32 prio = 0, acc = 0; 5551 u32 value = 0; 5552 int ret = 0; 5553 5554 lockdep_assert_held(&ar->conf_mutex); 5555 5556 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 5557 return 0; 5558 5559 switch (ac) { 5560 case IEEE80211_AC_VO: 5561 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 5562 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 5563 prio = 7; 5564 acc = 3; 5565 break; 5566 case IEEE80211_AC_VI: 5567 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 5568 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 5569 prio = 5; 5570 acc = 2; 5571 break; 5572 case IEEE80211_AC_BE: 5573 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 5574 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 5575 prio = 2; 5576 acc = 1; 5577 break; 5578 case IEEE80211_AC_BK: 5579 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 5580 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 5581 prio = 0; 5582 acc = 0; 5583 break; 5584 } 5585 5586 if (enable) 5587 arvif->u.sta.uapsd |= value; 5588 else 5589 arvif->u.sta.uapsd &= ~value; 5590 5591 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5592 WMI_STA_PS_PARAM_UAPSD, 5593 arvif->u.sta.uapsd); 5594 if (ret) { 5595 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret); 5596 goto exit; 5597 } 5598 5599 if (arvif->u.sta.uapsd) 5600 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 5601 else 5602 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 5603 5604 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5605 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 5606 value); 5607 if (ret) 5608 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret); 5609 5610 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif); 5611 if (ret) { 5612 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n", 5613 arvif->vdev_id, ret); 5614 return ret; 5615 } 5616 5617 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif); 5618 if (ret) { 5619 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n", 5620 arvif->vdev_id, ret); 5621 return ret; 5622 } 5623 5624 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) || 5625 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) { 5626 /* Only userspace can make an educated decision when to send 5627 * trigger frame. The following effectively disables u-UAPSD 5628 * autotrigger in firmware (which is enabled by default 5629 * provided the autotrigger service is available). 5630 */ 5631 5632 arg.wmm_ac = acc; 5633 arg.user_priority = prio; 5634 arg.service_interval = 0; 5635 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC; 5636 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC; 5637 5638 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id, 5639 arvif->bssid, &arg, 1); 5640 if (ret) { 5641 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n", 5642 ret); 5643 return ret; 5644 } 5645 } 5646 5647 exit: 5648 return ret; 5649 } 5650 5651 static int ath10k_conf_tx(struct ieee80211_hw *hw, 5652 struct ieee80211_vif *vif, u16 ac, 5653 const struct ieee80211_tx_queue_params *params) 5654 { 5655 struct ath10k *ar = hw->priv; 5656 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 5657 struct wmi_wmm_params_arg *p = NULL; 5658 int ret; 5659 5660 mutex_lock(&ar->conf_mutex); 5661 5662 switch (ac) { 5663 case IEEE80211_AC_VO: 5664 p = &arvif->wmm_params.ac_vo; 5665 break; 5666 case IEEE80211_AC_VI: 5667 p = &arvif->wmm_params.ac_vi; 5668 break; 5669 case IEEE80211_AC_BE: 5670 p = &arvif->wmm_params.ac_be; 5671 break; 5672 case IEEE80211_AC_BK: 5673 p = &arvif->wmm_params.ac_bk; 5674 break; 5675 } 5676 5677 if (WARN_ON(!p)) { 5678 ret = -EINVAL; 5679 goto exit; 5680 } 5681 5682 p->cwmin = params->cw_min; 5683 p->cwmax = params->cw_max; 5684 p->aifs = params->aifs; 5685 5686 /* 5687 * The channel time duration programmed in the HW is in absolute 5688 * microseconds, while mac80211 gives the txop in units of 5689 * 32 microseconds. 5690 */ 5691 p->txop = params->txop * 32; 5692 5693 if (ar->wmi.ops->gen_vdev_wmm_conf) { 5694 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id, 5695 &arvif->wmm_params); 5696 if (ret) { 5697 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n", 5698 arvif->vdev_id, ret); 5699 goto exit; 5700 } 5701 } else { 5702 /* This won't work well with multi-interface cases but it's 5703 * better than nothing. 5704 */ 5705 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params); 5706 if (ret) { 5707 ath10k_warn(ar, "failed to set wmm params: %d\n", ret); 5708 goto exit; 5709 } 5710 } 5711 5712 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 5713 if (ret) 5714 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret); 5715 5716 exit: 5717 mutex_unlock(&ar->conf_mutex); 5718 return ret; 5719 } 5720 5721 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ) 5722 5723 static int ath10k_remain_on_channel(struct ieee80211_hw *hw, 5724 struct ieee80211_vif *vif, 5725 struct ieee80211_channel *chan, 5726 int duration, 5727 enum ieee80211_roc_type type) 5728 { 5729 struct ath10k *ar = hw->priv; 5730 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 5731 struct wmi_start_scan_arg arg; 5732 int ret = 0; 5733 u32 scan_time_msec; 5734 5735 mutex_lock(&ar->conf_mutex); 5736 5737 spin_lock_bh(&ar->data_lock); 5738 switch (ar->scan.state) { 5739 case ATH10K_SCAN_IDLE: 5740 reinit_completion(&ar->scan.started); 5741 reinit_completion(&ar->scan.completed); 5742 reinit_completion(&ar->scan.on_channel); 5743 ar->scan.state = ATH10K_SCAN_STARTING; 5744 ar->scan.is_roc = true; 5745 ar->scan.vdev_id = arvif->vdev_id; 5746 ar->scan.roc_freq = chan->center_freq; 5747 ar->scan.roc_notify = true; 5748 ret = 0; 5749 break; 5750 case ATH10K_SCAN_STARTING: 5751 case ATH10K_SCAN_RUNNING: 5752 case ATH10K_SCAN_ABORTING: 5753 ret = -EBUSY; 5754 break; 5755 } 5756 spin_unlock_bh(&ar->data_lock); 5757 5758 if (ret) 5759 goto exit; 5760 5761 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2; 5762 5763 memset(&arg, 0, sizeof(arg)); 5764 ath10k_wmi_start_scan_init(ar, &arg); 5765 arg.vdev_id = arvif->vdev_id; 5766 arg.scan_id = ATH10K_SCAN_ID; 5767 arg.n_channels = 1; 5768 arg.channels[0] = chan->center_freq; 5769 arg.dwell_time_active = scan_time_msec; 5770 arg.dwell_time_passive = scan_time_msec; 5771 arg.max_scan_time = scan_time_msec; 5772 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 5773 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ; 5774 arg.burst_duration_ms = duration; 5775 5776 ret = ath10k_start_scan(ar, &arg); 5777 if (ret) { 5778 ath10k_warn(ar, "failed to start roc scan: %d\n", ret); 5779 spin_lock_bh(&ar->data_lock); 5780 ar->scan.state = ATH10K_SCAN_IDLE; 5781 spin_unlock_bh(&ar->data_lock); 5782 goto exit; 5783 } 5784 5785 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ); 5786 if (ret == 0) { 5787 ath10k_warn(ar, "failed to switch to channel for roc scan\n"); 5788 5789 ret = ath10k_scan_stop(ar); 5790 if (ret) 5791 ath10k_warn(ar, "failed to stop scan: %d\n", ret); 5792 5793 ret = -ETIMEDOUT; 5794 goto exit; 5795 } 5796 5797 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 5798 msecs_to_jiffies(duration)); 5799 5800 ret = 0; 5801 exit: 5802 mutex_unlock(&ar->conf_mutex); 5803 return ret; 5804 } 5805 5806 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw) 5807 { 5808 struct ath10k *ar = hw->priv; 5809 5810 mutex_lock(&ar->conf_mutex); 5811 5812 spin_lock_bh(&ar->data_lock); 5813 ar->scan.roc_notify = false; 5814 spin_unlock_bh(&ar->data_lock); 5815 5816 ath10k_scan_abort(ar); 5817 5818 mutex_unlock(&ar->conf_mutex); 5819 5820 cancel_delayed_work_sync(&ar->scan.timeout); 5821 5822 return 0; 5823 } 5824 5825 /* 5826 * Both RTS and Fragmentation threshold are interface-specific 5827 * in ath10k, but device-specific in mac80211. 5828 */ 5829 5830 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 5831 { 5832 struct ath10k *ar = hw->priv; 5833 struct ath10k_vif *arvif; 5834 int ret = 0; 5835 5836 mutex_lock(&ar->conf_mutex); 5837 list_for_each_entry(arvif, &ar->arvifs, list) { 5838 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n", 5839 arvif->vdev_id, value); 5840 5841 ret = ath10k_mac_set_rts(arvif, value); 5842 if (ret) { 5843 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n", 5844 arvif->vdev_id, ret); 5845 break; 5846 } 5847 } 5848 mutex_unlock(&ar->conf_mutex); 5849 5850 return ret; 5851 } 5852 5853 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 5854 { 5855 /* Even though there's a WMI enum for fragmentation threshold no known 5856 * firmware actually implements it. Moreover it is not possible to rely 5857 * frame fragmentation to mac80211 because firmware clears the "more 5858 * fragments" bit in frame control making it impossible for remote 5859 * devices to reassemble frames. 5860 * 5861 * Hence implement a dummy callback just to say fragmentation isn't 5862 * supported. This effectively prevents mac80211 from doing frame 5863 * fragmentation in software. 5864 */ 5865 return -EOPNOTSUPP; 5866 } 5867 5868 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 5869 u32 queues, bool drop) 5870 { 5871 struct ath10k *ar = hw->priv; 5872 bool skip; 5873 long time_left; 5874 5875 /* mac80211 doesn't care if we really xmit queued frames or not 5876 * we'll collect those frames either way if we stop/delete vdevs */ 5877 if (drop) 5878 return; 5879 5880 mutex_lock(&ar->conf_mutex); 5881 5882 if (ar->state == ATH10K_STATE_WEDGED) 5883 goto skip; 5884 5885 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({ 5886 bool empty; 5887 5888 spin_lock_bh(&ar->htt.tx_lock); 5889 empty = (ar->htt.num_pending_tx == 0); 5890 spin_unlock_bh(&ar->htt.tx_lock); 5891 5892 skip = (ar->state == ATH10K_STATE_WEDGED) || 5893 test_bit(ATH10K_FLAG_CRASH_FLUSH, 5894 &ar->dev_flags); 5895 5896 (empty || skip); 5897 }), ATH10K_FLUSH_TIMEOUT_HZ); 5898 5899 if (time_left == 0 || skip) 5900 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n", 5901 skip, ar->state, time_left); 5902 5903 skip: 5904 mutex_unlock(&ar->conf_mutex); 5905 } 5906 5907 /* TODO: Implement this function properly 5908 * For now it is needed to reply to Probe Requests in IBSS mode. 5909 * Propably we need this information from FW. 5910 */ 5911 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw) 5912 { 5913 return 1; 5914 } 5915 5916 static void ath10k_reconfig_complete(struct ieee80211_hw *hw, 5917 enum ieee80211_reconfig_type reconfig_type) 5918 { 5919 struct ath10k *ar = hw->priv; 5920 5921 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) 5922 return; 5923 5924 mutex_lock(&ar->conf_mutex); 5925 5926 /* If device failed to restart it will be in a different state, e.g. 5927 * ATH10K_STATE_WEDGED */ 5928 if (ar->state == ATH10K_STATE_RESTARTED) { 5929 ath10k_info(ar, "device successfully recovered\n"); 5930 ar->state = ATH10K_STATE_ON; 5931 ieee80211_wake_queues(ar->hw); 5932 } 5933 5934 mutex_unlock(&ar->conf_mutex); 5935 } 5936 5937 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx, 5938 struct survey_info *survey) 5939 { 5940 struct ath10k *ar = hw->priv; 5941 struct ieee80211_supported_band *sband; 5942 struct survey_info *ar_survey = &ar->survey[idx]; 5943 int ret = 0; 5944 5945 mutex_lock(&ar->conf_mutex); 5946 5947 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ]; 5948 if (sband && idx >= sband->n_channels) { 5949 idx -= sband->n_channels; 5950 sband = NULL; 5951 } 5952 5953 if (!sband) 5954 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ]; 5955 5956 if (!sband || idx >= sband->n_channels) { 5957 ret = -ENOENT; 5958 goto exit; 5959 } 5960 5961 spin_lock_bh(&ar->data_lock); 5962 memcpy(survey, ar_survey, sizeof(*survey)); 5963 spin_unlock_bh(&ar->data_lock); 5964 5965 survey->channel = &sband->channels[idx]; 5966 5967 if (ar->rx_channel == survey->channel) 5968 survey->filled |= SURVEY_INFO_IN_USE; 5969 5970 exit: 5971 mutex_unlock(&ar->conf_mutex); 5972 return ret; 5973 } 5974 5975 static bool 5976 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar, 5977 enum ieee80211_band band, 5978 const struct cfg80211_bitrate_mask *mask) 5979 { 5980 int num_rates = 0; 5981 int i; 5982 5983 num_rates += hweight32(mask->control[band].legacy); 5984 5985 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) 5986 num_rates += hweight8(mask->control[band].ht_mcs[i]); 5987 5988 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) 5989 num_rates += hweight16(mask->control[band].vht_mcs[i]); 5990 5991 return num_rates == 1; 5992 } 5993 5994 static bool 5995 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar, 5996 enum ieee80211_band band, 5997 const struct cfg80211_bitrate_mask *mask, 5998 int *nss) 5999 { 6000 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 6001 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 6002 u8 ht_nss_mask = 0; 6003 u8 vht_nss_mask = 0; 6004 int i; 6005 6006 if (mask->control[band].legacy) 6007 return false; 6008 6009 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 6010 if (mask->control[band].ht_mcs[i] == 0) 6011 continue; 6012 else if (mask->control[band].ht_mcs[i] == 6013 sband->ht_cap.mcs.rx_mask[i]) 6014 ht_nss_mask |= BIT(i); 6015 else 6016 return false; 6017 } 6018 6019 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 6020 if (mask->control[band].vht_mcs[i] == 0) 6021 continue; 6022 else if (mask->control[band].vht_mcs[i] == 6023 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i)) 6024 vht_nss_mask |= BIT(i); 6025 else 6026 return false; 6027 } 6028 6029 if (ht_nss_mask != vht_nss_mask) 6030 return false; 6031 6032 if (ht_nss_mask == 0) 6033 return false; 6034 6035 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask) 6036 return false; 6037 6038 *nss = fls(ht_nss_mask); 6039 6040 return true; 6041 } 6042 6043 static int 6044 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar, 6045 enum ieee80211_band band, 6046 const struct cfg80211_bitrate_mask *mask, 6047 u8 *rate, u8 *nss) 6048 { 6049 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 6050 int rate_idx; 6051 int i; 6052 u16 bitrate; 6053 u8 preamble; 6054 u8 hw_rate; 6055 6056 if (hweight32(mask->control[band].legacy) == 1) { 6057 rate_idx = ffs(mask->control[band].legacy) - 1; 6058 6059 hw_rate = sband->bitrates[rate_idx].hw_value; 6060 bitrate = sband->bitrates[rate_idx].bitrate; 6061 6062 if (ath10k_mac_bitrate_is_cck(bitrate)) 6063 preamble = WMI_RATE_PREAMBLE_CCK; 6064 else 6065 preamble = WMI_RATE_PREAMBLE_OFDM; 6066 6067 *nss = 1; 6068 *rate = preamble << 6 | 6069 (*nss - 1) << 4 | 6070 hw_rate << 0; 6071 6072 return 0; 6073 } 6074 6075 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 6076 if (hweight8(mask->control[band].ht_mcs[i]) == 1) { 6077 *nss = i + 1; 6078 *rate = WMI_RATE_PREAMBLE_HT << 6 | 6079 (*nss - 1) << 4 | 6080 (ffs(mask->control[band].ht_mcs[i]) - 1); 6081 6082 return 0; 6083 } 6084 } 6085 6086 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 6087 if (hweight16(mask->control[band].vht_mcs[i]) == 1) { 6088 *nss = i + 1; 6089 *rate = WMI_RATE_PREAMBLE_VHT << 6 | 6090 (*nss - 1) << 4 | 6091 (ffs(mask->control[band].vht_mcs[i]) - 1); 6092 6093 return 0; 6094 } 6095 } 6096 6097 return -EINVAL; 6098 } 6099 6100 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif, 6101 u8 rate, u8 nss, u8 sgi, u8 ldpc) 6102 { 6103 struct ath10k *ar = arvif->ar; 6104 u32 vdev_param; 6105 int ret; 6106 6107 lockdep_assert_held(&ar->conf_mutex); 6108 6109 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n", 6110 arvif->vdev_id, rate, nss, sgi); 6111 6112 vdev_param = ar->wmi.vdev_param->fixed_rate; 6113 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate); 6114 if (ret) { 6115 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n", 6116 rate, ret); 6117 return ret; 6118 } 6119 6120 vdev_param = ar->wmi.vdev_param->nss; 6121 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss); 6122 if (ret) { 6123 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret); 6124 return ret; 6125 } 6126 6127 vdev_param = ar->wmi.vdev_param->sgi; 6128 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi); 6129 if (ret) { 6130 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret); 6131 return ret; 6132 } 6133 6134 vdev_param = ar->wmi.vdev_param->ldpc; 6135 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc); 6136 if (ret) { 6137 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret); 6138 return ret; 6139 } 6140 6141 return 0; 6142 } 6143 6144 static bool 6145 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar, 6146 enum ieee80211_band band, 6147 const struct cfg80211_bitrate_mask *mask) 6148 { 6149 int i; 6150 u16 vht_mcs; 6151 6152 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible 6153 * to express all VHT MCS rate masks. Effectively only the following 6154 * ranges can be used: none, 0-7, 0-8 and 0-9. 6155 */ 6156 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 6157 vht_mcs = mask->control[band].vht_mcs[i]; 6158 6159 switch (vht_mcs) { 6160 case 0: 6161 case BIT(8) - 1: 6162 case BIT(9) - 1: 6163 case BIT(10) - 1: 6164 break; 6165 default: 6166 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n"); 6167 return false; 6168 } 6169 } 6170 6171 return true; 6172 } 6173 6174 static void ath10k_mac_set_bitrate_mask_iter(void *data, 6175 struct ieee80211_sta *sta) 6176 { 6177 struct ath10k_vif *arvif = data; 6178 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 6179 struct ath10k *ar = arvif->ar; 6180 6181 if (arsta->arvif != arvif) 6182 return; 6183 6184 spin_lock_bh(&ar->data_lock); 6185 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED; 6186 spin_unlock_bh(&ar->data_lock); 6187 6188 ieee80211_queue_work(ar->hw, &arsta->update_wk); 6189 } 6190 6191 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw, 6192 struct ieee80211_vif *vif, 6193 const struct cfg80211_bitrate_mask *mask) 6194 { 6195 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 6196 struct cfg80211_chan_def def; 6197 struct ath10k *ar = arvif->ar; 6198 enum ieee80211_band band; 6199 const u8 *ht_mcs_mask; 6200 const u16 *vht_mcs_mask; 6201 u8 rate; 6202 u8 nss; 6203 u8 sgi; 6204 u8 ldpc; 6205 int single_nss; 6206 int ret; 6207 6208 if (ath10k_mac_vif_chan(vif, &def)) 6209 return -EPERM; 6210 6211 band = def.chan->band; 6212 ht_mcs_mask = mask->control[band].ht_mcs; 6213 vht_mcs_mask = mask->control[band].vht_mcs; 6214 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC); 6215 6216 sgi = mask->control[band].gi; 6217 if (sgi == NL80211_TXRATE_FORCE_LGI) 6218 return -EINVAL; 6219 6220 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) { 6221 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask, 6222 &rate, &nss); 6223 if (ret) { 6224 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n", 6225 arvif->vdev_id, ret); 6226 return ret; 6227 } 6228 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask, 6229 &single_nss)) { 6230 rate = WMI_FIXED_RATE_NONE; 6231 nss = single_nss; 6232 } else { 6233 rate = WMI_FIXED_RATE_NONE; 6234 nss = min(ar->num_rf_chains, 6235 max(ath10k_mac_max_ht_nss(ht_mcs_mask), 6236 ath10k_mac_max_vht_nss(vht_mcs_mask))); 6237 6238 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask)) 6239 return -EINVAL; 6240 6241 mutex_lock(&ar->conf_mutex); 6242 6243 arvif->bitrate_mask = *mask; 6244 ieee80211_iterate_stations_atomic(ar->hw, 6245 ath10k_mac_set_bitrate_mask_iter, 6246 arvif); 6247 6248 mutex_unlock(&ar->conf_mutex); 6249 } 6250 6251 mutex_lock(&ar->conf_mutex); 6252 6253 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc); 6254 if (ret) { 6255 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n", 6256 arvif->vdev_id, ret); 6257 goto exit; 6258 } 6259 6260 exit: 6261 mutex_unlock(&ar->conf_mutex); 6262 6263 return ret; 6264 } 6265 6266 static void ath10k_sta_rc_update(struct ieee80211_hw *hw, 6267 struct ieee80211_vif *vif, 6268 struct ieee80211_sta *sta, 6269 u32 changed) 6270 { 6271 struct ath10k *ar = hw->priv; 6272 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 6273 u32 bw, smps; 6274 6275 spin_lock_bh(&ar->data_lock); 6276 6277 ath10k_dbg(ar, ATH10K_DBG_MAC, 6278 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 6279 sta->addr, changed, sta->bandwidth, sta->rx_nss, 6280 sta->smps_mode); 6281 6282 if (changed & IEEE80211_RC_BW_CHANGED) { 6283 bw = WMI_PEER_CHWIDTH_20MHZ; 6284 6285 switch (sta->bandwidth) { 6286 case IEEE80211_STA_RX_BW_20: 6287 bw = WMI_PEER_CHWIDTH_20MHZ; 6288 break; 6289 case IEEE80211_STA_RX_BW_40: 6290 bw = WMI_PEER_CHWIDTH_40MHZ; 6291 break; 6292 case IEEE80211_STA_RX_BW_80: 6293 bw = WMI_PEER_CHWIDTH_80MHZ; 6294 break; 6295 case IEEE80211_STA_RX_BW_160: 6296 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n", 6297 sta->bandwidth, sta->addr); 6298 bw = WMI_PEER_CHWIDTH_20MHZ; 6299 break; 6300 } 6301 6302 arsta->bw = bw; 6303 } 6304 6305 if (changed & IEEE80211_RC_NSS_CHANGED) 6306 arsta->nss = sta->rx_nss; 6307 6308 if (changed & IEEE80211_RC_SMPS_CHANGED) { 6309 smps = WMI_PEER_SMPS_PS_NONE; 6310 6311 switch (sta->smps_mode) { 6312 case IEEE80211_SMPS_AUTOMATIC: 6313 case IEEE80211_SMPS_OFF: 6314 smps = WMI_PEER_SMPS_PS_NONE; 6315 break; 6316 case IEEE80211_SMPS_STATIC: 6317 smps = WMI_PEER_SMPS_STATIC; 6318 break; 6319 case IEEE80211_SMPS_DYNAMIC: 6320 smps = WMI_PEER_SMPS_DYNAMIC; 6321 break; 6322 case IEEE80211_SMPS_NUM_MODES: 6323 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n", 6324 sta->smps_mode, sta->addr); 6325 smps = WMI_PEER_SMPS_PS_NONE; 6326 break; 6327 } 6328 6329 arsta->smps = smps; 6330 } 6331 6332 arsta->changed |= changed; 6333 6334 spin_unlock_bh(&ar->data_lock); 6335 6336 ieee80211_queue_work(hw, &arsta->update_wk); 6337 } 6338 6339 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 6340 { 6341 /* 6342 * FIXME: Return 0 for time being. Need to figure out whether FW 6343 * has the API to fetch 64-bit local TSF 6344 */ 6345 6346 return 0; 6347 } 6348 6349 static int ath10k_ampdu_action(struct ieee80211_hw *hw, 6350 struct ieee80211_vif *vif, 6351 enum ieee80211_ampdu_mlme_action action, 6352 struct ieee80211_sta *sta, u16 tid, u16 *ssn, 6353 u8 buf_size, bool amsdu) 6354 { 6355 struct ath10k *ar = hw->priv; 6356 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 6357 6358 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n", 6359 arvif->vdev_id, sta->addr, tid, action); 6360 6361 switch (action) { 6362 case IEEE80211_AMPDU_RX_START: 6363 case IEEE80211_AMPDU_RX_STOP: 6364 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session 6365 * creation/removal. Do we need to verify this? 6366 */ 6367 return 0; 6368 case IEEE80211_AMPDU_TX_START: 6369 case IEEE80211_AMPDU_TX_STOP_CONT: 6370 case IEEE80211_AMPDU_TX_STOP_FLUSH: 6371 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 6372 case IEEE80211_AMPDU_TX_OPERATIONAL: 6373 /* Firmware offloads Tx aggregation entirely so deny mac80211 6374 * Tx aggregation requests. 6375 */ 6376 return -EOPNOTSUPP; 6377 } 6378 6379 return -EINVAL; 6380 } 6381 6382 static void 6383 ath10k_mac_update_rx_channel(struct ath10k *ar, 6384 struct ieee80211_chanctx_conf *ctx, 6385 struct ieee80211_vif_chanctx_switch *vifs, 6386 int n_vifs) 6387 { 6388 struct cfg80211_chan_def *def = NULL; 6389 6390 /* Both locks are required because ar->rx_channel is modified. This 6391 * allows readers to hold either lock. 6392 */ 6393 lockdep_assert_held(&ar->conf_mutex); 6394 lockdep_assert_held(&ar->data_lock); 6395 6396 WARN_ON(ctx && vifs); 6397 WARN_ON(vifs && n_vifs != 1); 6398 6399 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are 6400 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each 6401 * ppdu on Rx may reduce performance on low-end systems. It should be 6402 * possible to make tables/hashmaps to speed the lookup up (be vary of 6403 * cpu data cache lines though regarding sizes) but to keep the initial 6404 * implementation simple and less intrusive fallback to the slow lookup 6405 * only for multi-channel cases. Single-channel cases will remain to 6406 * use the old channel derival and thus performance should not be 6407 * affected much. 6408 */ 6409 rcu_read_lock(); 6410 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) { 6411 ieee80211_iter_chan_contexts_atomic(ar->hw, 6412 ath10k_mac_get_any_chandef_iter, 6413 &def); 6414 6415 if (vifs) 6416 def = &vifs[0].new_ctx->def; 6417 6418 ar->rx_channel = def->chan; 6419 } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) { 6420 ar->rx_channel = ctx->def.chan; 6421 } else { 6422 ar->rx_channel = NULL; 6423 } 6424 rcu_read_unlock(); 6425 } 6426 6427 static void 6428 ath10k_mac_update_vif_chan(struct ath10k *ar, 6429 struct ieee80211_vif_chanctx_switch *vifs, 6430 int n_vifs) 6431 { 6432 struct ath10k_vif *arvif; 6433 int ret; 6434 int i; 6435 6436 lockdep_assert_held(&ar->conf_mutex); 6437 6438 /* First stop monitor interface. Some FW versions crash if there's a 6439 * lone monitor interface. 6440 */ 6441 if (ar->monitor_started) 6442 ath10k_monitor_stop(ar); 6443 6444 for (i = 0; i < n_vifs; i++) { 6445 arvif = ath10k_vif_to_arvif(vifs[i].vif); 6446 6447 ath10k_dbg(ar, ATH10K_DBG_MAC, 6448 "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n", 6449 arvif->vdev_id, 6450 vifs[i].old_ctx->def.chan->center_freq, 6451 vifs[i].new_ctx->def.chan->center_freq, 6452 vifs[i].old_ctx->def.width, 6453 vifs[i].new_ctx->def.width); 6454 6455 if (WARN_ON(!arvif->is_started)) 6456 continue; 6457 6458 if (WARN_ON(!arvif->is_up)) 6459 continue; 6460 6461 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 6462 if (ret) { 6463 ath10k_warn(ar, "failed to down vdev %d: %d\n", 6464 arvif->vdev_id, ret); 6465 continue; 6466 } 6467 } 6468 6469 /* All relevant vdevs are downed and associated channel resources 6470 * should be available for the channel switch now. 6471 */ 6472 6473 spin_lock_bh(&ar->data_lock); 6474 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs); 6475 spin_unlock_bh(&ar->data_lock); 6476 6477 for (i = 0; i < n_vifs; i++) { 6478 arvif = ath10k_vif_to_arvif(vifs[i].vif); 6479 6480 if (WARN_ON(!arvif->is_started)) 6481 continue; 6482 6483 if (WARN_ON(!arvif->is_up)) 6484 continue; 6485 6486 ret = ath10k_mac_setup_bcn_tmpl(arvif); 6487 if (ret) 6488 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n", 6489 ret); 6490 6491 ret = ath10k_mac_setup_prb_tmpl(arvif); 6492 if (ret) 6493 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n", 6494 ret); 6495 6496 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def); 6497 if (ret) { 6498 ath10k_warn(ar, "failed to restart vdev %d: %d\n", 6499 arvif->vdev_id, ret); 6500 continue; 6501 } 6502 6503 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 6504 arvif->bssid); 6505 if (ret) { 6506 ath10k_warn(ar, "failed to bring vdev up %d: %d\n", 6507 arvif->vdev_id, ret); 6508 continue; 6509 } 6510 } 6511 6512 ath10k_monitor_recalc(ar); 6513 } 6514 6515 static int 6516 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw, 6517 struct ieee80211_chanctx_conf *ctx) 6518 { 6519 struct ath10k *ar = hw->priv; 6520 6521 ath10k_dbg(ar, ATH10K_DBG_MAC, 6522 "mac chanctx add freq %hu width %d ptr %p\n", 6523 ctx->def.chan->center_freq, ctx->def.width, ctx); 6524 6525 mutex_lock(&ar->conf_mutex); 6526 6527 spin_lock_bh(&ar->data_lock); 6528 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0); 6529 spin_unlock_bh(&ar->data_lock); 6530 6531 ath10k_recalc_radar_detection(ar); 6532 ath10k_monitor_recalc(ar); 6533 6534 mutex_unlock(&ar->conf_mutex); 6535 6536 return 0; 6537 } 6538 6539 static void 6540 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw, 6541 struct ieee80211_chanctx_conf *ctx) 6542 { 6543 struct ath10k *ar = hw->priv; 6544 6545 ath10k_dbg(ar, ATH10K_DBG_MAC, 6546 "mac chanctx remove freq %hu width %d ptr %p\n", 6547 ctx->def.chan->center_freq, ctx->def.width, ctx); 6548 6549 mutex_lock(&ar->conf_mutex); 6550 6551 spin_lock_bh(&ar->data_lock); 6552 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0); 6553 spin_unlock_bh(&ar->data_lock); 6554 6555 ath10k_recalc_radar_detection(ar); 6556 ath10k_monitor_recalc(ar); 6557 6558 mutex_unlock(&ar->conf_mutex); 6559 } 6560 6561 struct ath10k_mac_change_chanctx_arg { 6562 struct ieee80211_chanctx_conf *ctx; 6563 struct ieee80211_vif_chanctx_switch *vifs; 6564 int n_vifs; 6565 int next_vif; 6566 }; 6567 6568 static void 6569 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac, 6570 struct ieee80211_vif *vif) 6571 { 6572 struct ath10k_mac_change_chanctx_arg *arg = data; 6573 6574 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx) 6575 return; 6576 6577 arg->n_vifs++; 6578 } 6579 6580 static void 6581 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac, 6582 struct ieee80211_vif *vif) 6583 { 6584 struct ath10k_mac_change_chanctx_arg *arg = data; 6585 struct ieee80211_chanctx_conf *ctx; 6586 6587 ctx = rcu_access_pointer(vif->chanctx_conf); 6588 if (ctx != arg->ctx) 6589 return; 6590 6591 if (WARN_ON(arg->next_vif == arg->n_vifs)) 6592 return; 6593 6594 arg->vifs[arg->next_vif].vif = vif; 6595 arg->vifs[arg->next_vif].old_ctx = ctx; 6596 arg->vifs[arg->next_vif].new_ctx = ctx; 6597 arg->next_vif++; 6598 } 6599 6600 static void 6601 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw, 6602 struct ieee80211_chanctx_conf *ctx, 6603 u32 changed) 6604 { 6605 struct ath10k *ar = hw->priv; 6606 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx }; 6607 6608 mutex_lock(&ar->conf_mutex); 6609 6610 ath10k_dbg(ar, ATH10K_DBG_MAC, 6611 "mac chanctx change freq %hu width %d ptr %p changed %x\n", 6612 ctx->def.chan->center_freq, ctx->def.width, ctx, changed); 6613 6614 /* This shouldn't really happen because channel switching should use 6615 * switch_vif_chanctx(). 6616 */ 6617 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL)) 6618 goto unlock; 6619 6620 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) { 6621 ieee80211_iterate_active_interfaces_atomic( 6622 hw, 6623 IEEE80211_IFACE_ITER_NORMAL, 6624 ath10k_mac_change_chanctx_cnt_iter, 6625 &arg); 6626 if (arg.n_vifs == 0) 6627 goto radar; 6628 6629 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), 6630 GFP_KERNEL); 6631 if (!arg.vifs) 6632 goto radar; 6633 6634 ieee80211_iterate_active_interfaces_atomic( 6635 hw, 6636 IEEE80211_IFACE_ITER_NORMAL, 6637 ath10k_mac_change_chanctx_fill_iter, 6638 &arg); 6639 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs); 6640 kfree(arg.vifs); 6641 } 6642 6643 radar: 6644 ath10k_recalc_radar_detection(ar); 6645 6646 /* FIXME: How to configure Rx chains properly? */ 6647 6648 /* No other actions are actually necessary. Firmware maintains channel 6649 * definitions per vdev internally and there's no host-side channel 6650 * context abstraction to configure, e.g. channel width. 6651 */ 6652 6653 unlock: 6654 mutex_unlock(&ar->conf_mutex); 6655 } 6656 6657 static int 6658 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw, 6659 struct ieee80211_vif *vif, 6660 struct ieee80211_chanctx_conf *ctx) 6661 { 6662 struct ath10k *ar = hw->priv; 6663 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6664 int ret; 6665 6666 mutex_lock(&ar->conf_mutex); 6667 6668 ath10k_dbg(ar, ATH10K_DBG_MAC, 6669 "mac chanctx assign ptr %p vdev_id %i\n", 6670 ctx, arvif->vdev_id); 6671 6672 if (WARN_ON(arvif->is_started)) { 6673 mutex_unlock(&ar->conf_mutex); 6674 return -EBUSY; 6675 } 6676 6677 ret = ath10k_vdev_start(arvif, &ctx->def); 6678 if (ret) { 6679 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n", 6680 arvif->vdev_id, vif->addr, 6681 ctx->def.chan->center_freq, ret); 6682 goto err; 6683 } 6684 6685 arvif->is_started = true; 6686 6687 ret = ath10k_mac_vif_setup_ps(arvif); 6688 if (ret) { 6689 ath10k_warn(ar, "failed to update vdev %i ps: %d\n", 6690 arvif->vdev_id, ret); 6691 goto err_stop; 6692 } 6693 6694 if (vif->type == NL80211_IFTYPE_MONITOR) { 6695 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr); 6696 if (ret) { 6697 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n", 6698 arvif->vdev_id, ret); 6699 goto err_stop; 6700 } 6701 6702 arvif->is_up = true; 6703 } 6704 6705 mutex_unlock(&ar->conf_mutex); 6706 return 0; 6707 6708 err_stop: 6709 ath10k_vdev_stop(arvif); 6710 arvif->is_started = false; 6711 ath10k_mac_vif_setup_ps(arvif); 6712 6713 err: 6714 mutex_unlock(&ar->conf_mutex); 6715 return ret; 6716 } 6717 6718 static void 6719 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 6720 struct ieee80211_vif *vif, 6721 struct ieee80211_chanctx_conf *ctx) 6722 { 6723 struct ath10k *ar = hw->priv; 6724 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6725 int ret; 6726 6727 mutex_lock(&ar->conf_mutex); 6728 6729 ath10k_dbg(ar, ATH10K_DBG_MAC, 6730 "mac chanctx unassign ptr %p vdev_id %i\n", 6731 ctx, arvif->vdev_id); 6732 6733 WARN_ON(!arvif->is_started); 6734 6735 if (vif->type == NL80211_IFTYPE_MONITOR) { 6736 WARN_ON(!arvif->is_up); 6737 6738 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 6739 if (ret) 6740 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n", 6741 arvif->vdev_id, ret); 6742 6743 arvif->is_up = false; 6744 } 6745 6746 ret = ath10k_vdev_stop(arvif); 6747 if (ret) 6748 ath10k_warn(ar, "failed to stop vdev %i: %d\n", 6749 arvif->vdev_id, ret); 6750 6751 arvif->is_started = false; 6752 6753 mutex_unlock(&ar->conf_mutex); 6754 } 6755 6756 static int 6757 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw, 6758 struct ieee80211_vif_chanctx_switch *vifs, 6759 int n_vifs, 6760 enum ieee80211_chanctx_switch_mode mode) 6761 { 6762 struct ath10k *ar = hw->priv; 6763 6764 mutex_lock(&ar->conf_mutex); 6765 6766 ath10k_dbg(ar, ATH10K_DBG_MAC, 6767 "mac chanctx switch n_vifs %d mode %d\n", 6768 n_vifs, mode); 6769 ath10k_mac_update_vif_chan(ar, vifs, n_vifs); 6770 6771 mutex_unlock(&ar->conf_mutex); 6772 return 0; 6773 } 6774 6775 static const struct ieee80211_ops ath10k_ops = { 6776 .tx = ath10k_tx, 6777 .start = ath10k_start, 6778 .stop = ath10k_stop, 6779 .config = ath10k_config, 6780 .add_interface = ath10k_add_interface, 6781 .remove_interface = ath10k_remove_interface, 6782 .configure_filter = ath10k_configure_filter, 6783 .bss_info_changed = ath10k_bss_info_changed, 6784 .hw_scan = ath10k_hw_scan, 6785 .cancel_hw_scan = ath10k_cancel_hw_scan, 6786 .set_key = ath10k_set_key, 6787 .set_default_unicast_key = ath10k_set_default_unicast_key, 6788 .sta_state = ath10k_sta_state, 6789 .conf_tx = ath10k_conf_tx, 6790 .remain_on_channel = ath10k_remain_on_channel, 6791 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel, 6792 .set_rts_threshold = ath10k_set_rts_threshold, 6793 .set_frag_threshold = ath10k_mac_op_set_frag_threshold, 6794 .flush = ath10k_flush, 6795 .tx_last_beacon = ath10k_tx_last_beacon, 6796 .set_antenna = ath10k_set_antenna, 6797 .get_antenna = ath10k_get_antenna, 6798 .reconfig_complete = ath10k_reconfig_complete, 6799 .get_survey = ath10k_get_survey, 6800 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask, 6801 .sta_rc_update = ath10k_sta_rc_update, 6802 .get_tsf = ath10k_get_tsf, 6803 .ampdu_action = ath10k_ampdu_action, 6804 .get_et_sset_count = ath10k_debug_get_et_sset_count, 6805 .get_et_stats = ath10k_debug_get_et_stats, 6806 .get_et_strings = ath10k_debug_get_et_strings, 6807 .add_chanctx = ath10k_mac_op_add_chanctx, 6808 .remove_chanctx = ath10k_mac_op_remove_chanctx, 6809 .change_chanctx = ath10k_mac_op_change_chanctx, 6810 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx, 6811 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx, 6812 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx, 6813 6814 CFG80211_TESTMODE_CMD(ath10k_tm_cmd) 6815 6816 #ifdef CONFIG_PM 6817 .suspend = ath10k_wow_op_suspend, 6818 .resume = ath10k_wow_op_resume, 6819 #endif 6820 #ifdef CONFIG_MAC80211_DEBUGFS 6821 .sta_add_debugfs = ath10k_sta_add_debugfs, 6822 #endif 6823 }; 6824 6825 #define CHAN2G(_channel, _freq, _flags) { \ 6826 .band = IEEE80211_BAND_2GHZ, \ 6827 .hw_value = (_channel), \ 6828 .center_freq = (_freq), \ 6829 .flags = (_flags), \ 6830 .max_antenna_gain = 0, \ 6831 .max_power = 30, \ 6832 } 6833 6834 #define CHAN5G(_channel, _freq, _flags) { \ 6835 .band = IEEE80211_BAND_5GHZ, \ 6836 .hw_value = (_channel), \ 6837 .center_freq = (_freq), \ 6838 .flags = (_flags), \ 6839 .max_antenna_gain = 0, \ 6840 .max_power = 30, \ 6841 } 6842 6843 static const struct ieee80211_channel ath10k_2ghz_channels[] = { 6844 CHAN2G(1, 2412, 0), 6845 CHAN2G(2, 2417, 0), 6846 CHAN2G(3, 2422, 0), 6847 CHAN2G(4, 2427, 0), 6848 CHAN2G(5, 2432, 0), 6849 CHAN2G(6, 2437, 0), 6850 CHAN2G(7, 2442, 0), 6851 CHAN2G(8, 2447, 0), 6852 CHAN2G(9, 2452, 0), 6853 CHAN2G(10, 2457, 0), 6854 CHAN2G(11, 2462, 0), 6855 CHAN2G(12, 2467, 0), 6856 CHAN2G(13, 2472, 0), 6857 CHAN2G(14, 2484, 0), 6858 }; 6859 6860 static const struct ieee80211_channel ath10k_5ghz_channels[] = { 6861 CHAN5G(36, 5180, 0), 6862 CHAN5G(40, 5200, 0), 6863 CHAN5G(44, 5220, 0), 6864 CHAN5G(48, 5240, 0), 6865 CHAN5G(52, 5260, 0), 6866 CHAN5G(56, 5280, 0), 6867 CHAN5G(60, 5300, 0), 6868 CHAN5G(64, 5320, 0), 6869 CHAN5G(100, 5500, 0), 6870 CHAN5G(104, 5520, 0), 6871 CHAN5G(108, 5540, 0), 6872 CHAN5G(112, 5560, 0), 6873 CHAN5G(116, 5580, 0), 6874 CHAN5G(120, 5600, 0), 6875 CHAN5G(124, 5620, 0), 6876 CHAN5G(128, 5640, 0), 6877 CHAN5G(132, 5660, 0), 6878 CHAN5G(136, 5680, 0), 6879 CHAN5G(140, 5700, 0), 6880 CHAN5G(144, 5720, 0), 6881 CHAN5G(149, 5745, 0), 6882 CHAN5G(153, 5765, 0), 6883 CHAN5G(157, 5785, 0), 6884 CHAN5G(161, 5805, 0), 6885 CHAN5G(165, 5825, 0), 6886 }; 6887 6888 struct ath10k *ath10k_mac_create(size_t priv_size) 6889 { 6890 struct ieee80211_hw *hw; 6891 struct ath10k *ar; 6892 6893 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops); 6894 if (!hw) 6895 return NULL; 6896 6897 ar = hw->priv; 6898 ar->hw = hw; 6899 6900 return ar; 6901 } 6902 6903 void ath10k_mac_destroy(struct ath10k *ar) 6904 { 6905 ieee80211_free_hw(ar->hw); 6906 } 6907 6908 static const struct ieee80211_iface_limit ath10k_if_limits[] = { 6909 { 6910 .max = 8, 6911 .types = BIT(NL80211_IFTYPE_STATION) 6912 | BIT(NL80211_IFTYPE_P2P_CLIENT) 6913 }, 6914 { 6915 .max = 3, 6916 .types = BIT(NL80211_IFTYPE_P2P_GO) 6917 }, 6918 { 6919 .max = 1, 6920 .types = BIT(NL80211_IFTYPE_P2P_DEVICE) 6921 }, 6922 { 6923 .max = 7, 6924 .types = BIT(NL80211_IFTYPE_AP) 6925 #ifdef CONFIG_MAC80211_MESH 6926 | BIT(NL80211_IFTYPE_MESH_POINT) 6927 #endif 6928 }, 6929 }; 6930 6931 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = { 6932 { 6933 .max = 8, 6934 .types = BIT(NL80211_IFTYPE_AP) 6935 #ifdef CONFIG_MAC80211_MESH 6936 | BIT(NL80211_IFTYPE_MESH_POINT) 6937 #endif 6938 }, 6939 }; 6940 6941 static const struct ieee80211_iface_combination ath10k_if_comb[] = { 6942 { 6943 .limits = ath10k_if_limits, 6944 .n_limits = ARRAY_SIZE(ath10k_if_limits), 6945 .max_interfaces = 8, 6946 .num_different_channels = 1, 6947 .beacon_int_infra_match = true, 6948 }, 6949 }; 6950 6951 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = { 6952 { 6953 .limits = ath10k_10x_if_limits, 6954 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits), 6955 .max_interfaces = 8, 6956 .num_different_channels = 1, 6957 .beacon_int_infra_match = true, 6958 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 6959 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 6960 BIT(NL80211_CHAN_WIDTH_20) | 6961 BIT(NL80211_CHAN_WIDTH_40) | 6962 BIT(NL80211_CHAN_WIDTH_80), 6963 #endif 6964 }, 6965 }; 6966 6967 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = { 6968 { 6969 .max = 2, 6970 .types = BIT(NL80211_IFTYPE_STATION), 6971 }, 6972 { 6973 .max = 2, 6974 .types = BIT(NL80211_IFTYPE_AP) | 6975 #ifdef CONFIG_MAC80211_MESH 6976 BIT(NL80211_IFTYPE_MESH_POINT) | 6977 #endif 6978 BIT(NL80211_IFTYPE_P2P_CLIENT) | 6979 BIT(NL80211_IFTYPE_P2P_GO), 6980 }, 6981 { 6982 .max = 1, 6983 .types = BIT(NL80211_IFTYPE_P2P_DEVICE), 6984 }, 6985 }; 6986 6987 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = { 6988 { 6989 .max = 2, 6990 .types = BIT(NL80211_IFTYPE_STATION), 6991 }, 6992 { 6993 .max = 2, 6994 .types = BIT(NL80211_IFTYPE_P2P_CLIENT), 6995 }, 6996 { 6997 .max = 1, 6998 .types = BIT(NL80211_IFTYPE_AP) | 6999 #ifdef CONFIG_MAC80211_MESH 7000 BIT(NL80211_IFTYPE_MESH_POINT) | 7001 #endif 7002 BIT(NL80211_IFTYPE_P2P_GO), 7003 }, 7004 { 7005 .max = 1, 7006 .types = BIT(NL80211_IFTYPE_P2P_DEVICE), 7007 }, 7008 }; 7009 7010 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = { 7011 { 7012 .max = 1, 7013 .types = BIT(NL80211_IFTYPE_STATION), 7014 }, 7015 { 7016 .max = 1, 7017 .types = BIT(NL80211_IFTYPE_ADHOC), 7018 }, 7019 }; 7020 7021 /* FIXME: This is not thouroughly tested. These combinations may over- or 7022 * underestimate hw/fw capabilities. 7023 */ 7024 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = { 7025 { 7026 .limits = ath10k_tlv_if_limit, 7027 .num_different_channels = 1, 7028 .max_interfaces = 4, 7029 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit), 7030 }, 7031 { 7032 .limits = ath10k_tlv_if_limit_ibss, 7033 .num_different_channels = 1, 7034 .max_interfaces = 2, 7035 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss), 7036 }, 7037 }; 7038 7039 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = { 7040 { 7041 .limits = ath10k_tlv_if_limit, 7042 .num_different_channels = 1, 7043 .max_interfaces = 4, 7044 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit), 7045 }, 7046 { 7047 .limits = ath10k_tlv_qcs_if_limit, 7048 .num_different_channels = 2, 7049 .max_interfaces = 4, 7050 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit), 7051 }, 7052 { 7053 .limits = ath10k_tlv_if_limit_ibss, 7054 .num_different_channels = 1, 7055 .max_interfaces = 2, 7056 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss), 7057 }, 7058 }; 7059 7060 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = { 7061 { 7062 .max = 1, 7063 .types = BIT(NL80211_IFTYPE_STATION), 7064 }, 7065 { 7066 .max = 16, 7067 .types = BIT(NL80211_IFTYPE_AP) 7068 #ifdef CONFIG_MAC80211_MESH 7069 | BIT(NL80211_IFTYPE_MESH_POINT) 7070 #endif 7071 }, 7072 }; 7073 7074 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = { 7075 { 7076 .limits = ath10k_10_4_if_limits, 7077 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits), 7078 .max_interfaces = 16, 7079 .num_different_channels = 1, 7080 .beacon_int_infra_match = true, 7081 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 7082 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 7083 BIT(NL80211_CHAN_WIDTH_20) | 7084 BIT(NL80211_CHAN_WIDTH_40) | 7085 BIT(NL80211_CHAN_WIDTH_80), 7086 #endif 7087 }, 7088 }; 7089 7090 static void ath10k_get_arvif_iter(void *data, u8 *mac, 7091 struct ieee80211_vif *vif) 7092 { 7093 struct ath10k_vif_iter *arvif_iter = data; 7094 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 7095 7096 if (arvif->vdev_id == arvif_iter->vdev_id) 7097 arvif_iter->arvif = arvif; 7098 } 7099 7100 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id) 7101 { 7102 struct ath10k_vif_iter arvif_iter; 7103 u32 flags; 7104 7105 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter)); 7106 arvif_iter.vdev_id = vdev_id; 7107 7108 flags = IEEE80211_IFACE_ITER_RESUME_ALL; 7109 ieee80211_iterate_active_interfaces_atomic(ar->hw, 7110 flags, 7111 ath10k_get_arvif_iter, 7112 &arvif_iter); 7113 if (!arvif_iter.arvif) { 7114 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id); 7115 return NULL; 7116 } 7117 7118 return arvif_iter.arvif; 7119 } 7120 7121 int ath10k_mac_register(struct ath10k *ar) 7122 { 7123 static const u32 cipher_suites[] = { 7124 WLAN_CIPHER_SUITE_WEP40, 7125 WLAN_CIPHER_SUITE_WEP104, 7126 WLAN_CIPHER_SUITE_TKIP, 7127 WLAN_CIPHER_SUITE_CCMP, 7128 WLAN_CIPHER_SUITE_AES_CMAC, 7129 }; 7130 struct ieee80211_supported_band *band; 7131 void *channels; 7132 int ret; 7133 7134 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 7135 7136 SET_IEEE80211_DEV(ar->hw, ar->dev); 7137 7138 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) + 7139 ARRAY_SIZE(ath10k_5ghz_channels)) != 7140 ATH10K_NUM_CHANS); 7141 7142 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) { 7143 channels = kmemdup(ath10k_2ghz_channels, 7144 sizeof(ath10k_2ghz_channels), 7145 GFP_KERNEL); 7146 if (!channels) { 7147 ret = -ENOMEM; 7148 goto err_free; 7149 } 7150 7151 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ]; 7152 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels); 7153 band->channels = channels; 7154 band->n_bitrates = ath10k_g_rates_size; 7155 band->bitrates = ath10k_g_rates; 7156 7157 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band; 7158 } 7159 7160 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) { 7161 channels = kmemdup(ath10k_5ghz_channels, 7162 sizeof(ath10k_5ghz_channels), 7163 GFP_KERNEL); 7164 if (!channels) { 7165 ret = -ENOMEM; 7166 goto err_free; 7167 } 7168 7169 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ]; 7170 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels); 7171 band->channels = channels; 7172 band->n_bitrates = ath10k_a_rates_size; 7173 band->bitrates = ath10k_a_rates; 7174 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band; 7175 } 7176 7177 ath10k_mac_setup_ht_vht_cap(ar); 7178 7179 ar->hw->wiphy->interface_modes = 7180 BIT(NL80211_IFTYPE_STATION) | 7181 BIT(NL80211_IFTYPE_AP) | 7182 BIT(NL80211_IFTYPE_MESH_POINT); 7183 7184 ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask; 7185 ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask; 7186 7187 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features)) 7188 ar->hw->wiphy->interface_modes |= 7189 BIT(NL80211_IFTYPE_P2P_DEVICE) | 7190 BIT(NL80211_IFTYPE_P2P_CLIENT) | 7191 BIT(NL80211_IFTYPE_P2P_GO); 7192 7193 ieee80211_hw_set(ar->hw, SIGNAL_DBM); 7194 ieee80211_hw_set(ar->hw, SUPPORTS_PS); 7195 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS); 7196 ieee80211_hw_set(ar->hw, MFP_CAPABLE); 7197 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS); 7198 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL); 7199 ieee80211_hw_set(ar->hw, AP_LINK_PS); 7200 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT); 7201 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT); 7202 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR); 7203 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK); 7204 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF); 7205 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA); 7206 ieee80211_hw_set(ar->hw, QUEUE_CONTROL); 7207 7208 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) 7209 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL); 7210 7211 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS; 7212 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 7213 7214 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 7215 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS; 7216 7217 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) { 7218 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION); 7219 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW); 7220 } 7221 7222 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 7223 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 7224 7225 ar->hw->vif_data_size = sizeof(struct ath10k_vif); 7226 ar->hw->sta_data_size = sizeof(struct ath10k_sta); 7227 7228 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL; 7229 7230 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) { 7231 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD; 7232 7233 /* Firmware delivers WPS/P2P Probe Requests frames to driver so 7234 * that userspace (e.g. wpa_supplicant/hostapd) can generate 7235 * correct Probe Responses. This is more of a hack advert.. 7236 */ 7237 ar->hw->wiphy->probe_resp_offload |= 7238 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS | 7239 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 | 7240 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P; 7241 } 7242 7243 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map)) 7244 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS; 7245 7246 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 7247 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 7248 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 7249 7250 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 7251 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE; 7252 7253 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations; 7254 7255 ret = ath10k_wow_init(ar); 7256 if (ret) { 7257 ath10k_warn(ar, "failed to init wow: %d\n", ret); 7258 goto err_free; 7259 } 7260 7261 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS); 7262 7263 /* 7264 * on LL hardware queues are managed entirely by the FW 7265 * so we only advertise to mac we can do the queues thing 7266 */ 7267 ar->hw->queues = IEEE80211_MAX_QUEUES; 7268 7269 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is 7270 * something that vdev_ids can't reach so that we don't stop the queue 7271 * accidentally. 7272 */ 7273 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1; 7274 7275 switch (ar->wmi.op_version) { 7276 case ATH10K_FW_WMI_OP_VERSION_MAIN: 7277 ar->hw->wiphy->iface_combinations = ath10k_if_comb; 7278 ar->hw->wiphy->n_iface_combinations = 7279 ARRAY_SIZE(ath10k_if_comb); 7280 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC); 7281 break; 7282 case ATH10K_FW_WMI_OP_VERSION_TLV: 7283 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) { 7284 ar->hw->wiphy->iface_combinations = 7285 ath10k_tlv_qcs_if_comb; 7286 ar->hw->wiphy->n_iface_combinations = 7287 ARRAY_SIZE(ath10k_tlv_qcs_if_comb); 7288 } else { 7289 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb; 7290 ar->hw->wiphy->n_iface_combinations = 7291 ARRAY_SIZE(ath10k_tlv_if_comb); 7292 } 7293 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC); 7294 break; 7295 case ATH10K_FW_WMI_OP_VERSION_10_1: 7296 case ATH10K_FW_WMI_OP_VERSION_10_2: 7297 case ATH10K_FW_WMI_OP_VERSION_10_2_4: 7298 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb; 7299 ar->hw->wiphy->n_iface_combinations = 7300 ARRAY_SIZE(ath10k_10x_if_comb); 7301 break; 7302 case ATH10K_FW_WMI_OP_VERSION_10_4: 7303 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb; 7304 ar->hw->wiphy->n_iface_combinations = 7305 ARRAY_SIZE(ath10k_10_4_if_comb); 7306 break; 7307 case ATH10K_FW_WMI_OP_VERSION_UNSET: 7308 case ATH10K_FW_WMI_OP_VERSION_MAX: 7309 WARN_ON(1); 7310 ret = -EINVAL; 7311 goto err_free; 7312 } 7313 7314 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) 7315 ar->hw->netdev_features = NETIF_F_HW_CSUM; 7316 7317 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) { 7318 /* Init ath dfs pattern detector */ 7319 ar->ath_common.debug_mask = ATH_DBG_DFS; 7320 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common, 7321 NL80211_DFS_UNSET); 7322 7323 if (!ar->dfs_detector) 7324 ath10k_warn(ar, "failed to initialise DFS pattern detector\n"); 7325 } 7326 7327 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy, 7328 ath10k_reg_notifier); 7329 if (ret) { 7330 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret); 7331 goto err_dfs_detector_exit; 7332 } 7333 7334 ar->hw->wiphy->cipher_suites = cipher_suites; 7335 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 7336 7337 ret = ieee80211_register_hw(ar->hw); 7338 if (ret) { 7339 ath10k_err(ar, "failed to register ieee80211: %d\n", ret); 7340 goto err_dfs_detector_exit; 7341 } 7342 7343 if (!ath_is_world_regd(&ar->ath_common.regulatory)) { 7344 ret = regulatory_hint(ar->hw->wiphy, 7345 ar->ath_common.regulatory.alpha2); 7346 if (ret) 7347 goto err_unregister; 7348 } 7349 7350 return 0; 7351 7352 err_unregister: 7353 ieee80211_unregister_hw(ar->hw); 7354 7355 err_dfs_detector_exit: 7356 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) 7357 ar->dfs_detector->exit(ar->dfs_detector); 7358 7359 err_free: 7360 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels); 7361 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels); 7362 7363 SET_IEEE80211_DEV(ar->hw, NULL); 7364 return ret; 7365 } 7366 7367 void ath10k_mac_unregister(struct ath10k *ar) 7368 { 7369 ieee80211_unregister_hw(ar->hw); 7370 7371 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) 7372 ar->dfs_detector->exit(ar->dfs_detector); 7373 7374 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels); 7375 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels); 7376 7377 SET_IEEE80211_DEV(ar->hw, NULL); 7378 } 7379