1 // SPDX-License-Identifier: ISC 2 /* 3 * Copyright (c) 2005-2011 Atheros Communications Inc. 4 * Copyright (c) 2011-2017 Qualcomm Atheros, Inc. 5 * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved. 6 */ 7 8 #include "mac.h" 9 10 #include <net/cfg80211.h> 11 #include <net/mac80211.h> 12 #include <linux/etherdevice.h> 13 #include <linux/acpi.h> 14 #include <linux/of.h> 15 #include <linux/bitfield.h> 16 17 #include "hif.h" 18 #include "core.h" 19 #include "debug.h" 20 #include "wmi.h" 21 #include "htt.h" 22 #include "txrx.h" 23 #include "testmode.h" 24 #include "wmi-tlv.h" 25 #include "wmi-ops.h" 26 #include "wow.h" 27 28 /*********/ 29 /* Rates */ 30 /*********/ 31 32 static struct ieee80211_rate ath10k_rates[] = { 33 { .bitrate = 10, 34 .hw_value = ATH10K_HW_RATE_CCK_LP_1M }, 35 { .bitrate = 20, 36 .hw_value = ATH10K_HW_RATE_CCK_LP_2M, 37 .hw_value_short = ATH10K_HW_RATE_CCK_SP_2M, 38 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 39 { .bitrate = 55, 40 .hw_value = ATH10K_HW_RATE_CCK_LP_5_5M, 41 .hw_value_short = ATH10K_HW_RATE_CCK_SP_5_5M, 42 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 43 { .bitrate = 110, 44 .hw_value = ATH10K_HW_RATE_CCK_LP_11M, 45 .hw_value_short = ATH10K_HW_RATE_CCK_SP_11M, 46 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 47 48 { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M }, 49 { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M }, 50 { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M }, 51 { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M }, 52 { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M }, 53 { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M }, 54 { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M }, 55 { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M }, 56 }; 57 58 static struct ieee80211_rate ath10k_rates_rev2[] = { 59 { .bitrate = 10, 60 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_1M }, 61 { .bitrate = 20, 62 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_2M, 63 .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_2M, 64 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 65 { .bitrate = 55, 66 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_5_5M, 67 .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_5_5M, 68 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 69 { .bitrate = 110, 70 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_11M, 71 .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_11M, 72 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 73 74 { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M }, 75 { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M }, 76 { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M }, 77 { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M }, 78 { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M }, 79 { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M }, 80 { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M }, 81 { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M }, 82 }; 83 84 #define ATH10K_MAC_FIRST_OFDM_RATE_IDX 4 85 86 #define ath10k_a_rates (ath10k_rates + ATH10K_MAC_FIRST_OFDM_RATE_IDX) 87 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - \ 88 ATH10K_MAC_FIRST_OFDM_RATE_IDX) 89 #define ath10k_g_rates (ath10k_rates + 0) 90 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates)) 91 92 #define ath10k_g_rates_rev2 (ath10k_rates_rev2 + 0) 93 #define ath10k_g_rates_rev2_size (ARRAY_SIZE(ath10k_rates_rev2)) 94 95 #define ath10k_wmi_legacy_rates ath10k_rates 96 97 static bool ath10k_mac_bitrate_is_cck(int bitrate) 98 { 99 switch (bitrate) { 100 case 10: 101 case 20: 102 case 55: 103 case 110: 104 return true; 105 } 106 107 return false; 108 } 109 110 static u8 ath10k_mac_bitrate_to_rate(int bitrate) 111 { 112 return DIV_ROUND_UP(bitrate, 5) | 113 (ath10k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0); 114 } 115 116 u8 ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband, 117 u8 hw_rate, bool cck) 118 { 119 const struct ieee80211_rate *rate; 120 int i; 121 122 for (i = 0; i < sband->n_bitrates; i++) { 123 rate = &sband->bitrates[i]; 124 125 if (ath10k_mac_bitrate_is_cck(rate->bitrate) != cck) 126 continue; 127 128 if (rate->hw_value == hw_rate) 129 return i; 130 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE && 131 rate->hw_value_short == hw_rate) 132 return i; 133 } 134 135 return 0; 136 } 137 138 u8 ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband, 139 u32 bitrate) 140 { 141 int i; 142 143 for (i = 0; i < sband->n_bitrates; i++) 144 if (sband->bitrates[i].bitrate == bitrate) 145 return i; 146 147 return 0; 148 } 149 150 static int ath10k_mac_get_rate_hw_value(int bitrate) 151 { 152 int i; 153 u8 hw_value_prefix = 0; 154 155 if (ath10k_mac_bitrate_is_cck(bitrate)) 156 hw_value_prefix = WMI_RATE_PREAMBLE_CCK << 6; 157 158 for (i = 0; i < ARRAY_SIZE(ath10k_rates); i++) { 159 if (ath10k_rates[i].bitrate == bitrate) 160 return hw_value_prefix | ath10k_rates[i].hw_value; 161 } 162 163 return -EINVAL; 164 } 165 166 static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss) 167 { 168 switch ((mcs_map >> (2 * nss)) & 0x3) { 169 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1; 170 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1; 171 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1; 172 } 173 return 0; 174 } 175 176 static u32 177 ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN]) 178 { 179 int nss; 180 181 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--) 182 if (ht_mcs_mask[nss]) 183 return nss + 1; 184 185 return 1; 186 } 187 188 static u32 189 ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX]) 190 { 191 int nss; 192 193 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--) 194 if (vht_mcs_mask[nss]) 195 return nss + 1; 196 197 return 1; 198 } 199 200 int ath10k_mac_ext_resource_config(struct ath10k *ar, u32 val) 201 { 202 enum wmi_host_platform_type platform_type; 203 int ret; 204 205 if (test_bit(WMI_SERVICE_TX_MODE_DYNAMIC, ar->wmi.svc_map)) 206 platform_type = WMI_HOST_PLATFORM_LOW_PERF; 207 else 208 platform_type = WMI_HOST_PLATFORM_HIGH_PERF; 209 210 ret = ath10k_wmi_ext_resource_config(ar, platform_type, val); 211 212 if (ret && ret != -EOPNOTSUPP) { 213 ath10k_warn(ar, "failed to configure ext resource: %d\n", ret); 214 return ret; 215 } 216 217 return 0; 218 } 219 220 /**********/ 221 /* Crypto */ 222 /**********/ 223 224 static int ath10k_send_key(struct ath10k_vif *arvif, 225 struct ieee80211_key_conf *key, 226 enum set_key_cmd cmd, 227 const u8 *macaddr, u32 flags) 228 { 229 struct ath10k *ar = arvif->ar; 230 struct wmi_vdev_install_key_arg arg = { 231 .vdev_id = arvif->vdev_id, 232 .key_idx = key->keyidx, 233 .key_len = key->keylen, 234 .key_data = key->key, 235 .key_flags = flags, 236 .macaddr = macaddr, 237 }; 238 239 lockdep_assert_held(&arvif->ar->conf_mutex); 240 241 switch (key->cipher) { 242 case WLAN_CIPHER_SUITE_CCMP: 243 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_CCM]; 244 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT; 245 break; 246 case WLAN_CIPHER_SUITE_TKIP: 247 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_TKIP]; 248 arg.key_txmic_len = 8; 249 arg.key_rxmic_len = 8; 250 break; 251 case WLAN_CIPHER_SUITE_WEP40: 252 case WLAN_CIPHER_SUITE_WEP104: 253 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_WEP]; 254 break; 255 case WLAN_CIPHER_SUITE_CCMP_256: 256 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_CCM]; 257 break; 258 case WLAN_CIPHER_SUITE_GCMP: 259 case WLAN_CIPHER_SUITE_GCMP_256: 260 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_GCM]; 261 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT; 262 break; 263 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 264 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 265 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 266 case WLAN_CIPHER_SUITE_AES_CMAC: 267 WARN_ON(1); 268 return -EINVAL; 269 default: 270 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher); 271 return -EOPNOTSUPP; 272 } 273 274 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) 275 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 276 277 if (cmd == DISABLE_KEY) { 278 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_NONE]; 279 arg.key_data = NULL; 280 } 281 282 return ath10k_wmi_vdev_install_key(arvif->ar, &arg); 283 } 284 285 static int ath10k_install_key(struct ath10k_vif *arvif, 286 struct ieee80211_key_conf *key, 287 enum set_key_cmd cmd, 288 const u8 *macaddr, u32 flags) 289 { 290 struct ath10k *ar = arvif->ar; 291 int ret; 292 unsigned long time_left; 293 294 lockdep_assert_held(&ar->conf_mutex); 295 296 reinit_completion(&ar->install_key_done); 297 298 if (arvif->nohwcrypt) 299 return 1; 300 301 ret = ath10k_send_key(arvif, key, cmd, macaddr, flags); 302 if (ret) 303 return ret; 304 305 time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ); 306 if (time_left == 0) 307 return -ETIMEDOUT; 308 309 return 0; 310 } 311 312 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif, 313 const u8 *addr) 314 { 315 struct ath10k *ar = arvif->ar; 316 struct ath10k_peer *peer; 317 int ret; 318 int i; 319 u32 flags; 320 321 lockdep_assert_held(&ar->conf_mutex); 322 323 if (WARN_ON(arvif->vif->type != NL80211_IFTYPE_AP && 324 arvif->vif->type != NL80211_IFTYPE_ADHOC && 325 arvif->vif->type != NL80211_IFTYPE_MESH_POINT)) 326 return -EINVAL; 327 328 spin_lock_bh(&ar->data_lock); 329 peer = ath10k_peer_find(ar, arvif->vdev_id, addr); 330 spin_unlock_bh(&ar->data_lock); 331 332 if (!peer) 333 return -ENOENT; 334 335 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) { 336 if (arvif->wep_keys[i] == NULL) 337 continue; 338 339 switch (arvif->vif->type) { 340 case NL80211_IFTYPE_AP: 341 flags = WMI_KEY_PAIRWISE; 342 343 if (arvif->def_wep_key_idx == i) 344 flags |= WMI_KEY_TX_USAGE; 345 346 ret = ath10k_install_key(arvif, arvif->wep_keys[i], 347 SET_KEY, addr, flags); 348 if (ret < 0) 349 return ret; 350 break; 351 case NL80211_IFTYPE_ADHOC: 352 ret = ath10k_install_key(arvif, arvif->wep_keys[i], 353 SET_KEY, addr, 354 WMI_KEY_PAIRWISE); 355 if (ret < 0) 356 return ret; 357 358 ret = ath10k_install_key(arvif, arvif->wep_keys[i], 359 SET_KEY, addr, WMI_KEY_GROUP); 360 if (ret < 0) 361 return ret; 362 break; 363 default: 364 WARN_ON(1); 365 return -EINVAL; 366 } 367 368 spin_lock_bh(&ar->data_lock); 369 peer->keys[i] = arvif->wep_keys[i]; 370 spin_unlock_bh(&ar->data_lock); 371 } 372 373 /* In some cases (notably with static WEP IBSS with multiple keys) 374 * multicast Tx becomes broken. Both pairwise and groupwise keys are 375 * installed already. Using WMI_KEY_TX_USAGE in different combinations 376 * didn't seem help. Using def_keyid vdev parameter seems to be 377 * effective so use that. 378 * 379 * FIXME: Revisit. Perhaps this can be done in a less hacky way. 380 */ 381 if (arvif->vif->type != NL80211_IFTYPE_ADHOC) 382 return 0; 383 384 if (arvif->def_wep_key_idx == -1) 385 return 0; 386 387 ret = ath10k_wmi_vdev_set_param(arvif->ar, 388 arvif->vdev_id, 389 arvif->ar->wmi.vdev_param->def_keyid, 390 arvif->def_wep_key_idx); 391 if (ret) { 392 ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n", 393 arvif->vdev_id, ret); 394 return ret; 395 } 396 397 return 0; 398 } 399 400 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif, 401 const u8 *addr) 402 { 403 struct ath10k *ar = arvif->ar; 404 struct ath10k_peer *peer; 405 int first_errno = 0; 406 int ret; 407 int i; 408 u32 flags = 0; 409 410 lockdep_assert_held(&ar->conf_mutex); 411 412 spin_lock_bh(&ar->data_lock); 413 peer = ath10k_peer_find(ar, arvif->vdev_id, addr); 414 spin_unlock_bh(&ar->data_lock); 415 416 if (!peer) 417 return -ENOENT; 418 419 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 420 if (peer->keys[i] == NULL) 421 continue; 422 423 /* key flags are not required to delete the key */ 424 ret = ath10k_install_key(arvif, peer->keys[i], 425 DISABLE_KEY, addr, flags); 426 if (ret < 0 && first_errno == 0) 427 first_errno = ret; 428 429 if (ret < 0) 430 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n", 431 i, ret); 432 433 spin_lock_bh(&ar->data_lock); 434 peer->keys[i] = NULL; 435 spin_unlock_bh(&ar->data_lock); 436 } 437 438 return first_errno; 439 } 440 441 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr, 442 u8 keyidx) 443 { 444 struct ath10k_peer *peer; 445 int i; 446 447 lockdep_assert_held(&ar->data_lock); 448 449 /* We don't know which vdev this peer belongs to, 450 * since WMI doesn't give us that information. 451 * 452 * FIXME: multi-bss needs to be handled. 453 */ 454 peer = ath10k_peer_find(ar, 0, addr); 455 if (!peer) 456 return false; 457 458 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 459 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx) 460 return true; 461 } 462 463 return false; 464 } 465 466 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif, 467 struct ieee80211_key_conf *key) 468 { 469 struct ath10k *ar = arvif->ar; 470 struct ath10k_peer *peer; 471 u8 addr[ETH_ALEN]; 472 int first_errno = 0; 473 int ret; 474 int i; 475 u32 flags = 0; 476 477 lockdep_assert_held(&ar->conf_mutex); 478 479 for (;;) { 480 /* since ath10k_install_key we can't hold data_lock all the 481 * time, so we try to remove the keys incrementally 482 */ 483 spin_lock_bh(&ar->data_lock); 484 i = 0; 485 list_for_each_entry(peer, &ar->peers, list) { 486 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 487 if (peer->keys[i] == key) { 488 ether_addr_copy(addr, peer->addr); 489 peer->keys[i] = NULL; 490 break; 491 } 492 } 493 494 if (i < ARRAY_SIZE(peer->keys)) 495 break; 496 } 497 spin_unlock_bh(&ar->data_lock); 498 499 if (i == ARRAY_SIZE(peer->keys)) 500 break; 501 /* key flags are not required to delete the key */ 502 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags); 503 if (ret < 0 && first_errno == 0) 504 first_errno = ret; 505 506 if (ret) 507 ath10k_warn(ar, "failed to remove key for %pM: %d\n", 508 addr, ret); 509 } 510 511 return first_errno; 512 } 513 514 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif, 515 struct ieee80211_key_conf *key) 516 { 517 struct ath10k *ar = arvif->ar; 518 struct ath10k_peer *peer; 519 int ret; 520 521 lockdep_assert_held(&ar->conf_mutex); 522 523 list_for_each_entry(peer, &ar->peers, list) { 524 if (ether_addr_equal(peer->addr, arvif->vif->addr)) 525 continue; 526 527 if (ether_addr_equal(peer->addr, arvif->bssid)) 528 continue; 529 530 if (peer->keys[key->keyidx] == key) 531 continue; 532 533 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n", 534 arvif->vdev_id, key->keyidx); 535 536 ret = ath10k_install_peer_wep_keys(arvif, peer->addr); 537 if (ret) { 538 ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n", 539 arvif->vdev_id, peer->addr, ret); 540 return ret; 541 } 542 } 543 544 return 0; 545 } 546 547 /*********************/ 548 /* General utilities */ 549 /*********************/ 550 551 static inline enum wmi_phy_mode 552 chan_to_phymode(const struct cfg80211_chan_def *chandef) 553 { 554 enum wmi_phy_mode phymode = MODE_UNKNOWN; 555 556 switch (chandef->chan->band) { 557 case NL80211_BAND_2GHZ: 558 switch (chandef->width) { 559 case NL80211_CHAN_WIDTH_20_NOHT: 560 if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM) 561 phymode = MODE_11B; 562 else 563 phymode = MODE_11G; 564 break; 565 case NL80211_CHAN_WIDTH_20: 566 phymode = MODE_11NG_HT20; 567 break; 568 case NL80211_CHAN_WIDTH_40: 569 phymode = MODE_11NG_HT40; 570 break; 571 default: 572 phymode = MODE_UNKNOWN; 573 break; 574 } 575 break; 576 case NL80211_BAND_5GHZ: 577 switch (chandef->width) { 578 case NL80211_CHAN_WIDTH_20_NOHT: 579 phymode = MODE_11A; 580 break; 581 case NL80211_CHAN_WIDTH_20: 582 phymode = MODE_11NA_HT20; 583 break; 584 case NL80211_CHAN_WIDTH_40: 585 phymode = MODE_11NA_HT40; 586 break; 587 case NL80211_CHAN_WIDTH_80: 588 phymode = MODE_11AC_VHT80; 589 break; 590 case NL80211_CHAN_WIDTH_160: 591 phymode = MODE_11AC_VHT160; 592 break; 593 case NL80211_CHAN_WIDTH_80P80: 594 phymode = MODE_11AC_VHT80_80; 595 break; 596 default: 597 phymode = MODE_UNKNOWN; 598 break; 599 } 600 break; 601 default: 602 break; 603 } 604 605 WARN_ON(phymode == MODE_UNKNOWN); 606 return phymode; 607 } 608 609 static u8 ath10k_parse_mpdudensity(u8 mpdudensity) 610 { 611 /* 612 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing": 613 * 0 for no restriction 614 * 1 for 1/4 us 615 * 2 for 1/2 us 616 * 3 for 1 us 617 * 4 for 2 us 618 * 5 for 4 us 619 * 6 for 8 us 620 * 7 for 16 us 621 */ 622 switch (mpdudensity) { 623 case 0: 624 return 0; 625 case 1: 626 case 2: 627 case 3: 628 /* Our lower layer calculations limit our precision to 629 * 1 microsecond 630 */ 631 return 1; 632 case 4: 633 return 2; 634 case 5: 635 return 4; 636 case 6: 637 return 8; 638 case 7: 639 return 16; 640 default: 641 return 0; 642 } 643 } 644 645 int ath10k_mac_vif_chan(struct ieee80211_vif *vif, 646 struct cfg80211_chan_def *def) 647 { 648 struct ieee80211_chanctx_conf *conf; 649 650 rcu_read_lock(); 651 conf = rcu_dereference(vif->chanctx_conf); 652 if (!conf) { 653 rcu_read_unlock(); 654 return -ENOENT; 655 } 656 657 *def = conf->def; 658 rcu_read_unlock(); 659 660 return 0; 661 } 662 663 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw, 664 struct ieee80211_chanctx_conf *conf, 665 void *data) 666 { 667 int *num = data; 668 669 (*num)++; 670 } 671 672 static int ath10k_mac_num_chanctxs(struct ath10k *ar) 673 { 674 int num = 0; 675 676 ieee80211_iter_chan_contexts_atomic(ar->hw, 677 ath10k_mac_num_chanctxs_iter, 678 &num); 679 680 return num; 681 } 682 683 static void 684 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw, 685 struct ieee80211_chanctx_conf *conf, 686 void *data) 687 { 688 struct cfg80211_chan_def **def = data; 689 690 *def = &conf->def; 691 } 692 693 static void ath10k_wait_for_peer_delete_done(struct ath10k *ar, u32 vdev_id, 694 const u8 *addr) 695 { 696 unsigned long time_left; 697 int ret; 698 699 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) { 700 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr); 701 if (ret) { 702 ath10k_warn(ar, "failed wait for peer deleted"); 703 return; 704 } 705 706 time_left = wait_for_completion_timeout(&ar->peer_delete_done, 707 5 * HZ); 708 if (!time_left) 709 ath10k_warn(ar, "Timeout in receiving peer delete response\n"); 710 } 711 } 712 713 static int ath10k_peer_create(struct ath10k *ar, 714 struct ieee80211_vif *vif, 715 struct ieee80211_sta *sta, 716 u32 vdev_id, 717 const u8 *addr, 718 enum wmi_peer_type peer_type) 719 { 720 struct ath10k_vif *arvif; 721 struct ath10k_peer *peer; 722 int num_peers = 0; 723 int ret; 724 725 lockdep_assert_held(&ar->conf_mutex); 726 727 num_peers = ar->num_peers; 728 729 /* Each vdev consumes a peer entry as well */ 730 list_for_each_entry(arvif, &ar->arvifs, list) 731 num_peers++; 732 733 if (num_peers >= ar->max_num_peers) 734 return -ENOBUFS; 735 736 ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type); 737 if (ret) { 738 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n", 739 addr, vdev_id, ret); 740 return ret; 741 } 742 743 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr); 744 if (ret) { 745 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n", 746 addr, vdev_id, ret); 747 return ret; 748 } 749 750 spin_lock_bh(&ar->data_lock); 751 752 peer = ath10k_peer_find(ar, vdev_id, addr); 753 if (!peer) { 754 spin_unlock_bh(&ar->data_lock); 755 ath10k_warn(ar, "failed to find peer %pM on vdev %i after creation\n", 756 addr, vdev_id); 757 ath10k_wait_for_peer_delete_done(ar, vdev_id, addr); 758 return -ENOENT; 759 } 760 761 peer->vif = vif; 762 peer->sta = sta; 763 764 spin_unlock_bh(&ar->data_lock); 765 766 ar->num_peers++; 767 768 return 0; 769 } 770 771 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif) 772 { 773 struct ath10k *ar = arvif->ar; 774 u32 param; 775 int ret; 776 777 param = ar->wmi.pdev_param->sta_kickout_th; 778 ret = ath10k_wmi_pdev_set_param(ar, param, 779 ATH10K_KICKOUT_THRESHOLD); 780 if (ret) { 781 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n", 782 arvif->vdev_id, ret); 783 return ret; 784 } 785 786 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs; 787 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, 788 ATH10K_KEEPALIVE_MIN_IDLE); 789 if (ret) { 790 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n", 791 arvif->vdev_id, ret); 792 return ret; 793 } 794 795 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs; 796 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, 797 ATH10K_KEEPALIVE_MAX_IDLE); 798 if (ret) { 799 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n", 800 arvif->vdev_id, ret); 801 return ret; 802 } 803 804 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs; 805 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, 806 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE); 807 if (ret) { 808 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n", 809 arvif->vdev_id, ret); 810 return ret; 811 } 812 813 return 0; 814 } 815 816 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value) 817 { 818 struct ath10k *ar = arvif->ar; 819 u32 vdev_param; 820 821 vdev_param = ar->wmi.vdev_param->rts_threshold; 822 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value); 823 } 824 825 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr) 826 { 827 int ret; 828 829 lockdep_assert_held(&ar->conf_mutex); 830 831 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr); 832 if (ret) 833 return ret; 834 835 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr); 836 if (ret) 837 return ret; 838 839 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) { 840 unsigned long time_left; 841 842 time_left = wait_for_completion_timeout 843 (&ar->peer_delete_done, 5 * HZ); 844 845 if (!time_left) { 846 ath10k_warn(ar, "Timeout in receiving peer delete response\n"); 847 return -ETIMEDOUT; 848 } 849 } 850 851 ar->num_peers--; 852 853 return 0; 854 } 855 856 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id) 857 { 858 struct ath10k_peer *peer, *tmp; 859 int peer_id; 860 int i; 861 862 lockdep_assert_held(&ar->conf_mutex); 863 864 spin_lock_bh(&ar->data_lock); 865 list_for_each_entry_safe(peer, tmp, &ar->peers, list) { 866 if (peer->vdev_id != vdev_id) 867 continue; 868 869 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n", 870 peer->addr, vdev_id); 871 872 for_each_set_bit(peer_id, peer->peer_ids, 873 ATH10K_MAX_NUM_PEER_IDS) { 874 ar->peer_map[peer_id] = NULL; 875 } 876 877 /* Double check that peer is properly un-referenced from 878 * the peer_map 879 */ 880 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) { 881 if (ar->peer_map[i] == peer) { 882 ath10k_warn(ar, "removing stale peer_map entry for %pM (ptr %pK idx %d)\n", 883 peer->addr, peer, i); 884 ar->peer_map[i] = NULL; 885 } 886 } 887 888 list_del(&peer->list); 889 kfree(peer); 890 ar->num_peers--; 891 } 892 spin_unlock_bh(&ar->data_lock); 893 } 894 895 static void ath10k_peer_cleanup_all(struct ath10k *ar) 896 { 897 struct ath10k_peer *peer, *tmp; 898 int i; 899 900 lockdep_assert_held(&ar->conf_mutex); 901 902 spin_lock_bh(&ar->data_lock); 903 list_for_each_entry_safe(peer, tmp, &ar->peers, list) { 904 list_del(&peer->list); 905 kfree(peer); 906 } 907 908 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) 909 ar->peer_map[i] = NULL; 910 911 spin_unlock_bh(&ar->data_lock); 912 913 ar->num_peers = 0; 914 ar->num_stations = 0; 915 } 916 917 static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id, 918 struct ieee80211_sta *sta, 919 enum wmi_tdls_peer_state state) 920 { 921 int ret; 922 struct wmi_tdls_peer_update_cmd_arg arg = {}; 923 struct wmi_tdls_peer_capab_arg cap = {}; 924 struct wmi_channel_arg chan_arg = {}; 925 926 lockdep_assert_held(&ar->conf_mutex); 927 928 arg.vdev_id = vdev_id; 929 arg.peer_state = state; 930 ether_addr_copy(arg.addr, sta->addr); 931 932 cap.peer_max_sp = sta->max_sp; 933 cap.peer_uapsd_queues = sta->uapsd_queues; 934 935 if (state == WMI_TDLS_PEER_STATE_CONNECTED && 936 !sta->tdls_initiator) 937 cap.is_peer_responder = 1; 938 939 ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg); 940 if (ret) { 941 ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n", 942 arg.addr, vdev_id, ret); 943 return ret; 944 } 945 946 return 0; 947 } 948 949 /************************/ 950 /* Interface management */ 951 /************************/ 952 953 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif) 954 { 955 struct ath10k *ar = arvif->ar; 956 957 lockdep_assert_held(&ar->data_lock); 958 959 if (!arvif->beacon) 960 return; 961 962 if (!arvif->beacon_buf) 963 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr, 964 arvif->beacon->len, DMA_TO_DEVICE); 965 966 if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED && 967 arvif->beacon_state != ATH10K_BEACON_SENT)) 968 return; 969 970 dev_kfree_skb_any(arvif->beacon); 971 972 arvif->beacon = NULL; 973 arvif->beacon_state = ATH10K_BEACON_SCHEDULED; 974 } 975 976 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif) 977 { 978 struct ath10k *ar = arvif->ar; 979 980 lockdep_assert_held(&ar->data_lock); 981 982 ath10k_mac_vif_beacon_free(arvif); 983 984 if (arvif->beacon_buf) { 985 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN, 986 arvif->beacon_buf, arvif->beacon_paddr); 987 arvif->beacon_buf = NULL; 988 } 989 } 990 991 static inline int ath10k_vdev_setup_sync(struct ath10k *ar) 992 { 993 unsigned long time_left; 994 995 lockdep_assert_held(&ar->conf_mutex); 996 997 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags)) 998 return -ESHUTDOWN; 999 1000 time_left = wait_for_completion_timeout(&ar->vdev_setup_done, 1001 ATH10K_VDEV_SETUP_TIMEOUT_HZ); 1002 if (time_left == 0) 1003 return -ETIMEDOUT; 1004 1005 return ar->last_wmi_vdev_start_status; 1006 } 1007 1008 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id) 1009 { 1010 struct cfg80211_chan_def *chandef = NULL; 1011 struct ieee80211_channel *channel = NULL; 1012 struct wmi_vdev_start_request_arg arg = {}; 1013 int ret = 0; 1014 1015 lockdep_assert_held(&ar->conf_mutex); 1016 1017 ieee80211_iter_chan_contexts_atomic(ar->hw, 1018 ath10k_mac_get_any_chandef_iter, 1019 &chandef); 1020 if (WARN_ON_ONCE(!chandef)) 1021 return -ENOENT; 1022 1023 channel = chandef->chan; 1024 1025 arg.vdev_id = vdev_id; 1026 arg.channel.freq = channel->center_freq; 1027 arg.channel.band_center_freq1 = chandef->center_freq1; 1028 arg.channel.band_center_freq2 = chandef->center_freq2; 1029 1030 /* TODO setup this dynamically, what in case we 1031 * don't have any vifs? 1032 */ 1033 arg.channel.mode = chan_to_phymode(chandef); 1034 arg.channel.chan_radar = 1035 !!(channel->flags & IEEE80211_CHAN_RADAR); 1036 1037 arg.channel.min_power = 0; 1038 arg.channel.max_power = channel->max_power * 2; 1039 arg.channel.max_reg_power = channel->max_reg_power * 2; 1040 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2; 1041 1042 reinit_completion(&ar->vdev_setup_done); 1043 reinit_completion(&ar->vdev_delete_done); 1044 1045 ret = ath10k_wmi_vdev_start(ar, &arg); 1046 if (ret) { 1047 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n", 1048 vdev_id, ret); 1049 return ret; 1050 } 1051 1052 ret = ath10k_vdev_setup_sync(ar); 1053 if (ret) { 1054 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n", 1055 vdev_id, ret); 1056 return ret; 1057 } 1058 1059 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr); 1060 if (ret) { 1061 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n", 1062 vdev_id, ret); 1063 goto vdev_stop; 1064 } 1065 1066 ar->monitor_vdev_id = vdev_id; 1067 1068 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n", 1069 ar->monitor_vdev_id); 1070 return 0; 1071 1072 vdev_stop: 1073 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id); 1074 if (ret) 1075 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n", 1076 ar->monitor_vdev_id, ret); 1077 1078 return ret; 1079 } 1080 1081 static int ath10k_monitor_vdev_stop(struct ath10k *ar) 1082 { 1083 int ret = 0; 1084 1085 lockdep_assert_held(&ar->conf_mutex); 1086 1087 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id); 1088 if (ret) 1089 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n", 1090 ar->monitor_vdev_id, ret); 1091 1092 reinit_completion(&ar->vdev_setup_done); 1093 reinit_completion(&ar->vdev_delete_done); 1094 1095 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id); 1096 if (ret) 1097 ath10k_warn(ar, "failed to request monitor vdev %i stop: %d\n", 1098 ar->monitor_vdev_id, ret); 1099 1100 ret = ath10k_vdev_setup_sync(ar); 1101 if (ret) 1102 ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n", 1103 ar->monitor_vdev_id, ret); 1104 1105 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n", 1106 ar->monitor_vdev_id); 1107 return ret; 1108 } 1109 1110 static int ath10k_monitor_vdev_create(struct ath10k *ar) 1111 { 1112 int bit, ret = 0; 1113 1114 lockdep_assert_held(&ar->conf_mutex); 1115 1116 if (ar->free_vdev_map == 0) { 1117 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n"); 1118 return -ENOMEM; 1119 } 1120 1121 bit = __ffs64(ar->free_vdev_map); 1122 1123 ar->monitor_vdev_id = bit; 1124 1125 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id, 1126 WMI_VDEV_TYPE_MONITOR, 1127 0, ar->mac_addr); 1128 if (ret) { 1129 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n", 1130 ar->monitor_vdev_id, ret); 1131 return ret; 1132 } 1133 1134 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id); 1135 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n", 1136 ar->monitor_vdev_id); 1137 1138 return 0; 1139 } 1140 1141 static int ath10k_monitor_vdev_delete(struct ath10k *ar) 1142 { 1143 int ret = 0; 1144 1145 lockdep_assert_held(&ar->conf_mutex); 1146 1147 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id); 1148 if (ret) { 1149 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n", 1150 ar->monitor_vdev_id, ret); 1151 return ret; 1152 } 1153 1154 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id; 1155 1156 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n", 1157 ar->monitor_vdev_id); 1158 return ret; 1159 } 1160 1161 static int ath10k_monitor_start(struct ath10k *ar) 1162 { 1163 int ret; 1164 1165 lockdep_assert_held(&ar->conf_mutex); 1166 1167 ret = ath10k_monitor_vdev_create(ar); 1168 if (ret) { 1169 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret); 1170 return ret; 1171 } 1172 1173 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id); 1174 if (ret) { 1175 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret); 1176 ath10k_monitor_vdev_delete(ar); 1177 return ret; 1178 } 1179 1180 ar->monitor_started = true; 1181 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n"); 1182 1183 return 0; 1184 } 1185 1186 static int ath10k_monitor_stop(struct ath10k *ar) 1187 { 1188 int ret; 1189 1190 lockdep_assert_held(&ar->conf_mutex); 1191 1192 ret = ath10k_monitor_vdev_stop(ar); 1193 if (ret) { 1194 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret); 1195 return ret; 1196 } 1197 1198 ret = ath10k_monitor_vdev_delete(ar); 1199 if (ret) { 1200 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret); 1201 return ret; 1202 } 1203 1204 ar->monitor_started = false; 1205 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n"); 1206 1207 return 0; 1208 } 1209 1210 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar) 1211 { 1212 int num_ctx; 1213 1214 /* At least one chanctx is required to derive a channel to start 1215 * monitor vdev on. 1216 */ 1217 num_ctx = ath10k_mac_num_chanctxs(ar); 1218 if (num_ctx == 0) 1219 return false; 1220 1221 /* If there's already an existing special monitor interface then don't 1222 * bother creating another monitor vdev. 1223 */ 1224 if (ar->monitor_arvif) 1225 return false; 1226 1227 return ar->monitor || 1228 (!test_bit(ATH10K_FW_FEATURE_ALLOWS_MESH_BCAST, 1229 ar->running_fw->fw_file.fw_features) && 1230 (ar->filter_flags & FIF_OTHER_BSS)) || 1231 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 1232 } 1233 1234 static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k *ar) 1235 { 1236 int num_ctx; 1237 1238 num_ctx = ath10k_mac_num_chanctxs(ar); 1239 1240 /* FIXME: Current interface combinations and cfg80211/mac80211 code 1241 * shouldn't allow this but make sure to prevent handling the following 1242 * case anyway since multi-channel DFS hasn't been tested at all. 1243 */ 1244 if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags) && num_ctx > 1) 1245 return false; 1246 1247 return true; 1248 } 1249 1250 static int ath10k_monitor_recalc(struct ath10k *ar) 1251 { 1252 bool needed; 1253 bool allowed; 1254 int ret; 1255 1256 lockdep_assert_held(&ar->conf_mutex); 1257 1258 needed = ath10k_mac_monitor_vdev_is_needed(ar); 1259 allowed = ath10k_mac_monitor_vdev_is_allowed(ar); 1260 1261 ath10k_dbg(ar, ATH10K_DBG_MAC, 1262 "mac monitor recalc started? %d needed? %d allowed? %d\n", 1263 ar->monitor_started, needed, allowed); 1264 1265 if (WARN_ON(needed && !allowed)) { 1266 if (ar->monitor_started) { 1267 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopping disallowed monitor\n"); 1268 1269 ret = ath10k_monitor_stop(ar); 1270 if (ret) 1271 ath10k_warn(ar, "failed to stop disallowed monitor: %d\n", 1272 ret); 1273 /* not serious */ 1274 } 1275 1276 return -EPERM; 1277 } 1278 1279 if (needed == ar->monitor_started) 1280 return 0; 1281 1282 if (needed) 1283 return ath10k_monitor_start(ar); 1284 else 1285 return ath10k_monitor_stop(ar); 1286 } 1287 1288 static bool ath10k_mac_can_set_cts_prot(struct ath10k_vif *arvif) 1289 { 1290 struct ath10k *ar = arvif->ar; 1291 1292 lockdep_assert_held(&ar->conf_mutex); 1293 1294 if (!arvif->is_started) { 1295 ath10k_dbg(ar, ATH10K_DBG_MAC, "defer cts setup, vdev is not ready yet\n"); 1296 return false; 1297 } 1298 1299 return true; 1300 } 1301 1302 static int ath10k_mac_set_cts_prot(struct ath10k_vif *arvif) 1303 { 1304 struct ath10k *ar = arvif->ar; 1305 u32 vdev_param; 1306 1307 lockdep_assert_held(&ar->conf_mutex); 1308 1309 vdev_param = ar->wmi.vdev_param->protection_mode; 1310 1311 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_protection %d\n", 1312 arvif->vdev_id, arvif->use_cts_prot); 1313 1314 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 1315 arvif->use_cts_prot ? 1 : 0); 1316 } 1317 1318 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif) 1319 { 1320 struct ath10k *ar = arvif->ar; 1321 u32 vdev_param, rts_cts = 0; 1322 1323 lockdep_assert_held(&ar->conf_mutex); 1324 1325 vdev_param = ar->wmi.vdev_param->enable_rtscts; 1326 1327 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET); 1328 1329 if (arvif->num_legacy_stations > 0) 1330 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES, 1331 WMI_RTSCTS_PROFILE); 1332 else 1333 rts_cts |= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES, 1334 WMI_RTSCTS_PROFILE); 1335 1336 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d recalc rts/cts prot %d\n", 1337 arvif->vdev_id, rts_cts); 1338 1339 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 1340 rts_cts); 1341 } 1342 1343 static int ath10k_start_cac(struct ath10k *ar) 1344 { 1345 int ret; 1346 1347 lockdep_assert_held(&ar->conf_mutex); 1348 1349 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 1350 1351 ret = ath10k_monitor_recalc(ar); 1352 if (ret) { 1353 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret); 1354 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 1355 return ret; 1356 } 1357 1358 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n", 1359 ar->monitor_vdev_id); 1360 1361 return 0; 1362 } 1363 1364 static int ath10k_stop_cac(struct ath10k *ar) 1365 { 1366 lockdep_assert_held(&ar->conf_mutex); 1367 1368 /* CAC is not running - do nothing */ 1369 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags)) 1370 return 0; 1371 1372 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 1373 ath10k_monitor_stop(ar); 1374 1375 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n"); 1376 1377 return 0; 1378 } 1379 1380 static void ath10k_mac_has_radar_iter(struct ieee80211_hw *hw, 1381 struct ieee80211_chanctx_conf *conf, 1382 void *data) 1383 { 1384 bool *ret = data; 1385 1386 if (!*ret && conf->radar_enabled) 1387 *ret = true; 1388 } 1389 1390 static bool ath10k_mac_has_radar_enabled(struct ath10k *ar) 1391 { 1392 bool has_radar = false; 1393 1394 ieee80211_iter_chan_contexts_atomic(ar->hw, 1395 ath10k_mac_has_radar_iter, 1396 &has_radar); 1397 1398 return has_radar; 1399 } 1400 1401 static void ath10k_recalc_radar_detection(struct ath10k *ar) 1402 { 1403 int ret; 1404 1405 lockdep_assert_held(&ar->conf_mutex); 1406 1407 ath10k_stop_cac(ar); 1408 1409 if (!ath10k_mac_has_radar_enabled(ar)) 1410 return; 1411 1412 if (ar->num_started_vdevs > 0) 1413 return; 1414 1415 ret = ath10k_start_cac(ar); 1416 if (ret) { 1417 /* 1418 * Not possible to start CAC on current channel so starting 1419 * radiation is not allowed, make this channel DFS_UNAVAILABLE 1420 * by indicating that radar was detected. 1421 */ 1422 ath10k_warn(ar, "failed to start CAC: %d\n", ret); 1423 ieee80211_radar_detected(ar->hw); 1424 } 1425 } 1426 1427 static int ath10k_vdev_stop(struct ath10k_vif *arvif) 1428 { 1429 struct ath10k *ar = arvif->ar; 1430 int ret; 1431 1432 lockdep_assert_held(&ar->conf_mutex); 1433 1434 reinit_completion(&ar->vdev_setup_done); 1435 reinit_completion(&ar->vdev_delete_done); 1436 1437 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id); 1438 if (ret) { 1439 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n", 1440 arvif->vdev_id, ret); 1441 return ret; 1442 } 1443 1444 ret = ath10k_vdev_setup_sync(ar); 1445 if (ret) { 1446 ath10k_warn(ar, "failed to synchronize setup for vdev %i: %d\n", 1447 arvif->vdev_id, ret); 1448 return ret; 1449 } 1450 1451 WARN_ON(ar->num_started_vdevs == 0); 1452 1453 if (ar->num_started_vdevs != 0) { 1454 ar->num_started_vdevs--; 1455 ath10k_recalc_radar_detection(ar); 1456 } 1457 1458 return ret; 1459 } 1460 1461 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif, 1462 const struct cfg80211_chan_def *chandef, 1463 bool restart) 1464 { 1465 struct ath10k *ar = arvif->ar; 1466 struct wmi_vdev_start_request_arg arg = {}; 1467 int ret = 0; 1468 1469 lockdep_assert_held(&ar->conf_mutex); 1470 1471 reinit_completion(&ar->vdev_setup_done); 1472 reinit_completion(&ar->vdev_delete_done); 1473 1474 arg.vdev_id = arvif->vdev_id; 1475 arg.dtim_period = arvif->dtim_period; 1476 arg.bcn_intval = arvif->beacon_interval; 1477 1478 arg.channel.freq = chandef->chan->center_freq; 1479 arg.channel.band_center_freq1 = chandef->center_freq1; 1480 arg.channel.band_center_freq2 = chandef->center_freq2; 1481 arg.channel.mode = chan_to_phymode(chandef); 1482 1483 arg.channel.min_power = 0; 1484 arg.channel.max_power = chandef->chan->max_power * 2; 1485 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2; 1486 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2; 1487 1488 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 1489 arg.ssid = arvif->u.ap.ssid; 1490 arg.ssid_len = arvif->u.ap.ssid_len; 1491 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 1492 1493 /* For now allow DFS for AP mode */ 1494 arg.channel.chan_radar = 1495 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR); 1496 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 1497 arg.ssid = arvif->vif->bss_conf.ssid; 1498 arg.ssid_len = arvif->vif->bss_conf.ssid_len; 1499 } 1500 1501 ath10k_dbg(ar, ATH10K_DBG_MAC, 1502 "mac vdev %d start center_freq %d phymode %s\n", 1503 arg.vdev_id, arg.channel.freq, 1504 ath10k_wmi_phymode_str(arg.channel.mode)); 1505 1506 if (restart) 1507 ret = ath10k_wmi_vdev_restart(ar, &arg); 1508 else 1509 ret = ath10k_wmi_vdev_start(ar, &arg); 1510 1511 if (ret) { 1512 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n", 1513 arg.vdev_id, ret); 1514 return ret; 1515 } 1516 1517 ret = ath10k_vdev_setup_sync(ar); 1518 if (ret) { 1519 ath10k_warn(ar, 1520 "failed to synchronize setup for vdev %i restart %d: %d\n", 1521 arg.vdev_id, restart, ret); 1522 return ret; 1523 } 1524 1525 ar->num_started_vdevs++; 1526 ath10k_recalc_radar_detection(ar); 1527 1528 return ret; 1529 } 1530 1531 static int ath10k_vdev_start(struct ath10k_vif *arvif, 1532 const struct cfg80211_chan_def *def) 1533 { 1534 return ath10k_vdev_start_restart(arvif, def, false); 1535 } 1536 1537 static int ath10k_vdev_restart(struct ath10k_vif *arvif, 1538 const struct cfg80211_chan_def *def) 1539 { 1540 return ath10k_vdev_start_restart(arvif, def, true); 1541 } 1542 1543 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif, 1544 struct sk_buff *bcn) 1545 { 1546 struct ath10k *ar = arvif->ar; 1547 struct ieee80211_mgmt *mgmt; 1548 const u8 *p2p_ie; 1549 int ret; 1550 1551 if (arvif->vif->type != NL80211_IFTYPE_AP || !arvif->vif->p2p) 1552 return 0; 1553 1554 mgmt = (void *)bcn->data; 1555 p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P, 1556 mgmt->u.beacon.variable, 1557 bcn->len - (mgmt->u.beacon.variable - 1558 bcn->data)); 1559 if (!p2p_ie) 1560 return -ENOENT; 1561 1562 ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie); 1563 if (ret) { 1564 ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n", 1565 arvif->vdev_id, ret); 1566 return ret; 1567 } 1568 1569 return 0; 1570 } 1571 1572 static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui, 1573 u8 oui_type, size_t ie_offset) 1574 { 1575 size_t len; 1576 const u8 *next; 1577 const u8 *end; 1578 u8 *ie; 1579 1580 if (WARN_ON(skb->len < ie_offset)) 1581 return -EINVAL; 1582 1583 ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type, 1584 skb->data + ie_offset, 1585 skb->len - ie_offset); 1586 if (!ie) 1587 return -ENOENT; 1588 1589 len = ie[1] + 2; 1590 end = skb->data + skb->len; 1591 next = ie + len; 1592 1593 if (WARN_ON(next > end)) 1594 return -EINVAL; 1595 1596 memmove(ie, next, end - next); 1597 skb_trim(skb, skb->len - len); 1598 1599 return 0; 1600 } 1601 1602 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif) 1603 { 1604 struct ath10k *ar = arvif->ar; 1605 struct ieee80211_hw *hw = ar->hw; 1606 struct ieee80211_vif *vif = arvif->vif; 1607 struct ieee80211_mutable_offsets offs = {}; 1608 struct sk_buff *bcn; 1609 int ret; 1610 1611 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) 1612 return 0; 1613 1614 if (arvif->vdev_type != WMI_VDEV_TYPE_AP && 1615 arvif->vdev_type != WMI_VDEV_TYPE_IBSS) 1616 return 0; 1617 1618 bcn = ieee80211_beacon_get_template(hw, vif, &offs); 1619 if (!bcn) { 1620 ath10k_warn(ar, "failed to get beacon template from mac80211\n"); 1621 return -EPERM; 1622 } 1623 1624 ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn); 1625 if (ret) { 1626 ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret); 1627 kfree_skb(bcn); 1628 return ret; 1629 } 1630 1631 /* P2P IE is inserted by firmware automatically (as configured above) 1632 * so remove it from the base beacon template to avoid duplicate P2P 1633 * IEs in beacon frames. 1634 */ 1635 ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P, 1636 offsetof(struct ieee80211_mgmt, 1637 u.beacon.variable)); 1638 1639 ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0, 1640 0, NULL, 0); 1641 kfree_skb(bcn); 1642 1643 if (ret) { 1644 ath10k_warn(ar, "failed to submit beacon template command: %d\n", 1645 ret); 1646 return ret; 1647 } 1648 1649 return 0; 1650 } 1651 1652 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif) 1653 { 1654 struct ath10k *ar = arvif->ar; 1655 struct ieee80211_hw *hw = ar->hw; 1656 struct ieee80211_vif *vif = arvif->vif; 1657 struct sk_buff *prb; 1658 int ret; 1659 1660 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) 1661 return 0; 1662 1663 if (arvif->vdev_type != WMI_VDEV_TYPE_AP) 1664 return 0; 1665 1666 /* For mesh, probe response and beacon share the same template */ 1667 if (ieee80211_vif_is_mesh(vif)) 1668 return 0; 1669 1670 prb = ieee80211_proberesp_get(hw, vif); 1671 if (!prb) { 1672 ath10k_warn(ar, "failed to get probe resp template from mac80211\n"); 1673 return -EPERM; 1674 } 1675 1676 ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb); 1677 kfree_skb(prb); 1678 1679 if (ret) { 1680 ath10k_warn(ar, "failed to submit probe resp template command: %d\n", 1681 ret); 1682 return ret; 1683 } 1684 1685 return 0; 1686 } 1687 1688 static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif *arvif) 1689 { 1690 struct ath10k *ar = arvif->ar; 1691 struct cfg80211_chan_def def; 1692 int ret; 1693 1694 /* When originally vdev is started during assign_vif_chanctx() some 1695 * information is missing, notably SSID. Firmware revisions with beacon 1696 * offloading require the SSID to be provided during vdev (re)start to 1697 * handle hidden SSID properly. 1698 * 1699 * Vdev restart must be done after vdev has been both started and 1700 * upped. Otherwise some firmware revisions (at least 10.2) fail to 1701 * deliver vdev restart response event causing timeouts during vdev 1702 * syncing in ath10k. 1703 * 1704 * Note: The vdev down/up and template reinstallation could be skipped 1705 * since only wmi-tlv firmware are known to have beacon offload and 1706 * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart 1707 * response delivery. It's probably more robust to keep it as is. 1708 */ 1709 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) 1710 return 0; 1711 1712 if (WARN_ON(!arvif->is_started)) 1713 return -EINVAL; 1714 1715 if (WARN_ON(!arvif->is_up)) 1716 return -EINVAL; 1717 1718 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def))) 1719 return -EINVAL; 1720 1721 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 1722 if (ret) { 1723 ath10k_warn(ar, "failed to bring down ap vdev %i: %d\n", 1724 arvif->vdev_id, ret); 1725 return ret; 1726 } 1727 1728 /* Vdev down reset beacon & presp templates. Reinstall them. Otherwise 1729 * firmware will crash upon vdev up. 1730 */ 1731 1732 ret = ath10k_mac_setup_bcn_tmpl(arvif); 1733 if (ret) { 1734 ath10k_warn(ar, "failed to update beacon template: %d\n", ret); 1735 return ret; 1736 } 1737 1738 ret = ath10k_mac_setup_prb_tmpl(arvif); 1739 if (ret) { 1740 ath10k_warn(ar, "failed to update presp template: %d\n", ret); 1741 return ret; 1742 } 1743 1744 ret = ath10k_vdev_restart(arvif, &def); 1745 if (ret) { 1746 ath10k_warn(ar, "failed to restart ap vdev %i: %d\n", 1747 arvif->vdev_id, ret); 1748 return ret; 1749 } 1750 1751 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 1752 arvif->bssid); 1753 if (ret) { 1754 ath10k_warn(ar, "failed to bring up ap vdev %i: %d\n", 1755 arvif->vdev_id, ret); 1756 return ret; 1757 } 1758 1759 return 0; 1760 } 1761 1762 static void ath10k_control_beaconing(struct ath10k_vif *arvif, 1763 struct ieee80211_bss_conf *info) 1764 { 1765 struct ath10k *ar = arvif->ar; 1766 int ret = 0; 1767 1768 lockdep_assert_held(&arvif->ar->conf_mutex); 1769 1770 if (!info->enable_beacon) { 1771 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 1772 if (ret) 1773 ath10k_warn(ar, "failed to down vdev_id %i: %d\n", 1774 arvif->vdev_id, ret); 1775 1776 arvif->is_up = false; 1777 1778 spin_lock_bh(&arvif->ar->data_lock); 1779 ath10k_mac_vif_beacon_free(arvif); 1780 spin_unlock_bh(&arvif->ar->data_lock); 1781 1782 return; 1783 } 1784 1785 arvif->tx_seq_no = 0x1000; 1786 1787 arvif->aid = 0; 1788 ether_addr_copy(arvif->bssid, info->bssid); 1789 1790 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 1791 arvif->bssid); 1792 if (ret) { 1793 ath10k_warn(ar, "failed to bring up vdev %d: %i\n", 1794 arvif->vdev_id, ret); 1795 return; 1796 } 1797 1798 arvif->is_up = true; 1799 1800 ret = ath10k_mac_vif_fix_hidden_ssid(arvif); 1801 if (ret) { 1802 ath10k_warn(ar, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n", 1803 arvif->vdev_id, ret); 1804 return; 1805 } 1806 1807 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id); 1808 } 1809 1810 static void ath10k_control_ibss(struct ath10k_vif *arvif, 1811 struct ieee80211_bss_conf *info, 1812 const u8 self_peer[ETH_ALEN]) 1813 { 1814 struct ath10k *ar = arvif->ar; 1815 u32 vdev_param; 1816 int ret = 0; 1817 1818 lockdep_assert_held(&arvif->ar->conf_mutex); 1819 1820 if (!info->ibss_joined) { 1821 if (is_zero_ether_addr(arvif->bssid)) 1822 return; 1823 1824 eth_zero_addr(arvif->bssid); 1825 1826 return; 1827 } 1828 1829 vdev_param = arvif->ar->wmi.vdev_param->atim_window; 1830 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param, 1831 ATH10K_DEFAULT_ATIM); 1832 if (ret) 1833 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n", 1834 arvif->vdev_id, ret); 1835 } 1836 1837 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif) 1838 { 1839 struct ath10k *ar = arvif->ar; 1840 u32 param; 1841 u32 value; 1842 int ret; 1843 1844 lockdep_assert_held(&arvif->ar->conf_mutex); 1845 1846 if (arvif->u.sta.uapsd) 1847 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER; 1848 else 1849 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 1850 1851 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 1852 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value); 1853 if (ret) { 1854 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n", 1855 value, arvif->vdev_id, ret); 1856 return ret; 1857 } 1858 1859 return 0; 1860 } 1861 1862 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif) 1863 { 1864 struct ath10k *ar = arvif->ar; 1865 u32 param; 1866 u32 value; 1867 int ret; 1868 1869 lockdep_assert_held(&arvif->ar->conf_mutex); 1870 1871 if (arvif->u.sta.uapsd) 1872 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD; 1873 else 1874 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 1875 1876 param = WMI_STA_PS_PARAM_PSPOLL_COUNT; 1877 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 1878 param, value); 1879 if (ret) { 1880 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n", 1881 value, arvif->vdev_id, ret); 1882 return ret; 1883 } 1884 1885 return 0; 1886 } 1887 1888 static int ath10k_mac_num_vifs_started(struct ath10k *ar) 1889 { 1890 struct ath10k_vif *arvif; 1891 int num = 0; 1892 1893 lockdep_assert_held(&ar->conf_mutex); 1894 1895 list_for_each_entry(arvif, &ar->arvifs, list) 1896 if (arvif->is_started) 1897 num++; 1898 1899 return num; 1900 } 1901 1902 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif) 1903 { 1904 struct ath10k *ar = arvif->ar; 1905 struct ieee80211_vif *vif = arvif->vif; 1906 struct ieee80211_conf *conf = &ar->hw->conf; 1907 enum wmi_sta_powersave_param param; 1908 enum wmi_sta_ps_mode psmode; 1909 int ret; 1910 int ps_timeout; 1911 bool enable_ps; 1912 1913 lockdep_assert_held(&arvif->ar->conf_mutex); 1914 1915 if (arvif->vif->type != NL80211_IFTYPE_STATION) 1916 return 0; 1917 1918 enable_ps = arvif->ps; 1919 1920 if (enable_ps && ath10k_mac_num_vifs_started(ar) > 1 && 1921 !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT, 1922 ar->running_fw->fw_file.fw_features)) { 1923 ath10k_warn(ar, "refusing to enable ps on vdev %i: not supported by fw\n", 1924 arvif->vdev_id); 1925 enable_ps = false; 1926 } 1927 1928 if (!arvif->is_started) { 1929 /* mac80211 can update vif powersave state while disconnected. 1930 * Firmware doesn't behave nicely and consumes more power than 1931 * necessary if PS is disabled on a non-started vdev. Hence 1932 * force-enable PS for non-running vdevs. 1933 */ 1934 psmode = WMI_STA_PS_MODE_ENABLED; 1935 } else if (enable_ps) { 1936 psmode = WMI_STA_PS_MODE_ENABLED; 1937 param = WMI_STA_PS_PARAM_INACTIVITY_TIME; 1938 1939 ps_timeout = conf->dynamic_ps_timeout; 1940 if (ps_timeout == 0) { 1941 /* Firmware doesn't like 0 */ 1942 ps_timeout = ieee80211_tu_to_usec( 1943 vif->bss_conf.beacon_int) / 1000; 1944 } 1945 1946 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, 1947 ps_timeout); 1948 if (ret) { 1949 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n", 1950 arvif->vdev_id, ret); 1951 return ret; 1952 } 1953 } else { 1954 psmode = WMI_STA_PS_MODE_DISABLED; 1955 } 1956 1957 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n", 1958 arvif->vdev_id, psmode ? "enable" : "disable"); 1959 1960 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode); 1961 if (ret) { 1962 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n", 1963 psmode, arvif->vdev_id, ret); 1964 return ret; 1965 } 1966 1967 return 0; 1968 } 1969 1970 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif) 1971 { 1972 struct ath10k *ar = arvif->ar; 1973 struct wmi_sta_keepalive_arg arg = {}; 1974 int ret; 1975 1976 lockdep_assert_held(&arvif->ar->conf_mutex); 1977 1978 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 1979 return 0; 1980 1981 if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map)) 1982 return 0; 1983 1984 /* Some firmware revisions have a bug and ignore the `enabled` field. 1985 * Instead use the interval to disable the keepalive. 1986 */ 1987 arg.vdev_id = arvif->vdev_id; 1988 arg.enabled = 1; 1989 arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME; 1990 arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE; 1991 1992 ret = ath10k_wmi_sta_keepalive(ar, &arg); 1993 if (ret) { 1994 ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n", 1995 arvif->vdev_id, ret); 1996 return ret; 1997 } 1998 1999 return 0; 2000 } 2001 2002 static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif *arvif) 2003 { 2004 struct ath10k *ar = arvif->ar; 2005 struct ieee80211_vif *vif = arvif->vif; 2006 int ret; 2007 2008 lockdep_assert_held(&arvif->ar->conf_mutex); 2009 2010 if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))) 2011 return; 2012 2013 if (arvif->vdev_type != WMI_VDEV_TYPE_AP) 2014 return; 2015 2016 if (!vif->csa_active) 2017 return; 2018 2019 if (!arvif->is_up) 2020 return; 2021 2022 if (!ieee80211_beacon_cntdwn_is_complete(vif)) { 2023 ieee80211_beacon_update_cntdwn(vif); 2024 2025 ret = ath10k_mac_setup_bcn_tmpl(arvif); 2026 if (ret) 2027 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n", 2028 ret); 2029 2030 ret = ath10k_mac_setup_prb_tmpl(arvif); 2031 if (ret) 2032 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n", 2033 ret); 2034 } else { 2035 ieee80211_csa_finish(vif); 2036 } 2037 } 2038 2039 static void ath10k_mac_vif_ap_csa_work(struct work_struct *work) 2040 { 2041 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif, 2042 ap_csa_work); 2043 struct ath10k *ar = arvif->ar; 2044 2045 mutex_lock(&ar->conf_mutex); 2046 ath10k_mac_vif_ap_csa_count_down(arvif); 2047 mutex_unlock(&ar->conf_mutex); 2048 } 2049 2050 static void ath10k_mac_handle_beacon_iter(void *data, u8 *mac, 2051 struct ieee80211_vif *vif) 2052 { 2053 struct sk_buff *skb = data; 2054 struct ieee80211_mgmt *mgmt = (void *)skb->data; 2055 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2056 2057 if (vif->type != NL80211_IFTYPE_STATION) 2058 return; 2059 2060 if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid)) 2061 return; 2062 2063 cancel_delayed_work(&arvif->connection_loss_work); 2064 } 2065 2066 void ath10k_mac_handle_beacon(struct ath10k *ar, struct sk_buff *skb) 2067 { 2068 ieee80211_iterate_active_interfaces_atomic(ar->hw, 2069 ATH10K_ITER_NORMAL_FLAGS, 2070 ath10k_mac_handle_beacon_iter, 2071 skb); 2072 } 2073 2074 static void ath10k_mac_handle_beacon_miss_iter(void *data, u8 *mac, 2075 struct ieee80211_vif *vif) 2076 { 2077 u32 *vdev_id = data; 2078 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2079 struct ath10k *ar = arvif->ar; 2080 struct ieee80211_hw *hw = ar->hw; 2081 2082 if (arvif->vdev_id != *vdev_id) 2083 return; 2084 2085 if (!arvif->is_up) 2086 return; 2087 2088 ieee80211_beacon_loss(vif); 2089 2090 /* Firmware doesn't report beacon loss events repeatedly. If AP probe 2091 * (done by mac80211) succeeds but beacons do not resume then it 2092 * doesn't make sense to continue operation. Queue connection loss work 2093 * which can be cancelled when beacon is received. 2094 */ 2095 ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work, 2096 ATH10K_CONNECTION_LOSS_HZ); 2097 } 2098 2099 void ath10k_mac_handle_beacon_miss(struct ath10k *ar, u32 vdev_id) 2100 { 2101 ieee80211_iterate_active_interfaces_atomic(ar->hw, 2102 ATH10K_ITER_NORMAL_FLAGS, 2103 ath10k_mac_handle_beacon_miss_iter, 2104 &vdev_id); 2105 } 2106 2107 static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct *work) 2108 { 2109 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif, 2110 connection_loss_work.work); 2111 struct ieee80211_vif *vif = arvif->vif; 2112 2113 if (!arvif->is_up) 2114 return; 2115 2116 ieee80211_connection_loss(vif); 2117 } 2118 2119 /**********************/ 2120 /* Station management */ 2121 /**********************/ 2122 2123 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar, 2124 struct ieee80211_vif *vif) 2125 { 2126 /* Some firmware revisions have unstable STA powersave when listen 2127 * interval is set too high (e.g. 5). The symptoms are firmware doesn't 2128 * generate NullFunc frames properly even if buffered frames have been 2129 * indicated in Beacon TIM. Firmware would seldom wake up to pull 2130 * buffered frames. Often pinging the device from AP would simply fail. 2131 * 2132 * As a workaround set it to 1. 2133 */ 2134 if (vif->type == NL80211_IFTYPE_STATION) 2135 return 1; 2136 2137 return ar->hw->conf.listen_interval; 2138 } 2139 2140 static void ath10k_peer_assoc_h_basic(struct ath10k *ar, 2141 struct ieee80211_vif *vif, 2142 struct ieee80211_sta *sta, 2143 struct wmi_peer_assoc_complete_arg *arg) 2144 { 2145 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2146 u32 aid; 2147 2148 lockdep_assert_held(&ar->conf_mutex); 2149 2150 if (vif->type == NL80211_IFTYPE_STATION) 2151 aid = vif->bss_conf.aid; 2152 else 2153 aid = sta->aid; 2154 2155 ether_addr_copy(arg->addr, sta->addr); 2156 arg->vdev_id = arvif->vdev_id; 2157 arg->peer_aid = aid; 2158 arg->peer_flags |= arvif->ar->wmi.peer_flags->auth; 2159 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif); 2160 arg->peer_num_spatial_streams = 1; 2161 arg->peer_caps = vif->bss_conf.assoc_capability; 2162 } 2163 2164 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar, 2165 struct ieee80211_vif *vif, 2166 struct ieee80211_sta *sta, 2167 struct wmi_peer_assoc_complete_arg *arg) 2168 { 2169 struct ieee80211_bss_conf *info = &vif->bss_conf; 2170 struct cfg80211_chan_def def; 2171 struct cfg80211_bss *bss; 2172 const u8 *rsnie = NULL; 2173 const u8 *wpaie = NULL; 2174 2175 lockdep_assert_held(&ar->conf_mutex); 2176 2177 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 2178 return; 2179 2180 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0, 2181 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY); 2182 if (bss) { 2183 const struct cfg80211_bss_ies *ies; 2184 2185 rcu_read_lock(); 2186 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN); 2187 2188 ies = rcu_dereference(bss->ies); 2189 2190 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, 2191 WLAN_OUI_TYPE_MICROSOFT_WPA, 2192 ies->data, 2193 ies->len); 2194 rcu_read_unlock(); 2195 cfg80211_put_bss(ar->hw->wiphy, bss); 2196 } 2197 2198 /* FIXME: base on RSN IE/WPA IE is a correct idea? */ 2199 if (rsnie || wpaie) { 2200 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__); 2201 arg->peer_flags |= ar->wmi.peer_flags->need_ptk_4_way; 2202 } 2203 2204 if (wpaie) { 2205 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__); 2206 arg->peer_flags |= ar->wmi.peer_flags->need_gtk_2_way; 2207 } 2208 2209 if (sta->mfp && 2210 test_bit(ATH10K_FW_FEATURE_MFP_SUPPORT, 2211 ar->running_fw->fw_file.fw_features)) { 2212 arg->peer_flags |= ar->wmi.peer_flags->pmf; 2213 } 2214 } 2215 2216 static void ath10k_peer_assoc_h_rates(struct ath10k *ar, 2217 struct ieee80211_vif *vif, 2218 struct ieee80211_sta *sta, 2219 struct wmi_peer_assoc_complete_arg *arg) 2220 { 2221 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2222 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates; 2223 struct cfg80211_chan_def def; 2224 const struct ieee80211_supported_band *sband; 2225 const struct ieee80211_rate *rates; 2226 enum nl80211_band band; 2227 u32 ratemask; 2228 u8 rate; 2229 int i; 2230 2231 lockdep_assert_held(&ar->conf_mutex); 2232 2233 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 2234 return; 2235 2236 band = def.chan->band; 2237 sband = ar->hw->wiphy->bands[band]; 2238 ratemask = sta->supp_rates[band]; 2239 ratemask &= arvif->bitrate_mask.control[band].legacy; 2240 rates = sband->bitrates; 2241 2242 rateset->num_rates = 0; 2243 2244 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) { 2245 if (!(ratemask & 1)) 2246 continue; 2247 2248 rate = ath10k_mac_bitrate_to_rate(rates->bitrate); 2249 rateset->rates[rateset->num_rates] = rate; 2250 rateset->num_rates++; 2251 } 2252 } 2253 2254 static bool 2255 ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN]) 2256 { 2257 int nss; 2258 2259 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++) 2260 if (ht_mcs_mask[nss]) 2261 return false; 2262 2263 return true; 2264 } 2265 2266 static bool 2267 ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX]) 2268 { 2269 int nss; 2270 2271 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) 2272 if (vht_mcs_mask[nss]) 2273 return false; 2274 2275 return true; 2276 } 2277 2278 static void ath10k_peer_assoc_h_ht(struct ath10k *ar, 2279 struct ieee80211_vif *vif, 2280 struct ieee80211_sta *sta, 2281 struct wmi_peer_assoc_complete_arg *arg) 2282 { 2283 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap; 2284 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2285 struct cfg80211_chan_def def; 2286 enum nl80211_band band; 2287 const u8 *ht_mcs_mask; 2288 const u16 *vht_mcs_mask; 2289 int i, n; 2290 u8 max_nss; 2291 u32 stbc; 2292 2293 lockdep_assert_held(&ar->conf_mutex); 2294 2295 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 2296 return; 2297 2298 if (!ht_cap->ht_supported) 2299 return; 2300 2301 band = def.chan->band; 2302 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 2303 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 2304 2305 if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask) && 2306 ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) 2307 return; 2308 2309 arg->peer_flags |= ar->wmi.peer_flags->ht; 2310 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + 2311 ht_cap->ampdu_factor)) - 1; 2312 2313 arg->peer_mpdu_density = 2314 ath10k_parse_mpdudensity(ht_cap->ampdu_density); 2315 2316 arg->peer_ht_caps = ht_cap->cap; 2317 arg->peer_rate_caps |= WMI_RC_HT_FLAG; 2318 2319 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING) 2320 arg->peer_flags |= ar->wmi.peer_flags->ldbc; 2321 2322 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) { 2323 arg->peer_flags |= ar->wmi.peer_flags->bw40; 2324 arg->peer_rate_caps |= WMI_RC_CW40_FLAG; 2325 } 2326 2327 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) { 2328 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20) 2329 arg->peer_rate_caps |= WMI_RC_SGI_FLAG; 2330 2331 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40) 2332 arg->peer_rate_caps |= WMI_RC_SGI_FLAG; 2333 } 2334 2335 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) { 2336 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG; 2337 arg->peer_flags |= ar->wmi.peer_flags->stbc; 2338 } 2339 2340 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) { 2341 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC; 2342 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT; 2343 stbc = stbc << WMI_RC_RX_STBC_FLAG_S; 2344 arg->peer_rate_caps |= stbc; 2345 arg->peer_flags |= ar->wmi.peer_flags->stbc; 2346 } 2347 2348 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2]) 2349 arg->peer_rate_caps |= WMI_RC_TS_FLAG; 2350 else if (ht_cap->mcs.rx_mask[1]) 2351 arg->peer_rate_caps |= WMI_RC_DS_FLAG; 2352 2353 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++) 2354 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) && 2355 (ht_mcs_mask[i / 8] & BIT(i % 8))) { 2356 max_nss = (i / 8) + 1; 2357 arg->peer_ht_rates.rates[n++] = i; 2358 } 2359 2360 /* 2361 * This is a workaround for HT-enabled STAs which break the spec 2362 * and have no HT capabilities RX mask (no HT RX MCS map). 2363 * 2364 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS), 2365 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs. 2366 * 2367 * Firmware asserts if such situation occurs. 2368 */ 2369 if (n == 0) { 2370 arg->peer_ht_rates.num_rates = 8; 2371 for (i = 0; i < arg->peer_ht_rates.num_rates; i++) 2372 arg->peer_ht_rates.rates[i] = i; 2373 } else { 2374 arg->peer_ht_rates.num_rates = n; 2375 arg->peer_num_spatial_streams = min(sta->rx_nss, max_nss); 2376 } 2377 2378 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n", 2379 arg->addr, 2380 arg->peer_ht_rates.num_rates, 2381 arg->peer_num_spatial_streams); 2382 } 2383 2384 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar, 2385 struct ath10k_vif *arvif, 2386 struct ieee80211_sta *sta) 2387 { 2388 u32 uapsd = 0; 2389 u32 max_sp = 0; 2390 int ret = 0; 2391 2392 lockdep_assert_held(&ar->conf_mutex); 2393 2394 if (sta->wme && sta->uapsd_queues) { 2395 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n", 2396 sta->uapsd_queues, sta->max_sp); 2397 2398 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) 2399 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN | 2400 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN; 2401 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) 2402 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN | 2403 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN; 2404 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) 2405 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN | 2406 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN; 2407 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) 2408 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN | 2409 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN; 2410 2411 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP) 2412 max_sp = sta->max_sp; 2413 2414 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, 2415 sta->addr, 2416 WMI_AP_PS_PEER_PARAM_UAPSD, 2417 uapsd); 2418 if (ret) { 2419 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n", 2420 arvif->vdev_id, ret); 2421 return ret; 2422 } 2423 2424 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, 2425 sta->addr, 2426 WMI_AP_PS_PEER_PARAM_MAX_SP, 2427 max_sp); 2428 if (ret) { 2429 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n", 2430 arvif->vdev_id, ret); 2431 return ret; 2432 } 2433 2434 /* TODO setup this based on STA listen interval and 2435 * beacon interval. Currently we don't know 2436 * sta->listen_interval - mac80211 patch required. 2437 * Currently use 10 seconds 2438 */ 2439 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr, 2440 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME, 2441 10); 2442 if (ret) { 2443 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n", 2444 arvif->vdev_id, ret); 2445 return ret; 2446 } 2447 } 2448 2449 return 0; 2450 } 2451 2452 static u16 2453 ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set, 2454 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX]) 2455 { 2456 int idx_limit; 2457 int nss; 2458 u16 mcs_map; 2459 u16 mcs; 2460 2461 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) { 2462 mcs_map = ath10k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) & 2463 vht_mcs_limit[nss]; 2464 2465 if (mcs_map) 2466 idx_limit = fls(mcs_map) - 1; 2467 else 2468 idx_limit = -1; 2469 2470 switch (idx_limit) { 2471 case 0: 2472 case 1: 2473 case 2: 2474 case 3: 2475 case 4: 2476 case 5: 2477 case 6: 2478 default: 2479 /* see ath10k_mac_can_set_bitrate_mask() */ 2480 WARN_ON(1); 2481 fallthrough; 2482 case -1: 2483 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED; 2484 break; 2485 case 7: 2486 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7; 2487 break; 2488 case 8: 2489 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8; 2490 break; 2491 case 9: 2492 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9; 2493 break; 2494 } 2495 2496 tx_mcs_set &= ~(0x3 << (nss * 2)); 2497 tx_mcs_set |= mcs << (nss * 2); 2498 } 2499 2500 return tx_mcs_set; 2501 } 2502 2503 static u32 get_160mhz_nss_from_maxrate(int rate) 2504 { 2505 u32 nss; 2506 2507 switch (rate) { 2508 case 780: 2509 nss = 1; 2510 break; 2511 case 1560: 2512 nss = 2; 2513 break; 2514 case 2106: 2515 nss = 3; /* not support MCS9 from spec*/ 2516 break; 2517 case 3120: 2518 nss = 4; 2519 break; 2520 default: 2521 nss = 1; 2522 } 2523 2524 return nss; 2525 } 2526 2527 static void ath10k_peer_assoc_h_vht(struct ath10k *ar, 2528 struct ieee80211_vif *vif, 2529 struct ieee80211_sta *sta, 2530 struct wmi_peer_assoc_complete_arg *arg) 2531 { 2532 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap; 2533 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2534 struct ath10k_hw_params *hw = &ar->hw_params; 2535 struct cfg80211_chan_def def; 2536 enum nl80211_band band; 2537 const u16 *vht_mcs_mask; 2538 u8 ampdu_factor; 2539 u8 max_nss, vht_mcs; 2540 int i; 2541 2542 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 2543 return; 2544 2545 if (!vht_cap->vht_supported) 2546 return; 2547 2548 band = def.chan->band; 2549 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 2550 2551 if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) 2552 return; 2553 2554 arg->peer_flags |= ar->wmi.peer_flags->vht; 2555 2556 if (def.chan->band == NL80211_BAND_2GHZ) 2557 arg->peer_flags |= ar->wmi.peer_flags->vht_2g; 2558 2559 arg->peer_vht_caps = vht_cap->cap; 2560 2561 ampdu_factor = (vht_cap->cap & 2562 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >> 2563 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT; 2564 2565 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to 2566 * zero in VHT IE. Using it would result in degraded throughput. 2567 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep 2568 * it if VHT max_mpdu is smaller. 2569 */ 2570 arg->peer_max_mpdu = max(arg->peer_max_mpdu, 2571 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR + 2572 ampdu_factor)) - 1); 2573 2574 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 2575 arg->peer_flags |= ar->wmi.peer_flags->bw80; 2576 2577 if (sta->bandwidth == IEEE80211_STA_RX_BW_160) 2578 arg->peer_flags |= ar->wmi.peer_flags->bw160; 2579 2580 /* Calculate peer NSS capability from VHT capabilities if STA 2581 * supports VHT. 2582 */ 2583 for (i = 0, max_nss = 0, vht_mcs = 0; i < NL80211_VHT_NSS_MAX; i++) { 2584 vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >> 2585 (2 * i) & 3; 2586 2587 if ((vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED) && 2588 vht_mcs_mask[i]) 2589 max_nss = i + 1; 2590 } 2591 arg->peer_num_spatial_streams = min(sta->rx_nss, max_nss); 2592 arg->peer_vht_rates.rx_max_rate = 2593 __le16_to_cpu(vht_cap->vht_mcs.rx_highest); 2594 arg->peer_vht_rates.rx_mcs_set = 2595 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map); 2596 arg->peer_vht_rates.tx_max_rate = 2597 __le16_to_cpu(vht_cap->vht_mcs.tx_highest); 2598 arg->peer_vht_rates.tx_mcs_set = ath10k_peer_assoc_h_vht_limit( 2599 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask); 2600 2601 /* Configure bandwidth-NSS mapping to FW 2602 * for the chip's tx chains setting on 160Mhz bw 2603 */ 2604 if (arg->peer_phymode == MODE_11AC_VHT160 || 2605 arg->peer_phymode == MODE_11AC_VHT80_80) { 2606 u32 rx_nss; 2607 u32 max_rate; 2608 2609 max_rate = arg->peer_vht_rates.rx_max_rate; 2610 rx_nss = get_160mhz_nss_from_maxrate(max_rate); 2611 2612 if (rx_nss == 0) 2613 rx_nss = arg->peer_num_spatial_streams; 2614 else 2615 rx_nss = min(arg->peer_num_spatial_streams, rx_nss); 2616 2617 max_rate = hw->vht160_mcs_tx_highest; 2618 rx_nss = min(rx_nss, get_160mhz_nss_from_maxrate(max_rate)); 2619 2620 arg->peer_bw_rxnss_override = 2621 FIELD_PREP(WMI_PEER_NSS_MAP_ENABLE, 1) | 2622 FIELD_PREP(WMI_PEER_NSS_160MHZ_MASK, (rx_nss - 1)); 2623 2624 if (arg->peer_phymode == MODE_11AC_VHT80_80) { 2625 arg->peer_bw_rxnss_override |= 2626 FIELD_PREP(WMI_PEER_NSS_80_80MHZ_MASK, (rx_nss - 1)); 2627 } 2628 } 2629 ath10k_dbg(ar, ATH10K_DBG_MAC, 2630 "mac vht peer %pM max_mpdu %d flags 0x%x peer_rx_nss_override 0x%x\n", 2631 sta->addr, arg->peer_max_mpdu, 2632 arg->peer_flags, arg->peer_bw_rxnss_override); 2633 } 2634 2635 static void ath10k_peer_assoc_h_qos(struct ath10k *ar, 2636 struct ieee80211_vif *vif, 2637 struct ieee80211_sta *sta, 2638 struct wmi_peer_assoc_complete_arg *arg) 2639 { 2640 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2641 2642 switch (arvif->vdev_type) { 2643 case WMI_VDEV_TYPE_AP: 2644 if (sta->wme) 2645 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos; 2646 2647 if (sta->wme && sta->uapsd_queues) { 2648 arg->peer_flags |= arvif->ar->wmi.peer_flags->apsd; 2649 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG; 2650 } 2651 break; 2652 case WMI_VDEV_TYPE_STA: 2653 if (sta->wme) 2654 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos; 2655 break; 2656 case WMI_VDEV_TYPE_IBSS: 2657 if (sta->wme) 2658 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos; 2659 break; 2660 default: 2661 break; 2662 } 2663 2664 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n", 2665 sta->addr, !!(arg->peer_flags & 2666 arvif->ar->wmi.peer_flags->qos)); 2667 } 2668 2669 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta) 2670 { 2671 return sta->supp_rates[NL80211_BAND_2GHZ] >> 2672 ATH10K_MAC_FIRST_OFDM_RATE_IDX; 2673 } 2674 2675 static enum wmi_phy_mode ath10k_mac_get_phymode_vht(struct ath10k *ar, 2676 struct ieee80211_sta *sta) 2677 { 2678 if (sta->bandwidth == IEEE80211_STA_RX_BW_160) { 2679 switch (sta->vht_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) { 2680 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ: 2681 return MODE_11AC_VHT160; 2682 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ: 2683 return MODE_11AC_VHT80_80; 2684 default: 2685 /* not sure if this is a valid case? */ 2686 return MODE_11AC_VHT160; 2687 } 2688 } 2689 2690 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 2691 return MODE_11AC_VHT80; 2692 2693 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2694 return MODE_11AC_VHT40; 2695 2696 if (sta->bandwidth == IEEE80211_STA_RX_BW_20) 2697 return MODE_11AC_VHT20; 2698 2699 return MODE_UNKNOWN; 2700 } 2701 2702 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar, 2703 struct ieee80211_vif *vif, 2704 struct ieee80211_sta *sta, 2705 struct wmi_peer_assoc_complete_arg *arg) 2706 { 2707 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2708 struct cfg80211_chan_def def; 2709 enum nl80211_band band; 2710 const u8 *ht_mcs_mask; 2711 const u16 *vht_mcs_mask; 2712 enum wmi_phy_mode phymode = MODE_UNKNOWN; 2713 2714 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 2715 return; 2716 2717 band = def.chan->band; 2718 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 2719 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 2720 2721 switch (band) { 2722 case NL80211_BAND_2GHZ: 2723 if (sta->vht_cap.vht_supported && 2724 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2725 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2726 phymode = MODE_11AC_VHT40; 2727 else 2728 phymode = MODE_11AC_VHT20; 2729 } else if (sta->ht_cap.ht_supported && 2730 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2731 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2732 phymode = MODE_11NG_HT40; 2733 else 2734 phymode = MODE_11NG_HT20; 2735 } else if (ath10k_mac_sta_has_ofdm_only(sta)) { 2736 phymode = MODE_11G; 2737 } else { 2738 phymode = MODE_11B; 2739 } 2740 2741 break; 2742 case NL80211_BAND_5GHZ: 2743 /* 2744 * Check VHT first. 2745 */ 2746 if (sta->vht_cap.vht_supported && 2747 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2748 phymode = ath10k_mac_get_phymode_vht(ar, sta); 2749 } else if (sta->ht_cap.ht_supported && 2750 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2751 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) 2752 phymode = MODE_11NA_HT40; 2753 else 2754 phymode = MODE_11NA_HT20; 2755 } else { 2756 phymode = MODE_11A; 2757 } 2758 2759 break; 2760 default: 2761 break; 2762 } 2763 2764 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n", 2765 sta->addr, ath10k_wmi_phymode_str(phymode)); 2766 2767 arg->peer_phymode = phymode; 2768 WARN_ON(phymode == MODE_UNKNOWN); 2769 } 2770 2771 static int ath10k_peer_assoc_prepare(struct ath10k *ar, 2772 struct ieee80211_vif *vif, 2773 struct ieee80211_sta *sta, 2774 struct wmi_peer_assoc_complete_arg *arg) 2775 { 2776 lockdep_assert_held(&ar->conf_mutex); 2777 2778 memset(arg, 0, sizeof(*arg)); 2779 2780 ath10k_peer_assoc_h_basic(ar, vif, sta, arg); 2781 ath10k_peer_assoc_h_crypto(ar, vif, sta, arg); 2782 ath10k_peer_assoc_h_rates(ar, vif, sta, arg); 2783 ath10k_peer_assoc_h_ht(ar, vif, sta, arg); 2784 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg); 2785 ath10k_peer_assoc_h_vht(ar, vif, sta, arg); 2786 ath10k_peer_assoc_h_qos(ar, vif, sta, arg); 2787 2788 return 0; 2789 } 2790 2791 static const u32 ath10k_smps_map[] = { 2792 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC, 2793 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC, 2794 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE, 2795 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE, 2796 }; 2797 2798 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif, 2799 const u8 *addr, 2800 const struct ieee80211_sta_ht_cap *ht_cap) 2801 { 2802 int smps; 2803 2804 if (!ht_cap->ht_supported) 2805 return 0; 2806 2807 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 2808 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 2809 2810 if (smps >= ARRAY_SIZE(ath10k_smps_map)) 2811 return -EINVAL; 2812 2813 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr, 2814 ar->wmi.peer_param->smps_state, 2815 ath10k_smps_map[smps]); 2816 } 2817 2818 static int ath10k_mac_vif_recalc_txbf(struct ath10k *ar, 2819 struct ieee80211_vif *vif, 2820 struct ieee80211_sta_vht_cap vht_cap) 2821 { 2822 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2823 int ret; 2824 u32 param; 2825 u32 value; 2826 2827 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_AFTER_ASSOC) 2828 return 0; 2829 2830 if (!(ar->vht_cap_info & 2831 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 2832 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE | 2833 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 2834 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))) 2835 return 0; 2836 2837 param = ar->wmi.vdev_param->txbf; 2838 value = 0; 2839 2840 if (WARN_ON(param == WMI_VDEV_PARAM_UNSUPPORTED)) 2841 return 0; 2842 2843 /* The following logic is correct. If a remote STA advertises support 2844 * for being a beamformer then we should enable us being a beamformee. 2845 */ 2846 2847 if (ar->vht_cap_info & 2848 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 2849 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) { 2850 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) 2851 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 2852 2853 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) 2854 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE; 2855 } 2856 2857 if (ar->vht_cap_info & 2858 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 2859 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) { 2860 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) 2861 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 2862 2863 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) 2864 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER; 2865 } 2866 2867 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFEE) 2868 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 2869 2870 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFER) 2871 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 2872 2873 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, value); 2874 if (ret) { 2875 ath10k_warn(ar, "failed to submit vdev param txbf 0x%x: %d\n", 2876 value, ret); 2877 return ret; 2878 } 2879 2880 return 0; 2881 } 2882 2883 /* can be called only in mac80211 callbacks due to `key_count` usage */ 2884 static void ath10k_bss_assoc(struct ieee80211_hw *hw, 2885 struct ieee80211_vif *vif, 2886 struct ieee80211_bss_conf *bss_conf) 2887 { 2888 struct ath10k *ar = hw->priv; 2889 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2890 struct ieee80211_sta_ht_cap ht_cap; 2891 struct ieee80211_sta_vht_cap vht_cap; 2892 struct wmi_peer_assoc_complete_arg peer_arg; 2893 struct ieee80211_sta *ap_sta; 2894 int ret; 2895 2896 lockdep_assert_held(&ar->conf_mutex); 2897 2898 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n", 2899 arvif->vdev_id, arvif->bssid, arvif->aid); 2900 2901 rcu_read_lock(); 2902 2903 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid); 2904 if (!ap_sta) { 2905 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n", 2906 bss_conf->bssid, arvif->vdev_id); 2907 rcu_read_unlock(); 2908 return; 2909 } 2910 2911 /* ap_sta must be accessed only within rcu section which must be left 2912 * before calling ath10k_setup_peer_smps() which might sleep. 2913 */ 2914 ht_cap = ap_sta->ht_cap; 2915 vht_cap = ap_sta->vht_cap; 2916 2917 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg); 2918 if (ret) { 2919 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n", 2920 bss_conf->bssid, arvif->vdev_id, ret); 2921 rcu_read_unlock(); 2922 return; 2923 } 2924 2925 rcu_read_unlock(); 2926 2927 ret = ath10k_wmi_peer_assoc(ar, &peer_arg); 2928 if (ret) { 2929 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n", 2930 bss_conf->bssid, arvif->vdev_id, ret); 2931 return; 2932 } 2933 2934 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap); 2935 if (ret) { 2936 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n", 2937 arvif->vdev_id, ret); 2938 return; 2939 } 2940 2941 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap); 2942 if (ret) { 2943 ath10k_warn(ar, "failed to recalc txbf for vdev %i on bss %pM: %d\n", 2944 arvif->vdev_id, bss_conf->bssid, ret); 2945 return; 2946 } 2947 2948 ath10k_dbg(ar, ATH10K_DBG_MAC, 2949 "mac vdev %d up (associated) bssid %pM aid %d\n", 2950 arvif->vdev_id, bss_conf->bssid, bss_conf->aid); 2951 2952 WARN_ON(arvif->is_up); 2953 2954 arvif->aid = bss_conf->aid; 2955 ether_addr_copy(arvif->bssid, bss_conf->bssid); 2956 2957 ret = ath10k_wmi_pdev_set_param(ar, 2958 ar->wmi.pdev_param->peer_stats_info_enable, 1); 2959 if (ret) 2960 ath10k_warn(ar, "failed to enable peer stats info: %d\n", ret); 2961 2962 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid); 2963 if (ret) { 2964 ath10k_warn(ar, "failed to set vdev %d up: %d\n", 2965 arvif->vdev_id, ret); 2966 return; 2967 } 2968 2969 arvif->is_up = true; 2970 2971 /* Workaround: Some firmware revisions (tested with qca6174 2972 * WLAN.RM.2.0-00073) have buggy powersave state machine and must be 2973 * poked with peer param command. 2974 */ 2975 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid, 2976 ar->wmi.peer_param->dummy_var, 1); 2977 if (ret) { 2978 ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n", 2979 arvif->bssid, arvif->vdev_id, ret); 2980 return; 2981 } 2982 } 2983 2984 static void ath10k_bss_disassoc(struct ieee80211_hw *hw, 2985 struct ieee80211_vif *vif) 2986 { 2987 struct ath10k *ar = hw->priv; 2988 struct ath10k_vif *arvif = (void *)vif->drv_priv; 2989 struct ieee80211_sta_vht_cap vht_cap = {}; 2990 int ret; 2991 2992 lockdep_assert_held(&ar->conf_mutex); 2993 2994 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n", 2995 arvif->vdev_id, arvif->bssid); 2996 2997 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 2998 if (ret) 2999 ath10k_warn(ar, "failed to down vdev %i: %d\n", 3000 arvif->vdev_id, ret); 3001 3002 arvif->def_wep_key_idx = -1; 3003 3004 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap); 3005 if (ret) { 3006 ath10k_warn(ar, "failed to recalc txbf for vdev %i: %d\n", 3007 arvif->vdev_id, ret); 3008 return; 3009 } 3010 3011 arvif->is_up = false; 3012 3013 cancel_delayed_work_sync(&arvif->connection_loss_work); 3014 } 3015 3016 static int ath10k_new_peer_tid_config(struct ath10k *ar, 3017 struct ieee80211_sta *sta, 3018 struct ath10k_vif *arvif) 3019 { 3020 struct wmi_per_peer_per_tid_cfg_arg arg = {}; 3021 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 3022 bool config_apply; 3023 int ret, i; 3024 3025 for (i = 0; i < ATH10K_TID_MAX; i++) { 3026 config_apply = false; 3027 if (arvif->retry_long[i] || arvif->ampdu[i] || 3028 arvif->rate_ctrl[i] || arvif->rtscts[i]) { 3029 config_apply = true; 3030 arg.tid = i; 3031 arg.vdev_id = arvif->vdev_id; 3032 arg.retry_count = arvif->retry_long[i]; 3033 arg.aggr_control = arvif->ampdu[i]; 3034 arg.rate_ctrl = arvif->rate_ctrl[i]; 3035 arg.rcode_flags = arvif->rate_code[i]; 3036 3037 if (arvif->rtscts[i]) 3038 arg.ext_tid_cfg_bitmap = 3039 WMI_EXT_TID_RTS_CTS_CONFIG; 3040 else 3041 arg.ext_tid_cfg_bitmap = 0; 3042 3043 arg.rtscts_ctrl = arvif->rtscts[i]; 3044 } 3045 3046 if (arvif->noack[i]) { 3047 arg.ack_policy = arvif->noack[i]; 3048 arg.rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_DEFAULT_LOWEST_RATE; 3049 arg.aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_DISABLE; 3050 config_apply = true; 3051 } 3052 3053 /* Assign default value(-1) to newly connected station. 3054 * This is to identify station specific tid configuration not 3055 * configured for the station. 3056 */ 3057 arsta->retry_long[i] = -1; 3058 arsta->noack[i] = -1; 3059 arsta->ampdu[i] = -1; 3060 3061 if (!config_apply) 3062 continue; 3063 3064 ether_addr_copy(arg.peer_macaddr.addr, sta->addr); 3065 3066 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg); 3067 if (ret) { 3068 ath10k_warn(ar, "failed to set per tid retry/aggr config for sta %pM: %d\n", 3069 sta->addr, ret); 3070 return ret; 3071 } 3072 3073 memset(&arg, 0, sizeof(arg)); 3074 } 3075 3076 return 0; 3077 } 3078 3079 static int ath10k_station_assoc(struct ath10k *ar, 3080 struct ieee80211_vif *vif, 3081 struct ieee80211_sta *sta, 3082 bool reassoc) 3083 { 3084 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3085 struct wmi_peer_assoc_complete_arg peer_arg; 3086 int ret = 0; 3087 3088 lockdep_assert_held(&ar->conf_mutex); 3089 3090 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg); 3091 if (ret) { 3092 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n", 3093 sta->addr, arvif->vdev_id, ret); 3094 return ret; 3095 } 3096 3097 ret = ath10k_wmi_peer_assoc(ar, &peer_arg); 3098 if (ret) { 3099 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n", 3100 sta->addr, arvif->vdev_id, ret); 3101 return ret; 3102 } 3103 3104 /* Re-assoc is run only to update supported rates for given station. It 3105 * doesn't make much sense to reconfigure the peer completely. 3106 */ 3107 if (!reassoc) { 3108 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr, 3109 &sta->ht_cap); 3110 if (ret) { 3111 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n", 3112 arvif->vdev_id, ret); 3113 return ret; 3114 } 3115 3116 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta); 3117 if (ret) { 3118 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n", 3119 sta->addr, arvif->vdev_id, ret); 3120 return ret; 3121 } 3122 3123 if (!sta->wme) { 3124 arvif->num_legacy_stations++; 3125 ret = ath10k_recalc_rtscts_prot(arvif); 3126 if (ret) { 3127 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n", 3128 arvif->vdev_id, ret); 3129 return ret; 3130 } 3131 } 3132 3133 /* Plumb cached keys only for static WEP */ 3134 if ((arvif->def_wep_key_idx != -1) && (!sta->tdls)) { 3135 ret = ath10k_install_peer_wep_keys(arvif, sta->addr); 3136 if (ret) { 3137 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n", 3138 arvif->vdev_id, ret); 3139 return ret; 3140 } 3141 } 3142 } 3143 3144 if (!test_bit(WMI_SERVICE_PEER_TID_CONFIGS_SUPPORT, ar->wmi.svc_map)) 3145 return ret; 3146 3147 return ath10k_new_peer_tid_config(ar, sta, arvif); 3148 } 3149 3150 static int ath10k_station_disassoc(struct ath10k *ar, 3151 struct ieee80211_vif *vif, 3152 struct ieee80211_sta *sta) 3153 { 3154 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3155 int ret = 0; 3156 3157 lockdep_assert_held(&ar->conf_mutex); 3158 3159 if (!sta->wme) { 3160 arvif->num_legacy_stations--; 3161 ret = ath10k_recalc_rtscts_prot(arvif); 3162 if (ret) { 3163 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n", 3164 arvif->vdev_id, ret); 3165 return ret; 3166 } 3167 } 3168 3169 ret = ath10k_clear_peer_keys(arvif, sta->addr); 3170 if (ret) { 3171 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n", 3172 arvif->vdev_id, ret); 3173 return ret; 3174 } 3175 3176 return ret; 3177 } 3178 3179 /**************/ 3180 /* Regulatory */ 3181 /**************/ 3182 3183 static int ath10k_update_channel_list(struct ath10k *ar) 3184 { 3185 struct ieee80211_hw *hw = ar->hw; 3186 struct ieee80211_supported_band **bands; 3187 enum nl80211_band band; 3188 struct ieee80211_channel *channel; 3189 struct wmi_scan_chan_list_arg arg = {0}; 3190 struct wmi_channel_arg *ch; 3191 bool passive; 3192 int len; 3193 int ret; 3194 int i; 3195 3196 lockdep_assert_held(&ar->conf_mutex); 3197 3198 bands = hw->wiphy->bands; 3199 for (band = 0; band < NUM_NL80211_BANDS; band++) { 3200 if (!bands[band]) 3201 continue; 3202 3203 for (i = 0; i < bands[band]->n_channels; i++) { 3204 if (bands[band]->channels[i].flags & 3205 IEEE80211_CHAN_DISABLED) 3206 continue; 3207 3208 arg.n_channels++; 3209 } 3210 } 3211 3212 len = sizeof(struct wmi_channel_arg) * arg.n_channels; 3213 arg.channels = kzalloc(len, GFP_KERNEL); 3214 if (!arg.channels) 3215 return -ENOMEM; 3216 3217 ch = arg.channels; 3218 for (band = 0; band < NUM_NL80211_BANDS; band++) { 3219 if (!bands[band]) 3220 continue; 3221 3222 for (i = 0; i < bands[band]->n_channels; i++) { 3223 channel = &bands[band]->channels[i]; 3224 3225 if (channel->flags & IEEE80211_CHAN_DISABLED) 3226 continue; 3227 3228 ch->allow_ht = true; 3229 3230 /* FIXME: when should we really allow VHT? */ 3231 ch->allow_vht = true; 3232 3233 ch->allow_ibss = 3234 !(channel->flags & IEEE80211_CHAN_NO_IR); 3235 3236 ch->ht40plus = 3237 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS); 3238 3239 ch->chan_radar = 3240 !!(channel->flags & IEEE80211_CHAN_RADAR); 3241 3242 passive = channel->flags & IEEE80211_CHAN_NO_IR; 3243 ch->passive = passive; 3244 3245 /* the firmware is ignoring the "radar" flag of the 3246 * channel and is scanning actively using Probe Requests 3247 * on "Radar detection"/DFS channels which are not 3248 * marked as "available" 3249 */ 3250 ch->passive |= ch->chan_radar; 3251 3252 ch->freq = channel->center_freq; 3253 ch->band_center_freq1 = channel->center_freq; 3254 ch->min_power = 0; 3255 ch->max_power = channel->max_power * 2; 3256 ch->max_reg_power = channel->max_reg_power * 2; 3257 ch->max_antenna_gain = channel->max_antenna_gain * 2; 3258 ch->reg_class_id = 0; /* FIXME */ 3259 3260 /* FIXME: why use only legacy modes, why not any 3261 * HT/VHT modes? Would that even make any 3262 * difference? 3263 */ 3264 if (channel->band == NL80211_BAND_2GHZ) 3265 ch->mode = MODE_11G; 3266 else 3267 ch->mode = MODE_11A; 3268 3269 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN)) 3270 continue; 3271 3272 ath10k_dbg(ar, ATH10K_DBG_WMI, 3273 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n", 3274 ch - arg.channels, arg.n_channels, 3275 ch->freq, ch->max_power, ch->max_reg_power, 3276 ch->max_antenna_gain, ch->mode); 3277 3278 ch++; 3279 } 3280 } 3281 3282 ret = ath10k_wmi_scan_chan_list(ar, &arg); 3283 kfree(arg.channels); 3284 3285 return ret; 3286 } 3287 3288 static enum wmi_dfs_region 3289 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region) 3290 { 3291 switch (dfs_region) { 3292 case NL80211_DFS_UNSET: 3293 return WMI_UNINIT_DFS_DOMAIN; 3294 case NL80211_DFS_FCC: 3295 return WMI_FCC_DFS_DOMAIN; 3296 case NL80211_DFS_ETSI: 3297 return WMI_ETSI_DFS_DOMAIN; 3298 case NL80211_DFS_JP: 3299 return WMI_MKK4_DFS_DOMAIN; 3300 } 3301 return WMI_UNINIT_DFS_DOMAIN; 3302 } 3303 3304 static void ath10k_regd_update(struct ath10k *ar) 3305 { 3306 struct reg_dmn_pair_mapping *regpair; 3307 int ret; 3308 enum wmi_dfs_region wmi_dfs_reg; 3309 enum nl80211_dfs_regions nl_dfs_reg; 3310 3311 lockdep_assert_held(&ar->conf_mutex); 3312 3313 ret = ath10k_update_channel_list(ar); 3314 if (ret) 3315 ath10k_warn(ar, "failed to update channel list: %d\n", ret); 3316 3317 regpair = ar->ath_common.regulatory.regpair; 3318 3319 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) { 3320 nl_dfs_reg = ar->dfs_detector->region; 3321 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg); 3322 } else { 3323 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN; 3324 } 3325 3326 /* Target allows setting up per-band regdomain but ath_common provides 3327 * a combined one only 3328 */ 3329 ret = ath10k_wmi_pdev_set_regdomain(ar, 3330 regpair->reg_domain, 3331 regpair->reg_domain, /* 2ghz */ 3332 regpair->reg_domain, /* 5ghz */ 3333 regpair->reg_2ghz_ctl, 3334 regpair->reg_5ghz_ctl, 3335 wmi_dfs_reg); 3336 if (ret) 3337 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret); 3338 } 3339 3340 static void ath10k_mac_update_channel_list(struct ath10k *ar, 3341 struct ieee80211_supported_band *band) 3342 { 3343 int i; 3344 3345 if (ar->low_5ghz_chan && ar->high_5ghz_chan) { 3346 for (i = 0; i < band->n_channels; i++) { 3347 if (band->channels[i].center_freq < ar->low_5ghz_chan || 3348 band->channels[i].center_freq > ar->high_5ghz_chan) 3349 band->channels[i].flags |= 3350 IEEE80211_CHAN_DISABLED; 3351 } 3352 } 3353 } 3354 3355 static void ath10k_reg_notifier(struct wiphy *wiphy, 3356 struct regulatory_request *request) 3357 { 3358 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 3359 struct ath10k *ar = hw->priv; 3360 bool result; 3361 3362 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory); 3363 3364 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) { 3365 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n", 3366 request->dfs_region); 3367 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector, 3368 request->dfs_region); 3369 if (!result) 3370 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n", 3371 request->dfs_region); 3372 } 3373 3374 mutex_lock(&ar->conf_mutex); 3375 if (ar->state == ATH10K_STATE_ON) 3376 ath10k_regd_update(ar); 3377 mutex_unlock(&ar->conf_mutex); 3378 3379 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) 3380 ath10k_mac_update_channel_list(ar, 3381 ar->hw->wiphy->bands[NL80211_BAND_5GHZ]); 3382 } 3383 3384 static void ath10k_stop_radar_confirmation(struct ath10k *ar) 3385 { 3386 spin_lock_bh(&ar->data_lock); 3387 ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_STOPPED; 3388 spin_unlock_bh(&ar->data_lock); 3389 3390 cancel_work_sync(&ar->radar_confirmation_work); 3391 } 3392 3393 /***************/ 3394 /* TX handlers */ 3395 /***************/ 3396 3397 enum ath10k_mac_tx_path { 3398 ATH10K_MAC_TX_HTT, 3399 ATH10K_MAC_TX_HTT_MGMT, 3400 ATH10K_MAC_TX_WMI_MGMT, 3401 ATH10K_MAC_TX_UNKNOWN, 3402 }; 3403 3404 void ath10k_mac_tx_lock(struct ath10k *ar, int reason) 3405 { 3406 lockdep_assert_held(&ar->htt.tx_lock); 3407 3408 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX); 3409 ar->tx_paused |= BIT(reason); 3410 ieee80211_stop_queues(ar->hw); 3411 } 3412 3413 static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac, 3414 struct ieee80211_vif *vif) 3415 { 3416 struct ath10k *ar = data; 3417 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3418 3419 if (arvif->tx_paused) 3420 return; 3421 3422 ieee80211_wake_queue(ar->hw, arvif->vdev_id); 3423 } 3424 3425 void ath10k_mac_tx_unlock(struct ath10k *ar, int reason) 3426 { 3427 lockdep_assert_held(&ar->htt.tx_lock); 3428 3429 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX); 3430 ar->tx_paused &= ~BIT(reason); 3431 3432 if (ar->tx_paused) 3433 return; 3434 3435 ieee80211_iterate_active_interfaces_atomic(ar->hw, 3436 ATH10K_ITER_RESUME_FLAGS, 3437 ath10k_mac_tx_unlock_iter, 3438 ar); 3439 3440 ieee80211_wake_queue(ar->hw, ar->hw->offchannel_tx_hw_queue); 3441 } 3442 3443 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason) 3444 { 3445 struct ath10k *ar = arvif->ar; 3446 3447 lockdep_assert_held(&ar->htt.tx_lock); 3448 3449 WARN_ON(reason >= BITS_PER_LONG); 3450 arvif->tx_paused |= BIT(reason); 3451 ieee80211_stop_queue(ar->hw, arvif->vdev_id); 3452 } 3453 3454 void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason) 3455 { 3456 struct ath10k *ar = arvif->ar; 3457 3458 lockdep_assert_held(&ar->htt.tx_lock); 3459 3460 WARN_ON(reason >= BITS_PER_LONG); 3461 arvif->tx_paused &= ~BIT(reason); 3462 3463 if (ar->tx_paused) 3464 return; 3465 3466 if (arvif->tx_paused) 3467 return; 3468 3469 ieee80211_wake_queue(ar->hw, arvif->vdev_id); 3470 } 3471 3472 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif, 3473 enum wmi_tlv_tx_pause_id pause_id, 3474 enum wmi_tlv_tx_pause_action action) 3475 { 3476 struct ath10k *ar = arvif->ar; 3477 3478 lockdep_assert_held(&ar->htt.tx_lock); 3479 3480 switch (action) { 3481 case WMI_TLV_TX_PAUSE_ACTION_STOP: 3482 ath10k_mac_vif_tx_lock(arvif, pause_id); 3483 break; 3484 case WMI_TLV_TX_PAUSE_ACTION_WAKE: 3485 ath10k_mac_vif_tx_unlock(arvif, pause_id); 3486 break; 3487 default: 3488 ath10k_dbg(ar, ATH10K_DBG_BOOT, 3489 "received unknown tx pause action %d on vdev %i, ignoring\n", 3490 action, arvif->vdev_id); 3491 break; 3492 } 3493 } 3494 3495 struct ath10k_mac_tx_pause { 3496 u32 vdev_id; 3497 enum wmi_tlv_tx_pause_id pause_id; 3498 enum wmi_tlv_tx_pause_action action; 3499 }; 3500 3501 static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac, 3502 struct ieee80211_vif *vif) 3503 { 3504 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3505 struct ath10k_mac_tx_pause *arg = data; 3506 3507 if (arvif->vdev_id != arg->vdev_id) 3508 return; 3509 3510 ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action); 3511 } 3512 3513 void ath10k_mac_handle_tx_pause_vdev(struct ath10k *ar, u32 vdev_id, 3514 enum wmi_tlv_tx_pause_id pause_id, 3515 enum wmi_tlv_tx_pause_action action) 3516 { 3517 struct ath10k_mac_tx_pause arg = { 3518 .vdev_id = vdev_id, 3519 .pause_id = pause_id, 3520 .action = action, 3521 }; 3522 3523 spin_lock_bh(&ar->htt.tx_lock); 3524 ieee80211_iterate_active_interfaces_atomic(ar->hw, 3525 ATH10K_ITER_RESUME_FLAGS, 3526 ath10k_mac_handle_tx_pause_iter, 3527 &arg); 3528 spin_unlock_bh(&ar->htt.tx_lock); 3529 } 3530 3531 static enum ath10k_hw_txrx_mode 3532 ath10k_mac_tx_h_get_txmode(struct ath10k *ar, 3533 struct ieee80211_vif *vif, 3534 struct ieee80211_sta *sta, 3535 struct sk_buff *skb) 3536 { 3537 const struct ieee80211_hdr *hdr = (void *)skb->data; 3538 const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb); 3539 __le16 fc = hdr->frame_control; 3540 3541 if (!vif || vif->type == NL80211_IFTYPE_MONITOR) 3542 return ATH10K_HW_TXRX_RAW; 3543 3544 if (ieee80211_is_mgmt(fc)) 3545 return ATH10K_HW_TXRX_MGMT; 3546 3547 /* Workaround: 3548 * 3549 * NullFunc frames are mostly used to ping if a client or AP are still 3550 * reachable and responsive. This implies tx status reports must be 3551 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can 3552 * come to a conclusion that the other end disappeared and tear down 3553 * BSS connection or it can never disconnect from BSS/client (which is 3554 * the case). 3555 * 3556 * Firmware with HTT older than 3.0 delivers incorrect tx status for 3557 * NullFunc frames to driver. However there's a HTT Mgmt Tx command 3558 * which seems to deliver correct tx reports for NullFunc frames. The 3559 * downside of using it is it ignores client powersave state so it can 3560 * end up disconnecting sleeping clients in AP mode. It should fix STA 3561 * mode though because AP don't sleep. 3562 */ 3563 if (ar->htt.target_version_major < 3 && 3564 (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) && 3565 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, 3566 ar->running_fw->fw_file.fw_features)) 3567 return ATH10K_HW_TXRX_MGMT; 3568 3569 /* Workaround: 3570 * 3571 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for 3572 * NativeWifi txmode - it selects AP key instead of peer key. It seems 3573 * to work with Ethernet txmode so use it. 3574 * 3575 * FIXME: Check if raw mode works with TDLS. 3576 */ 3577 if (ieee80211_is_data_present(fc) && sta && sta->tdls) 3578 return ATH10K_HW_TXRX_ETHERNET; 3579 3580 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) || 3581 skb_cb->flags & ATH10K_SKB_F_RAW_TX) 3582 return ATH10K_HW_TXRX_RAW; 3583 3584 return ATH10K_HW_TXRX_NATIVE_WIFI; 3585 } 3586 3587 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif, 3588 struct sk_buff *skb) 3589 { 3590 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 3591 const struct ieee80211_hdr *hdr = (void *)skb->data; 3592 const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT | 3593 IEEE80211_TX_CTL_INJECTED; 3594 3595 if (!ieee80211_has_protected(hdr->frame_control)) 3596 return false; 3597 3598 if ((info->flags & mask) == mask) 3599 return false; 3600 3601 if (vif) 3602 return !((struct ath10k_vif *)vif->drv_priv)->nohwcrypt; 3603 3604 return true; 3605 } 3606 3607 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS 3608 * Control in the header. 3609 */ 3610 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb) 3611 { 3612 struct ieee80211_hdr *hdr = (void *)skb->data; 3613 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb); 3614 u8 *qos_ctl; 3615 3616 if (!ieee80211_is_data_qos(hdr->frame_control)) 3617 return; 3618 3619 qos_ctl = ieee80211_get_qos_ctl(hdr); 3620 memmove(skb->data + IEEE80211_QOS_CTL_LEN, 3621 skb->data, (void *)qos_ctl - (void *)skb->data); 3622 skb_pull(skb, IEEE80211_QOS_CTL_LEN); 3623 3624 /* Some firmware revisions don't handle sending QoS NullFunc well. 3625 * These frames are mainly used for CQM purposes so it doesn't really 3626 * matter whether QoS NullFunc or NullFunc are sent. 3627 */ 3628 hdr = (void *)skb->data; 3629 if (ieee80211_is_qos_nullfunc(hdr->frame_control)) 3630 cb->flags &= ~ATH10K_SKB_F_QOS; 3631 3632 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA); 3633 } 3634 3635 static void ath10k_tx_h_8023(struct sk_buff *skb) 3636 { 3637 struct ieee80211_hdr *hdr; 3638 struct rfc1042_hdr *rfc1042; 3639 struct ethhdr *eth; 3640 size_t hdrlen; 3641 u8 da[ETH_ALEN]; 3642 u8 sa[ETH_ALEN]; 3643 __be16 type; 3644 3645 hdr = (void *)skb->data; 3646 hdrlen = ieee80211_hdrlen(hdr->frame_control); 3647 rfc1042 = (void *)skb->data + hdrlen; 3648 3649 ether_addr_copy(da, ieee80211_get_DA(hdr)); 3650 ether_addr_copy(sa, ieee80211_get_SA(hdr)); 3651 type = rfc1042->snap_type; 3652 3653 skb_pull(skb, hdrlen + sizeof(*rfc1042)); 3654 skb_push(skb, sizeof(*eth)); 3655 3656 eth = (void *)skb->data; 3657 ether_addr_copy(eth->h_dest, da); 3658 ether_addr_copy(eth->h_source, sa); 3659 eth->h_proto = type; 3660 } 3661 3662 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, 3663 struct ieee80211_vif *vif, 3664 struct sk_buff *skb) 3665 { 3666 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 3667 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3668 3669 /* This is case only for P2P_GO */ 3670 if (vif->type != NL80211_IFTYPE_AP || !vif->p2p) 3671 return; 3672 3673 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) { 3674 spin_lock_bh(&ar->data_lock); 3675 if (arvif->u.ap.noa_data) 3676 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len, 3677 GFP_ATOMIC)) 3678 skb_put_data(skb, arvif->u.ap.noa_data, 3679 arvif->u.ap.noa_len); 3680 spin_unlock_bh(&ar->data_lock); 3681 } 3682 } 3683 3684 static void ath10k_mac_tx_h_fill_cb(struct ath10k *ar, 3685 struct ieee80211_vif *vif, 3686 struct ieee80211_txq *txq, 3687 struct ieee80211_sta *sta, 3688 struct sk_buff *skb, u16 airtime) 3689 { 3690 struct ieee80211_hdr *hdr = (void *)skb->data; 3691 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb); 3692 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 3693 bool is_data = ieee80211_is_data(hdr->frame_control) || 3694 ieee80211_is_data_qos(hdr->frame_control); 3695 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3696 struct ath10k_sta *arsta; 3697 u8 tid, *qos_ctl; 3698 bool noack = false; 3699 3700 cb->flags = 0; 3701 if (!ath10k_tx_h_use_hwcrypto(vif, skb)) 3702 cb->flags |= ATH10K_SKB_F_NO_HWCRYPT; 3703 3704 if (ieee80211_is_mgmt(hdr->frame_control)) 3705 cb->flags |= ATH10K_SKB_F_MGMT; 3706 3707 if (ieee80211_is_data_qos(hdr->frame_control)) { 3708 cb->flags |= ATH10K_SKB_F_QOS; 3709 qos_ctl = ieee80211_get_qos_ctl(hdr); 3710 tid = (*qos_ctl) & IEEE80211_QOS_CTL_TID_MASK; 3711 3712 if (arvif->noack[tid] == WMI_PEER_TID_CONFIG_NOACK) 3713 noack = true; 3714 3715 if (sta) { 3716 arsta = (struct ath10k_sta *)sta->drv_priv; 3717 3718 if (arsta->noack[tid] == WMI_PEER_TID_CONFIG_NOACK) 3719 noack = true; 3720 3721 if (arsta->noack[tid] == WMI_PEER_TID_CONFIG_ACK) 3722 noack = false; 3723 } 3724 3725 if (noack) 3726 cb->flags |= ATH10K_SKB_F_NOACK_TID; 3727 } 3728 3729 /* Data frames encrypted in software will be posted to firmware 3730 * with tx encap mode set to RAW. Ex: Multicast traffic generated 3731 * for a specific VLAN group will always be encrypted in software. 3732 */ 3733 if (is_data && ieee80211_has_protected(hdr->frame_control) && 3734 !info->control.hw_key) { 3735 cb->flags |= ATH10K_SKB_F_NO_HWCRYPT; 3736 cb->flags |= ATH10K_SKB_F_RAW_TX; 3737 } 3738 3739 cb->vif = vif; 3740 cb->txq = txq; 3741 cb->airtime_est = airtime; 3742 if (sta) { 3743 arsta = (struct ath10k_sta *)sta->drv_priv; 3744 spin_lock_bh(&ar->data_lock); 3745 cb->ucast_cipher = arsta->ucast_cipher; 3746 spin_unlock_bh(&ar->data_lock); 3747 } 3748 } 3749 3750 bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar) 3751 { 3752 /* FIXME: Not really sure since when the behaviour changed. At some 3753 * point new firmware stopped requiring creation of peer entries for 3754 * offchannel tx (and actually creating them causes issues with wmi-htc 3755 * tx credit replenishment and reliability). Assuming it's at least 3.4 3756 * because that's when the `freq` was introduced to TX_FRM HTT command. 3757 */ 3758 return (ar->htt.target_version_major >= 3 && 3759 ar->htt.target_version_minor >= 4 && 3760 ar->running_fw->fw_file.htt_op_version == ATH10K_FW_HTT_OP_VERSION_TLV); 3761 } 3762 3763 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb) 3764 { 3765 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue; 3766 int ret = 0; 3767 3768 spin_lock_bh(&ar->data_lock); 3769 3770 if (skb_queue_len(q) == ATH10K_MAX_NUM_MGMT_PENDING) { 3771 ath10k_warn(ar, "wmi mgmt tx queue is full\n"); 3772 ret = -ENOSPC; 3773 goto unlock; 3774 } 3775 3776 __skb_queue_tail(q, skb); 3777 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work); 3778 3779 unlock: 3780 spin_unlock_bh(&ar->data_lock); 3781 3782 return ret; 3783 } 3784 3785 static enum ath10k_mac_tx_path 3786 ath10k_mac_tx_h_get_txpath(struct ath10k *ar, 3787 struct sk_buff *skb, 3788 enum ath10k_hw_txrx_mode txmode) 3789 { 3790 switch (txmode) { 3791 case ATH10K_HW_TXRX_RAW: 3792 case ATH10K_HW_TXRX_NATIVE_WIFI: 3793 case ATH10K_HW_TXRX_ETHERNET: 3794 return ATH10K_MAC_TX_HTT; 3795 case ATH10K_HW_TXRX_MGMT: 3796 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, 3797 ar->running_fw->fw_file.fw_features) || 3798 test_bit(WMI_SERVICE_MGMT_TX_WMI, 3799 ar->wmi.svc_map)) 3800 return ATH10K_MAC_TX_WMI_MGMT; 3801 else if (ar->htt.target_version_major >= 3) 3802 return ATH10K_MAC_TX_HTT; 3803 else 3804 return ATH10K_MAC_TX_HTT_MGMT; 3805 } 3806 3807 return ATH10K_MAC_TX_UNKNOWN; 3808 } 3809 3810 static int ath10k_mac_tx_submit(struct ath10k *ar, 3811 enum ath10k_hw_txrx_mode txmode, 3812 enum ath10k_mac_tx_path txpath, 3813 struct sk_buff *skb) 3814 { 3815 struct ath10k_htt *htt = &ar->htt; 3816 int ret = -EINVAL; 3817 3818 switch (txpath) { 3819 case ATH10K_MAC_TX_HTT: 3820 ret = ath10k_htt_tx(htt, txmode, skb); 3821 break; 3822 case ATH10K_MAC_TX_HTT_MGMT: 3823 ret = ath10k_htt_mgmt_tx(htt, skb); 3824 break; 3825 case ATH10K_MAC_TX_WMI_MGMT: 3826 ret = ath10k_mac_tx_wmi_mgmt(ar, skb); 3827 break; 3828 case ATH10K_MAC_TX_UNKNOWN: 3829 WARN_ON_ONCE(1); 3830 ret = -EINVAL; 3831 break; 3832 } 3833 3834 if (ret) { 3835 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n", 3836 ret); 3837 ieee80211_free_txskb(ar->hw, skb); 3838 } 3839 3840 return ret; 3841 } 3842 3843 /* This function consumes the sk_buff regardless of return value as far as 3844 * caller is concerned so no freeing is necessary afterwards. 3845 */ 3846 static int ath10k_mac_tx(struct ath10k *ar, 3847 struct ieee80211_vif *vif, 3848 enum ath10k_hw_txrx_mode txmode, 3849 enum ath10k_mac_tx_path txpath, 3850 struct sk_buff *skb, bool noque_offchan) 3851 { 3852 struct ieee80211_hw *hw = ar->hw; 3853 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 3854 const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb); 3855 int ret; 3856 3857 /* We should disable CCK RATE due to P2P */ 3858 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE) 3859 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n"); 3860 3861 switch (txmode) { 3862 case ATH10K_HW_TXRX_MGMT: 3863 case ATH10K_HW_TXRX_NATIVE_WIFI: 3864 ath10k_tx_h_nwifi(hw, skb); 3865 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb); 3866 ath10k_tx_h_seq_no(vif, skb); 3867 break; 3868 case ATH10K_HW_TXRX_ETHERNET: 3869 ath10k_tx_h_8023(skb); 3870 break; 3871 case ATH10K_HW_TXRX_RAW: 3872 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) && 3873 !(skb_cb->flags & ATH10K_SKB_F_RAW_TX)) { 3874 WARN_ON_ONCE(1); 3875 ieee80211_free_txskb(hw, skb); 3876 return -ENOTSUPP; 3877 } 3878 } 3879 3880 if (!noque_offchan && info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) { 3881 if (!ath10k_mac_tx_frm_has_freq(ar)) { 3882 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac queued offchannel skb %pK len %d\n", 3883 skb, skb->len); 3884 3885 skb_queue_tail(&ar->offchan_tx_queue, skb); 3886 ieee80211_queue_work(hw, &ar->offchan_tx_work); 3887 return 0; 3888 } 3889 } 3890 3891 ret = ath10k_mac_tx_submit(ar, txmode, txpath, skb); 3892 if (ret) { 3893 ath10k_warn(ar, "failed to submit frame: %d\n", ret); 3894 return ret; 3895 } 3896 3897 return 0; 3898 } 3899 3900 void ath10k_offchan_tx_purge(struct ath10k *ar) 3901 { 3902 struct sk_buff *skb; 3903 3904 for (;;) { 3905 skb = skb_dequeue(&ar->offchan_tx_queue); 3906 if (!skb) 3907 break; 3908 3909 ieee80211_free_txskb(ar->hw, skb); 3910 } 3911 } 3912 3913 void ath10k_offchan_tx_work(struct work_struct *work) 3914 { 3915 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work); 3916 struct ath10k_peer *peer; 3917 struct ath10k_vif *arvif; 3918 enum ath10k_hw_txrx_mode txmode; 3919 enum ath10k_mac_tx_path txpath; 3920 struct ieee80211_hdr *hdr; 3921 struct ieee80211_vif *vif; 3922 struct ieee80211_sta *sta; 3923 struct sk_buff *skb; 3924 const u8 *peer_addr; 3925 int vdev_id; 3926 int ret; 3927 unsigned long time_left; 3928 bool tmp_peer_created = false; 3929 3930 /* FW requirement: We must create a peer before FW will send out 3931 * an offchannel frame. Otherwise the frame will be stuck and 3932 * never transmitted. We delete the peer upon tx completion. 3933 * It is unlikely that a peer for offchannel tx will already be 3934 * present. However it may be in some rare cases so account for that. 3935 * Otherwise we might remove a legitimate peer and break stuff. 3936 */ 3937 3938 for (;;) { 3939 skb = skb_dequeue(&ar->offchan_tx_queue); 3940 if (!skb) 3941 break; 3942 3943 mutex_lock(&ar->conf_mutex); 3944 3945 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %pK len %d\n", 3946 skb, skb->len); 3947 3948 hdr = (struct ieee80211_hdr *)skb->data; 3949 peer_addr = ieee80211_get_DA(hdr); 3950 3951 spin_lock_bh(&ar->data_lock); 3952 vdev_id = ar->scan.vdev_id; 3953 peer = ath10k_peer_find(ar, vdev_id, peer_addr); 3954 spin_unlock_bh(&ar->data_lock); 3955 3956 if (peer) 3957 /* FIXME: should this use ath10k_warn()? */ 3958 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n", 3959 peer_addr, vdev_id); 3960 3961 if (!peer) { 3962 ret = ath10k_peer_create(ar, NULL, NULL, vdev_id, 3963 peer_addr, 3964 WMI_PEER_TYPE_DEFAULT); 3965 if (ret) 3966 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n", 3967 peer_addr, vdev_id, ret); 3968 tmp_peer_created = (ret == 0); 3969 } 3970 3971 spin_lock_bh(&ar->data_lock); 3972 reinit_completion(&ar->offchan_tx_completed); 3973 ar->offchan_tx_skb = skb; 3974 spin_unlock_bh(&ar->data_lock); 3975 3976 /* It's safe to access vif and sta - conf_mutex guarantees that 3977 * sta_state() and remove_interface() are locked exclusively 3978 * out wrt to this offchannel worker. 3979 */ 3980 arvif = ath10k_get_arvif(ar, vdev_id); 3981 if (arvif) { 3982 vif = arvif->vif; 3983 sta = ieee80211_find_sta(vif, peer_addr); 3984 } else { 3985 vif = NULL; 3986 sta = NULL; 3987 } 3988 3989 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb); 3990 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode); 3991 3992 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, true); 3993 if (ret) { 3994 ath10k_warn(ar, "failed to transmit offchannel frame: %d\n", 3995 ret); 3996 /* not serious */ 3997 } 3998 3999 time_left = 4000 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ); 4001 if (time_left == 0) 4002 ath10k_warn(ar, "timed out waiting for offchannel skb %pK, len: %d\n", 4003 skb, skb->len); 4004 4005 if (!peer && tmp_peer_created) { 4006 ret = ath10k_peer_delete(ar, vdev_id, peer_addr); 4007 if (ret) 4008 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n", 4009 peer_addr, vdev_id, ret); 4010 } 4011 4012 mutex_unlock(&ar->conf_mutex); 4013 } 4014 } 4015 4016 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar) 4017 { 4018 struct sk_buff *skb; 4019 4020 for (;;) { 4021 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue); 4022 if (!skb) 4023 break; 4024 4025 ieee80211_free_txskb(ar->hw, skb); 4026 } 4027 } 4028 4029 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work) 4030 { 4031 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work); 4032 struct sk_buff *skb; 4033 dma_addr_t paddr; 4034 int ret; 4035 4036 for (;;) { 4037 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue); 4038 if (!skb) 4039 break; 4040 4041 if (test_bit(ATH10K_FW_FEATURE_MGMT_TX_BY_REF, 4042 ar->running_fw->fw_file.fw_features)) { 4043 paddr = dma_map_single(ar->dev, skb->data, 4044 skb->len, DMA_TO_DEVICE); 4045 if (dma_mapping_error(ar->dev, paddr)) { 4046 ieee80211_free_txskb(ar->hw, skb); 4047 continue; 4048 } 4049 ret = ath10k_wmi_mgmt_tx_send(ar, skb, paddr); 4050 if (ret) { 4051 ath10k_warn(ar, "failed to transmit management frame by ref via WMI: %d\n", 4052 ret); 4053 /* remove this msdu from idr tracking */ 4054 ath10k_wmi_cleanup_mgmt_tx_send(ar, skb); 4055 4056 dma_unmap_single(ar->dev, paddr, skb->len, 4057 DMA_TO_DEVICE); 4058 ieee80211_free_txskb(ar->hw, skb); 4059 } 4060 } else { 4061 ret = ath10k_wmi_mgmt_tx(ar, skb); 4062 if (ret) { 4063 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n", 4064 ret); 4065 ieee80211_free_txskb(ar->hw, skb); 4066 } 4067 } 4068 } 4069 } 4070 4071 static void ath10k_mac_txq_init(struct ieee80211_txq *txq) 4072 { 4073 struct ath10k_txq *artxq; 4074 4075 if (!txq) 4076 return; 4077 4078 artxq = (void *)txq->drv_priv; 4079 INIT_LIST_HEAD(&artxq->list); 4080 } 4081 4082 static void ath10k_mac_txq_unref(struct ath10k *ar, struct ieee80211_txq *txq) 4083 { 4084 struct ath10k_skb_cb *cb; 4085 struct sk_buff *msdu; 4086 int msdu_id; 4087 4088 if (!txq) 4089 return; 4090 4091 spin_lock_bh(&ar->htt.tx_lock); 4092 idr_for_each_entry(&ar->htt.pending_tx, msdu, msdu_id) { 4093 cb = ATH10K_SKB_CB(msdu); 4094 if (cb->txq == txq) 4095 cb->txq = NULL; 4096 } 4097 spin_unlock_bh(&ar->htt.tx_lock); 4098 } 4099 4100 struct ieee80211_txq *ath10k_mac_txq_lookup(struct ath10k *ar, 4101 u16 peer_id, 4102 u8 tid) 4103 { 4104 struct ath10k_peer *peer; 4105 4106 lockdep_assert_held(&ar->data_lock); 4107 4108 peer = ar->peer_map[peer_id]; 4109 if (!peer) 4110 return NULL; 4111 4112 if (peer->removed) 4113 return NULL; 4114 4115 if (peer->sta) 4116 return peer->sta->txq[tid]; 4117 else if (peer->vif) 4118 return peer->vif->txq; 4119 else 4120 return NULL; 4121 } 4122 4123 static bool ath10k_mac_tx_can_push(struct ieee80211_hw *hw, 4124 struct ieee80211_txq *txq) 4125 { 4126 struct ath10k *ar = hw->priv; 4127 struct ath10k_txq *artxq = (void *)txq->drv_priv; 4128 4129 /* No need to get locks */ 4130 if (ar->htt.tx_q_state.mode == HTT_TX_MODE_SWITCH_PUSH) 4131 return true; 4132 4133 if (ar->htt.num_pending_tx < ar->htt.tx_q_state.num_push_allowed) 4134 return true; 4135 4136 if (artxq->num_fw_queued < artxq->num_push_allowed) 4137 return true; 4138 4139 return false; 4140 } 4141 4142 /* Return estimated airtime in microsecond, which is calculated using last 4143 * reported TX rate. This is just a rough estimation because host driver has no 4144 * knowledge of the actual transmit rate, retries or aggregation. If actual 4145 * airtime can be reported by firmware, then delta between estimated and actual 4146 * airtime can be adjusted from deficit. 4147 */ 4148 #define IEEE80211_ATF_OVERHEAD 100 /* IFS + some slot time */ 4149 #define IEEE80211_ATF_OVERHEAD_IFS 16 /* IFS only */ 4150 static u16 ath10k_mac_update_airtime(struct ath10k *ar, 4151 struct ieee80211_txq *txq, 4152 struct sk_buff *skb) 4153 { 4154 struct ath10k_sta *arsta; 4155 u32 pktlen; 4156 u16 airtime = 0; 4157 4158 if (!txq || !txq->sta) 4159 return airtime; 4160 4161 if (test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map)) 4162 return airtime; 4163 4164 spin_lock_bh(&ar->data_lock); 4165 arsta = (struct ath10k_sta *)txq->sta->drv_priv; 4166 4167 pktlen = skb->len + 38; /* Assume MAC header 30, SNAP 8 for most case */ 4168 if (arsta->last_tx_bitrate) { 4169 /* airtime in us, last_tx_bitrate in 100kbps */ 4170 airtime = (pktlen * 8 * (1000 / 100)) 4171 / arsta->last_tx_bitrate; 4172 /* overhead for media access time and IFS */ 4173 airtime += IEEE80211_ATF_OVERHEAD_IFS; 4174 } else { 4175 /* This is mostly for throttle excessive BC/MC frames, and the 4176 * airtime/rate doesn't need be exact. Airtime of BC/MC frames 4177 * in 2G get some discount, which helps prevent very low rate 4178 * frames from being blocked for too long. 4179 */ 4180 airtime = (pktlen * 8 * (1000 / 100)) / 60; /* 6M */ 4181 airtime += IEEE80211_ATF_OVERHEAD; 4182 } 4183 spin_unlock_bh(&ar->data_lock); 4184 4185 return airtime; 4186 } 4187 4188 int ath10k_mac_tx_push_txq(struct ieee80211_hw *hw, 4189 struct ieee80211_txq *txq) 4190 { 4191 struct ath10k *ar = hw->priv; 4192 struct ath10k_htt *htt = &ar->htt; 4193 struct ath10k_txq *artxq = (void *)txq->drv_priv; 4194 struct ieee80211_vif *vif = txq->vif; 4195 struct ieee80211_sta *sta = txq->sta; 4196 enum ath10k_hw_txrx_mode txmode; 4197 enum ath10k_mac_tx_path txpath; 4198 struct sk_buff *skb; 4199 struct ieee80211_hdr *hdr; 4200 size_t skb_len; 4201 bool is_mgmt, is_presp; 4202 int ret; 4203 u16 airtime; 4204 4205 spin_lock_bh(&ar->htt.tx_lock); 4206 ret = ath10k_htt_tx_inc_pending(htt); 4207 spin_unlock_bh(&ar->htt.tx_lock); 4208 4209 if (ret) 4210 return ret; 4211 4212 skb = ieee80211_tx_dequeue_ni(hw, txq); 4213 if (!skb) { 4214 spin_lock_bh(&ar->htt.tx_lock); 4215 ath10k_htt_tx_dec_pending(htt); 4216 spin_unlock_bh(&ar->htt.tx_lock); 4217 4218 return -ENOENT; 4219 } 4220 4221 airtime = ath10k_mac_update_airtime(ar, txq, skb); 4222 ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime); 4223 4224 skb_len = skb->len; 4225 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb); 4226 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode); 4227 is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT); 4228 4229 if (is_mgmt) { 4230 hdr = (struct ieee80211_hdr *)skb->data; 4231 is_presp = ieee80211_is_probe_resp(hdr->frame_control); 4232 4233 spin_lock_bh(&ar->htt.tx_lock); 4234 ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp); 4235 4236 if (ret) { 4237 ath10k_htt_tx_dec_pending(htt); 4238 spin_unlock_bh(&ar->htt.tx_lock); 4239 return ret; 4240 } 4241 spin_unlock_bh(&ar->htt.tx_lock); 4242 } 4243 4244 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false); 4245 if (unlikely(ret)) { 4246 ath10k_warn(ar, "failed to push frame: %d\n", ret); 4247 4248 spin_lock_bh(&ar->htt.tx_lock); 4249 ath10k_htt_tx_dec_pending(htt); 4250 if (is_mgmt) 4251 ath10k_htt_tx_mgmt_dec_pending(htt); 4252 spin_unlock_bh(&ar->htt.tx_lock); 4253 4254 return ret; 4255 } 4256 4257 spin_lock_bh(&ar->htt.tx_lock); 4258 artxq->num_fw_queued++; 4259 spin_unlock_bh(&ar->htt.tx_lock); 4260 4261 return skb_len; 4262 } 4263 4264 static int ath10k_mac_schedule_txq(struct ieee80211_hw *hw, u32 ac) 4265 { 4266 struct ieee80211_txq *txq; 4267 int ret = 0; 4268 4269 ieee80211_txq_schedule_start(hw, ac); 4270 while ((txq = ieee80211_next_txq(hw, ac))) { 4271 while (ath10k_mac_tx_can_push(hw, txq)) { 4272 ret = ath10k_mac_tx_push_txq(hw, txq); 4273 if (ret < 0) 4274 break; 4275 } 4276 ieee80211_return_txq(hw, txq, false); 4277 ath10k_htt_tx_txq_update(hw, txq); 4278 if (ret == -EBUSY) 4279 break; 4280 } 4281 ieee80211_txq_schedule_end(hw, ac); 4282 4283 return ret; 4284 } 4285 4286 void ath10k_mac_tx_push_pending(struct ath10k *ar) 4287 { 4288 struct ieee80211_hw *hw = ar->hw; 4289 u32 ac; 4290 4291 if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH) 4292 return; 4293 4294 if (ar->htt.num_pending_tx >= (ar->htt.max_num_pending_tx / 2)) 4295 return; 4296 4297 rcu_read_lock(); 4298 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 4299 if (ath10k_mac_schedule_txq(hw, ac) == -EBUSY) 4300 break; 4301 } 4302 rcu_read_unlock(); 4303 } 4304 EXPORT_SYMBOL(ath10k_mac_tx_push_pending); 4305 4306 /************/ 4307 /* Scanning */ 4308 /************/ 4309 4310 void __ath10k_scan_finish(struct ath10k *ar) 4311 { 4312 lockdep_assert_held(&ar->data_lock); 4313 4314 switch (ar->scan.state) { 4315 case ATH10K_SCAN_IDLE: 4316 break; 4317 case ATH10K_SCAN_RUNNING: 4318 case ATH10K_SCAN_ABORTING: 4319 if (!ar->scan.is_roc) { 4320 struct cfg80211_scan_info info = { 4321 .aborted = (ar->scan.state == 4322 ATH10K_SCAN_ABORTING), 4323 }; 4324 4325 ieee80211_scan_completed(ar->hw, &info); 4326 } else if (ar->scan.roc_notify) { 4327 ieee80211_remain_on_channel_expired(ar->hw); 4328 } 4329 fallthrough; 4330 case ATH10K_SCAN_STARTING: 4331 ar->scan.state = ATH10K_SCAN_IDLE; 4332 ar->scan_channel = NULL; 4333 ar->scan.roc_freq = 0; 4334 ath10k_offchan_tx_purge(ar); 4335 cancel_delayed_work(&ar->scan.timeout); 4336 complete(&ar->scan.completed); 4337 break; 4338 } 4339 } 4340 4341 void ath10k_scan_finish(struct ath10k *ar) 4342 { 4343 spin_lock_bh(&ar->data_lock); 4344 __ath10k_scan_finish(ar); 4345 spin_unlock_bh(&ar->data_lock); 4346 } 4347 4348 static int ath10k_scan_stop(struct ath10k *ar) 4349 { 4350 struct wmi_stop_scan_arg arg = { 4351 .req_id = 1, /* FIXME */ 4352 .req_type = WMI_SCAN_STOP_ONE, 4353 .u.scan_id = ATH10K_SCAN_ID, 4354 }; 4355 int ret; 4356 4357 lockdep_assert_held(&ar->conf_mutex); 4358 4359 ret = ath10k_wmi_stop_scan(ar, &arg); 4360 if (ret) { 4361 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret); 4362 goto out; 4363 } 4364 4365 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ); 4366 if (ret == 0) { 4367 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n"); 4368 ret = -ETIMEDOUT; 4369 } else if (ret > 0) { 4370 ret = 0; 4371 } 4372 4373 out: 4374 /* Scan state should be updated upon scan completion but in case 4375 * firmware fails to deliver the event (for whatever reason) it is 4376 * desired to clean up scan state anyway. Firmware may have just 4377 * dropped the scan completion event delivery due to transport pipe 4378 * being overflown with data and/or it can recover on its own before 4379 * next scan request is submitted. 4380 */ 4381 spin_lock_bh(&ar->data_lock); 4382 if (ar->scan.state != ATH10K_SCAN_IDLE) 4383 __ath10k_scan_finish(ar); 4384 spin_unlock_bh(&ar->data_lock); 4385 4386 return ret; 4387 } 4388 4389 static void ath10k_scan_abort(struct ath10k *ar) 4390 { 4391 int ret; 4392 4393 lockdep_assert_held(&ar->conf_mutex); 4394 4395 spin_lock_bh(&ar->data_lock); 4396 4397 switch (ar->scan.state) { 4398 case ATH10K_SCAN_IDLE: 4399 /* This can happen if timeout worker kicked in and called 4400 * abortion while scan completion was being processed. 4401 */ 4402 break; 4403 case ATH10K_SCAN_STARTING: 4404 case ATH10K_SCAN_ABORTING: 4405 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n", 4406 ath10k_scan_state_str(ar->scan.state), 4407 ar->scan.state); 4408 break; 4409 case ATH10K_SCAN_RUNNING: 4410 ar->scan.state = ATH10K_SCAN_ABORTING; 4411 spin_unlock_bh(&ar->data_lock); 4412 4413 ret = ath10k_scan_stop(ar); 4414 if (ret) 4415 ath10k_warn(ar, "failed to abort scan: %d\n", ret); 4416 4417 spin_lock_bh(&ar->data_lock); 4418 break; 4419 } 4420 4421 spin_unlock_bh(&ar->data_lock); 4422 } 4423 4424 void ath10k_scan_timeout_work(struct work_struct *work) 4425 { 4426 struct ath10k *ar = container_of(work, struct ath10k, 4427 scan.timeout.work); 4428 4429 mutex_lock(&ar->conf_mutex); 4430 ath10k_scan_abort(ar); 4431 mutex_unlock(&ar->conf_mutex); 4432 } 4433 4434 static int ath10k_start_scan(struct ath10k *ar, 4435 const struct wmi_start_scan_arg *arg) 4436 { 4437 int ret; 4438 4439 lockdep_assert_held(&ar->conf_mutex); 4440 4441 ret = ath10k_wmi_start_scan(ar, arg); 4442 if (ret) 4443 return ret; 4444 4445 ret = wait_for_completion_timeout(&ar->scan.started, 1 * HZ); 4446 if (ret == 0) { 4447 ret = ath10k_scan_stop(ar); 4448 if (ret) 4449 ath10k_warn(ar, "failed to stop scan: %d\n", ret); 4450 4451 return -ETIMEDOUT; 4452 } 4453 4454 /* If we failed to start the scan, return error code at 4455 * this point. This is probably due to some issue in the 4456 * firmware, but no need to wedge the driver due to that... 4457 */ 4458 spin_lock_bh(&ar->data_lock); 4459 if (ar->scan.state == ATH10K_SCAN_IDLE) { 4460 spin_unlock_bh(&ar->data_lock); 4461 return -EINVAL; 4462 } 4463 spin_unlock_bh(&ar->data_lock); 4464 4465 return 0; 4466 } 4467 4468 /**********************/ 4469 /* mac80211 callbacks */ 4470 /**********************/ 4471 4472 static void ath10k_mac_op_tx(struct ieee80211_hw *hw, 4473 struct ieee80211_tx_control *control, 4474 struct sk_buff *skb) 4475 { 4476 struct ath10k *ar = hw->priv; 4477 struct ath10k_htt *htt = &ar->htt; 4478 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 4479 struct ieee80211_vif *vif = info->control.vif; 4480 struct ieee80211_sta *sta = control->sta; 4481 struct ieee80211_txq *txq = NULL; 4482 struct ieee80211_hdr *hdr = (void *)skb->data; 4483 enum ath10k_hw_txrx_mode txmode; 4484 enum ath10k_mac_tx_path txpath; 4485 bool is_htt; 4486 bool is_mgmt; 4487 bool is_presp; 4488 int ret; 4489 u16 airtime; 4490 4491 airtime = ath10k_mac_update_airtime(ar, txq, skb); 4492 ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime); 4493 4494 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb); 4495 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode); 4496 is_htt = (txpath == ATH10K_MAC_TX_HTT || 4497 txpath == ATH10K_MAC_TX_HTT_MGMT); 4498 is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT); 4499 4500 if (is_htt) { 4501 spin_lock_bh(&ar->htt.tx_lock); 4502 is_presp = ieee80211_is_probe_resp(hdr->frame_control); 4503 4504 ret = ath10k_htt_tx_inc_pending(htt); 4505 if (ret) { 4506 ath10k_warn(ar, "failed to increase tx pending count: %d, dropping\n", 4507 ret); 4508 spin_unlock_bh(&ar->htt.tx_lock); 4509 ieee80211_free_txskb(ar->hw, skb); 4510 return; 4511 } 4512 4513 ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp); 4514 if (ret) { 4515 ath10k_dbg(ar, ATH10K_DBG_MAC, "failed to increase tx mgmt pending count: %d, dropping\n", 4516 ret); 4517 ath10k_htt_tx_dec_pending(htt); 4518 spin_unlock_bh(&ar->htt.tx_lock); 4519 ieee80211_free_txskb(ar->hw, skb); 4520 return; 4521 } 4522 spin_unlock_bh(&ar->htt.tx_lock); 4523 } 4524 4525 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false); 4526 if (ret) { 4527 ath10k_warn(ar, "failed to transmit frame: %d\n", ret); 4528 if (is_htt) { 4529 spin_lock_bh(&ar->htt.tx_lock); 4530 ath10k_htt_tx_dec_pending(htt); 4531 if (is_mgmt) 4532 ath10k_htt_tx_mgmt_dec_pending(htt); 4533 spin_unlock_bh(&ar->htt.tx_lock); 4534 } 4535 return; 4536 } 4537 } 4538 4539 static void ath10k_mac_op_wake_tx_queue(struct ieee80211_hw *hw, 4540 struct ieee80211_txq *txq) 4541 { 4542 struct ath10k *ar = hw->priv; 4543 int ret; 4544 u8 ac; 4545 4546 ath10k_htt_tx_txq_update(hw, txq); 4547 if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH) 4548 return; 4549 4550 ac = txq->ac; 4551 ieee80211_txq_schedule_start(hw, ac); 4552 txq = ieee80211_next_txq(hw, ac); 4553 if (!txq) 4554 goto out; 4555 4556 while (ath10k_mac_tx_can_push(hw, txq)) { 4557 ret = ath10k_mac_tx_push_txq(hw, txq); 4558 if (ret < 0) 4559 break; 4560 } 4561 ieee80211_return_txq(hw, txq, false); 4562 ath10k_htt_tx_txq_update(hw, txq); 4563 out: 4564 ieee80211_txq_schedule_end(hw, ac); 4565 } 4566 4567 /* Must not be called with conf_mutex held as workers can use that also. */ 4568 void ath10k_drain_tx(struct ath10k *ar) 4569 { 4570 /* make sure rcu-protected mac80211 tx path itself is drained */ 4571 synchronize_net(); 4572 4573 ath10k_offchan_tx_purge(ar); 4574 ath10k_mgmt_over_wmi_tx_purge(ar); 4575 4576 cancel_work_sync(&ar->offchan_tx_work); 4577 cancel_work_sync(&ar->wmi_mgmt_tx_work); 4578 } 4579 4580 void ath10k_halt(struct ath10k *ar) 4581 { 4582 struct ath10k_vif *arvif; 4583 4584 lockdep_assert_held(&ar->conf_mutex); 4585 4586 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 4587 ar->filter_flags = 0; 4588 ar->monitor = false; 4589 ar->monitor_arvif = NULL; 4590 4591 if (ar->monitor_started) 4592 ath10k_monitor_stop(ar); 4593 4594 ar->monitor_started = false; 4595 ar->tx_paused = 0; 4596 4597 ath10k_scan_finish(ar); 4598 ath10k_peer_cleanup_all(ar); 4599 ath10k_stop_radar_confirmation(ar); 4600 ath10k_core_stop(ar); 4601 ath10k_hif_power_down(ar); 4602 4603 spin_lock_bh(&ar->data_lock); 4604 list_for_each_entry(arvif, &ar->arvifs, list) 4605 ath10k_mac_vif_beacon_cleanup(arvif); 4606 spin_unlock_bh(&ar->data_lock); 4607 } 4608 4609 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 4610 { 4611 struct ath10k *ar = hw->priv; 4612 4613 mutex_lock(&ar->conf_mutex); 4614 4615 *tx_ant = ar->cfg_tx_chainmask; 4616 *rx_ant = ar->cfg_rx_chainmask; 4617 4618 mutex_unlock(&ar->conf_mutex); 4619 4620 return 0; 4621 } 4622 4623 static bool ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg) 4624 { 4625 /* It is not clear that allowing gaps in chainmask 4626 * is helpful. Probably it will not do what user 4627 * is hoping for, so warn in that case. 4628 */ 4629 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0) 4630 return true; 4631 4632 ath10k_warn(ar, "mac %s antenna chainmask is invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n", 4633 dbg, cm); 4634 return false; 4635 } 4636 4637 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar) 4638 { 4639 int nsts = ar->vht_cap_info; 4640 4641 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 4642 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 4643 4644 /* If firmware does not deliver to host number of space-time 4645 * streams supported, assume it support up to 4 BF STS and return 4646 * the value for VHT CAP: nsts-1) 4647 */ 4648 if (nsts == 0) 4649 return 3; 4650 4651 return nsts; 4652 } 4653 4654 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar) 4655 { 4656 int sound_dim = ar->vht_cap_info; 4657 4658 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 4659 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 4660 4661 /* If the sounding dimension is not advertised by the firmware, 4662 * let's use a default value of 1 4663 */ 4664 if (sound_dim == 0) 4665 return 1; 4666 4667 return sound_dim; 4668 } 4669 4670 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar) 4671 { 4672 struct ieee80211_sta_vht_cap vht_cap = {0}; 4673 struct ath10k_hw_params *hw = &ar->hw_params; 4674 u16 mcs_map; 4675 u32 val; 4676 int i; 4677 4678 vht_cap.vht_supported = 1; 4679 vht_cap.cap = ar->vht_cap_info; 4680 4681 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 4682 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) { 4683 val = ath10k_mac_get_vht_cap_bf_sts(ar); 4684 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 4685 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 4686 4687 vht_cap.cap |= val; 4688 } 4689 4690 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 4691 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) { 4692 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar); 4693 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 4694 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 4695 4696 vht_cap.cap |= val; 4697 } 4698 4699 mcs_map = 0; 4700 for (i = 0; i < 8; i++) { 4701 if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i))) 4702 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 4703 else 4704 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 4705 } 4706 4707 if (ar->cfg_tx_chainmask <= 1) 4708 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC; 4709 4710 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map); 4711 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map); 4712 4713 /* If we are supporting 160Mhz or 80+80, then the NIC may be able to do 4714 * a restricted NSS for 160 or 80+80 vs what it can do for 80Mhz. Give 4715 * user-space a clue if that is the case. 4716 */ 4717 if ((vht_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) && 4718 (hw->vht160_mcs_rx_highest != 0 || 4719 hw->vht160_mcs_tx_highest != 0)) { 4720 vht_cap.vht_mcs.rx_highest = cpu_to_le16(hw->vht160_mcs_rx_highest); 4721 vht_cap.vht_mcs.tx_highest = cpu_to_le16(hw->vht160_mcs_tx_highest); 4722 } 4723 4724 return vht_cap; 4725 } 4726 4727 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar) 4728 { 4729 int i; 4730 struct ieee80211_sta_ht_cap ht_cap = {0}; 4731 4732 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED)) 4733 return ht_cap; 4734 4735 ht_cap.ht_supported = 1; 4736 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 4737 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8; 4738 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 4739 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 4740 ht_cap.cap |= 4741 WLAN_HT_CAP_SM_PS_DISABLED << IEEE80211_HT_CAP_SM_PS_SHIFT; 4742 4743 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI) 4744 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 4745 4746 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI) 4747 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 4748 4749 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) { 4750 u32 smps; 4751 4752 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 4753 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 4754 4755 ht_cap.cap |= smps; 4756 } 4757 4758 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC && (ar->cfg_tx_chainmask > 1)) 4759 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 4760 4761 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) { 4762 u32 stbc; 4763 4764 stbc = ar->ht_cap_info; 4765 stbc &= WMI_HT_CAP_RX_STBC; 4766 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 4767 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 4768 stbc &= IEEE80211_HT_CAP_RX_STBC; 4769 4770 ht_cap.cap |= stbc; 4771 } 4772 4773 if (ar->ht_cap_info & WMI_HT_CAP_LDPC || (ar->ht_cap_info & 4774 WMI_HT_CAP_RX_LDPC && (ar->ht_cap_info & WMI_HT_CAP_TX_LDPC))) 4775 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 4776 4777 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT) 4778 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 4779 4780 /* max AMSDU is implicitly taken from vht_cap_info */ 4781 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 4782 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 4783 4784 for (i = 0; i < ar->num_rf_chains; i++) { 4785 if (ar->cfg_rx_chainmask & BIT(i)) 4786 ht_cap.mcs.rx_mask[i] = 0xFF; 4787 } 4788 4789 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 4790 4791 return ht_cap; 4792 } 4793 4794 static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar) 4795 { 4796 struct ieee80211_supported_band *band; 4797 struct ieee80211_sta_vht_cap vht_cap; 4798 struct ieee80211_sta_ht_cap ht_cap; 4799 4800 ht_cap = ath10k_get_ht_cap(ar); 4801 vht_cap = ath10k_create_vht_cap(ar); 4802 4803 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) { 4804 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 4805 band->ht_cap = ht_cap; 4806 } 4807 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) { 4808 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 4809 band->ht_cap = ht_cap; 4810 band->vht_cap = vht_cap; 4811 } 4812 } 4813 4814 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant) 4815 { 4816 int ret; 4817 bool is_valid_tx_chain_mask, is_valid_rx_chain_mask; 4818 4819 lockdep_assert_held(&ar->conf_mutex); 4820 4821 is_valid_tx_chain_mask = ath10k_check_chain_mask(ar, tx_ant, "tx"); 4822 is_valid_rx_chain_mask = ath10k_check_chain_mask(ar, rx_ant, "rx"); 4823 4824 if (!is_valid_tx_chain_mask || !is_valid_rx_chain_mask) 4825 return -EINVAL; 4826 4827 ar->cfg_tx_chainmask = tx_ant; 4828 ar->cfg_rx_chainmask = rx_ant; 4829 4830 if ((ar->state != ATH10K_STATE_ON) && 4831 (ar->state != ATH10K_STATE_RESTARTED)) 4832 return 0; 4833 4834 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask, 4835 tx_ant); 4836 if (ret) { 4837 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n", 4838 ret, tx_ant); 4839 return ret; 4840 } 4841 4842 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask, 4843 rx_ant); 4844 if (ret) { 4845 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n", 4846 ret, rx_ant); 4847 return ret; 4848 } 4849 4850 /* Reload HT/VHT capability */ 4851 ath10k_mac_setup_ht_vht_cap(ar); 4852 4853 return 0; 4854 } 4855 4856 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 4857 { 4858 struct ath10k *ar = hw->priv; 4859 int ret; 4860 4861 mutex_lock(&ar->conf_mutex); 4862 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant); 4863 mutex_unlock(&ar->conf_mutex); 4864 return ret; 4865 } 4866 4867 static int __ath10k_fetch_bb_timing_dt(struct ath10k *ar, 4868 struct wmi_bb_timing_cfg_arg *bb_timing) 4869 { 4870 struct device_node *node; 4871 const char *fem_name; 4872 int ret; 4873 4874 node = ar->dev->of_node; 4875 if (!node) 4876 return -ENOENT; 4877 4878 ret = of_property_read_string_index(node, "ext-fem-name", 0, &fem_name); 4879 if (ret) 4880 return -ENOENT; 4881 4882 /* 4883 * If external Front End module used in hardware, then default base band timing 4884 * parameter cannot be used since they were fine tuned for reference hardware, 4885 * so choosing different value suitable for that external FEM. 4886 */ 4887 if (!strcmp("microsemi-lx5586", fem_name)) { 4888 bb_timing->bb_tx_timing = 0x00; 4889 bb_timing->bb_xpa_timing = 0x0101; 4890 } else { 4891 return -ENOENT; 4892 } 4893 4894 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot bb_tx_timing 0x%x bb_xpa_timing 0x%x\n", 4895 bb_timing->bb_tx_timing, bb_timing->bb_xpa_timing); 4896 return 0; 4897 } 4898 4899 static int ath10k_mac_rfkill_config(struct ath10k *ar) 4900 { 4901 u32 param; 4902 int ret; 4903 4904 if (ar->hw_values->rfkill_pin == 0) { 4905 ath10k_warn(ar, "ath10k does not support hardware rfkill with this device\n"); 4906 return -EOPNOTSUPP; 4907 } 4908 4909 ath10k_dbg(ar, ATH10K_DBG_MAC, 4910 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d", 4911 ar->hw_values->rfkill_pin, ar->hw_values->rfkill_cfg, 4912 ar->hw_values->rfkill_on_level); 4913 4914 param = FIELD_PREP(WMI_TLV_RFKILL_CFG_RADIO_LEVEL, 4915 ar->hw_values->rfkill_on_level) | 4916 FIELD_PREP(WMI_TLV_RFKILL_CFG_GPIO_PIN_NUM, 4917 ar->hw_values->rfkill_pin) | 4918 FIELD_PREP(WMI_TLV_RFKILL_CFG_PIN_AS_GPIO, 4919 ar->hw_values->rfkill_cfg); 4920 4921 ret = ath10k_wmi_pdev_set_param(ar, 4922 ar->wmi.pdev_param->rfkill_config, 4923 param); 4924 if (ret) { 4925 ath10k_warn(ar, 4926 "failed to set rfkill config 0x%x: %d\n", 4927 param, ret); 4928 return ret; 4929 } 4930 return 0; 4931 } 4932 4933 int ath10k_mac_rfkill_enable_radio(struct ath10k *ar, bool enable) 4934 { 4935 enum wmi_tlv_rfkill_enable_radio param; 4936 int ret; 4937 4938 if (enable) 4939 param = WMI_TLV_RFKILL_ENABLE_RADIO_ON; 4940 else 4941 param = WMI_TLV_RFKILL_ENABLE_RADIO_OFF; 4942 4943 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac rfkill enable %d", param); 4944 4945 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rfkill_enable, 4946 param); 4947 if (ret) { 4948 ath10k_warn(ar, "failed to set rfkill enable param %d: %d\n", 4949 param, ret); 4950 return ret; 4951 } 4952 4953 return 0; 4954 } 4955 4956 static int ath10k_start(struct ieee80211_hw *hw) 4957 { 4958 struct ath10k *ar = hw->priv; 4959 u32 param; 4960 int ret = 0; 4961 struct wmi_bb_timing_cfg_arg bb_timing = {0}; 4962 4963 /* 4964 * This makes sense only when restarting hw. It is harmless to call 4965 * unconditionally. This is necessary to make sure no HTT/WMI tx 4966 * commands will be submitted while restarting. 4967 */ 4968 ath10k_drain_tx(ar); 4969 4970 mutex_lock(&ar->conf_mutex); 4971 4972 switch (ar->state) { 4973 case ATH10K_STATE_OFF: 4974 ar->state = ATH10K_STATE_ON; 4975 break; 4976 case ATH10K_STATE_RESTARTING: 4977 ar->state = ATH10K_STATE_RESTARTED; 4978 break; 4979 case ATH10K_STATE_ON: 4980 case ATH10K_STATE_RESTARTED: 4981 case ATH10K_STATE_WEDGED: 4982 WARN_ON(1); 4983 ret = -EINVAL; 4984 goto err; 4985 case ATH10K_STATE_UTF: 4986 ret = -EBUSY; 4987 goto err; 4988 } 4989 4990 spin_lock_bh(&ar->data_lock); 4991 4992 if (ar->hw_rfkill_on) { 4993 ar->hw_rfkill_on = false; 4994 spin_unlock_bh(&ar->data_lock); 4995 goto err; 4996 } 4997 4998 spin_unlock_bh(&ar->data_lock); 4999 5000 ret = ath10k_hif_power_up(ar, ATH10K_FIRMWARE_MODE_NORMAL); 5001 if (ret) { 5002 ath10k_err(ar, "Could not init hif: %d\n", ret); 5003 goto err_off; 5004 } 5005 5006 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL, 5007 &ar->normal_mode_fw); 5008 if (ret) { 5009 ath10k_err(ar, "Could not init core: %d\n", ret); 5010 goto err_power_down; 5011 } 5012 5013 if (ar->sys_cap_info & WMI_TLV_SYS_CAP_INFO_RFKILL) { 5014 ret = ath10k_mac_rfkill_config(ar); 5015 if (ret && ret != -EOPNOTSUPP) { 5016 ath10k_warn(ar, "failed to configure rfkill: %d", ret); 5017 goto err_core_stop; 5018 } 5019 } 5020 5021 param = ar->wmi.pdev_param->pmf_qos; 5022 ret = ath10k_wmi_pdev_set_param(ar, param, 1); 5023 if (ret) { 5024 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret); 5025 goto err_core_stop; 5026 } 5027 5028 param = ar->wmi.pdev_param->dynamic_bw; 5029 ret = ath10k_wmi_pdev_set_param(ar, param, 1); 5030 if (ret) { 5031 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret); 5032 goto err_core_stop; 5033 } 5034 5035 if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) { 5036 ret = ath10k_wmi_scan_prob_req_oui(ar, ar->mac_addr); 5037 if (ret) { 5038 ath10k_err(ar, "failed to set prob req oui: %i\n", ret); 5039 goto err_core_stop; 5040 } 5041 } 5042 5043 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) { 5044 ret = ath10k_wmi_adaptive_qcs(ar, true); 5045 if (ret) { 5046 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n", 5047 ret); 5048 goto err_core_stop; 5049 } 5050 } 5051 5052 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) { 5053 param = ar->wmi.pdev_param->burst_enable; 5054 ret = ath10k_wmi_pdev_set_param(ar, param, 0); 5055 if (ret) { 5056 ath10k_warn(ar, "failed to disable burst: %d\n", ret); 5057 goto err_core_stop; 5058 } 5059 } 5060 5061 param = ar->wmi.pdev_param->idle_ps_config; 5062 ret = ath10k_wmi_pdev_set_param(ar, param, 1); 5063 if (ret && ret != -EOPNOTSUPP) { 5064 ath10k_warn(ar, "failed to enable idle_ps_config: %d\n", ret); 5065 goto err_core_stop; 5066 } 5067 5068 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask); 5069 5070 /* 5071 * By default FW set ARP frames ac to voice (6). In that case ARP 5072 * exchange is not working properly for UAPSD enabled AP. ARP requests 5073 * which arrives with access category 0 are processed by network stack 5074 * and send back with access category 0, but FW changes access category 5075 * to 6. Set ARP frames access category to best effort (0) solves 5076 * this problem. 5077 */ 5078 5079 param = ar->wmi.pdev_param->arp_ac_override; 5080 ret = ath10k_wmi_pdev_set_param(ar, param, 0); 5081 if (ret) { 5082 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n", 5083 ret); 5084 goto err_core_stop; 5085 } 5086 5087 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA, 5088 ar->running_fw->fw_file.fw_features)) { 5089 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1, 5090 WMI_CCA_DETECT_LEVEL_AUTO, 5091 WMI_CCA_DETECT_MARGIN_AUTO); 5092 if (ret) { 5093 ath10k_warn(ar, "failed to enable adaptive cca: %d\n", 5094 ret); 5095 goto err_core_stop; 5096 } 5097 } 5098 5099 param = ar->wmi.pdev_param->ani_enable; 5100 ret = ath10k_wmi_pdev_set_param(ar, param, 1); 5101 if (ret) { 5102 ath10k_warn(ar, "failed to enable ani by default: %d\n", 5103 ret); 5104 goto err_core_stop; 5105 } 5106 5107 ar->ani_enabled = true; 5108 5109 if (ath10k_peer_stats_enabled(ar)) { 5110 param = ar->wmi.pdev_param->peer_stats_update_period; 5111 ret = ath10k_wmi_pdev_set_param(ar, param, 5112 PEER_DEFAULT_STATS_UPDATE_PERIOD); 5113 if (ret) { 5114 ath10k_warn(ar, 5115 "failed to set peer stats period : %d\n", 5116 ret); 5117 goto err_core_stop; 5118 } 5119 } 5120 5121 param = ar->wmi.pdev_param->enable_btcoex; 5122 if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map) && 5123 test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM, 5124 ar->running_fw->fw_file.fw_features) && 5125 ar->coex_support) { 5126 ret = ath10k_wmi_pdev_set_param(ar, param, 0); 5127 if (ret) { 5128 ath10k_warn(ar, 5129 "failed to set btcoex param: %d\n", ret); 5130 goto err_core_stop; 5131 } 5132 clear_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags); 5133 } 5134 5135 if (test_bit(WMI_SERVICE_BB_TIMING_CONFIG_SUPPORT, ar->wmi.svc_map)) { 5136 ret = __ath10k_fetch_bb_timing_dt(ar, &bb_timing); 5137 if (!ret) { 5138 ret = ath10k_wmi_pdev_bb_timing(ar, &bb_timing); 5139 if (ret) { 5140 ath10k_warn(ar, 5141 "failed to set bb timings: %d\n", 5142 ret); 5143 goto err_core_stop; 5144 } 5145 } 5146 } 5147 5148 ar->num_started_vdevs = 0; 5149 ath10k_regd_update(ar); 5150 5151 ath10k_spectral_start(ar); 5152 ath10k_thermal_set_throttling(ar); 5153 5154 ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_IDLE; 5155 5156 mutex_unlock(&ar->conf_mutex); 5157 return 0; 5158 5159 err_core_stop: 5160 ath10k_core_stop(ar); 5161 5162 err_power_down: 5163 ath10k_hif_power_down(ar); 5164 5165 err_off: 5166 ar->state = ATH10K_STATE_OFF; 5167 5168 err: 5169 mutex_unlock(&ar->conf_mutex); 5170 return ret; 5171 } 5172 5173 static void ath10k_stop(struct ieee80211_hw *hw) 5174 { 5175 struct ath10k *ar = hw->priv; 5176 5177 ath10k_drain_tx(ar); 5178 5179 mutex_lock(&ar->conf_mutex); 5180 if (ar->state != ATH10K_STATE_OFF) { 5181 if (!ar->hw_rfkill_on) 5182 ath10k_halt(ar); 5183 ar->state = ATH10K_STATE_OFF; 5184 } 5185 mutex_unlock(&ar->conf_mutex); 5186 5187 cancel_work_sync(&ar->set_coverage_class_work); 5188 cancel_delayed_work_sync(&ar->scan.timeout); 5189 cancel_work_sync(&ar->restart_work); 5190 } 5191 5192 static int ath10k_config_ps(struct ath10k *ar) 5193 { 5194 struct ath10k_vif *arvif; 5195 int ret = 0; 5196 5197 lockdep_assert_held(&ar->conf_mutex); 5198 5199 list_for_each_entry(arvif, &ar->arvifs, list) { 5200 ret = ath10k_mac_vif_setup_ps(arvif); 5201 if (ret) { 5202 ath10k_warn(ar, "failed to setup powersave: %d\n", ret); 5203 break; 5204 } 5205 } 5206 5207 return ret; 5208 } 5209 5210 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower) 5211 { 5212 int ret; 5213 u32 param; 5214 5215 lockdep_assert_held(&ar->conf_mutex); 5216 5217 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower); 5218 5219 param = ar->wmi.pdev_param->txpower_limit2g; 5220 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2); 5221 if (ret) { 5222 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n", 5223 txpower, ret); 5224 return ret; 5225 } 5226 5227 param = ar->wmi.pdev_param->txpower_limit5g; 5228 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2); 5229 if (ret) { 5230 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n", 5231 txpower, ret); 5232 return ret; 5233 } 5234 5235 return 0; 5236 } 5237 5238 static int ath10k_mac_txpower_recalc(struct ath10k *ar) 5239 { 5240 struct ath10k_vif *arvif; 5241 int ret, txpower = -1; 5242 5243 lockdep_assert_held(&ar->conf_mutex); 5244 5245 list_for_each_entry(arvif, &ar->arvifs, list) { 5246 /* txpower not initialized yet? */ 5247 if (arvif->txpower == INT_MIN) 5248 continue; 5249 5250 if (txpower == -1) 5251 txpower = arvif->txpower; 5252 else 5253 txpower = min(txpower, arvif->txpower); 5254 } 5255 5256 if (txpower == -1) 5257 return 0; 5258 5259 ret = ath10k_mac_txpower_setup(ar, txpower); 5260 if (ret) { 5261 ath10k_warn(ar, "failed to setup tx power %d: %d\n", 5262 txpower, ret); 5263 return ret; 5264 } 5265 5266 return 0; 5267 } 5268 5269 static int ath10k_config(struct ieee80211_hw *hw, u32 changed) 5270 { 5271 struct ath10k *ar = hw->priv; 5272 struct ieee80211_conf *conf = &hw->conf; 5273 int ret = 0; 5274 5275 mutex_lock(&ar->conf_mutex); 5276 5277 if (changed & IEEE80211_CONF_CHANGE_PS) 5278 ath10k_config_ps(ar); 5279 5280 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 5281 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR; 5282 ret = ath10k_monitor_recalc(ar); 5283 if (ret) 5284 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 5285 } 5286 5287 mutex_unlock(&ar->conf_mutex); 5288 return ret; 5289 } 5290 5291 static u32 get_nss_from_chainmask(u16 chain_mask) 5292 { 5293 if ((chain_mask & 0xf) == 0xf) 5294 return 4; 5295 else if ((chain_mask & 0x7) == 0x7) 5296 return 3; 5297 else if ((chain_mask & 0x3) == 0x3) 5298 return 2; 5299 return 1; 5300 } 5301 5302 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif) 5303 { 5304 u32 value = 0; 5305 struct ath10k *ar = arvif->ar; 5306 int nsts; 5307 int sound_dim; 5308 5309 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC) 5310 return 0; 5311 5312 nsts = ath10k_mac_get_vht_cap_bf_sts(ar); 5313 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 5314 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) 5315 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET); 5316 5317 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar); 5318 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 5319 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) 5320 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET); 5321 5322 if (!value) 5323 return 0; 5324 5325 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) 5326 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 5327 5328 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) 5329 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER | 5330 WMI_VDEV_PARAM_TXBF_SU_TX_BFER); 5331 5332 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) 5333 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 5334 5335 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) 5336 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE | 5337 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE); 5338 5339 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 5340 ar->wmi.vdev_param->txbf, value); 5341 } 5342 5343 /* 5344 * TODO: 5345 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE, 5346 * because we will send mgmt frames without CCK. This requirement 5347 * for P2P_FIND/GO_NEG should be handled by checking CCK flag 5348 * in the TX packet. 5349 */ 5350 static int ath10k_add_interface(struct ieee80211_hw *hw, 5351 struct ieee80211_vif *vif) 5352 { 5353 struct ath10k *ar = hw->priv; 5354 struct ath10k_vif *arvif = (void *)vif->drv_priv; 5355 struct ath10k_peer *peer; 5356 enum wmi_sta_powersave_param param; 5357 int ret = 0; 5358 u32 value; 5359 int bit; 5360 int i; 5361 u32 vdev_param; 5362 5363 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 5364 5365 mutex_lock(&ar->conf_mutex); 5366 5367 memset(arvif, 0, sizeof(*arvif)); 5368 ath10k_mac_txq_init(vif->txq); 5369 5370 arvif->ar = ar; 5371 arvif->vif = vif; 5372 5373 INIT_LIST_HEAD(&arvif->list); 5374 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work); 5375 INIT_DELAYED_WORK(&arvif->connection_loss_work, 5376 ath10k_mac_vif_sta_connection_loss_work); 5377 5378 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) { 5379 arvif->bitrate_mask.control[i].legacy = 0xffffffff; 5380 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff, 5381 sizeof(arvif->bitrate_mask.control[i].ht_mcs)); 5382 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff, 5383 sizeof(arvif->bitrate_mask.control[i].vht_mcs)); 5384 } 5385 5386 if (ar->num_peers >= ar->max_num_peers) { 5387 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n"); 5388 ret = -ENOBUFS; 5389 goto err; 5390 } 5391 5392 if (ar->free_vdev_map == 0) { 5393 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n"); 5394 ret = -EBUSY; 5395 goto err; 5396 } 5397 bit = __ffs64(ar->free_vdev_map); 5398 5399 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n", 5400 bit, ar->free_vdev_map); 5401 5402 arvif->vdev_id = bit; 5403 arvif->vdev_subtype = 5404 ath10k_wmi_get_vdev_subtype(ar, WMI_VDEV_SUBTYPE_NONE); 5405 5406 switch (vif->type) { 5407 case NL80211_IFTYPE_P2P_DEVICE: 5408 arvif->vdev_type = WMI_VDEV_TYPE_STA; 5409 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype 5410 (ar, WMI_VDEV_SUBTYPE_P2P_DEVICE); 5411 break; 5412 case NL80211_IFTYPE_UNSPECIFIED: 5413 case NL80211_IFTYPE_STATION: 5414 arvif->vdev_type = WMI_VDEV_TYPE_STA; 5415 if (vif->p2p) 5416 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype 5417 (ar, WMI_VDEV_SUBTYPE_P2P_CLIENT); 5418 break; 5419 case NL80211_IFTYPE_ADHOC: 5420 arvif->vdev_type = WMI_VDEV_TYPE_IBSS; 5421 break; 5422 case NL80211_IFTYPE_MESH_POINT: 5423 if (test_bit(WMI_SERVICE_MESH_11S, ar->wmi.svc_map)) { 5424 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype 5425 (ar, WMI_VDEV_SUBTYPE_MESH_11S); 5426 } else if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) { 5427 ret = -EINVAL; 5428 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n"); 5429 goto err; 5430 } 5431 arvif->vdev_type = WMI_VDEV_TYPE_AP; 5432 break; 5433 case NL80211_IFTYPE_AP: 5434 arvif->vdev_type = WMI_VDEV_TYPE_AP; 5435 5436 if (vif->p2p) 5437 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype 5438 (ar, WMI_VDEV_SUBTYPE_P2P_GO); 5439 break; 5440 case NL80211_IFTYPE_MONITOR: 5441 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 5442 break; 5443 default: 5444 WARN_ON(1); 5445 break; 5446 } 5447 5448 /* Using vdev_id as queue number will make it very easy to do per-vif 5449 * tx queue locking. This shouldn't wrap due to interface combinations 5450 * but do a modulo for correctness sake and prevent using offchannel tx 5451 * queues for regular vif tx. 5452 */ 5453 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1); 5454 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 5455 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1); 5456 5457 /* Some firmware revisions don't wait for beacon tx completion before 5458 * sending another SWBA event. This could lead to hardware using old 5459 * (freed) beacon data in some cases, e.g. tx credit starvation 5460 * combined with missed TBTT. This is very rare. 5461 * 5462 * On non-IOMMU-enabled hosts this could be a possible security issue 5463 * because hw could beacon some random data on the air. On 5464 * IOMMU-enabled hosts DMAR faults would occur in most cases and target 5465 * device would crash. 5466 * 5467 * Since there are no beacon tx completions (implicit nor explicit) 5468 * propagated to host the only workaround for this is to allocate a 5469 * DMA-coherent buffer for a lifetime of a vif and use it for all 5470 * beacon tx commands. Worst case for this approach is some beacons may 5471 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap. 5472 */ 5473 if (vif->type == NL80211_IFTYPE_ADHOC || 5474 vif->type == NL80211_IFTYPE_MESH_POINT || 5475 vif->type == NL80211_IFTYPE_AP) { 5476 arvif->beacon_buf = dma_alloc_coherent(ar->dev, 5477 IEEE80211_MAX_FRAME_LEN, 5478 &arvif->beacon_paddr, 5479 GFP_ATOMIC); 5480 if (!arvif->beacon_buf) { 5481 ret = -ENOMEM; 5482 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n", 5483 ret); 5484 goto err; 5485 } 5486 } 5487 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags)) 5488 arvif->nohwcrypt = true; 5489 5490 if (arvif->nohwcrypt && 5491 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) { 5492 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n"); 5493 goto err; 5494 } 5495 5496 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n", 5497 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype, 5498 arvif->beacon_buf ? "single-buf" : "per-skb"); 5499 5500 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type, 5501 arvif->vdev_subtype, vif->addr); 5502 if (ret) { 5503 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n", 5504 arvif->vdev_id, ret); 5505 goto err; 5506 } 5507 5508 if (test_bit(WMI_SERVICE_VDEV_DISABLE_4_ADDR_SRC_LRN_SUPPORT, 5509 ar->wmi.svc_map)) { 5510 vdev_param = ar->wmi.vdev_param->disable_4addr_src_lrn; 5511 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5512 WMI_VDEV_DISABLE_4_ADDR_SRC_LRN); 5513 if (ret && ret != -EOPNOTSUPP) { 5514 ath10k_warn(ar, "failed to disable 4addr src lrn vdev %i: %d\n", 5515 arvif->vdev_id, ret); 5516 } 5517 } 5518 5519 ar->free_vdev_map &= ~(1LL << arvif->vdev_id); 5520 spin_lock_bh(&ar->data_lock); 5521 list_add(&arvif->list, &ar->arvifs); 5522 spin_unlock_bh(&ar->data_lock); 5523 5524 /* It makes no sense to have firmware do keepalives. mac80211 already 5525 * takes care of this with idle connection polling. 5526 */ 5527 ret = ath10k_mac_vif_disable_keepalive(arvif); 5528 if (ret) { 5529 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n", 5530 arvif->vdev_id, ret); 5531 goto err_vdev_delete; 5532 } 5533 5534 arvif->def_wep_key_idx = -1; 5535 5536 vdev_param = ar->wmi.vdev_param->tx_encap_type; 5537 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5538 ATH10K_HW_TXRX_NATIVE_WIFI); 5539 /* 10.X firmware does not support this VDEV parameter. Do not warn */ 5540 if (ret && ret != -EOPNOTSUPP) { 5541 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n", 5542 arvif->vdev_id, ret); 5543 goto err_vdev_delete; 5544 } 5545 5546 /* Configuring number of spatial stream for monitor interface is causing 5547 * target assert in qca9888 and qca6174. 5548 */ 5549 if (ar->cfg_tx_chainmask && (vif->type != NL80211_IFTYPE_MONITOR)) { 5550 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask); 5551 5552 vdev_param = ar->wmi.vdev_param->nss; 5553 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5554 nss); 5555 if (ret) { 5556 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n", 5557 arvif->vdev_id, ar->cfg_tx_chainmask, nss, 5558 ret); 5559 goto err_vdev_delete; 5560 } 5561 } 5562 5563 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 5564 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 5565 ret = ath10k_peer_create(ar, vif, NULL, arvif->vdev_id, 5566 vif->addr, WMI_PEER_TYPE_DEFAULT); 5567 if (ret) { 5568 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n", 5569 arvif->vdev_id, ret); 5570 goto err_vdev_delete; 5571 } 5572 5573 spin_lock_bh(&ar->data_lock); 5574 5575 peer = ath10k_peer_find(ar, arvif->vdev_id, vif->addr); 5576 if (!peer) { 5577 ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n", 5578 vif->addr, arvif->vdev_id); 5579 spin_unlock_bh(&ar->data_lock); 5580 ret = -ENOENT; 5581 goto err_peer_delete; 5582 } 5583 5584 arvif->peer_id = find_first_bit(peer->peer_ids, 5585 ATH10K_MAX_NUM_PEER_IDS); 5586 5587 spin_unlock_bh(&ar->data_lock); 5588 } else { 5589 arvif->peer_id = HTT_INVALID_PEERID; 5590 } 5591 5592 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 5593 ret = ath10k_mac_set_kickout(arvif); 5594 if (ret) { 5595 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n", 5596 arvif->vdev_id, ret); 5597 goto err_peer_delete; 5598 } 5599 } 5600 5601 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) { 5602 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 5603 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 5604 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5605 param, value); 5606 if (ret) { 5607 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n", 5608 arvif->vdev_id, ret); 5609 goto err_peer_delete; 5610 } 5611 5612 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif); 5613 if (ret) { 5614 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n", 5615 arvif->vdev_id, ret); 5616 goto err_peer_delete; 5617 } 5618 5619 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif); 5620 if (ret) { 5621 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n", 5622 arvif->vdev_id, ret); 5623 goto err_peer_delete; 5624 } 5625 } 5626 5627 ret = ath10k_mac_set_txbf_conf(arvif); 5628 if (ret) { 5629 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n", 5630 arvif->vdev_id, ret); 5631 goto err_peer_delete; 5632 } 5633 5634 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold); 5635 if (ret) { 5636 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n", 5637 arvif->vdev_id, ret); 5638 goto err_peer_delete; 5639 } 5640 5641 arvif->txpower = vif->bss_conf.txpower; 5642 ret = ath10k_mac_txpower_recalc(ar); 5643 if (ret) { 5644 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret); 5645 goto err_peer_delete; 5646 } 5647 5648 if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) { 5649 vdev_param = ar->wmi.vdev_param->rtt_responder_role; 5650 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5651 arvif->ftm_responder); 5652 5653 /* It is harmless to not set FTM role. Do not warn */ 5654 if (ret && ret != -EOPNOTSUPP) 5655 ath10k_warn(ar, "failed to set vdev %i FTM Responder: %d\n", 5656 arvif->vdev_id, ret); 5657 } 5658 5659 if (vif->type == NL80211_IFTYPE_MONITOR) { 5660 ar->monitor_arvif = arvif; 5661 ret = ath10k_monitor_recalc(ar); 5662 if (ret) { 5663 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 5664 goto err_peer_delete; 5665 } 5666 } 5667 5668 spin_lock_bh(&ar->htt.tx_lock); 5669 if (!ar->tx_paused) 5670 ieee80211_wake_queue(ar->hw, arvif->vdev_id); 5671 spin_unlock_bh(&ar->htt.tx_lock); 5672 5673 mutex_unlock(&ar->conf_mutex); 5674 return 0; 5675 5676 err_peer_delete: 5677 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 5678 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 5679 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr); 5680 ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id, 5681 vif->addr); 5682 } 5683 5684 err_vdev_delete: 5685 ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 5686 ar->free_vdev_map |= 1LL << arvif->vdev_id; 5687 spin_lock_bh(&ar->data_lock); 5688 list_del(&arvif->list); 5689 spin_unlock_bh(&ar->data_lock); 5690 5691 err: 5692 if (arvif->beacon_buf) { 5693 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN, 5694 arvif->beacon_buf, arvif->beacon_paddr); 5695 arvif->beacon_buf = NULL; 5696 } 5697 5698 mutex_unlock(&ar->conf_mutex); 5699 5700 return ret; 5701 } 5702 5703 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif) 5704 { 5705 int i; 5706 5707 for (i = 0; i < BITS_PER_LONG; i++) 5708 ath10k_mac_vif_tx_unlock(arvif, i); 5709 } 5710 5711 static void ath10k_remove_interface(struct ieee80211_hw *hw, 5712 struct ieee80211_vif *vif) 5713 { 5714 struct ath10k *ar = hw->priv; 5715 struct ath10k_vif *arvif = (void *)vif->drv_priv; 5716 struct ath10k_peer *peer; 5717 unsigned long time_left; 5718 int ret; 5719 int i; 5720 5721 cancel_work_sync(&arvif->ap_csa_work); 5722 cancel_delayed_work_sync(&arvif->connection_loss_work); 5723 5724 mutex_lock(&ar->conf_mutex); 5725 5726 ret = ath10k_spectral_vif_stop(arvif); 5727 if (ret) 5728 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n", 5729 arvif->vdev_id, ret); 5730 5731 ar->free_vdev_map |= 1LL << arvif->vdev_id; 5732 spin_lock_bh(&ar->data_lock); 5733 list_del(&arvif->list); 5734 spin_unlock_bh(&ar->data_lock); 5735 5736 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 5737 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 5738 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id, 5739 vif->addr); 5740 if (ret) 5741 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n", 5742 arvif->vdev_id, ret); 5743 5744 ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id, 5745 vif->addr); 5746 kfree(arvif->u.ap.noa_data); 5747 } 5748 5749 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n", 5750 arvif->vdev_id); 5751 5752 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 5753 if (ret) 5754 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n", 5755 arvif->vdev_id, ret); 5756 5757 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) { 5758 time_left = wait_for_completion_timeout(&ar->vdev_delete_done, 5759 ATH10K_VDEV_DELETE_TIMEOUT_HZ); 5760 if (time_left == 0) { 5761 ath10k_warn(ar, "Timeout in receiving vdev delete response\n"); 5762 goto out; 5763 } 5764 } 5765 5766 /* Some firmware revisions don't notify host about self-peer removal 5767 * until after associated vdev is deleted. 5768 */ 5769 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 5770 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 5771 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id, 5772 vif->addr); 5773 if (ret) 5774 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n", 5775 arvif->vdev_id, ret); 5776 5777 spin_lock_bh(&ar->data_lock); 5778 ar->num_peers--; 5779 spin_unlock_bh(&ar->data_lock); 5780 } 5781 5782 spin_lock_bh(&ar->data_lock); 5783 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) { 5784 peer = ar->peer_map[i]; 5785 if (!peer) 5786 continue; 5787 5788 if (peer->vif == vif) { 5789 ath10k_warn(ar, "found vif peer %pM entry on vdev %i after it was supposedly removed\n", 5790 vif->addr, arvif->vdev_id); 5791 peer->vif = NULL; 5792 } 5793 } 5794 5795 /* Clean this up late, less opportunity for firmware to access 5796 * DMA memory we have deleted. 5797 */ 5798 ath10k_mac_vif_beacon_cleanup(arvif); 5799 spin_unlock_bh(&ar->data_lock); 5800 5801 ath10k_peer_cleanup(ar, arvif->vdev_id); 5802 ath10k_mac_txq_unref(ar, vif->txq); 5803 5804 if (vif->type == NL80211_IFTYPE_MONITOR) { 5805 ar->monitor_arvif = NULL; 5806 ret = ath10k_monitor_recalc(ar); 5807 if (ret) 5808 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 5809 } 5810 5811 ret = ath10k_mac_txpower_recalc(ar); 5812 if (ret) 5813 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret); 5814 5815 spin_lock_bh(&ar->htt.tx_lock); 5816 ath10k_mac_vif_tx_unlock_all(arvif); 5817 spin_unlock_bh(&ar->htt.tx_lock); 5818 5819 ath10k_mac_txq_unref(ar, vif->txq); 5820 5821 out: 5822 mutex_unlock(&ar->conf_mutex); 5823 } 5824 5825 /* 5826 * FIXME: Has to be verified. 5827 */ 5828 #define SUPPORTED_FILTERS \ 5829 (FIF_ALLMULTI | \ 5830 FIF_CONTROL | \ 5831 FIF_PSPOLL | \ 5832 FIF_OTHER_BSS | \ 5833 FIF_BCN_PRBRESP_PROMISC | \ 5834 FIF_PROBE_REQ | \ 5835 FIF_FCSFAIL) 5836 5837 static void ath10k_configure_filter(struct ieee80211_hw *hw, 5838 unsigned int changed_flags, 5839 unsigned int *total_flags, 5840 u64 multicast) 5841 { 5842 struct ath10k *ar = hw->priv; 5843 int ret; 5844 5845 mutex_lock(&ar->conf_mutex); 5846 5847 changed_flags &= SUPPORTED_FILTERS; 5848 *total_flags &= SUPPORTED_FILTERS; 5849 ar->filter_flags = *total_flags; 5850 5851 ret = ath10k_monitor_recalc(ar); 5852 if (ret) 5853 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 5854 5855 mutex_unlock(&ar->conf_mutex); 5856 } 5857 5858 static void ath10k_recalculate_mgmt_rate(struct ath10k *ar, 5859 struct ieee80211_vif *vif, 5860 struct cfg80211_chan_def *def) 5861 { 5862 struct ath10k_vif *arvif = (void *)vif->drv_priv; 5863 const struct ieee80211_supported_band *sband; 5864 u8 basic_rate_idx; 5865 int hw_rate_code; 5866 u32 vdev_param; 5867 u16 bitrate; 5868 int ret; 5869 5870 lockdep_assert_held(&ar->conf_mutex); 5871 5872 sband = ar->hw->wiphy->bands[def->chan->band]; 5873 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1; 5874 bitrate = sband->bitrates[basic_rate_idx].bitrate; 5875 5876 hw_rate_code = ath10k_mac_get_rate_hw_value(bitrate); 5877 if (hw_rate_code < 0) { 5878 ath10k_warn(ar, "bitrate not supported %d\n", bitrate); 5879 return; 5880 } 5881 5882 vdev_param = ar->wmi.vdev_param->mgmt_rate; 5883 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5884 hw_rate_code); 5885 if (ret) 5886 ath10k_warn(ar, "failed to set mgmt tx rate %d\n", ret); 5887 } 5888 5889 static void ath10k_bss_info_changed(struct ieee80211_hw *hw, 5890 struct ieee80211_vif *vif, 5891 struct ieee80211_bss_conf *info, 5892 u32 changed) 5893 { 5894 struct ath10k *ar = hw->priv; 5895 struct ath10k_vif *arvif = (void *)vif->drv_priv; 5896 struct cfg80211_chan_def def; 5897 u32 vdev_param, pdev_param, slottime, preamble; 5898 u16 bitrate, hw_value; 5899 u8 rate, rateidx; 5900 int ret = 0, mcast_rate; 5901 enum nl80211_band band; 5902 5903 mutex_lock(&ar->conf_mutex); 5904 5905 if (changed & BSS_CHANGED_IBSS) 5906 ath10k_control_ibss(arvif, info, vif->addr); 5907 5908 if (changed & BSS_CHANGED_BEACON_INT) { 5909 arvif->beacon_interval = info->beacon_int; 5910 vdev_param = ar->wmi.vdev_param->beacon_interval; 5911 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5912 arvif->beacon_interval); 5913 ath10k_dbg(ar, ATH10K_DBG_MAC, 5914 "mac vdev %d beacon_interval %d\n", 5915 arvif->vdev_id, arvif->beacon_interval); 5916 5917 if (ret) 5918 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n", 5919 arvif->vdev_id, ret); 5920 } 5921 5922 if (changed & BSS_CHANGED_BEACON) { 5923 ath10k_dbg(ar, ATH10K_DBG_MAC, 5924 "vdev %d set beacon tx mode to staggered\n", 5925 arvif->vdev_id); 5926 5927 pdev_param = ar->wmi.pdev_param->beacon_tx_mode; 5928 ret = ath10k_wmi_pdev_set_param(ar, pdev_param, 5929 WMI_BEACON_STAGGERED_MODE); 5930 if (ret) 5931 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n", 5932 arvif->vdev_id, ret); 5933 5934 ret = ath10k_mac_setup_bcn_tmpl(arvif); 5935 if (ret) 5936 ath10k_warn(ar, "failed to update beacon template: %d\n", 5937 ret); 5938 5939 if (ieee80211_vif_is_mesh(vif)) { 5940 /* mesh doesn't use SSID but firmware needs it */ 5941 strncpy(arvif->u.ap.ssid, "mesh", 5942 sizeof(arvif->u.ap.ssid)); 5943 arvif->u.ap.ssid_len = 4; 5944 } 5945 } 5946 5947 if (changed & BSS_CHANGED_AP_PROBE_RESP) { 5948 ret = ath10k_mac_setup_prb_tmpl(arvif); 5949 if (ret) 5950 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n", 5951 arvif->vdev_id, ret); 5952 } 5953 5954 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) { 5955 arvif->dtim_period = info->dtim_period; 5956 5957 ath10k_dbg(ar, ATH10K_DBG_MAC, 5958 "mac vdev %d dtim_period %d\n", 5959 arvif->vdev_id, arvif->dtim_period); 5960 5961 vdev_param = ar->wmi.vdev_param->dtim_period; 5962 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5963 arvif->dtim_period); 5964 if (ret) 5965 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n", 5966 arvif->vdev_id, ret); 5967 } 5968 5969 if (changed & BSS_CHANGED_SSID && 5970 vif->type == NL80211_IFTYPE_AP) { 5971 arvif->u.ap.ssid_len = info->ssid_len; 5972 if (info->ssid_len) 5973 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len); 5974 arvif->u.ap.hidden_ssid = info->hidden_ssid; 5975 } 5976 5977 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid)) 5978 ether_addr_copy(arvif->bssid, info->bssid); 5979 5980 if (changed & BSS_CHANGED_FTM_RESPONDER && 5981 arvif->ftm_responder != info->ftm_responder && 5982 test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) { 5983 arvif->ftm_responder = info->ftm_responder; 5984 5985 vdev_param = ar->wmi.vdev_param->rtt_responder_role; 5986 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5987 arvif->ftm_responder); 5988 5989 ath10k_dbg(ar, ATH10K_DBG_MAC, 5990 "mac vdev %d ftm_responder %d:ret %d\n", 5991 arvif->vdev_id, arvif->ftm_responder, ret); 5992 } 5993 5994 if (changed & BSS_CHANGED_BEACON_ENABLED) 5995 ath10k_control_beaconing(arvif, info); 5996 5997 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 5998 arvif->use_cts_prot = info->use_cts_prot; 5999 6000 ret = ath10k_recalc_rtscts_prot(arvif); 6001 if (ret) 6002 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n", 6003 arvif->vdev_id, ret); 6004 6005 if (ath10k_mac_can_set_cts_prot(arvif)) { 6006 ret = ath10k_mac_set_cts_prot(arvif); 6007 if (ret) 6008 ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n", 6009 arvif->vdev_id, ret); 6010 } 6011 } 6012 6013 if (changed & BSS_CHANGED_ERP_SLOT) { 6014 if (info->use_short_slot) 6015 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 6016 6017 else 6018 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 6019 6020 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n", 6021 arvif->vdev_id, slottime); 6022 6023 vdev_param = ar->wmi.vdev_param->slot_time; 6024 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 6025 slottime); 6026 if (ret) 6027 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n", 6028 arvif->vdev_id, ret); 6029 } 6030 6031 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 6032 if (info->use_short_preamble) 6033 preamble = WMI_VDEV_PREAMBLE_SHORT; 6034 else 6035 preamble = WMI_VDEV_PREAMBLE_LONG; 6036 6037 ath10k_dbg(ar, ATH10K_DBG_MAC, 6038 "mac vdev %d preamble %dn", 6039 arvif->vdev_id, preamble); 6040 6041 vdev_param = ar->wmi.vdev_param->preamble; 6042 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 6043 preamble); 6044 if (ret) 6045 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n", 6046 arvif->vdev_id, ret); 6047 } 6048 6049 if (changed & BSS_CHANGED_ASSOC) { 6050 if (info->assoc) { 6051 /* Workaround: Make sure monitor vdev is not running 6052 * when associating to prevent some firmware revisions 6053 * (e.g. 10.1 and 10.2) from crashing. 6054 */ 6055 if (ar->monitor_started) 6056 ath10k_monitor_stop(ar); 6057 ath10k_bss_assoc(hw, vif, info); 6058 ath10k_monitor_recalc(ar); 6059 } else { 6060 ath10k_bss_disassoc(hw, vif); 6061 } 6062 } 6063 6064 if (changed & BSS_CHANGED_TXPOWER) { 6065 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n", 6066 arvif->vdev_id, info->txpower); 6067 6068 arvif->txpower = info->txpower; 6069 ret = ath10k_mac_txpower_recalc(ar); 6070 if (ret) 6071 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret); 6072 } 6073 6074 if (changed & BSS_CHANGED_PS) { 6075 arvif->ps = vif->bss_conf.ps; 6076 6077 ret = ath10k_config_ps(ar); 6078 if (ret) 6079 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n", 6080 arvif->vdev_id, ret); 6081 } 6082 6083 if (changed & BSS_CHANGED_MCAST_RATE && 6084 !ath10k_mac_vif_chan(arvif->vif, &def)) { 6085 band = def.chan->band; 6086 mcast_rate = vif->bss_conf.mcast_rate[band]; 6087 if (mcast_rate > 0) 6088 rateidx = mcast_rate - 1; 6089 else 6090 rateidx = ffs(vif->bss_conf.basic_rates) - 1; 6091 6092 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) 6093 rateidx += ATH10K_MAC_FIRST_OFDM_RATE_IDX; 6094 6095 bitrate = ath10k_wmi_legacy_rates[rateidx].bitrate; 6096 hw_value = ath10k_wmi_legacy_rates[rateidx].hw_value; 6097 if (ath10k_mac_bitrate_is_cck(bitrate)) 6098 preamble = WMI_RATE_PREAMBLE_CCK; 6099 else 6100 preamble = WMI_RATE_PREAMBLE_OFDM; 6101 6102 rate = ATH10K_HW_RATECODE(hw_value, 0, preamble); 6103 6104 ath10k_dbg(ar, ATH10K_DBG_MAC, 6105 "mac vdev %d mcast_rate %x\n", 6106 arvif->vdev_id, rate); 6107 6108 vdev_param = ar->wmi.vdev_param->mcast_data_rate; 6109 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 6110 vdev_param, rate); 6111 if (ret) 6112 ath10k_warn(ar, 6113 "failed to set mcast rate on vdev %i: %d\n", 6114 arvif->vdev_id, ret); 6115 6116 vdev_param = ar->wmi.vdev_param->bcast_data_rate; 6117 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 6118 vdev_param, rate); 6119 if (ret) 6120 ath10k_warn(ar, 6121 "failed to set bcast rate on vdev %i: %d\n", 6122 arvif->vdev_id, ret); 6123 } 6124 6125 if (changed & BSS_CHANGED_BASIC_RATES && 6126 !ath10k_mac_vif_chan(arvif->vif, &def)) 6127 ath10k_recalculate_mgmt_rate(ar, vif, &def); 6128 6129 mutex_unlock(&ar->conf_mutex); 6130 } 6131 6132 static void ath10k_mac_op_set_coverage_class(struct ieee80211_hw *hw, s16 value) 6133 { 6134 struct ath10k *ar = hw->priv; 6135 6136 /* This function should never be called if setting the coverage class 6137 * is not supported on this hardware. 6138 */ 6139 if (!ar->hw_params.hw_ops->set_coverage_class) { 6140 WARN_ON_ONCE(1); 6141 return; 6142 } 6143 ar->hw_params.hw_ops->set_coverage_class(ar, value); 6144 } 6145 6146 struct ath10k_mac_tdls_iter_data { 6147 u32 num_tdls_stations; 6148 struct ieee80211_vif *curr_vif; 6149 }; 6150 6151 static void ath10k_mac_tdls_vif_stations_count_iter(void *data, 6152 struct ieee80211_sta *sta) 6153 { 6154 struct ath10k_mac_tdls_iter_data *iter_data = data; 6155 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 6156 struct ieee80211_vif *sta_vif = arsta->arvif->vif; 6157 6158 if (sta->tdls && sta_vif == iter_data->curr_vif) 6159 iter_data->num_tdls_stations++; 6160 } 6161 6162 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw, 6163 struct ieee80211_vif *vif) 6164 { 6165 struct ath10k_mac_tdls_iter_data data = {}; 6166 6167 data.curr_vif = vif; 6168 6169 ieee80211_iterate_stations_atomic(hw, 6170 ath10k_mac_tdls_vif_stations_count_iter, 6171 &data); 6172 return data.num_tdls_stations; 6173 } 6174 6175 static int ath10k_hw_scan(struct ieee80211_hw *hw, 6176 struct ieee80211_vif *vif, 6177 struct ieee80211_scan_request *hw_req) 6178 { 6179 struct ath10k *ar = hw->priv; 6180 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6181 struct cfg80211_scan_request *req = &hw_req->req; 6182 struct wmi_start_scan_arg arg; 6183 int ret = 0; 6184 int i; 6185 u32 scan_timeout; 6186 6187 mutex_lock(&ar->conf_mutex); 6188 6189 if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) { 6190 ret = -EBUSY; 6191 goto exit; 6192 } 6193 6194 spin_lock_bh(&ar->data_lock); 6195 switch (ar->scan.state) { 6196 case ATH10K_SCAN_IDLE: 6197 reinit_completion(&ar->scan.started); 6198 reinit_completion(&ar->scan.completed); 6199 ar->scan.state = ATH10K_SCAN_STARTING; 6200 ar->scan.is_roc = false; 6201 ar->scan.vdev_id = arvif->vdev_id; 6202 ret = 0; 6203 break; 6204 case ATH10K_SCAN_STARTING: 6205 case ATH10K_SCAN_RUNNING: 6206 case ATH10K_SCAN_ABORTING: 6207 ret = -EBUSY; 6208 break; 6209 } 6210 spin_unlock_bh(&ar->data_lock); 6211 6212 if (ret) 6213 goto exit; 6214 6215 memset(&arg, 0, sizeof(arg)); 6216 ath10k_wmi_start_scan_init(ar, &arg); 6217 arg.vdev_id = arvif->vdev_id; 6218 arg.scan_id = ATH10K_SCAN_ID; 6219 6220 if (req->ie_len) { 6221 arg.ie_len = req->ie_len; 6222 memcpy(arg.ie, req->ie, arg.ie_len); 6223 } 6224 6225 if (req->n_ssids) { 6226 arg.n_ssids = req->n_ssids; 6227 for (i = 0; i < arg.n_ssids; i++) { 6228 arg.ssids[i].len = req->ssids[i].ssid_len; 6229 arg.ssids[i].ssid = req->ssids[i].ssid; 6230 } 6231 } else { 6232 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 6233 } 6234 6235 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 6236 arg.scan_ctrl_flags |= WMI_SCAN_ADD_SPOOFED_MAC_IN_PROBE_REQ; 6237 ether_addr_copy(arg.mac_addr.addr, req->mac_addr); 6238 ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask); 6239 } 6240 6241 if (req->n_channels) { 6242 arg.n_channels = req->n_channels; 6243 for (i = 0; i < arg.n_channels; i++) 6244 arg.channels[i] = req->channels[i]->center_freq; 6245 } 6246 6247 /* if duration is set, default dwell times will be overwritten */ 6248 if (req->duration) { 6249 arg.dwell_time_active = req->duration; 6250 arg.dwell_time_passive = req->duration; 6251 arg.burst_duration_ms = req->duration; 6252 6253 scan_timeout = min_t(u32, arg.max_rest_time * 6254 (arg.n_channels - 1) + (req->duration + 6255 ATH10K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD) * 6256 arg.n_channels, arg.max_scan_time + 200); 6257 6258 } else { 6259 /* Add a 200ms margin to account for event/command processing */ 6260 scan_timeout = arg.max_scan_time + 200; 6261 } 6262 6263 ret = ath10k_start_scan(ar, &arg); 6264 if (ret) { 6265 ath10k_warn(ar, "failed to start hw scan: %d\n", ret); 6266 spin_lock_bh(&ar->data_lock); 6267 ar->scan.state = ATH10K_SCAN_IDLE; 6268 spin_unlock_bh(&ar->data_lock); 6269 } 6270 6271 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 6272 msecs_to_jiffies(scan_timeout)); 6273 6274 exit: 6275 mutex_unlock(&ar->conf_mutex); 6276 return ret; 6277 } 6278 6279 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw, 6280 struct ieee80211_vif *vif) 6281 { 6282 struct ath10k *ar = hw->priv; 6283 6284 mutex_lock(&ar->conf_mutex); 6285 ath10k_scan_abort(ar); 6286 mutex_unlock(&ar->conf_mutex); 6287 6288 cancel_delayed_work_sync(&ar->scan.timeout); 6289 } 6290 6291 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar, 6292 struct ath10k_vif *arvif, 6293 enum set_key_cmd cmd, 6294 struct ieee80211_key_conf *key) 6295 { 6296 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid; 6297 int ret; 6298 6299 /* 10.1 firmware branch requires default key index to be set to group 6300 * key index after installing it. Otherwise FW/HW Txes corrupted 6301 * frames with multi-vif APs. This is not required for main firmware 6302 * branch (e.g. 636). 6303 * 6304 * This is also needed for 636 fw for IBSS-RSN to work more reliably. 6305 * 6306 * FIXME: It remains unknown if this is required for multi-vif STA 6307 * interfaces on 10.1. 6308 */ 6309 6310 if (arvif->vdev_type != WMI_VDEV_TYPE_AP && 6311 arvif->vdev_type != WMI_VDEV_TYPE_IBSS) 6312 return; 6313 6314 if (key->cipher == WLAN_CIPHER_SUITE_WEP40) 6315 return; 6316 6317 if (key->cipher == WLAN_CIPHER_SUITE_WEP104) 6318 return; 6319 6320 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 6321 return; 6322 6323 if (cmd != SET_KEY) 6324 return; 6325 6326 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 6327 key->keyidx); 6328 if (ret) 6329 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n", 6330 arvif->vdev_id, ret); 6331 } 6332 6333 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 6334 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 6335 struct ieee80211_key_conf *key) 6336 { 6337 struct ath10k *ar = hw->priv; 6338 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6339 struct ath10k_sta *arsta; 6340 struct ath10k_peer *peer; 6341 const u8 *peer_addr; 6342 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 || 6343 key->cipher == WLAN_CIPHER_SUITE_WEP104; 6344 int ret = 0; 6345 int ret2; 6346 u32 flags = 0; 6347 u32 flags2; 6348 6349 /* this one needs to be done in software */ 6350 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC || 6351 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 || 6352 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 || 6353 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256) 6354 return 1; 6355 6356 if (arvif->nohwcrypt) 6357 return 1; 6358 6359 if (key->keyidx > WMI_MAX_KEY_INDEX) 6360 return -ENOSPC; 6361 6362 mutex_lock(&ar->conf_mutex); 6363 6364 if (sta) { 6365 arsta = (struct ath10k_sta *)sta->drv_priv; 6366 peer_addr = sta->addr; 6367 spin_lock_bh(&ar->data_lock); 6368 arsta->ucast_cipher = key->cipher; 6369 spin_unlock_bh(&ar->data_lock); 6370 } else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) { 6371 peer_addr = vif->bss_conf.bssid; 6372 } else { 6373 peer_addr = vif->addr; 6374 } 6375 6376 key->hw_key_idx = key->keyidx; 6377 6378 if (is_wep) { 6379 if (cmd == SET_KEY) 6380 arvif->wep_keys[key->keyidx] = key; 6381 else 6382 arvif->wep_keys[key->keyidx] = NULL; 6383 } 6384 6385 /* the peer should not disappear in mid-way (unless FW goes awry) since 6386 * we already hold conf_mutex. we just make sure its there now. 6387 */ 6388 spin_lock_bh(&ar->data_lock); 6389 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 6390 spin_unlock_bh(&ar->data_lock); 6391 6392 if (!peer) { 6393 if (cmd == SET_KEY) { 6394 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n", 6395 peer_addr); 6396 ret = -EOPNOTSUPP; 6397 goto exit; 6398 } else { 6399 /* if the peer doesn't exist there is no key to disable anymore */ 6400 goto exit; 6401 } 6402 } 6403 6404 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 6405 flags |= WMI_KEY_PAIRWISE; 6406 else 6407 flags |= WMI_KEY_GROUP; 6408 6409 if (is_wep) { 6410 if (cmd == DISABLE_KEY) 6411 ath10k_clear_vdev_key(arvif, key); 6412 6413 /* When WEP keys are uploaded it's possible that there are 6414 * stations associated already (e.g. when merging) without any 6415 * keys. Static WEP needs an explicit per-peer key upload. 6416 */ 6417 if (vif->type == NL80211_IFTYPE_ADHOC && 6418 cmd == SET_KEY) 6419 ath10k_mac_vif_update_wep_key(arvif, key); 6420 6421 /* 802.1x never sets the def_wep_key_idx so each set_key() 6422 * call changes default tx key. 6423 * 6424 * Static WEP sets def_wep_key_idx via .set_default_unicast_key 6425 * after first set_key(). 6426 */ 6427 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1) 6428 flags |= WMI_KEY_TX_USAGE; 6429 } 6430 6431 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags); 6432 if (ret) { 6433 WARN_ON(ret > 0); 6434 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n", 6435 arvif->vdev_id, peer_addr, ret); 6436 goto exit; 6437 } 6438 6439 /* mac80211 sets static WEP keys as groupwise while firmware requires 6440 * them to be installed twice as both pairwise and groupwise. 6441 */ 6442 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) { 6443 flags2 = flags; 6444 flags2 &= ~WMI_KEY_GROUP; 6445 flags2 |= WMI_KEY_PAIRWISE; 6446 6447 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2); 6448 if (ret) { 6449 WARN_ON(ret > 0); 6450 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n", 6451 arvif->vdev_id, peer_addr, ret); 6452 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY, 6453 peer_addr, flags); 6454 if (ret2) { 6455 WARN_ON(ret2 > 0); 6456 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n", 6457 arvif->vdev_id, peer_addr, ret2); 6458 } 6459 goto exit; 6460 } 6461 } 6462 6463 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key); 6464 6465 spin_lock_bh(&ar->data_lock); 6466 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 6467 if (peer && cmd == SET_KEY) 6468 peer->keys[key->keyidx] = key; 6469 else if (peer && cmd == DISABLE_KEY) 6470 peer->keys[key->keyidx] = NULL; 6471 else if (peer == NULL) 6472 /* impossible unless FW goes crazy */ 6473 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr); 6474 spin_unlock_bh(&ar->data_lock); 6475 6476 if (sta && sta->tdls) 6477 ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6478 ar->wmi.peer_param->authorize, 1); 6479 else if (sta && cmd == SET_KEY && (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 6480 ath10k_wmi_peer_set_param(ar, arvif->vdev_id, peer_addr, 6481 ar->wmi.peer_param->authorize, 1); 6482 6483 exit: 6484 mutex_unlock(&ar->conf_mutex); 6485 return ret; 6486 } 6487 6488 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw, 6489 struct ieee80211_vif *vif, 6490 int keyidx) 6491 { 6492 struct ath10k *ar = hw->priv; 6493 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6494 int ret; 6495 6496 mutex_lock(&arvif->ar->conf_mutex); 6497 6498 if (arvif->ar->state != ATH10K_STATE_ON) 6499 goto unlock; 6500 6501 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n", 6502 arvif->vdev_id, keyidx); 6503 6504 ret = ath10k_wmi_vdev_set_param(arvif->ar, 6505 arvif->vdev_id, 6506 arvif->ar->wmi.vdev_param->def_keyid, 6507 keyidx); 6508 6509 if (ret) { 6510 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n", 6511 arvif->vdev_id, 6512 ret); 6513 goto unlock; 6514 } 6515 6516 arvif->def_wep_key_idx = keyidx; 6517 6518 unlock: 6519 mutex_unlock(&arvif->ar->conf_mutex); 6520 } 6521 6522 static void ath10k_sta_rc_update_wk(struct work_struct *wk) 6523 { 6524 struct ath10k *ar; 6525 struct ath10k_vif *arvif; 6526 struct ath10k_sta *arsta; 6527 struct ieee80211_sta *sta; 6528 struct cfg80211_chan_def def; 6529 enum nl80211_band band; 6530 const u8 *ht_mcs_mask; 6531 const u16 *vht_mcs_mask; 6532 u32 changed, bw, nss, smps; 6533 int err; 6534 6535 arsta = container_of(wk, struct ath10k_sta, update_wk); 6536 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 6537 arvif = arsta->arvif; 6538 ar = arvif->ar; 6539 6540 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def))) 6541 return; 6542 6543 band = def.chan->band; 6544 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 6545 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 6546 6547 spin_lock_bh(&ar->data_lock); 6548 6549 changed = arsta->changed; 6550 arsta->changed = 0; 6551 6552 bw = arsta->bw; 6553 nss = arsta->nss; 6554 smps = arsta->smps; 6555 6556 spin_unlock_bh(&ar->data_lock); 6557 6558 mutex_lock(&ar->conf_mutex); 6559 6560 nss = max_t(u32, 1, nss); 6561 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask), 6562 ath10k_mac_max_vht_nss(vht_mcs_mask))); 6563 6564 if (changed & IEEE80211_RC_BW_CHANGED) { 6565 enum wmi_phy_mode mode; 6566 6567 mode = chan_to_phymode(&def); 6568 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d phymode %d\n", 6569 sta->addr, bw, mode); 6570 6571 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6572 ar->wmi.peer_param->phymode, mode); 6573 if (err) { 6574 ath10k_warn(ar, "failed to update STA %pM peer phymode %d: %d\n", 6575 sta->addr, mode, err); 6576 goto exit; 6577 } 6578 6579 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6580 ar->wmi.peer_param->chan_width, bw); 6581 if (err) 6582 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n", 6583 sta->addr, bw, err); 6584 } 6585 6586 if (changed & IEEE80211_RC_NSS_CHANGED) { 6587 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n", 6588 sta->addr, nss); 6589 6590 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6591 ar->wmi.peer_param->nss, nss); 6592 if (err) 6593 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n", 6594 sta->addr, nss, err); 6595 } 6596 6597 if (changed & IEEE80211_RC_SMPS_CHANGED) { 6598 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n", 6599 sta->addr, smps); 6600 6601 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6602 ar->wmi.peer_param->smps_state, smps); 6603 if (err) 6604 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n", 6605 sta->addr, smps, err); 6606 } 6607 6608 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) { 6609 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates\n", 6610 sta->addr); 6611 6612 err = ath10k_station_assoc(ar, arvif->vif, sta, true); 6613 if (err) 6614 ath10k_warn(ar, "failed to reassociate station: %pM\n", 6615 sta->addr); 6616 } 6617 6618 exit: 6619 mutex_unlock(&ar->conf_mutex); 6620 } 6621 6622 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif, 6623 struct ieee80211_sta *sta) 6624 { 6625 struct ath10k *ar = arvif->ar; 6626 6627 lockdep_assert_held(&ar->conf_mutex); 6628 6629 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 6630 return 0; 6631 6632 if (ar->num_stations >= ar->max_num_stations) 6633 return -ENOBUFS; 6634 6635 ar->num_stations++; 6636 6637 return 0; 6638 } 6639 6640 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif, 6641 struct ieee80211_sta *sta) 6642 { 6643 struct ath10k *ar = arvif->ar; 6644 6645 lockdep_assert_held(&ar->conf_mutex); 6646 6647 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 6648 return; 6649 6650 ar->num_stations--; 6651 } 6652 6653 static int ath10k_sta_set_txpwr(struct ieee80211_hw *hw, 6654 struct ieee80211_vif *vif, 6655 struct ieee80211_sta *sta) 6656 { 6657 struct ath10k *ar = hw->priv; 6658 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6659 int ret = 0; 6660 s16 txpwr; 6661 6662 if (sta->txpwr.type == NL80211_TX_POWER_AUTOMATIC) { 6663 txpwr = 0; 6664 } else { 6665 txpwr = sta->txpwr.power; 6666 if (!txpwr) 6667 return -EINVAL; 6668 } 6669 6670 if (txpwr > ATH10K_TX_POWER_MAX_VAL || txpwr < ATH10K_TX_POWER_MIN_VAL) 6671 return -EINVAL; 6672 6673 mutex_lock(&ar->conf_mutex); 6674 6675 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6676 ar->wmi.peer_param->use_fixed_power, txpwr); 6677 if (ret) { 6678 ath10k_warn(ar, "failed to set tx power for station ret: %d\n", 6679 ret); 6680 goto out; 6681 } 6682 6683 out: 6684 mutex_unlock(&ar->conf_mutex); 6685 return ret; 6686 } 6687 6688 struct ath10k_mac_iter_tid_conf_data { 6689 struct ieee80211_vif *curr_vif; 6690 struct ath10k *ar; 6691 bool reset_config; 6692 }; 6693 6694 static bool 6695 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar, 6696 enum nl80211_band band, 6697 const struct cfg80211_bitrate_mask *mask, 6698 int *vht_num_rates) 6699 { 6700 int num_rates = 0; 6701 int i, tmp; 6702 6703 num_rates += hweight32(mask->control[band].legacy); 6704 6705 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) 6706 num_rates += hweight8(mask->control[band].ht_mcs[i]); 6707 6708 *vht_num_rates = 0; 6709 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 6710 tmp = hweight16(mask->control[band].vht_mcs[i]); 6711 num_rates += tmp; 6712 *vht_num_rates += tmp; 6713 } 6714 6715 return num_rates == 1; 6716 } 6717 6718 static int 6719 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar, 6720 enum nl80211_band band, 6721 const struct cfg80211_bitrate_mask *mask, 6722 u8 *rate, u8 *nss, bool vht_only) 6723 { 6724 int rate_idx; 6725 int i; 6726 u16 bitrate; 6727 u8 preamble; 6728 u8 hw_rate; 6729 6730 if (vht_only) 6731 goto next; 6732 6733 if (hweight32(mask->control[band].legacy) == 1) { 6734 rate_idx = ffs(mask->control[band].legacy) - 1; 6735 6736 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) 6737 rate_idx += ATH10K_MAC_FIRST_OFDM_RATE_IDX; 6738 6739 hw_rate = ath10k_wmi_legacy_rates[rate_idx].hw_value; 6740 bitrate = ath10k_wmi_legacy_rates[rate_idx].bitrate; 6741 6742 if (ath10k_mac_bitrate_is_cck(bitrate)) 6743 preamble = WMI_RATE_PREAMBLE_CCK; 6744 else 6745 preamble = WMI_RATE_PREAMBLE_OFDM; 6746 6747 *nss = 1; 6748 *rate = preamble << 6 | 6749 (*nss - 1) << 4 | 6750 hw_rate << 0; 6751 6752 return 0; 6753 } 6754 6755 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 6756 if (hweight8(mask->control[band].ht_mcs[i]) == 1) { 6757 *nss = i + 1; 6758 *rate = WMI_RATE_PREAMBLE_HT << 6 | 6759 (*nss - 1) << 4 | 6760 (ffs(mask->control[band].ht_mcs[i]) - 1); 6761 6762 return 0; 6763 } 6764 } 6765 6766 next: 6767 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 6768 if (hweight16(mask->control[band].vht_mcs[i]) == 1) { 6769 *nss = i + 1; 6770 *rate = WMI_RATE_PREAMBLE_VHT << 6 | 6771 (*nss - 1) << 4 | 6772 (ffs(mask->control[band].vht_mcs[i]) - 1); 6773 6774 return 0; 6775 } 6776 } 6777 6778 return -EINVAL; 6779 } 6780 6781 static int ath10k_mac_validate_rate_mask(struct ath10k *ar, 6782 struct ieee80211_sta *sta, 6783 u32 rate_ctrl_flag, u8 nss) 6784 { 6785 if (nss > sta->rx_nss) { 6786 ath10k_warn(ar, "Invalid nss field, configured %u limit %u\n", 6787 nss, sta->rx_nss); 6788 return -EINVAL; 6789 } 6790 6791 if (ATH10K_HW_PREAMBLE(rate_ctrl_flag) == WMI_RATE_PREAMBLE_VHT) { 6792 if (!sta->vht_cap.vht_supported) { 6793 ath10k_warn(ar, "Invalid VHT rate for sta %pM\n", 6794 sta->addr); 6795 return -EINVAL; 6796 } 6797 } else if (ATH10K_HW_PREAMBLE(rate_ctrl_flag) == WMI_RATE_PREAMBLE_HT) { 6798 if (!sta->ht_cap.ht_supported || sta->vht_cap.vht_supported) { 6799 ath10k_warn(ar, "Invalid HT rate for sta %pM\n", 6800 sta->addr); 6801 return -EINVAL; 6802 } 6803 } else { 6804 if (sta->ht_cap.ht_supported || sta->vht_cap.vht_supported) 6805 return -EINVAL; 6806 } 6807 6808 return 0; 6809 } 6810 6811 static int 6812 ath10k_mac_tid_bitrate_config(struct ath10k *ar, 6813 struct ieee80211_vif *vif, 6814 struct ieee80211_sta *sta, 6815 u32 *rate_ctrl_flag, u8 *rate_ctrl, 6816 enum nl80211_tx_rate_setting txrate_type, 6817 const struct cfg80211_bitrate_mask *mask) 6818 { 6819 struct cfg80211_chan_def def; 6820 enum nl80211_band band; 6821 u8 nss, rate; 6822 int vht_num_rates, ret; 6823 6824 if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) 6825 return -EINVAL; 6826 6827 if (txrate_type == NL80211_TX_RATE_AUTOMATIC) { 6828 *rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_AUTO; 6829 *rate_ctrl_flag = 0; 6830 return 0; 6831 } 6832 6833 band = def.chan->band; 6834 6835 if (!ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask, 6836 &vht_num_rates)) { 6837 return -EINVAL; 6838 } 6839 6840 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask, 6841 &rate, &nss, false); 6842 if (ret) { 6843 ath10k_warn(ar, "failed to get single rate: %d\n", 6844 ret); 6845 return ret; 6846 } 6847 6848 *rate_ctrl_flag = rate; 6849 6850 if (sta && ath10k_mac_validate_rate_mask(ar, sta, *rate_ctrl_flag, nss)) 6851 return -EINVAL; 6852 6853 if (txrate_type == NL80211_TX_RATE_FIXED) 6854 *rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_FIXED_RATE; 6855 else if (txrate_type == NL80211_TX_RATE_LIMITED && 6856 (test_bit(WMI_SERVICE_EXT_PEER_TID_CONFIGS_SUPPORT, 6857 ar->wmi.svc_map))) 6858 *rate_ctrl = WMI_PEER_TID_CONFIG_RATE_UPPER_CAP; 6859 else 6860 return -EOPNOTSUPP; 6861 6862 return 0; 6863 } 6864 6865 static int ath10k_mac_set_tid_config(struct ath10k *ar, struct ieee80211_sta *sta, 6866 struct ieee80211_vif *vif, u32 changed, 6867 struct wmi_per_peer_per_tid_cfg_arg *arg) 6868 { 6869 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6870 struct ath10k_sta *arsta; 6871 int ret; 6872 6873 if (sta) { 6874 if (!sta->wme) 6875 return -ENOTSUPP; 6876 6877 arsta = (struct ath10k_sta *)sta->drv_priv; 6878 6879 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) { 6880 if ((arsta->retry_long[arg->tid] > 0 || 6881 arsta->rate_code[arg->tid] > 0 || 6882 arsta->ampdu[arg->tid] == 6883 WMI_TID_CONFIG_AGGR_CONTROL_ENABLE) && 6884 arg->ack_policy == WMI_PEER_TID_CONFIG_NOACK) { 6885 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_NOACK); 6886 arg->ack_policy = 0; 6887 arg->aggr_control = 0; 6888 arg->rate_ctrl = 0; 6889 arg->rcode_flags = 0; 6890 } 6891 } 6892 6893 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) { 6894 if (arsta->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK || 6895 arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) { 6896 arg->aggr_control = 0; 6897 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG); 6898 } 6899 } 6900 6901 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) | 6902 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) { 6903 if (arsta->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK || 6904 arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) { 6905 arg->rate_ctrl = 0; 6906 arg->rcode_flags = 0; 6907 } 6908 } 6909 6910 ether_addr_copy(arg->peer_macaddr.addr, sta->addr); 6911 6912 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, arg); 6913 if (ret) 6914 return ret; 6915 6916 /* Store the configured parameters in success case */ 6917 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) { 6918 arsta->noack[arg->tid] = arg->ack_policy; 6919 arg->ack_policy = 0; 6920 arg->aggr_control = 0; 6921 arg->rate_ctrl = 0; 6922 arg->rcode_flags = 0; 6923 } 6924 6925 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) { 6926 arsta->retry_long[arg->tid] = arg->retry_count; 6927 arg->retry_count = 0; 6928 } 6929 6930 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) { 6931 arsta->ampdu[arg->tid] = arg->aggr_control; 6932 arg->aggr_control = 0; 6933 } 6934 6935 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) | 6936 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) { 6937 arsta->rate_ctrl[arg->tid] = arg->rate_ctrl; 6938 arg->rate_ctrl = 0; 6939 arg->rcode_flags = 0; 6940 } 6941 6942 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) { 6943 arsta->rtscts[arg->tid] = arg->rtscts_ctrl; 6944 arg->ext_tid_cfg_bitmap = 0; 6945 } 6946 } else { 6947 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) { 6948 if ((arvif->retry_long[arg->tid] || 6949 arvif->rate_code[arg->tid] || 6950 arvif->ampdu[arg->tid] == 6951 WMI_TID_CONFIG_AGGR_CONTROL_ENABLE) && 6952 arg->ack_policy == WMI_PEER_TID_CONFIG_NOACK) { 6953 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_NOACK); 6954 } else { 6955 arvif->noack[arg->tid] = arg->ack_policy; 6956 arvif->ampdu[arg->tid] = arg->aggr_control; 6957 arvif->rate_ctrl[arg->tid] = arg->rate_ctrl; 6958 } 6959 } 6960 6961 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) { 6962 if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) 6963 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG); 6964 else 6965 arvif->retry_long[arg->tid] = arg->retry_count; 6966 } 6967 6968 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) { 6969 if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) 6970 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL); 6971 else 6972 arvif->ampdu[arg->tid] = arg->aggr_control; 6973 } 6974 6975 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) | 6976 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) { 6977 if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) { 6978 changed &= ~(BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) | 6979 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE)); 6980 } else { 6981 arvif->rate_ctrl[arg->tid] = arg->rate_ctrl; 6982 arvif->rate_code[arg->tid] = arg->rcode_flags; 6983 } 6984 } 6985 6986 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) { 6987 arvif->rtscts[arg->tid] = arg->rtscts_ctrl; 6988 arg->ext_tid_cfg_bitmap = 0; 6989 } 6990 6991 if (changed) 6992 arvif->tid_conf_changed[arg->tid] |= changed; 6993 } 6994 6995 return 0; 6996 } 6997 6998 static int 6999 ath10k_mac_parse_tid_config(struct ath10k *ar, 7000 struct ieee80211_sta *sta, 7001 struct ieee80211_vif *vif, 7002 struct cfg80211_tid_cfg *tid_conf, 7003 struct wmi_per_peer_per_tid_cfg_arg *arg) 7004 { 7005 u32 changed = tid_conf->mask; 7006 int ret = 0, i = 0; 7007 7008 if (!changed) 7009 return -EINVAL; 7010 7011 while (i < ATH10K_TID_MAX) { 7012 if (!(tid_conf->tids & BIT(i))) { 7013 i++; 7014 continue; 7015 } 7016 7017 arg->tid = i; 7018 7019 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) { 7020 if (tid_conf->noack == NL80211_TID_CONFIG_ENABLE) { 7021 arg->ack_policy = WMI_PEER_TID_CONFIG_NOACK; 7022 arg->rate_ctrl = 7023 WMI_TID_CONFIG_RATE_CONTROL_DEFAULT_LOWEST_RATE; 7024 arg->aggr_control = 7025 WMI_TID_CONFIG_AGGR_CONTROL_DISABLE; 7026 } else { 7027 arg->ack_policy = 7028 WMI_PEER_TID_CONFIG_ACK; 7029 arg->rate_ctrl = 7030 WMI_TID_CONFIG_RATE_CONTROL_AUTO; 7031 arg->aggr_control = 7032 WMI_TID_CONFIG_AGGR_CONTROL_ENABLE; 7033 } 7034 } 7035 7036 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) 7037 arg->retry_count = tid_conf->retry_long; 7038 7039 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) { 7040 if (tid_conf->noack == NL80211_TID_CONFIG_ENABLE) 7041 arg->aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_ENABLE; 7042 else 7043 arg->aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_DISABLE; 7044 } 7045 7046 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) | 7047 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) { 7048 ret = ath10k_mac_tid_bitrate_config(ar, vif, sta, 7049 &arg->rcode_flags, 7050 &arg->rate_ctrl, 7051 tid_conf->txrate_type, 7052 &tid_conf->txrate_mask); 7053 if (ret) { 7054 ath10k_warn(ar, "failed to configure bitrate mask %d\n", 7055 ret); 7056 arg->rcode_flags = 0; 7057 arg->rate_ctrl = 0; 7058 } 7059 } 7060 7061 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) { 7062 if (tid_conf->rtscts) 7063 arg->rtscts_ctrl = tid_conf->rtscts; 7064 7065 arg->ext_tid_cfg_bitmap = WMI_EXT_TID_RTS_CTS_CONFIG; 7066 } 7067 7068 ret = ath10k_mac_set_tid_config(ar, sta, vif, changed, arg); 7069 if (ret) 7070 return ret; 7071 i++; 7072 } 7073 7074 return ret; 7075 } 7076 7077 static int ath10k_mac_reset_tid_config(struct ath10k *ar, 7078 struct ieee80211_sta *sta, 7079 struct ath10k_vif *arvif, 7080 u8 tids) 7081 { 7082 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 7083 struct wmi_per_peer_per_tid_cfg_arg arg; 7084 int ret = 0, i = 0; 7085 7086 arg.vdev_id = arvif->vdev_id; 7087 while (i < ATH10K_TID_MAX) { 7088 if (!(tids & BIT(i))) { 7089 i++; 7090 continue; 7091 } 7092 7093 arg.tid = i; 7094 arg.ack_policy = WMI_PEER_TID_CONFIG_ACK; 7095 arg.retry_count = ATH10K_MAX_RETRY_COUNT; 7096 arg.rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_AUTO; 7097 arg.aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_ENABLE; 7098 arg.rtscts_ctrl = WMI_TID_CONFIG_RTSCTS_CONTROL_ENABLE; 7099 arg.ext_tid_cfg_bitmap = WMI_EXT_TID_RTS_CTS_CONFIG; 7100 7101 ether_addr_copy(arg.peer_macaddr.addr, sta->addr); 7102 7103 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg); 7104 if (ret) 7105 return ret; 7106 7107 if (!arvif->tids_rst) { 7108 arsta->retry_long[i] = -1; 7109 arsta->noack[i] = -1; 7110 arsta->ampdu[i] = -1; 7111 arsta->rate_code[i] = -1; 7112 arsta->rate_ctrl[i] = 0; 7113 arsta->rtscts[i] = -1; 7114 } else { 7115 arvif->retry_long[i] = 0; 7116 arvif->noack[i] = 0; 7117 arvif->ampdu[i] = 0; 7118 arvif->rate_code[i] = 0; 7119 arvif->rate_ctrl[i] = 0; 7120 arvif->rtscts[i] = 0; 7121 } 7122 7123 i++; 7124 } 7125 7126 return ret; 7127 } 7128 7129 static void ath10k_sta_tid_cfg_wk(struct work_struct *wk) 7130 { 7131 struct wmi_per_peer_per_tid_cfg_arg arg = {}; 7132 struct ieee80211_sta *sta; 7133 struct ath10k_sta *arsta; 7134 struct ath10k_vif *arvif; 7135 struct ath10k *ar; 7136 bool config_apply; 7137 int ret, i; 7138 u32 changed; 7139 u8 nss; 7140 7141 arsta = container_of(wk, struct ath10k_sta, tid_config_wk); 7142 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 7143 arvif = arsta->arvif; 7144 ar = arvif->ar; 7145 7146 mutex_lock(&ar->conf_mutex); 7147 7148 if (arvif->tids_rst) { 7149 ret = ath10k_mac_reset_tid_config(ar, sta, arvif, 7150 arvif->tids_rst); 7151 goto exit; 7152 } 7153 7154 ether_addr_copy(arg.peer_macaddr.addr, sta->addr); 7155 7156 for (i = 0; i < ATH10K_TID_MAX; i++) { 7157 config_apply = false; 7158 changed = arvif->tid_conf_changed[i]; 7159 7160 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) { 7161 if (arsta->noack[i] != -1) { 7162 arg.ack_policy = 0; 7163 } else { 7164 config_apply = true; 7165 arg.ack_policy = arvif->noack[i]; 7166 arg.aggr_control = arvif->ampdu[i]; 7167 arg.rate_ctrl = arvif->rate_ctrl[i]; 7168 } 7169 } 7170 7171 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) { 7172 if (arsta->retry_long[i] != -1 || 7173 arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK || 7174 arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) { 7175 arg.retry_count = 0; 7176 } else { 7177 arg.retry_count = arvif->retry_long[i]; 7178 config_apply = true; 7179 } 7180 } 7181 7182 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) { 7183 if (arsta->ampdu[i] != -1 || 7184 arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK || 7185 arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) { 7186 arg.aggr_control = 0; 7187 } else { 7188 arg.aggr_control = arvif->ampdu[i]; 7189 config_apply = true; 7190 } 7191 } 7192 7193 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) | 7194 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) { 7195 nss = ATH10K_HW_NSS(arvif->rate_code[i]); 7196 ret = ath10k_mac_validate_rate_mask(ar, sta, 7197 arvif->rate_code[i], 7198 nss); 7199 if (ret && 7200 arvif->rate_ctrl[i] > WMI_TID_CONFIG_RATE_CONTROL_AUTO) { 7201 arg.rate_ctrl = 0; 7202 arg.rcode_flags = 0; 7203 } 7204 7205 if (arsta->rate_ctrl[i] > 7206 WMI_TID_CONFIG_RATE_CONTROL_AUTO || 7207 arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK || 7208 arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) { 7209 arg.rate_ctrl = 0; 7210 arg.rcode_flags = 0; 7211 } else { 7212 arg.rate_ctrl = arvif->rate_ctrl[i]; 7213 arg.rcode_flags = arvif->rate_code[i]; 7214 config_apply = true; 7215 } 7216 } 7217 7218 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) { 7219 if (arsta->rtscts[i]) { 7220 arg.rtscts_ctrl = 0; 7221 arg.ext_tid_cfg_bitmap = 0; 7222 } else { 7223 arg.rtscts_ctrl = arvif->rtscts[i] - 1; 7224 arg.ext_tid_cfg_bitmap = 7225 WMI_EXT_TID_RTS_CTS_CONFIG; 7226 config_apply = true; 7227 } 7228 } 7229 7230 arg.tid = i; 7231 7232 if (config_apply) { 7233 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg); 7234 if (ret) 7235 ath10k_warn(ar, "failed to set per tid config for sta %pM: %d\n", 7236 sta->addr, ret); 7237 } 7238 7239 arg.ack_policy = 0; 7240 arg.retry_count = 0; 7241 arg.aggr_control = 0; 7242 arg.rate_ctrl = 0; 7243 arg.rcode_flags = 0; 7244 } 7245 7246 exit: 7247 mutex_unlock(&ar->conf_mutex); 7248 } 7249 7250 static void ath10k_mac_vif_stations_tid_conf(void *data, 7251 struct ieee80211_sta *sta) 7252 { 7253 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 7254 struct ath10k_mac_iter_tid_conf_data *iter_data = data; 7255 struct ieee80211_vif *sta_vif = arsta->arvif->vif; 7256 7257 if (sta_vif != iter_data->curr_vif || !sta->wme) 7258 return; 7259 7260 ieee80211_queue_work(iter_data->ar->hw, &arsta->tid_config_wk); 7261 } 7262 7263 static int ath10k_sta_state(struct ieee80211_hw *hw, 7264 struct ieee80211_vif *vif, 7265 struct ieee80211_sta *sta, 7266 enum ieee80211_sta_state old_state, 7267 enum ieee80211_sta_state new_state) 7268 { 7269 struct ath10k *ar = hw->priv; 7270 struct ath10k_vif *arvif = (void *)vif->drv_priv; 7271 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 7272 struct ath10k_peer *peer; 7273 int ret = 0; 7274 int i; 7275 7276 if (old_state == IEEE80211_STA_NOTEXIST && 7277 new_state == IEEE80211_STA_NONE) { 7278 memset(arsta, 0, sizeof(*arsta)); 7279 arsta->arvif = arvif; 7280 arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED; 7281 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk); 7282 INIT_WORK(&arsta->tid_config_wk, ath10k_sta_tid_cfg_wk); 7283 7284 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) 7285 ath10k_mac_txq_init(sta->txq[i]); 7286 } 7287 7288 /* cancel must be done outside the mutex to avoid deadlock */ 7289 if ((old_state == IEEE80211_STA_NONE && 7290 new_state == IEEE80211_STA_NOTEXIST)) { 7291 cancel_work_sync(&arsta->update_wk); 7292 cancel_work_sync(&arsta->tid_config_wk); 7293 } 7294 7295 mutex_lock(&ar->conf_mutex); 7296 7297 if (old_state == IEEE80211_STA_NOTEXIST && 7298 new_state == IEEE80211_STA_NONE) { 7299 /* 7300 * New station addition. 7301 */ 7302 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT; 7303 u32 num_tdls_stations; 7304 7305 ath10k_dbg(ar, ATH10K_DBG_MAC, 7306 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n", 7307 arvif->vdev_id, sta->addr, 7308 ar->num_stations + 1, ar->max_num_stations, 7309 ar->num_peers + 1, ar->max_num_peers); 7310 7311 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif); 7312 7313 if (sta->tdls) { 7314 if (num_tdls_stations >= ar->max_num_tdls_vdevs) { 7315 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n", 7316 arvif->vdev_id, 7317 ar->max_num_tdls_vdevs); 7318 ret = -ELNRNG; 7319 goto exit; 7320 } 7321 peer_type = WMI_PEER_TYPE_TDLS; 7322 } 7323 7324 ret = ath10k_mac_inc_num_stations(arvif, sta); 7325 if (ret) { 7326 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n", 7327 ar->max_num_stations); 7328 goto exit; 7329 } 7330 7331 if (ath10k_debug_is_extd_tx_stats_enabled(ar)) { 7332 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), 7333 GFP_KERNEL); 7334 if (!arsta->tx_stats) { 7335 ath10k_mac_dec_num_stations(arvif, sta); 7336 ret = -ENOMEM; 7337 goto exit; 7338 } 7339 } 7340 7341 ret = ath10k_peer_create(ar, vif, sta, arvif->vdev_id, 7342 sta->addr, peer_type); 7343 if (ret) { 7344 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n", 7345 sta->addr, arvif->vdev_id, ret); 7346 ath10k_mac_dec_num_stations(arvif, sta); 7347 kfree(arsta->tx_stats); 7348 goto exit; 7349 } 7350 7351 spin_lock_bh(&ar->data_lock); 7352 7353 peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr); 7354 if (!peer) { 7355 ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n", 7356 vif->addr, arvif->vdev_id); 7357 spin_unlock_bh(&ar->data_lock); 7358 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 7359 ath10k_mac_dec_num_stations(arvif, sta); 7360 kfree(arsta->tx_stats); 7361 ret = -ENOENT; 7362 goto exit; 7363 } 7364 7365 arsta->peer_id = find_first_bit(peer->peer_ids, 7366 ATH10K_MAX_NUM_PEER_IDS); 7367 7368 spin_unlock_bh(&ar->data_lock); 7369 7370 if (!sta->tdls) 7371 goto exit; 7372 7373 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id, 7374 WMI_TDLS_ENABLE_ACTIVE); 7375 if (ret) { 7376 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n", 7377 arvif->vdev_id, ret); 7378 ath10k_peer_delete(ar, arvif->vdev_id, 7379 sta->addr); 7380 ath10k_mac_dec_num_stations(arvif, sta); 7381 kfree(arsta->tx_stats); 7382 goto exit; 7383 } 7384 7385 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta, 7386 WMI_TDLS_PEER_STATE_PEERING); 7387 if (ret) { 7388 ath10k_warn(ar, 7389 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n", 7390 sta->addr, arvif->vdev_id, ret); 7391 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 7392 ath10k_mac_dec_num_stations(arvif, sta); 7393 kfree(arsta->tx_stats); 7394 7395 if (num_tdls_stations != 0) 7396 goto exit; 7397 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id, 7398 WMI_TDLS_DISABLE); 7399 } 7400 } else if ((old_state == IEEE80211_STA_NONE && 7401 new_state == IEEE80211_STA_NOTEXIST)) { 7402 /* 7403 * Existing station deletion. 7404 */ 7405 ath10k_dbg(ar, ATH10K_DBG_MAC, 7406 "mac vdev %d peer delete %pM sta %pK (sta gone)\n", 7407 arvif->vdev_id, sta->addr, sta); 7408 7409 if (sta->tdls) { 7410 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, 7411 sta, 7412 WMI_TDLS_PEER_STATE_TEARDOWN); 7413 if (ret) 7414 ath10k_warn(ar, "failed to update tdls peer state for %pM state %d: %i\n", 7415 sta->addr, 7416 WMI_TDLS_PEER_STATE_TEARDOWN, ret); 7417 } 7418 7419 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 7420 if (ret) 7421 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n", 7422 sta->addr, arvif->vdev_id, ret); 7423 7424 ath10k_mac_dec_num_stations(arvif, sta); 7425 7426 spin_lock_bh(&ar->data_lock); 7427 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) { 7428 peer = ar->peer_map[i]; 7429 if (!peer) 7430 continue; 7431 7432 if (peer->sta == sta) { 7433 ath10k_warn(ar, "found sta peer %pM (ptr %pK id %d) entry on vdev %i after it was supposedly removed\n", 7434 sta->addr, peer, i, arvif->vdev_id); 7435 peer->sta = NULL; 7436 7437 /* Clean up the peer object as well since we 7438 * must have failed to do this above. 7439 */ 7440 list_del(&peer->list); 7441 ar->peer_map[i] = NULL; 7442 kfree(peer); 7443 ar->num_peers--; 7444 } 7445 } 7446 spin_unlock_bh(&ar->data_lock); 7447 7448 if (ath10k_debug_is_extd_tx_stats_enabled(ar)) { 7449 kfree(arsta->tx_stats); 7450 arsta->tx_stats = NULL; 7451 } 7452 7453 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) 7454 ath10k_mac_txq_unref(ar, sta->txq[i]); 7455 7456 if (!sta->tdls) 7457 goto exit; 7458 7459 if (ath10k_mac_tdls_vif_stations_count(hw, vif)) 7460 goto exit; 7461 7462 /* This was the last tdls peer in current vif */ 7463 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id, 7464 WMI_TDLS_DISABLE); 7465 if (ret) { 7466 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n", 7467 arvif->vdev_id, ret); 7468 } 7469 } else if (old_state == IEEE80211_STA_AUTH && 7470 new_state == IEEE80211_STA_ASSOC && 7471 (vif->type == NL80211_IFTYPE_AP || 7472 vif->type == NL80211_IFTYPE_MESH_POINT || 7473 vif->type == NL80211_IFTYPE_ADHOC)) { 7474 /* 7475 * New association. 7476 */ 7477 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n", 7478 sta->addr); 7479 7480 ret = ath10k_station_assoc(ar, vif, sta, false); 7481 if (ret) 7482 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n", 7483 sta->addr, arvif->vdev_id, ret); 7484 } else if (old_state == IEEE80211_STA_ASSOC && 7485 new_state == IEEE80211_STA_AUTHORIZED && 7486 sta->tdls) { 7487 /* 7488 * Tdls station authorized. 7489 */ 7490 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n", 7491 sta->addr); 7492 7493 ret = ath10k_station_assoc(ar, vif, sta, false); 7494 if (ret) { 7495 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n", 7496 sta->addr, arvif->vdev_id, ret); 7497 goto exit; 7498 } 7499 7500 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta, 7501 WMI_TDLS_PEER_STATE_CONNECTED); 7502 if (ret) 7503 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n", 7504 sta->addr, arvif->vdev_id, ret); 7505 } else if (old_state == IEEE80211_STA_ASSOC && 7506 new_state == IEEE80211_STA_AUTH && 7507 (vif->type == NL80211_IFTYPE_AP || 7508 vif->type == NL80211_IFTYPE_MESH_POINT || 7509 vif->type == NL80211_IFTYPE_ADHOC)) { 7510 /* 7511 * Disassociation. 7512 */ 7513 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n", 7514 sta->addr); 7515 7516 ret = ath10k_station_disassoc(ar, vif, sta); 7517 if (ret) 7518 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n", 7519 sta->addr, arvif->vdev_id, ret); 7520 } 7521 exit: 7522 mutex_unlock(&ar->conf_mutex); 7523 return ret; 7524 } 7525 7526 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif, 7527 u16 ac, bool enable) 7528 { 7529 struct ath10k_vif *arvif = (void *)vif->drv_priv; 7530 struct wmi_sta_uapsd_auto_trig_arg arg = {}; 7531 u32 prio = 0, acc = 0; 7532 u32 value = 0; 7533 int ret = 0; 7534 7535 lockdep_assert_held(&ar->conf_mutex); 7536 7537 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 7538 return 0; 7539 7540 switch (ac) { 7541 case IEEE80211_AC_VO: 7542 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 7543 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 7544 prio = 7; 7545 acc = 3; 7546 break; 7547 case IEEE80211_AC_VI: 7548 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 7549 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 7550 prio = 5; 7551 acc = 2; 7552 break; 7553 case IEEE80211_AC_BE: 7554 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 7555 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 7556 prio = 2; 7557 acc = 1; 7558 break; 7559 case IEEE80211_AC_BK: 7560 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 7561 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 7562 prio = 0; 7563 acc = 0; 7564 break; 7565 } 7566 7567 if (enable) 7568 arvif->u.sta.uapsd |= value; 7569 else 7570 arvif->u.sta.uapsd &= ~value; 7571 7572 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 7573 WMI_STA_PS_PARAM_UAPSD, 7574 arvif->u.sta.uapsd); 7575 if (ret) { 7576 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret); 7577 goto exit; 7578 } 7579 7580 if (arvif->u.sta.uapsd) 7581 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 7582 else 7583 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 7584 7585 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 7586 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 7587 value); 7588 if (ret) 7589 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret); 7590 7591 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif); 7592 if (ret) { 7593 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n", 7594 arvif->vdev_id, ret); 7595 return ret; 7596 } 7597 7598 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif); 7599 if (ret) { 7600 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n", 7601 arvif->vdev_id, ret); 7602 return ret; 7603 } 7604 7605 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) || 7606 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) { 7607 /* Only userspace can make an educated decision when to send 7608 * trigger frame. The following effectively disables u-UAPSD 7609 * autotrigger in firmware (which is enabled by default 7610 * provided the autotrigger service is available). 7611 */ 7612 7613 arg.wmm_ac = acc; 7614 arg.user_priority = prio; 7615 arg.service_interval = 0; 7616 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC; 7617 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC; 7618 7619 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id, 7620 arvif->bssid, &arg, 1); 7621 if (ret) { 7622 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n", 7623 ret); 7624 return ret; 7625 } 7626 } 7627 7628 exit: 7629 return ret; 7630 } 7631 7632 static int ath10k_conf_tx(struct ieee80211_hw *hw, 7633 struct ieee80211_vif *vif, u16 ac, 7634 const struct ieee80211_tx_queue_params *params) 7635 { 7636 struct ath10k *ar = hw->priv; 7637 struct ath10k_vif *arvif = (void *)vif->drv_priv; 7638 struct wmi_wmm_params_arg *p = NULL; 7639 int ret; 7640 7641 mutex_lock(&ar->conf_mutex); 7642 7643 switch (ac) { 7644 case IEEE80211_AC_VO: 7645 p = &arvif->wmm_params.ac_vo; 7646 break; 7647 case IEEE80211_AC_VI: 7648 p = &arvif->wmm_params.ac_vi; 7649 break; 7650 case IEEE80211_AC_BE: 7651 p = &arvif->wmm_params.ac_be; 7652 break; 7653 case IEEE80211_AC_BK: 7654 p = &arvif->wmm_params.ac_bk; 7655 break; 7656 } 7657 7658 if (WARN_ON(!p)) { 7659 ret = -EINVAL; 7660 goto exit; 7661 } 7662 7663 p->cwmin = params->cw_min; 7664 p->cwmax = params->cw_max; 7665 p->aifs = params->aifs; 7666 7667 /* 7668 * The channel time duration programmed in the HW is in absolute 7669 * microseconds, while mac80211 gives the txop in units of 7670 * 32 microseconds. 7671 */ 7672 p->txop = params->txop * 32; 7673 7674 if (ar->wmi.ops->gen_vdev_wmm_conf) { 7675 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id, 7676 &arvif->wmm_params); 7677 if (ret) { 7678 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n", 7679 arvif->vdev_id, ret); 7680 goto exit; 7681 } 7682 } else { 7683 /* This won't work well with multi-interface cases but it's 7684 * better than nothing. 7685 */ 7686 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params); 7687 if (ret) { 7688 ath10k_warn(ar, "failed to set wmm params: %d\n", ret); 7689 goto exit; 7690 } 7691 } 7692 7693 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 7694 if (ret) 7695 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret); 7696 7697 exit: 7698 mutex_unlock(&ar->conf_mutex); 7699 return ret; 7700 } 7701 7702 static int ath10k_remain_on_channel(struct ieee80211_hw *hw, 7703 struct ieee80211_vif *vif, 7704 struct ieee80211_channel *chan, 7705 int duration, 7706 enum ieee80211_roc_type type) 7707 { 7708 struct ath10k *ar = hw->priv; 7709 struct ath10k_vif *arvif = (void *)vif->drv_priv; 7710 struct wmi_start_scan_arg arg; 7711 int ret = 0; 7712 u32 scan_time_msec; 7713 7714 mutex_lock(&ar->conf_mutex); 7715 7716 if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) { 7717 ret = -EBUSY; 7718 goto exit; 7719 } 7720 7721 spin_lock_bh(&ar->data_lock); 7722 switch (ar->scan.state) { 7723 case ATH10K_SCAN_IDLE: 7724 reinit_completion(&ar->scan.started); 7725 reinit_completion(&ar->scan.completed); 7726 reinit_completion(&ar->scan.on_channel); 7727 ar->scan.state = ATH10K_SCAN_STARTING; 7728 ar->scan.is_roc = true; 7729 ar->scan.vdev_id = arvif->vdev_id; 7730 ar->scan.roc_freq = chan->center_freq; 7731 ar->scan.roc_notify = true; 7732 ret = 0; 7733 break; 7734 case ATH10K_SCAN_STARTING: 7735 case ATH10K_SCAN_RUNNING: 7736 case ATH10K_SCAN_ABORTING: 7737 ret = -EBUSY; 7738 break; 7739 } 7740 spin_unlock_bh(&ar->data_lock); 7741 7742 if (ret) 7743 goto exit; 7744 7745 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2; 7746 7747 memset(&arg, 0, sizeof(arg)); 7748 ath10k_wmi_start_scan_init(ar, &arg); 7749 arg.vdev_id = arvif->vdev_id; 7750 arg.scan_id = ATH10K_SCAN_ID; 7751 arg.n_channels = 1; 7752 arg.channels[0] = chan->center_freq; 7753 arg.dwell_time_active = scan_time_msec; 7754 arg.dwell_time_passive = scan_time_msec; 7755 arg.max_scan_time = scan_time_msec; 7756 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 7757 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ; 7758 arg.burst_duration_ms = duration; 7759 7760 ret = ath10k_start_scan(ar, &arg); 7761 if (ret) { 7762 ath10k_warn(ar, "failed to start roc scan: %d\n", ret); 7763 spin_lock_bh(&ar->data_lock); 7764 ar->scan.state = ATH10K_SCAN_IDLE; 7765 spin_unlock_bh(&ar->data_lock); 7766 goto exit; 7767 } 7768 7769 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ); 7770 if (ret == 0) { 7771 ath10k_warn(ar, "failed to switch to channel for roc scan\n"); 7772 7773 ret = ath10k_scan_stop(ar); 7774 if (ret) 7775 ath10k_warn(ar, "failed to stop scan: %d\n", ret); 7776 7777 ret = -ETIMEDOUT; 7778 goto exit; 7779 } 7780 7781 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 7782 msecs_to_jiffies(duration)); 7783 7784 ret = 0; 7785 exit: 7786 mutex_unlock(&ar->conf_mutex); 7787 return ret; 7788 } 7789 7790 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw, 7791 struct ieee80211_vif *vif) 7792 { 7793 struct ath10k *ar = hw->priv; 7794 7795 mutex_lock(&ar->conf_mutex); 7796 7797 spin_lock_bh(&ar->data_lock); 7798 ar->scan.roc_notify = false; 7799 spin_unlock_bh(&ar->data_lock); 7800 7801 ath10k_scan_abort(ar); 7802 7803 mutex_unlock(&ar->conf_mutex); 7804 7805 cancel_delayed_work_sync(&ar->scan.timeout); 7806 7807 return 0; 7808 } 7809 7810 /* 7811 * Both RTS and Fragmentation threshold are interface-specific 7812 * in ath10k, but device-specific in mac80211. 7813 */ 7814 7815 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 7816 { 7817 struct ath10k *ar = hw->priv; 7818 struct ath10k_vif *arvif; 7819 int ret = 0; 7820 7821 mutex_lock(&ar->conf_mutex); 7822 list_for_each_entry(arvif, &ar->arvifs, list) { 7823 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n", 7824 arvif->vdev_id, value); 7825 7826 ret = ath10k_mac_set_rts(arvif, value); 7827 if (ret) { 7828 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n", 7829 arvif->vdev_id, ret); 7830 break; 7831 } 7832 } 7833 mutex_unlock(&ar->conf_mutex); 7834 7835 return ret; 7836 } 7837 7838 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 7839 { 7840 /* Even though there's a WMI enum for fragmentation threshold no known 7841 * firmware actually implements it. Moreover it is not possible to rely 7842 * frame fragmentation to mac80211 because firmware clears the "more 7843 * fragments" bit in frame control making it impossible for remote 7844 * devices to reassemble frames. 7845 * 7846 * Hence implement a dummy callback just to say fragmentation isn't 7847 * supported. This effectively prevents mac80211 from doing frame 7848 * fragmentation in software. 7849 */ 7850 return -EOPNOTSUPP; 7851 } 7852 7853 void ath10k_mac_wait_tx_complete(struct ath10k *ar) 7854 { 7855 bool skip; 7856 long time_left; 7857 7858 /* mac80211 doesn't care if we really xmit queued frames or not 7859 * we'll collect those frames either way if we stop/delete vdevs 7860 */ 7861 7862 if (ar->state == ATH10K_STATE_WEDGED) 7863 return; 7864 7865 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({ 7866 bool empty; 7867 7868 spin_lock_bh(&ar->htt.tx_lock); 7869 empty = (ar->htt.num_pending_tx == 0); 7870 spin_unlock_bh(&ar->htt.tx_lock); 7871 7872 skip = (ar->state == ATH10K_STATE_WEDGED) || 7873 test_bit(ATH10K_FLAG_CRASH_FLUSH, 7874 &ar->dev_flags); 7875 7876 (empty || skip); 7877 }), ATH10K_FLUSH_TIMEOUT_HZ); 7878 7879 if (time_left == 0 || skip) 7880 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n", 7881 skip, ar->state, time_left); 7882 } 7883 7884 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 7885 u32 queues, bool drop) 7886 { 7887 struct ath10k *ar = hw->priv; 7888 struct ath10k_vif *arvif; 7889 u32 bitmap; 7890 7891 if (drop) { 7892 if (vif && vif->type == NL80211_IFTYPE_STATION) { 7893 bitmap = ~(1 << WMI_MGMT_TID); 7894 list_for_each_entry(arvif, &ar->arvifs, list) { 7895 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 7896 ath10k_wmi_peer_flush(ar, arvif->vdev_id, 7897 arvif->bssid, bitmap); 7898 } 7899 ath10k_htt_flush_tx(&ar->htt); 7900 } 7901 return; 7902 } 7903 7904 mutex_lock(&ar->conf_mutex); 7905 ath10k_mac_wait_tx_complete(ar); 7906 mutex_unlock(&ar->conf_mutex); 7907 } 7908 7909 /* TODO: Implement this function properly 7910 * For now it is needed to reply to Probe Requests in IBSS mode. 7911 * Propably we need this information from FW. 7912 */ 7913 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw) 7914 { 7915 return 1; 7916 } 7917 7918 static void ath10k_reconfig_complete(struct ieee80211_hw *hw, 7919 enum ieee80211_reconfig_type reconfig_type) 7920 { 7921 struct ath10k *ar = hw->priv; 7922 7923 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) 7924 return; 7925 7926 mutex_lock(&ar->conf_mutex); 7927 7928 /* If device failed to restart it will be in a different state, e.g. 7929 * ATH10K_STATE_WEDGED 7930 */ 7931 if (ar->state == ATH10K_STATE_RESTARTED) { 7932 ath10k_info(ar, "device successfully recovered\n"); 7933 ar->state = ATH10K_STATE_ON; 7934 ieee80211_wake_queues(ar->hw); 7935 clear_bit(ATH10K_FLAG_RESTARTING, &ar->dev_flags); 7936 } 7937 7938 mutex_unlock(&ar->conf_mutex); 7939 } 7940 7941 static void 7942 ath10k_mac_update_bss_chan_survey(struct ath10k *ar, 7943 struct ieee80211_channel *channel) 7944 { 7945 int ret; 7946 enum wmi_bss_survey_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ; 7947 7948 lockdep_assert_held(&ar->conf_mutex); 7949 7950 if (!test_bit(WMI_SERVICE_BSS_CHANNEL_INFO_64, ar->wmi.svc_map) || 7951 (ar->rx_channel != channel)) 7952 return; 7953 7954 if (ar->scan.state != ATH10K_SCAN_IDLE) { 7955 ath10k_dbg(ar, ATH10K_DBG_MAC, "ignoring bss chan info request while scanning..\n"); 7956 return; 7957 } 7958 7959 reinit_completion(&ar->bss_survey_done); 7960 7961 ret = ath10k_wmi_pdev_bss_chan_info_request(ar, type); 7962 if (ret) { 7963 ath10k_warn(ar, "failed to send pdev bss chan info request\n"); 7964 return; 7965 } 7966 7967 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ); 7968 if (!ret) { 7969 ath10k_warn(ar, "bss channel survey timed out\n"); 7970 return; 7971 } 7972 } 7973 7974 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx, 7975 struct survey_info *survey) 7976 { 7977 struct ath10k *ar = hw->priv; 7978 struct ieee80211_supported_band *sband; 7979 struct survey_info *ar_survey = &ar->survey[idx]; 7980 int ret = 0; 7981 7982 mutex_lock(&ar->conf_mutex); 7983 7984 sband = hw->wiphy->bands[NL80211_BAND_2GHZ]; 7985 if (sband && idx >= sband->n_channels) { 7986 idx -= sband->n_channels; 7987 sband = NULL; 7988 } 7989 7990 if (!sband) 7991 sband = hw->wiphy->bands[NL80211_BAND_5GHZ]; 7992 7993 if (!sband || idx >= sband->n_channels) { 7994 ret = -ENOENT; 7995 goto exit; 7996 } 7997 7998 ath10k_mac_update_bss_chan_survey(ar, &sband->channels[idx]); 7999 8000 spin_lock_bh(&ar->data_lock); 8001 memcpy(survey, ar_survey, sizeof(*survey)); 8002 spin_unlock_bh(&ar->data_lock); 8003 8004 survey->channel = &sband->channels[idx]; 8005 8006 if (ar->rx_channel == survey->channel) 8007 survey->filled |= SURVEY_INFO_IN_USE; 8008 8009 exit: 8010 mutex_unlock(&ar->conf_mutex); 8011 return ret; 8012 } 8013 8014 static bool 8015 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar, 8016 enum nl80211_band band, 8017 const struct cfg80211_bitrate_mask *mask, 8018 int *nss) 8019 { 8020 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 8021 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 8022 u8 ht_nss_mask = 0; 8023 u8 vht_nss_mask = 0; 8024 int i; 8025 8026 if (mask->control[band].legacy) 8027 return false; 8028 8029 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 8030 if (mask->control[band].ht_mcs[i] == 0) 8031 continue; 8032 else if (mask->control[band].ht_mcs[i] == 8033 sband->ht_cap.mcs.rx_mask[i]) 8034 ht_nss_mask |= BIT(i); 8035 else 8036 return false; 8037 } 8038 8039 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 8040 if (mask->control[band].vht_mcs[i] == 0) 8041 continue; 8042 else if (mask->control[band].vht_mcs[i] == 8043 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i)) 8044 vht_nss_mask |= BIT(i); 8045 else 8046 return false; 8047 } 8048 8049 if (ht_nss_mask != vht_nss_mask) 8050 return false; 8051 8052 if (ht_nss_mask == 0) 8053 return false; 8054 8055 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask) 8056 return false; 8057 8058 *nss = fls(ht_nss_mask); 8059 8060 return true; 8061 } 8062 8063 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif, 8064 u8 rate, u8 nss, u8 sgi, u8 ldpc) 8065 { 8066 struct ath10k *ar = arvif->ar; 8067 u32 vdev_param; 8068 int ret; 8069 8070 lockdep_assert_held(&ar->conf_mutex); 8071 8072 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n", 8073 arvif->vdev_id, rate, nss, sgi); 8074 8075 vdev_param = ar->wmi.vdev_param->fixed_rate; 8076 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate); 8077 if (ret) { 8078 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n", 8079 rate, ret); 8080 return ret; 8081 } 8082 8083 vdev_param = ar->wmi.vdev_param->nss; 8084 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss); 8085 if (ret) { 8086 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret); 8087 return ret; 8088 } 8089 8090 vdev_param = ar->wmi.vdev_param->sgi; 8091 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi); 8092 if (ret) { 8093 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret); 8094 return ret; 8095 } 8096 8097 vdev_param = ar->wmi.vdev_param->ldpc; 8098 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc); 8099 if (ret) { 8100 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret); 8101 return ret; 8102 } 8103 8104 return 0; 8105 } 8106 8107 static bool 8108 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar, 8109 enum nl80211_band band, 8110 const struct cfg80211_bitrate_mask *mask, 8111 bool allow_pfr) 8112 { 8113 int i; 8114 u16 vht_mcs; 8115 8116 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible 8117 * to express all VHT MCS rate masks. Effectively only the following 8118 * ranges can be used: none, 0-7, 0-8 and 0-9. 8119 */ 8120 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 8121 vht_mcs = mask->control[band].vht_mcs[i]; 8122 8123 switch (vht_mcs) { 8124 case 0: 8125 case BIT(8) - 1: 8126 case BIT(9) - 1: 8127 case BIT(10) - 1: 8128 break; 8129 default: 8130 if (!allow_pfr) 8131 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n"); 8132 return false; 8133 } 8134 } 8135 8136 return true; 8137 } 8138 8139 static bool ath10k_mac_set_vht_bitrate_mask_fixup(struct ath10k *ar, 8140 struct ath10k_vif *arvif, 8141 struct ieee80211_sta *sta) 8142 { 8143 int err; 8144 u8 rate = arvif->vht_pfr; 8145 8146 /* skip non vht and multiple rate peers */ 8147 if (!sta->vht_cap.vht_supported || arvif->vht_num_rates != 1) 8148 return false; 8149 8150 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 8151 WMI_PEER_PARAM_FIXED_RATE, rate); 8152 if (err) 8153 ath10k_warn(ar, "failed to enable STA %pM peer fixed rate: %d\n", 8154 sta->addr, err); 8155 8156 return true; 8157 } 8158 8159 static void ath10k_mac_set_bitrate_mask_iter(void *data, 8160 struct ieee80211_sta *sta) 8161 { 8162 struct ath10k_vif *arvif = data; 8163 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 8164 struct ath10k *ar = arvif->ar; 8165 8166 if (arsta->arvif != arvif) 8167 return; 8168 8169 if (ath10k_mac_set_vht_bitrate_mask_fixup(ar, arvif, sta)) 8170 return; 8171 8172 spin_lock_bh(&ar->data_lock); 8173 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED; 8174 spin_unlock_bh(&ar->data_lock); 8175 8176 ieee80211_queue_work(ar->hw, &arsta->update_wk); 8177 } 8178 8179 static void ath10k_mac_clr_bitrate_mask_iter(void *data, 8180 struct ieee80211_sta *sta) 8181 { 8182 struct ath10k_vif *arvif = data; 8183 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 8184 struct ath10k *ar = arvif->ar; 8185 int err; 8186 8187 /* clear vht peers only */ 8188 if (arsta->arvif != arvif || !sta->vht_cap.vht_supported) 8189 return; 8190 8191 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 8192 WMI_PEER_PARAM_FIXED_RATE, 8193 WMI_FIXED_RATE_NONE); 8194 if (err) 8195 ath10k_warn(ar, "failed to clear STA %pM peer fixed rate: %d\n", 8196 sta->addr, err); 8197 } 8198 8199 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw, 8200 struct ieee80211_vif *vif, 8201 const struct cfg80211_bitrate_mask *mask) 8202 { 8203 struct ath10k_vif *arvif = (void *)vif->drv_priv; 8204 struct cfg80211_chan_def def; 8205 struct ath10k *ar = arvif->ar; 8206 enum nl80211_band band; 8207 const u8 *ht_mcs_mask; 8208 const u16 *vht_mcs_mask; 8209 u8 rate; 8210 u8 nss; 8211 u8 sgi; 8212 u8 ldpc; 8213 int single_nss; 8214 int ret; 8215 int vht_num_rates, allow_pfr; 8216 u8 vht_pfr; 8217 bool update_bitrate_mask = true; 8218 8219 if (ath10k_mac_vif_chan(vif, &def)) 8220 return -EPERM; 8221 8222 band = def.chan->band; 8223 ht_mcs_mask = mask->control[band].ht_mcs; 8224 vht_mcs_mask = mask->control[band].vht_mcs; 8225 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC); 8226 8227 sgi = mask->control[band].gi; 8228 if (sgi == NL80211_TXRATE_FORCE_LGI) 8229 return -EINVAL; 8230 8231 allow_pfr = test_bit(ATH10K_FW_FEATURE_PEER_FIXED_RATE, 8232 ar->normal_mode_fw.fw_file.fw_features); 8233 if (allow_pfr) { 8234 mutex_lock(&ar->conf_mutex); 8235 ieee80211_iterate_stations_atomic(ar->hw, 8236 ath10k_mac_clr_bitrate_mask_iter, 8237 arvif); 8238 mutex_unlock(&ar->conf_mutex); 8239 } 8240 8241 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask, 8242 &vht_num_rates)) { 8243 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask, 8244 &rate, &nss, 8245 false); 8246 if (ret) { 8247 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n", 8248 arvif->vdev_id, ret); 8249 return ret; 8250 } 8251 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask, 8252 &single_nss)) { 8253 rate = WMI_FIXED_RATE_NONE; 8254 nss = single_nss; 8255 } else { 8256 rate = WMI_FIXED_RATE_NONE; 8257 nss = min(ar->num_rf_chains, 8258 max(ath10k_mac_max_ht_nss(ht_mcs_mask), 8259 ath10k_mac_max_vht_nss(vht_mcs_mask))); 8260 8261 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask, 8262 allow_pfr)) { 8263 u8 vht_nss; 8264 8265 if (!allow_pfr || vht_num_rates != 1) 8266 return -EINVAL; 8267 8268 /* Reach here, firmware supports peer fixed rate and has 8269 * single vht rate, and don't update vif birate_mask, as 8270 * the rate only for specific peer. 8271 */ 8272 ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask, 8273 &vht_pfr, 8274 &vht_nss, 8275 true); 8276 update_bitrate_mask = false; 8277 } else { 8278 vht_pfr = 0; 8279 } 8280 8281 mutex_lock(&ar->conf_mutex); 8282 8283 if (update_bitrate_mask) 8284 arvif->bitrate_mask = *mask; 8285 arvif->vht_num_rates = vht_num_rates; 8286 arvif->vht_pfr = vht_pfr; 8287 ieee80211_iterate_stations_atomic(ar->hw, 8288 ath10k_mac_set_bitrate_mask_iter, 8289 arvif); 8290 8291 mutex_unlock(&ar->conf_mutex); 8292 } 8293 8294 mutex_lock(&ar->conf_mutex); 8295 8296 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc); 8297 if (ret) { 8298 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n", 8299 arvif->vdev_id, ret); 8300 goto exit; 8301 } 8302 8303 exit: 8304 mutex_unlock(&ar->conf_mutex); 8305 8306 return ret; 8307 } 8308 8309 static void ath10k_sta_rc_update(struct ieee80211_hw *hw, 8310 struct ieee80211_vif *vif, 8311 struct ieee80211_sta *sta, 8312 u32 changed) 8313 { 8314 struct ath10k *ar = hw->priv; 8315 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 8316 struct ath10k_vif *arvif = (void *)vif->drv_priv; 8317 struct ath10k_peer *peer; 8318 u32 bw, smps; 8319 8320 spin_lock_bh(&ar->data_lock); 8321 8322 peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr); 8323 if (!peer) { 8324 spin_unlock_bh(&ar->data_lock); 8325 ath10k_warn(ar, "mac sta rc update failed to find peer %pM on vdev %i\n", 8326 sta->addr, arvif->vdev_id); 8327 return; 8328 } 8329 8330 ath10k_dbg(ar, ATH10K_DBG_MAC, 8331 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 8332 sta->addr, changed, sta->bandwidth, sta->rx_nss, 8333 sta->smps_mode); 8334 8335 if (changed & IEEE80211_RC_BW_CHANGED) { 8336 bw = WMI_PEER_CHWIDTH_20MHZ; 8337 8338 switch (sta->bandwidth) { 8339 case IEEE80211_STA_RX_BW_20: 8340 bw = WMI_PEER_CHWIDTH_20MHZ; 8341 break; 8342 case IEEE80211_STA_RX_BW_40: 8343 bw = WMI_PEER_CHWIDTH_40MHZ; 8344 break; 8345 case IEEE80211_STA_RX_BW_80: 8346 bw = WMI_PEER_CHWIDTH_80MHZ; 8347 break; 8348 case IEEE80211_STA_RX_BW_160: 8349 bw = WMI_PEER_CHWIDTH_160MHZ; 8350 break; 8351 default: 8352 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n", 8353 sta->bandwidth, sta->addr); 8354 bw = WMI_PEER_CHWIDTH_20MHZ; 8355 break; 8356 } 8357 8358 arsta->bw = bw; 8359 } 8360 8361 if (changed & IEEE80211_RC_NSS_CHANGED) 8362 arsta->nss = sta->rx_nss; 8363 8364 if (changed & IEEE80211_RC_SMPS_CHANGED) { 8365 smps = WMI_PEER_SMPS_PS_NONE; 8366 8367 switch (sta->smps_mode) { 8368 case IEEE80211_SMPS_AUTOMATIC: 8369 case IEEE80211_SMPS_OFF: 8370 smps = WMI_PEER_SMPS_PS_NONE; 8371 break; 8372 case IEEE80211_SMPS_STATIC: 8373 smps = WMI_PEER_SMPS_STATIC; 8374 break; 8375 case IEEE80211_SMPS_DYNAMIC: 8376 smps = WMI_PEER_SMPS_DYNAMIC; 8377 break; 8378 case IEEE80211_SMPS_NUM_MODES: 8379 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n", 8380 sta->smps_mode, sta->addr); 8381 smps = WMI_PEER_SMPS_PS_NONE; 8382 break; 8383 } 8384 8385 arsta->smps = smps; 8386 } 8387 8388 arsta->changed |= changed; 8389 8390 spin_unlock_bh(&ar->data_lock); 8391 8392 ieee80211_queue_work(hw, &arsta->update_wk); 8393 } 8394 8395 static void ath10k_offset_tsf(struct ieee80211_hw *hw, 8396 struct ieee80211_vif *vif, s64 tsf_offset) 8397 { 8398 struct ath10k *ar = hw->priv; 8399 struct ath10k_vif *arvif = (void *)vif->drv_priv; 8400 u32 offset, vdev_param; 8401 int ret; 8402 8403 if (tsf_offset < 0) { 8404 vdev_param = ar->wmi.vdev_param->dec_tsf; 8405 offset = -tsf_offset; 8406 } else { 8407 vdev_param = ar->wmi.vdev_param->inc_tsf; 8408 offset = tsf_offset; 8409 } 8410 8411 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 8412 vdev_param, offset); 8413 8414 if (ret && ret != -EOPNOTSUPP) 8415 ath10k_warn(ar, "failed to set tsf offset %d cmd %d: %d\n", 8416 offset, vdev_param, ret); 8417 } 8418 8419 static int ath10k_ampdu_action(struct ieee80211_hw *hw, 8420 struct ieee80211_vif *vif, 8421 struct ieee80211_ampdu_params *params) 8422 { 8423 struct ath10k *ar = hw->priv; 8424 struct ath10k_vif *arvif = (void *)vif->drv_priv; 8425 struct ieee80211_sta *sta = params->sta; 8426 enum ieee80211_ampdu_mlme_action action = params->action; 8427 u16 tid = params->tid; 8428 8429 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n", 8430 arvif->vdev_id, sta->addr, tid, action); 8431 8432 switch (action) { 8433 case IEEE80211_AMPDU_RX_START: 8434 case IEEE80211_AMPDU_RX_STOP: 8435 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session 8436 * creation/removal. Do we need to verify this? 8437 */ 8438 return 0; 8439 case IEEE80211_AMPDU_TX_START: 8440 case IEEE80211_AMPDU_TX_STOP_CONT: 8441 case IEEE80211_AMPDU_TX_STOP_FLUSH: 8442 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 8443 case IEEE80211_AMPDU_TX_OPERATIONAL: 8444 /* Firmware offloads Tx aggregation entirely so deny mac80211 8445 * Tx aggregation requests. 8446 */ 8447 return -EOPNOTSUPP; 8448 } 8449 8450 return -EINVAL; 8451 } 8452 8453 static void 8454 ath10k_mac_update_rx_channel(struct ath10k *ar, 8455 struct ieee80211_chanctx_conf *ctx, 8456 struct ieee80211_vif_chanctx_switch *vifs, 8457 int n_vifs) 8458 { 8459 struct cfg80211_chan_def *def = NULL; 8460 8461 /* Both locks are required because ar->rx_channel is modified. This 8462 * allows readers to hold either lock. 8463 */ 8464 lockdep_assert_held(&ar->conf_mutex); 8465 lockdep_assert_held(&ar->data_lock); 8466 8467 WARN_ON(ctx && vifs); 8468 WARN_ON(vifs && !n_vifs); 8469 8470 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are 8471 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each 8472 * ppdu on Rx may reduce performance on low-end systems. It should be 8473 * possible to make tables/hashmaps to speed the lookup up (be vary of 8474 * cpu data cache lines though regarding sizes) but to keep the initial 8475 * implementation simple and less intrusive fallback to the slow lookup 8476 * only for multi-channel cases. Single-channel cases will remain to 8477 * use the old channel derival and thus performance should not be 8478 * affected much. 8479 */ 8480 rcu_read_lock(); 8481 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) { 8482 ieee80211_iter_chan_contexts_atomic(ar->hw, 8483 ath10k_mac_get_any_chandef_iter, 8484 &def); 8485 8486 if (vifs) 8487 def = &vifs[0].new_ctx->def; 8488 8489 ar->rx_channel = def->chan; 8490 } else if ((ctx && ath10k_mac_num_chanctxs(ar) == 0) || 8491 (ctx && (ar->state == ATH10K_STATE_RESTARTED))) { 8492 /* During driver restart due to firmware assert, since mac80211 8493 * already has valid channel context for given radio, channel 8494 * context iteration return num_chanctx > 0. So fix rx_channel 8495 * when restart is in progress. 8496 */ 8497 ar->rx_channel = ctx->def.chan; 8498 } else { 8499 ar->rx_channel = NULL; 8500 } 8501 rcu_read_unlock(); 8502 } 8503 8504 static void 8505 ath10k_mac_update_vif_chan(struct ath10k *ar, 8506 struct ieee80211_vif_chanctx_switch *vifs, 8507 int n_vifs) 8508 { 8509 struct ath10k_vif *arvif; 8510 int ret; 8511 int i; 8512 8513 lockdep_assert_held(&ar->conf_mutex); 8514 8515 /* First stop monitor interface. Some FW versions crash if there's a 8516 * lone monitor interface. 8517 */ 8518 if (ar->monitor_started) 8519 ath10k_monitor_stop(ar); 8520 8521 for (i = 0; i < n_vifs; i++) { 8522 arvif = (void *)vifs[i].vif->drv_priv; 8523 8524 ath10k_dbg(ar, ATH10K_DBG_MAC, 8525 "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n", 8526 arvif->vdev_id, 8527 vifs[i].old_ctx->def.chan->center_freq, 8528 vifs[i].new_ctx->def.chan->center_freq, 8529 vifs[i].old_ctx->def.width, 8530 vifs[i].new_ctx->def.width); 8531 8532 if (WARN_ON(!arvif->is_started)) 8533 continue; 8534 8535 if (WARN_ON(!arvif->is_up)) 8536 continue; 8537 8538 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 8539 if (ret) { 8540 ath10k_warn(ar, "failed to down vdev %d: %d\n", 8541 arvif->vdev_id, ret); 8542 continue; 8543 } 8544 } 8545 8546 /* All relevant vdevs are downed and associated channel resources 8547 * should be available for the channel switch now. 8548 */ 8549 8550 spin_lock_bh(&ar->data_lock); 8551 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs); 8552 spin_unlock_bh(&ar->data_lock); 8553 8554 for (i = 0; i < n_vifs; i++) { 8555 arvif = (void *)vifs[i].vif->drv_priv; 8556 8557 if (WARN_ON(!arvif->is_started)) 8558 continue; 8559 8560 if (WARN_ON(!arvif->is_up)) 8561 continue; 8562 8563 ret = ath10k_mac_setup_bcn_tmpl(arvif); 8564 if (ret) 8565 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n", 8566 ret); 8567 8568 ret = ath10k_mac_setup_prb_tmpl(arvif); 8569 if (ret) 8570 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n", 8571 ret); 8572 8573 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def); 8574 if (ret) { 8575 ath10k_warn(ar, "failed to restart vdev %d: %d\n", 8576 arvif->vdev_id, ret); 8577 continue; 8578 } 8579 8580 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 8581 arvif->bssid); 8582 if (ret) { 8583 ath10k_warn(ar, "failed to bring vdev up %d: %d\n", 8584 arvif->vdev_id, ret); 8585 continue; 8586 } 8587 } 8588 8589 ath10k_monitor_recalc(ar); 8590 } 8591 8592 static int 8593 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw, 8594 struct ieee80211_chanctx_conf *ctx) 8595 { 8596 struct ath10k *ar = hw->priv; 8597 8598 ath10k_dbg(ar, ATH10K_DBG_MAC, 8599 "mac chanctx add freq %hu width %d ptr %pK\n", 8600 ctx->def.chan->center_freq, ctx->def.width, ctx); 8601 8602 mutex_lock(&ar->conf_mutex); 8603 8604 spin_lock_bh(&ar->data_lock); 8605 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0); 8606 spin_unlock_bh(&ar->data_lock); 8607 8608 ath10k_recalc_radar_detection(ar); 8609 ath10k_monitor_recalc(ar); 8610 8611 mutex_unlock(&ar->conf_mutex); 8612 8613 return 0; 8614 } 8615 8616 static void 8617 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw, 8618 struct ieee80211_chanctx_conf *ctx) 8619 { 8620 struct ath10k *ar = hw->priv; 8621 8622 ath10k_dbg(ar, ATH10K_DBG_MAC, 8623 "mac chanctx remove freq %hu width %d ptr %pK\n", 8624 ctx->def.chan->center_freq, ctx->def.width, ctx); 8625 8626 mutex_lock(&ar->conf_mutex); 8627 8628 spin_lock_bh(&ar->data_lock); 8629 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0); 8630 spin_unlock_bh(&ar->data_lock); 8631 8632 ath10k_recalc_radar_detection(ar); 8633 ath10k_monitor_recalc(ar); 8634 8635 mutex_unlock(&ar->conf_mutex); 8636 } 8637 8638 struct ath10k_mac_change_chanctx_arg { 8639 struct ieee80211_chanctx_conf *ctx; 8640 struct ieee80211_vif_chanctx_switch *vifs; 8641 int n_vifs; 8642 int next_vif; 8643 }; 8644 8645 static void 8646 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac, 8647 struct ieee80211_vif *vif) 8648 { 8649 struct ath10k_mac_change_chanctx_arg *arg = data; 8650 8651 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx) 8652 return; 8653 8654 arg->n_vifs++; 8655 } 8656 8657 static void 8658 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac, 8659 struct ieee80211_vif *vif) 8660 { 8661 struct ath10k_mac_change_chanctx_arg *arg = data; 8662 struct ieee80211_chanctx_conf *ctx; 8663 8664 ctx = rcu_access_pointer(vif->chanctx_conf); 8665 if (ctx != arg->ctx) 8666 return; 8667 8668 if (WARN_ON(arg->next_vif == arg->n_vifs)) 8669 return; 8670 8671 arg->vifs[arg->next_vif].vif = vif; 8672 arg->vifs[arg->next_vif].old_ctx = ctx; 8673 arg->vifs[arg->next_vif].new_ctx = ctx; 8674 arg->next_vif++; 8675 } 8676 8677 static void 8678 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw, 8679 struct ieee80211_chanctx_conf *ctx, 8680 u32 changed) 8681 { 8682 struct ath10k *ar = hw->priv; 8683 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx }; 8684 8685 mutex_lock(&ar->conf_mutex); 8686 8687 ath10k_dbg(ar, ATH10K_DBG_MAC, 8688 "mac chanctx change freq %hu width %d ptr %pK changed %x\n", 8689 ctx->def.chan->center_freq, ctx->def.width, ctx, changed); 8690 8691 /* This shouldn't really happen because channel switching should use 8692 * switch_vif_chanctx(). 8693 */ 8694 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL)) 8695 goto unlock; 8696 8697 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) { 8698 ieee80211_iterate_active_interfaces_atomic( 8699 hw, 8700 ATH10K_ITER_NORMAL_FLAGS, 8701 ath10k_mac_change_chanctx_cnt_iter, 8702 &arg); 8703 if (arg.n_vifs == 0) 8704 goto radar; 8705 8706 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), 8707 GFP_KERNEL); 8708 if (!arg.vifs) 8709 goto radar; 8710 8711 ieee80211_iterate_active_interfaces_atomic( 8712 hw, 8713 ATH10K_ITER_NORMAL_FLAGS, 8714 ath10k_mac_change_chanctx_fill_iter, 8715 &arg); 8716 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs); 8717 kfree(arg.vifs); 8718 } 8719 8720 radar: 8721 ath10k_recalc_radar_detection(ar); 8722 8723 /* FIXME: How to configure Rx chains properly? */ 8724 8725 /* No other actions are actually necessary. Firmware maintains channel 8726 * definitions per vdev internally and there's no host-side channel 8727 * context abstraction to configure, e.g. channel width. 8728 */ 8729 8730 unlock: 8731 mutex_unlock(&ar->conf_mutex); 8732 } 8733 8734 static int 8735 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw, 8736 struct ieee80211_vif *vif, 8737 struct ieee80211_chanctx_conf *ctx) 8738 { 8739 struct ath10k *ar = hw->priv; 8740 struct ath10k_vif *arvif = (void *)vif->drv_priv; 8741 int ret; 8742 8743 mutex_lock(&ar->conf_mutex); 8744 8745 ath10k_dbg(ar, ATH10K_DBG_MAC, 8746 "mac chanctx assign ptr %pK vdev_id %i\n", 8747 ctx, arvif->vdev_id); 8748 8749 if (WARN_ON(arvif->is_started)) { 8750 mutex_unlock(&ar->conf_mutex); 8751 return -EBUSY; 8752 } 8753 8754 ret = ath10k_vdev_start(arvif, &ctx->def); 8755 if (ret) { 8756 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n", 8757 arvif->vdev_id, vif->addr, 8758 ctx->def.chan->center_freq, ret); 8759 goto err; 8760 } 8761 8762 arvif->is_started = true; 8763 8764 ret = ath10k_mac_vif_setup_ps(arvif); 8765 if (ret) { 8766 ath10k_warn(ar, "failed to update vdev %i ps: %d\n", 8767 arvif->vdev_id, ret); 8768 goto err_stop; 8769 } 8770 8771 if (vif->type == NL80211_IFTYPE_MONITOR) { 8772 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr); 8773 if (ret) { 8774 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n", 8775 arvif->vdev_id, ret); 8776 goto err_stop; 8777 } 8778 8779 arvif->is_up = true; 8780 } 8781 8782 if (ath10k_mac_can_set_cts_prot(arvif)) { 8783 ret = ath10k_mac_set_cts_prot(arvif); 8784 if (ret) 8785 ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n", 8786 arvif->vdev_id, ret); 8787 } 8788 8789 if (ath10k_peer_stats_enabled(ar) && 8790 ar->hw_params.tx_stats_over_pktlog) { 8791 ar->pktlog_filter |= ATH10K_PKTLOG_PEER_STATS; 8792 ret = ath10k_wmi_pdev_pktlog_enable(ar, 8793 ar->pktlog_filter); 8794 if (ret) { 8795 ath10k_warn(ar, "failed to enable pktlog %d\n", ret); 8796 goto err_stop; 8797 } 8798 } 8799 8800 mutex_unlock(&ar->conf_mutex); 8801 return 0; 8802 8803 err_stop: 8804 ath10k_vdev_stop(arvif); 8805 arvif->is_started = false; 8806 ath10k_mac_vif_setup_ps(arvif); 8807 8808 err: 8809 mutex_unlock(&ar->conf_mutex); 8810 return ret; 8811 } 8812 8813 static void 8814 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 8815 struct ieee80211_vif *vif, 8816 struct ieee80211_chanctx_conf *ctx) 8817 { 8818 struct ath10k *ar = hw->priv; 8819 struct ath10k_vif *arvif = (void *)vif->drv_priv; 8820 int ret; 8821 8822 mutex_lock(&ar->conf_mutex); 8823 8824 ath10k_dbg(ar, ATH10K_DBG_MAC, 8825 "mac chanctx unassign ptr %pK vdev_id %i\n", 8826 ctx, arvif->vdev_id); 8827 8828 WARN_ON(!arvif->is_started); 8829 8830 if (vif->type == NL80211_IFTYPE_MONITOR) { 8831 WARN_ON(!arvif->is_up); 8832 8833 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 8834 if (ret) 8835 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n", 8836 arvif->vdev_id, ret); 8837 8838 arvif->is_up = false; 8839 } 8840 8841 ret = ath10k_vdev_stop(arvif); 8842 if (ret) 8843 ath10k_warn(ar, "failed to stop vdev %i: %d\n", 8844 arvif->vdev_id, ret); 8845 8846 arvif->is_started = false; 8847 8848 mutex_unlock(&ar->conf_mutex); 8849 } 8850 8851 static int 8852 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw, 8853 struct ieee80211_vif_chanctx_switch *vifs, 8854 int n_vifs, 8855 enum ieee80211_chanctx_switch_mode mode) 8856 { 8857 struct ath10k *ar = hw->priv; 8858 8859 mutex_lock(&ar->conf_mutex); 8860 8861 ath10k_dbg(ar, ATH10K_DBG_MAC, 8862 "mac chanctx switch n_vifs %d mode %d\n", 8863 n_vifs, mode); 8864 ath10k_mac_update_vif_chan(ar, vifs, n_vifs); 8865 8866 mutex_unlock(&ar->conf_mutex); 8867 return 0; 8868 } 8869 8870 static void ath10k_mac_op_sta_pre_rcu_remove(struct ieee80211_hw *hw, 8871 struct ieee80211_vif *vif, 8872 struct ieee80211_sta *sta) 8873 { 8874 struct ath10k *ar; 8875 struct ath10k_peer *peer; 8876 8877 ar = hw->priv; 8878 8879 list_for_each_entry(peer, &ar->peers, list) 8880 if (peer->sta == sta) 8881 peer->removed = true; 8882 } 8883 8884 /* HT MCS parameters with Nss = 1 */ 8885 static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss1[] = { 8886 /* MCS L20 L40 S20 S40 */ 8887 {0, { 65, 135, 72, 150} }, 8888 {1, { 130, 270, 144, 300} }, 8889 {2, { 195, 405, 217, 450} }, 8890 {3, { 260, 540, 289, 600} }, 8891 {4, { 390, 810, 433, 900} }, 8892 {5, { 520, 1080, 578, 1200} }, 8893 {6, { 585, 1215, 650, 1350} }, 8894 {7, { 650, 1350, 722, 1500} } 8895 }; 8896 8897 /* HT MCS parameters with Nss = 2 */ 8898 static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss2[] = { 8899 /* MCS L20 L40 S20 S40 */ 8900 {0, {130, 270, 144, 300} }, 8901 {1, {260, 540, 289, 600} }, 8902 {2, {390, 810, 433, 900} }, 8903 {3, {520, 1080, 578, 1200} }, 8904 {4, {780, 1620, 867, 1800} }, 8905 {5, {1040, 2160, 1156, 2400} }, 8906 {6, {1170, 2430, 1300, 2700} }, 8907 {7, {1300, 2700, 1444, 3000} } 8908 }; 8909 8910 /* MCS parameters with Nss = 1 */ 8911 static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss1[] = { 8912 /* MCS L80 S80 L40 S40 L20 S20 */ 8913 {0, {293, 325}, {135, 150}, {65, 72} }, 8914 {1, {585, 650}, {270, 300}, {130, 144} }, 8915 {2, {878, 975}, {405, 450}, {195, 217} }, 8916 {3, {1170, 1300}, {540, 600}, {260, 289} }, 8917 {4, {1755, 1950}, {810, 900}, {390, 433} }, 8918 {5, {2340, 2600}, {1080, 1200}, {520, 578} }, 8919 {6, {2633, 2925}, {1215, 1350}, {585, 650} }, 8920 {7, {2925, 3250}, {1350, 1500}, {650, 722} }, 8921 {8, {3510, 3900}, {1620, 1800}, {780, 867} }, 8922 {9, {3900, 4333}, {1800, 2000}, {780, 867} } 8923 }; 8924 8925 /*MCS parameters with Nss = 2 */ 8926 static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss2[] = { 8927 /* MCS L80 S80 L40 S40 L20 S20 */ 8928 {0, {585, 650}, {270, 300}, {130, 144} }, 8929 {1, {1170, 1300}, {540, 600}, {260, 289} }, 8930 {2, {1755, 1950}, {810, 900}, {390, 433} }, 8931 {3, {2340, 2600}, {1080, 1200}, {520, 578} }, 8932 {4, {3510, 3900}, {1620, 1800}, {780, 867} }, 8933 {5, {4680, 5200}, {2160, 2400}, {1040, 1156} }, 8934 {6, {5265, 5850}, {2430, 2700}, {1170, 1300} }, 8935 {7, {5850, 6500}, {2700, 3000}, {1300, 1444} }, 8936 {8, {7020, 7800}, {3240, 3600}, {1560, 1733} }, 8937 {9, {7800, 8667}, {3600, 4000}, {1560, 1733} } 8938 }; 8939 8940 static void ath10k_mac_get_rate_flags_ht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs, 8941 u8 *flags, u8 *bw) 8942 { 8943 struct ath10k_index_ht_data_rate_type *mcs_rate; 8944 u8 index; 8945 size_t len_nss1 = ARRAY_SIZE(supported_ht_mcs_rate_nss1); 8946 size_t len_nss2 = ARRAY_SIZE(supported_ht_mcs_rate_nss2); 8947 8948 if (mcs >= (len_nss1 + len_nss2)) { 8949 ath10k_warn(ar, "not supported mcs %d in current rate table", mcs); 8950 return; 8951 } 8952 8953 mcs_rate = (struct ath10k_index_ht_data_rate_type *) 8954 ((nss == 1) ? &supported_ht_mcs_rate_nss1 : 8955 &supported_ht_mcs_rate_nss2); 8956 8957 if (mcs >= len_nss1) 8958 index = mcs - len_nss1; 8959 else 8960 index = mcs; 8961 8962 if (rate == mcs_rate[index].supported_rate[0]) { 8963 *bw = RATE_INFO_BW_20; 8964 } else if (rate == mcs_rate[index].supported_rate[1]) { 8965 *bw |= RATE_INFO_BW_40; 8966 } else if (rate == mcs_rate[index].supported_rate[2]) { 8967 *bw |= RATE_INFO_BW_20; 8968 *flags |= RATE_INFO_FLAGS_SHORT_GI; 8969 } else if (rate == mcs_rate[index].supported_rate[3]) { 8970 *bw |= RATE_INFO_BW_40; 8971 *flags |= RATE_INFO_FLAGS_SHORT_GI; 8972 } else { 8973 ath10k_warn(ar, "invalid ht params rate %d 100kbps nss %d mcs %d", 8974 rate, nss, mcs); 8975 } 8976 } 8977 8978 static void ath10k_mac_get_rate_flags_vht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs, 8979 u8 *flags, u8 *bw) 8980 { 8981 struct ath10k_index_vht_data_rate_type *mcs_rate; 8982 8983 mcs_rate = (struct ath10k_index_vht_data_rate_type *) 8984 ((nss == 1) ? &supported_vht_mcs_rate_nss1 : 8985 &supported_vht_mcs_rate_nss2); 8986 8987 if (rate == mcs_rate[mcs].supported_VHT80_rate[0]) { 8988 *bw = RATE_INFO_BW_80; 8989 } else if (rate == mcs_rate[mcs].supported_VHT80_rate[1]) { 8990 *bw = RATE_INFO_BW_80; 8991 *flags |= RATE_INFO_FLAGS_SHORT_GI; 8992 } else if (rate == mcs_rate[mcs].supported_VHT40_rate[0]) { 8993 *bw = RATE_INFO_BW_40; 8994 } else if (rate == mcs_rate[mcs].supported_VHT40_rate[1]) { 8995 *bw = RATE_INFO_BW_40; 8996 *flags |= RATE_INFO_FLAGS_SHORT_GI; 8997 } else if (rate == mcs_rate[mcs].supported_VHT20_rate[0]) { 8998 *bw = RATE_INFO_BW_20; 8999 } else if (rate == mcs_rate[mcs].supported_VHT20_rate[1]) { 9000 *bw = RATE_INFO_BW_20; 9001 *flags |= RATE_INFO_FLAGS_SHORT_GI; 9002 } else { 9003 ath10k_warn(ar, "invalid vht params rate %d 100kbps nss %d mcs %d", 9004 rate, nss, mcs); 9005 } 9006 } 9007 9008 static void ath10k_mac_get_rate_flags(struct ath10k *ar, u32 rate, 9009 enum ath10k_phy_mode mode, u8 nss, u8 mcs, 9010 u8 *flags, u8 *bw) 9011 { 9012 if (mode == ATH10K_PHY_MODE_HT) { 9013 *flags = RATE_INFO_FLAGS_MCS; 9014 ath10k_mac_get_rate_flags_ht(ar, rate, nss, mcs, flags, bw); 9015 } else if (mode == ATH10K_PHY_MODE_VHT) { 9016 *flags = RATE_INFO_FLAGS_VHT_MCS; 9017 ath10k_mac_get_rate_flags_vht(ar, rate, nss, mcs, flags, bw); 9018 } 9019 } 9020 9021 static void ath10k_mac_parse_bitrate(struct ath10k *ar, u32 rate_code, 9022 u32 bitrate_kbps, struct rate_info *rate) 9023 { 9024 enum ath10k_phy_mode mode = ATH10K_PHY_MODE_LEGACY; 9025 enum wmi_rate_preamble preamble = WMI_TLV_GET_HW_RC_PREAM_V1(rate_code); 9026 u8 nss = WMI_TLV_GET_HW_RC_NSS_V1(rate_code) + 1; 9027 u8 mcs = WMI_TLV_GET_HW_RC_RATE_V1(rate_code); 9028 u8 flags = 0, bw = 0; 9029 9030 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac parse rate code 0x%x bitrate %d kbps\n", 9031 rate_code, bitrate_kbps); 9032 9033 if (preamble == WMI_RATE_PREAMBLE_HT) 9034 mode = ATH10K_PHY_MODE_HT; 9035 else if (preamble == WMI_RATE_PREAMBLE_VHT) 9036 mode = ATH10K_PHY_MODE_VHT; 9037 9038 ath10k_mac_get_rate_flags(ar, bitrate_kbps / 100, mode, nss, mcs, &flags, &bw); 9039 9040 ath10k_dbg(ar, ATH10K_DBG_MAC, 9041 "mac parse bitrate preamble %d mode %d nss %d mcs %d flags %x bw %d\n", 9042 preamble, mode, nss, mcs, flags, bw); 9043 9044 rate->flags = flags; 9045 rate->bw = bw; 9046 rate->legacy = bitrate_kbps / 100; 9047 rate->nss = nss; 9048 rate->mcs = mcs; 9049 } 9050 9051 static void ath10k_mac_sta_get_peer_stats_info(struct ath10k *ar, 9052 struct ieee80211_sta *sta, 9053 struct station_info *sinfo) 9054 { 9055 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 9056 struct ath10k_peer *peer; 9057 unsigned long time_left; 9058 int ret; 9059 9060 if (!(ar->hw_params.supports_peer_stats_info && 9061 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA)) 9062 return; 9063 9064 spin_lock_bh(&ar->data_lock); 9065 peer = ath10k_peer_find(ar, arsta->arvif->vdev_id, sta->addr); 9066 spin_unlock_bh(&ar->data_lock); 9067 if (!peer) 9068 return; 9069 9070 reinit_completion(&ar->peer_stats_info_complete); 9071 9072 ret = ath10k_wmi_request_peer_stats_info(ar, 9073 arsta->arvif->vdev_id, 9074 WMI_REQUEST_ONE_PEER_STATS_INFO, 9075 arsta->arvif->bssid, 9076 0); 9077 if (ret && ret != -EOPNOTSUPP) { 9078 ath10k_warn(ar, "could not request peer stats info: %d\n", ret); 9079 return; 9080 } 9081 9082 time_left = wait_for_completion_timeout(&ar->peer_stats_info_complete, 3 * HZ); 9083 if (time_left == 0) { 9084 ath10k_warn(ar, "timed out waiting peer stats info\n"); 9085 return; 9086 } 9087 9088 if (arsta->rx_rate_code != 0 && arsta->rx_bitrate_kbps != 0) { 9089 ath10k_mac_parse_bitrate(ar, arsta->rx_rate_code, 9090 arsta->rx_bitrate_kbps, 9091 &sinfo->rxrate); 9092 9093 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE); 9094 arsta->rx_rate_code = 0; 9095 arsta->rx_bitrate_kbps = 0; 9096 } 9097 9098 if (arsta->tx_rate_code != 0 && arsta->tx_bitrate_kbps != 0) { 9099 ath10k_mac_parse_bitrate(ar, arsta->tx_rate_code, 9100 arsta->tx_bitrate_kbps, 9101 &sinfo->txrate); 9102 9103 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 9104 arsta->tx_rate_code = 0; 9105 arsta->tx_bitrate_kbps = 0; 9106 } 9107 } 9108 9109 static void ath10k_sta_statistics(struct ieee80211_hw *hw, 9110 struct ieee80211_vif *vif, 9111 struct ieee80211_sta *sta, 9112 struct station_info *sinfo) 9113 { 9114 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 9115 struct ath10k *ar = arsta->arvif->ar; 9116 9117 if (!ath10k_peer_stats_enabled(ar)) 9118 return; 9119 9120 ath10k_debug_fw_stats_request(ar); 9121 9122 sinfo->rx_duration = arsta->rx_duration; 9123 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION); 9124 9125 if (arsta->txrate.legacy || arsta->txrate.nss) { 9126 if (arsta->txrate.legacy) { 9127 sinfo->txrate.legacy = arsta->txrate.legacy; 9128 } else { 9129 sinfo->txrate.mcs = arsta->txrate.mcs; 9130 sinfo->txrate.nss = arsta->txrate.nss; 9131 sinfo->txrate.bw = arsta->txrate.bw; 9132 } 9133 sinfo->txrate.flags = arsta->txrate.flags; 9134 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 9135 } 9136 9137 if (ar->htt.disable_tx_comp) { 9138 sinfo->tx_failed = arsta->tx_failed; 9139 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED); 9140 } 9141 9142 sinfo->tx_retries = arsta->tx_retries; 9143 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES); 9144 9145 ath10k_mac_sta_get_peer_stats_info(ar, sta, sinfo); 9146 } 9147 9148 static int ath10k_mac_op_set_tid_config(struct ieee80211_hw *hw, 9149 struct ieee80211_vif *vif, 9150 struct ieee80211_sta *sta, 9151 struct cfg80211_tid_config *tid_config) 9152 { 9153 struct ath10k *ar = hw->priv; 9154 struct ath10k_vif *arvif = (void *)vif->drv_priv; 9155 struct ath10k_mac_iter_tid_conf_data data = {}; 9156 struct wmi_per_peer_per_tid_cfg_arg arg = {}; 9157 int ret, i; 9158 9159 mutex_lock(&ar->conf_mutex); 9160 arg.vdev_id = arvif->vdev_id; 9161 9162 arvif->tids_rst = 0; 9163 memset(arvif->tid_conf_changed, 0, sizeof(arvif->tid_conf_changed)); 9164 9165 for (i = 0; i < tid_config->n_tid_conf; i++) { 9166 ret = ath10k_mac_parse_tid_config(ar, sta, vif, 9167 &tid_config->tid_conf[i], 9168 &arg); 9169 if (ret) 9170 goto exit; 9171 } 9172 9173 ret = 0; 9174 9175 if (sta) 9176 goto exit; 9177 9178 arvif->tids_rst = 0; 9179 data.curr_vif = vif; 9180 data.ar = ar; 9181 9182 ieee80211_iterate_stations_atomic(hw, ath10k_mac_vif_stations_tid_conf, 9183 &data); 9184 9185 exit: 9186 mutex_unlock(&ar->conf_mutex); 9187 return ret; 9188 } 9189 9190 static int ath10k_mac_op_reset_tid_config(struct ieee80211_hw *hw, 9191 struct ieee80211_vif *vif, 9192 struct ieee80211_sta *sta, 9193 u8 tids) 9194 { 9195 struct ath10k_vif *arvif = (void *)vif->drv_priv; 9196 struct ath10k_mac_iter_tid_conf_data data = {}; 9197 struct ath10k *ar = hw->priv; 9198 int ret = 0; 9199 9200 mutex_lock(&ar->conf_mutex); 9201 9202 if (sta) { 9203 arvif->tids_rst = 0; 9204 ret = ath10k_mac_reset_tid_config(ar, sta, arvif, tids); 9205 goto exit; 9206 } 9207 9208 arvif->tids_rst = tids; 9209 data.curr_vif = vif; 9210 data.ar = ar; 9211 ieee80211_iterate_stations_atomic(hw, ath10k_mac_vif_stations_tid_conf, 9212 &data); 9213 9214 exit: 9215 mutex_unlock(&ar->conf_mutex); 9216 return ret; 9217 } 9218 9219 static const struct ieee80211_ops ath10k_ops = { 9220 .tx = ath10k_mac_op_tx, 9221 .wake_tx_queue = ath10k_mac_op_wake_tx_queue, 9222 .start = ath10k_start, 9223 .stop = ath10k_stop, 9224 .config = ath10k_config, 9225 .add_interface = ath10k_add_interface, 9226 .remove_interface = ath10k_remove_interface, 9227 .configure_filter = ath10k_configure_filter, 9228 .bss_info_changed = ath10k_bss_info_changed, 9229 .set_coverage_class = ath10k_mac_op_set_coverage_class, 9230 .hw_scan = ath10k_hw_scan, 9231 .cancel_hw_scan = ath10k_cancel_hw_scan, 9232 .set_key = ath10k_set_key, 9233 .set_default_unicast_key = ath10k_set_default_unicast_key, 9234 .sta_state = ath10k_sta_state, 9235 .sta_set_txpwr = ath10k_sta_set_txpwr, 9236 .conf_tx = ath10k_conf_tx, 9237 .remain_on_channel = ath10k_remain_on_channel, 9238 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel, 9239 .set_rts_threshold = ath10k_set_rts_threshold, 9240 .set_frag_threshold = ath10k_mac_op_set_frag_threshold, 9241 .flush = ath10k_flush, 9242 .tx_last_beacon = ath10k_tx_last_beacon, 9243 .set_antenna = ath10k_set_antenna, 9244 .get_antenna = ath10k_get_antenna, 9245 .reconfig_complete = ath10k_reconfig_complete, 9246 .get_survey = ath10k_get_survey, 9247 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask, 9248 .sta_rc_update = ath10k_sta_rc_update, 9249 .offset_tsf = ath10k_offset_tsf, 9250 .ampdu_action = ath10k_ampdu_action, 9251 .get_et_sset_count = ath10k_debug_get_et_sset_count, 9252 .get_et_stats = ath10k_debug_get_et_stats, 9253 .get_et_strings = ath10k_debug_get_et_strings, 9254 .add_chanctx = ath10k_mac_op_add_chanctx, 9255 .remove_chanctx = ath10k_mac_op_remove_chanctx, 9256 .change_chanctx = ath10k_mac_op_change_chanctx, 9257 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx, 9258 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx, 9259 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx, 9260 .sta_pre_rcu_remove = ath10k_mac_op_sta_pre_rcu_remove, 9261 .sta_statistics = ath10k_sta_statistics, 9262 .set_tid_config = ath10k_mac_op_set_tid_config, 9263 .reset_tid_config = ath10k_mac_op_reset_tid_config, 9264 9265 CFG80211_TESTMODE_CMD(ath10k_tm_cmd) 9266 9267 #ifdef CONFIG_PM 9268 .suspend = ath10k_wow_op_suspend, 9269 .resume = ath10k_wow_op_resume, 9270 .set_wakeup = ath10k_wow_op_set_wakeup, 9271 #endif 9272 #ifdef CONFIG_MAC80211_DEBUGFS 9273 .sta_add_debugfs = ath10k_sta_add_debugfs, 9274 #endif 9275 }; 9276 9277 #define CHAN2G(_channel, _freq, _flags) { \ 9278 .band = NL80211_BAND_2GHZ, \ 9279 .hw_value = (_channel), \ 9280 .center_freq = (_freq), \ 9281 .flags = (_flags), \ 9282 .max_antenna_gain = 0, \ 9283 .max_power = 30, \ 9284 } 9285 9286 #define CHAN5G(_channel, _freq, _flags) { \ 9287 .band = NL80211_BAND_5GHZ, \ 9288 .hw_value = (_channel), \ 9289 .center_freq = (_freq), \ 9290 .flags = (_flags), \ 9291 .max_antenna_gain = 0, \ 9292 .max_power = 30, \ 9293 } 9294 9295 static const struct ieee80211_channel ath10k_2ghz_channels[] = { 9296 CHAN2G(1, 2412, 0), 9297 CHAN2G(2, 2417, 0), 9298 CHAN2G(3, 2422, 0), 9299 CHAN2G(4, 2427, 0), 9300 CHAN2G(5, 2432, 0), 9301 CHAN2G(6, 2437, 0), 9302 CHAN2G(7, 2442, 0), 9303 CHAN2G(8, 2447, 0), 9304 CHAN2G(9, 2452, 0), 9305 CHAN2G(10, 2457, 0), 9306 CHAN2G(11, 2462, 0), 9307 CHAN2G(12, 2467, 0), 9308 CHAN2G(13, 2472, 0), 9309 CHAN2G(14, 2484, 0), 9310 }; 9311 9312 static const struct ieee80211_channel ath10k_5ghz_channels[] = { 9313 CHAN5G(36, 5180, 0), 9314 CHAN5G(40, 5200, 0), 9315 CHAN5G(44, 5220, 0), 9316 CHAN5G(48, 5240, 0), 9317 CHAN5G(52, 5260, 0), 9318 CHAN5G(56, 5280, 0), 9319 CHAN5G(60, 5300, 0), 9320 CHAN5G(64, 5320, 0), 9321 CHAN5G(100, 5500, 0), 9322 CHAN5G(104, 5520, 0), 9323 CHAN5G(108, 5540, 0), 9324 CHAN5G(112, 5560, 0), 9325 CHAN5G(116, 5580, 0), 9326 CHAN5G(120, 5600, 0), 9327 CHAN5G(124, 5620, 0), 9328 CHAN5G(128, 5640, 0), 9329 CHAN5G(132, 5660, 0), 9330 CHAN5G(136, 5680, 0), 9331 CHAN5G(140, 5700, 0), 9332 CHAN5G(144, 5720, 0), 9333 CHAN5G(149, 5745, 0), 9334 CHAN5G(153, 5765, 0), 9335 CHAN5G(157, 5785, 0), 9336 CHAN5G(161, 5805, 0), 9337 CHAN5G(165, 5825, 0), 9338 CHAN5G(169, 5845, 0), 9339 CHAN5G(173, 5865, 0), 9340 /* If you add more, you may need to change ATH10K_MAX_5G_CHAN */ 9341 /* And you will definitely need to change ATH10K_NUM_CHANS in core.h */ 9342 }; 9343 9344 struct ath10k *ath10k_mac_create(size_t priv_size) 9345 { 9346 struct ieee80211_hw *hw; 9347 struct ieee80211_ops *ops; 9348 struct ath10k *ar; 9349 9350 ops = kmemdup(&ath10k_ops, sizeof(ath10k_ops), GFP_KERNEL); 9351 if (!ops) 9352 return NULL; 9353 9354 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, ops); 9355 if (!hw) { 9356 kfree(ops); 9357 return NULL; 9358 } 9359 9360 ar = hw->priv; 9361 ar->hw = hw; 9362 ar->ops = ops; 9363 9364 return ar; 9365 } 9366 9367 void ath10k_mac_destroy(struct ath10k *ar) 9368 { 9369 struct ieee80211_ops *ops = ar->ops; 9370 9371 ieee80211_free_hw(ar->hw); 9372 kfree(ops); 9373 } 9374 9375 static const struct ieee80211_iface_limit ath10k_if_limits[] = { 9376 { 9377 .max = 8, 9378 .types = BIT(NL80211_IFTYPE_STATION) 9379 | BIT(NL80211_IFTYPE_P2P_CLIENT) 9380 }, 9381 { 9382 .max = 3, 9383 .types = BIT(NL80211_IFTYPE_P2P_GO) 9384 }, 9385 { 9386 .max = 1, 9387 .types = BIT(NL80211_IFTYPE_P2P_DEVICE) 9388 }, 9389 { 9390 .max = 7, 9391 .types = BIT(NL80211_IFTYPE_AP) 9392 #ifdef CONFIG_MAC80211_MESH 9393 | BIT(NL80211_IFTYPE_MESH_POINT) 9394 #endif 9395 }, 9396 }; 9397 9398 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = { 9399 { 9400 .max = 8, 9401 .types = BIT(NL80211_IFTYPE_AP) 9402 #ifdef CONFIG_MAC80211_MESH 9403 | BIT(NL80211_IFTYPE_MESH_POINT) 9404 #endif 9405 }, 9406 { 9407 .max = 1, 9408 .types = BIT(NL80211_IFTYPE_STATION) 9409 }, 9410 }; 9411 9412 static const struct ieee80211_iface_combination ath10k_if_comb[] = { 9413 { 9414 .limits = ath10k_if_limits, 9415 .n_limits = ARRAY_SIZE(ath10k_if_limits), 9416 .max_interfaces = 8, 9417 .num_different_channels = 1, 9418 .beacon_int_infra_match = true, 9419 }, 9420 }; 9421 9422 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = { 9423 { 9424 .limits = ath10k_10x_if_limits, 9425 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits), 9426 .max_interfaces = 8, 9427 .num_different_channels = 1, 9428 .beacon_int_infra_match = true, 9429 .beacon_int_min_gcd = 1, 9430 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 9431 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 9432 BIT(NL80211_CHAN_WIDTH_20) | 9433 BIT(NL80211_CHAN_WIDTH_40) | 9434 BIT(NL80211_CHAN_WIDTH_80), 9435 #endif 9436 }, 9437 }; 9438 9439 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = { 9440 { 9441 .max = 2, 9442 .types = BIT(NL80211_IFTYPE_STATION), 9443 }, 9444 { 9445 .max = 2, 9446 .types = BIT(NL80211_IFTYPE_AP) | 9447 #ifdef CONFIG_MAC80211_MESH 9448 BIT(NL80211_IFTYPE_MESH_POINT) | 9449 #endif 9450 BIT(NL80211_IFTYPE_P2P_CLIENT) | 9451 BIT(NL80211_IFTYPE_P2P_GO), 9452 }, 9453 { 9454 .max = 1, 9455 .types = BIT(NL80211_IFTYPE_P2P_DEVICE), 9456 }, 9457 }; 9458 9459 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = { 9460 { 9461 .max = 2, 9462 .types = BIT(NL80211_IFTYPE_STATION), 9463 }, 9464 { 9465 .max = 2, 9466 .types = BIT(NL80211_IFTYPE_P2P_CLIENT), 9467 }, 9468 { 9469 .max = 1, 9470 .types = BIT(NL80211_IFTYPE_AP) | 9471 #ifdef CONFIG_MAC80211_MESH 9472 BIT(NL80211_IFTYPE_MESH_POINT) | 9473 #endif 9474 BIT(NL80211_IFTYPE_P2P_GO), 9475 }, 9476 { 9477 .max = 1, 9478 .types = BIT(NL80211_IFTYPE_P2P_DEVICE), 9479 }, 9480 }; 9481 9482 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = { 9483 { 9484 .max = 1, 9485 .types = BIT(NL80211_IFTYPE_STATION), 9486 }, 9487 { 9488 .max = 1, 9489 .types = BIT(NL80211_IFTYPE_ADHOC), 9490 }, 9491 }; 9492 9493 /* FIXME: This is not thouroughly tested. These combinations may over- or 9494 * underestimate hw/fw capabilities. 9495 */ 9496 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = { 9497 { 9498 .limits = ath10k_tlv_if_limit, 9499 .num_different_channels = 1, 9500 .max_interfaces = 4, 9501 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit), 9502 }, 9503 { 9504 .limits = ath10k_tlv_if_limit_ibss, 9505 .num_different_channels = 1, 9506 .max_interfaces = 2, 9507 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss), 9508 }, 9509 }; 9510 9511 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = { 9512 { 9513 .limits = ath10k_tlv_if_limit, 9514 .num_different_channels = 1, 9515 .max_interfaces = 4, 9516 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit), 9517 }, 9518 { 9519 .limits = ath10k_tlv_qcs_if_limit, 9520 .num_different_channels = 2, 9521 .max_interfaces = 4, 9522 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit), 9523 }, 9524 { 9525 .limits = ath10k_tlv_if_limit_ibss, 9526 .num_different_channels = 1, 9527 .max_interfaces = 2, 9528 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss), 9529 }, 9530 }; 9531 9532 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = { 9533 { 9534 .max = 1, 9535 .types = BIT(NL80211_IFTYPE_STATION), 9536 }, 9537 { 9538 .max = 16, 9539 .types = BIT(NL80211_IFTYPE_AP) 9540 #ifdef CONFIG_MAC80211_MESH 9541 | BIT(NL80211_IFTYPE_MESH_POINT) 9542 #endif 9543 }, 9544 }; 9545 9546 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = { 9547 { 9548 .limits = ath10k_10_4_if_limits, 9549 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits), 9550 .max_interfaces = 16, 9551 .num_different_channels = 1, 9552 .beacon_int_infra_match = true, 9553 .beacon_int_min_gcd = 1, 9554 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 9555 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 9556 BIT(NL80211_CHAN_WIDTH_20) | 9557 BIT(NL80211_CHAN_WIDTH_40) | 9558 BIT(NL80211_CHAN_WIDTH_80) | 9559 BIT(NL80211_CHAN_WIDTH_80P80) | 9560 BIT(NL80211_CHAN_WIDTH_160), 9561 #endif 9562 }, 9563 }; 9564 9565 static const struct 9566 ieee80211_iface_combination ath10k_10_4_bcn_int_if_comb[] = { 9567 { 9568 .limits = ath10k_10_4_if_limits, 9569 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits), 9570 .max_interfaces = 16, 9571 .num_different_channels = 1, 9572 .beacon_int_infra_match = true, 9573 .beacon_int_min_gcd = 100, 9574 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 9575 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 9576 BIT(NL80211_CHAN_WIDTH_20) | 9577 BIT(NL80211_CHAN_WIDTH_40) | 9578 BIT(NL80211_CHAN_WIDTH_80) | 9579 BIT(NL80211_CHAN_WIDTH_80P80) | 9580 BIT(NL80211_CHAN_WIDTH_160), 9581 #endif 9582 }, 9583 }; 9584 9585 static void ath10k_get_arvif_iter(void *data, u8 *mac, 9586 struct ieee80211_vif *vif) 9587 { 9588 struct ath10k_vif_iter *arvif_iter = data; 9589 struct ath10k_vif *arvif = (void *)vif->drv_priv; 9590 9591 if (arvif->vdev_id == arvif_iter->vdev_id) 9592 arvif_iter->arvif = arvif; 9593 } 9594 9595 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id) 9596 { 9597 struct ath10k_vif_iter arvif_iter; 9598 9599 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter)); 9600 arvif_iter.vdev_id = vdev_id; 9601 9602 ieee80211_iterate_active_interfaces_atomic(ar->hw, 9603 ATH10K_ITER_RESUME_FLAGS, 9604 ath10k_get_arvif_iter, 9605 &arvif_iter); 9606 if (!arvif_iter.arvif) { 9607 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id); 9608 return NULL; 9609 } 9610 9611 return arvif_iter.arvif; 9612 } 9613 9614 #define WRD_METHOD "WRDD" 9615 #define WRDD_WIFI (0x07) 9616 9617 static u32 ath10k_mac_wrdd_get_mcc(struct ath10k *ar, union acpi_object *wrdd) 9618 { 9619 union acpi_object *mcc_pkg; 9620 union acpi_object *domain_type; 9621 union acpi_object *mcc_value; 9622 u32 i; 9623 9624 if (wrdd->type != ACPI_TYPE_PACKAGE || 9625 wrdd->package.count < 2 || 9626 wrdd->package.elements[0].type != ACPI_TYPE_INTEGER || 9627 wrdd->package.elements[0].integer.value != 0) { 9628 ath10k_warn(ar, "ignoring malformed/unsupported wrdd structure\n"); 9629 return 0; 9630 } 9631 9632 for (i = 1; i < wrdd->package.count; ++i) { 9633 mcc_pkg = &wrdd->package.elements[i]; 9634 9635 if (mcc_pkg->type != ACPI_TYPE_PACKAGE) 9636 continue; 9637 if (mcc_pkg->package.count < 2) 9638 continue; 9639 if (mcc_pkg->package.elements[0].type != ACPI_TYPE_INTEGER || 9640 mcc_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) 9641 continue; 9642 9643 domain_type = &mcc_pkg->package.elements[0]; 9644 if (domain_type->integer.value != WRDD_WIFI) 9645 continue; 9646 9647 mcc_value = &mcc_pkg->package.elements[1]; 9648 return mcc_value->integer.value; 9649 } 9650 return 0; 9651 } 9652 9653 static int ath10k_mac_get_wrdd_regulatory(struct ath10k *ar, u16 *rd) 9654 { 9655 acpi_handle root_handle; 9656 acpi_handle handle; 9657 struct acpi_buffer wrdd = {ACPI_ALLOCATE_BUFFER, NULL}; 9658 acpi_status status; 9659 u32 alpha2_code; 9660 char alpha2[3]; 9661 9662 root_handle = ACPI_HANDLE(ar->dev); 9663 if (!root_handle) 9664 return -EOPNOTSUPP; 9665 9666 status = acpi_get_handle(root_handle, (acpi_string)WRD_METHOD, &handle); 9667 if (ACPI_FAILURE(status)) { 9668 ath10k_dbg(ar, ATH10K_DBG_BOOT, 9669 "failed to get wrd method %d\n", status); 9670 return -EIO; 9671 } 9672 9673 status = acpi_evaluate_object(handle, NULL, NULL, &wrdd); 9674 if (ACPI_FAILURE(status)) { 9675 ath10k_dbg(ar, ATH10K_DBG_BOOT, 9676 "failed to call wrdc %d\n", status); 9677 return -EIO; 9678 } 9679 9680 alpha2_code = ath10k_mac_wrdd_get_mcc(ar, wrdd.pointer); 9681 kfree(wrdd.pointer); 9682 if (!alpha2_code) 9683 return -EIO; 9684 9685 alpha2[0] = (alpha2_code >> 8) & 0xff; 9686 alpha2[1] = (alpha2_code >> 0) & 0xff; 9687 alpha2[2] = '\0'; 9688 9689 ath10k_dbg(ar, ATH10K_DBG_BOOT, 9690 "regulatory hint from WRDD (alpha2-code): %s\n", alpha2); 9691 9692 *rd = ath_regd_find_country_by_name(alpha2); 9693 if (*rd == 0xffff) 9694 return -EIO; 9695 9696 *rd |= COUNTRY_ERD_FLAG; 9697 return 0; 9698 } 9699 9700 static int ath10k_mac_init_rd(struct ath10k *ar) 9701 { 9702 int ret; 9703 u16 rd; 9704 9705 ret = ath10k_mac_get_wrdd_regulatory(ar, &rd); 9706 if (ret) { 9707 ath10k_dbg(ar, ATH10K_DBG_BOOT, 9708 "fallback to eeprom programmed regulatory settings\n"); 9709 rd = ar->hw_eeprom_rd; 9710 } 9711 9712 ar->ath_common.regulatory.current_rd = rd; 9713 return 0; 9714 } 9715 9716 int ath10k_mac_register(struct ath10k *ar) 9717 { 9718 static const u32 cipher_suites[] = { 9719 WLAN_CIPHER_SUITE_WEP40, 9720 WLAN_CIPHER_SUITE_WEP104, 9721 WLAN_CIPHER_SUITE_TKIP, 9722 WLAN_CIPHER_SUITE_CCMP, 9723 9724 /* Do not add hardware supported ciphers before this line. 9725 * Allow software encryption for all chips. Don't forget to 9726 * update n_cipher_suites below. 9727 */ 9728 WLAN_CIPHER_SUITE_AES_CMAC, 9729 WLAN_CIPHER_SUITE_BIP_CMAC_256, 9730 WLAN_CIPHER_SUITE_BIP_GMAC_128, 9731 WLAN_CIPHER_SUITE_BIP_GMAC_256, 9732 9733 /* Only QCA99x0 and QCA4019 varients support GCMP-128, GCMP-256 9734 * and CCMP-256 in hardware. 9735 */ 9736 WLAN_CIPHER_SUITE_GCMP, 9737 WLAN_CIPHER_SUITE_GCMP_256, 9738 WLAN_CIPHER_SUITE_CCMP_256, 9739 }; 9740 struct ieee80211_supported_band *band; 9741 void *channels; 9742 int ret; 9743 9744 if (!is_valid_ether_addr(ar->mac_addr)) { 9745 ath10k_warn(ar, "invalid MAC address; choosing random\n"); 9746 eth_random_addr(ar->mac_addr); 9747 } 9748 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 9749 9750 SET_IEEE80211_DEV(ar->hw, ar->dev); 9751 9752 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) + 9753 ARRAY_SIZE(ath10k_5ghz_channels)) != 9754 ATH10K_NUM_CHANS); 9755 9756 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) { 9757 channels = kmemdup(ath10k_2ghz_channels, 9758 sizeof(ath10k_2ghz_channels), 9759 GFP_KERNEL); 9760 if (!channels) { 9761 ret = -ENOMEM; 9762 goto err_free; 9763 } 9764 9765 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 9766 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels); 9767 band->channels = channels; 9768 9769 if (ar->hw_params.cck_rate_map_rev2) { 9770 band->n_bitrates = ath10k_g_rates_rev2_size; 9771 band->bitrates = ath10k_g_rates_rev2; 9772 } else { 9773 band->n_bitrates = ath10k_g_rates_size; 9774 band->bitrates = ath10k_g_rates; 9775 } 9776 9777 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band; 9778 } 9779 9780 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) { 9781 channels = kmemdup(ath10k_5ghz_channels, 9782 sizeof(ath10k_5ghz_channels), 9783 GFP_KERNEL); 9784 if (!channels) { 9785 ret = -ENOMEM; 9786 goto err_free; 9787 } 9788 9789 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 9790 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels); 9791 band->channels = channels; 9792 band->n_bitrates = ath10k_a_rates_size; 9793 band->bitrates = ath10k_a_rates; 9794 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band; 9795 } 9796 9797 wiphy_read_of_freq_limits(ar->hw->wiphy); 9798 ath10k_mac_setup_ht_vht_cap(ar); 9799 9800 ar->hw->wiphy->interface_modes = 9801 BIT(NL80211_IFTYPE_STATION) | 9802 BIT(NL80211_IFTYPE_AP) | 9803 BIT(NL80211_IFTYPE_MESH_POINT); 9804 9805 ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask; 9806 ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask; 9807 9808 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->normal_mode_fw.fw_file.fw_features)) 9809 ar->hw->wiphy->interface_modes |= 9810 BIT(NL80211_IFTYPE_P2P_DEVICE) | 9811 BIT(NL80211_IFTYPE_P2P_CLIENT) | 9812 BIT(NL80211_IFTYPE_P2P_GO); 9813 9814 ieee80211_hw_set(ar->hw, SIGNAL_DBM); 9815 9816 if (!test_bit(ATH10K_FW_FEATURE_NO_PS, 9817 ar->running_fw->fw_file.fw_features)) { 9818 ieee80211_hw_set(ar->hw, SUPPORTS_PS); 9819 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS); 9820 } 9821 9822 ieee80211_hw_set(ar->hw, MFP_CAPABLE); 9823 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS); 9824 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL); 9825 ieee80211_hw_set(ar->hw, AP_LINK_PS); 9826 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT); 9827 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT); 9828 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR); 9829 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK); 9830 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF); 9831 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA); 9832 ieee80211_hw_set(ar->hw, QUEUE_CONTROL); 9833 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG); 9834 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK); 9835 9836 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) 9837 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL); 9838 9839 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS; 9840 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 9841 9842 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 9843 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS; 9844 9845 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) { 9846 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION); 9847 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW); 9848 } 9849 9850 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 9851 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 9852 9853 if (test_bit(WMI_SERVICE_NLO, ar->wmi.svc_map)) { 9854 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS; 9855 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS; 9856 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH; 9857 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS; 9858 ar->hw->wiphy->max_sched_scan_plan_interval = 9859 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT; 9860 ar->hw->wiphy->max_sched_scan_plan_iterations = 9861 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS; 9862 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR; 9863 } 9864 9865 ar->hw->vif_data_size = sizeof(struct ath10k_vif); 9866 ar->hw->sta_data_size = sizeof(struct ath10k_sta); 9867 ar->hw->txq_data_size = sizeof(struct ath10k_txq); 9868 9869 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL; 9870 9871 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) { 9872 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD; 9873 9874 /* Firmware delivers WPS/P2P Probe Requests frames to driver so 9875 * that userspace (e.g. wpa_supplicant/hostapd) can generate 9876 * correct Probe Responses. This is more of a hack advert.. 9877 */ 9878 ar->hw->wiphy->probe_resp_offload |= 9879 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS | 9880 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 | 9881 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P; 9882 } 9883 9884 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map) || 9885 test_bit(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY, ar->wmi.svc_map)) { 9886 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS; 9887 if (test_bit(WMI_SERVICE_TDLS_WIDER_BANDWIDTH, ar->wmi.svc_map)) 9888 ieee80211_hw_set(ar->hw, TDLS_WIDER_BW); 9889 } 9890 9891 if (test_bit(WMI_SERVICE_TDLS_UAPSD_BUFFER_STA, ar->wmi.svc_map)) 9892 ieee80211_hw_set(ar->hw, SUPPORTS_TDLS_BUFFER_STA); 9893 9894 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 9895 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 9896 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 9897 9898 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 9899 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 9900 NL80211_FEATURE_AP_SCAN; 9901 9902 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations; 9903 9904 ret = ath10k_wow_init(ar); 9905 if (ret) { 9906 ath10k_warn(ar, "failed to init wow: %d\n", ret); 9907 goto err_free; 9908 } 9909 9910 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS); 9911 wiphy_ext_feature_set(ar->hw->wiphy, 9912 NL80211_EXT_FEATURE_SET_SCAN_DWELL); 9913 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_AQL); 9914 9915 if (test_bit(WMI_SERVICE_TX_DATA_ACK_RSSI, ar->wmi.svc_map) || 9916 test_bit(WMI_SERVICE_HTT_MGMT_TX_COMP_VALID_FLAGS, ar->wmi.svc_map)) 9917 wiphy_ext_feature_set(ar->hw->wiphy, 9918 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT); 9919 9920 if (ath10k_peer_stats_enabled(ar) || 9921 test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map)) 9922 wiphy_ext_feature_set(ar->hw->wiphy, 9923 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS); 9924 9925 if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) 9926 wiphy_ext_feature_set(ar->hw->wiphy, 9927 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER); 9928 9929 if (test_bit(WMI_SERVICE_TX_PWR_PER_PEER, ar->wmi.svc_map)) 9930 wiphy_ext_feature_set(ar->hw->wiphy, 9931 NL80211_EXT_FEATURE_STA_TX_PWR); 9932 9933 if (test_bit(WMI_SERVICE_PEER_TID_CONFIGS_SUPPORT, ar->wmi.svc_map)) { 9934 ar->hw->wiphy->tid_config_support.vif |= 9935 BIT(NL80211_TID_CONFIG_ATTR_NOACK) | 9936 BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT) | 9937 BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG) | 9938 BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL) | 9939 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) | 9940 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE); 9941 9942 if (test_bit(WMI_SERVICE_EXT_PEER_TID_CONFIGS_SUPPORT, 9943 ar->wmi.svc_map)) { 9944 ar->hw->wiphy->tid_config_support.vif |= 9945 BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL); 9946 } 9947 9948 ar->hw->wiphy->tid_config_support.peer = 9949 ar->hw->wiphy->tid_config_support.vif; 9950 ar->hw->wiphy->max_data_retry_count = ATH10K_MAX_RETRY_COUNT; 9951 } else { 9952 ar->ops->set_tid_config = NULL; 9953 } 9954 /* 9955 * on LL hardware queues are managed entirely by the FW 9956 * so we only advertise to mac we can do the queues thing 9957 */ 9958 ar->hw->queues = IEEE80211_MAX_QUEUES; 9959 9960 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is 9961 * something that vdev_ids can't reach so that we don't stop the queue 9962 * accidentally. 9963 */ 9964 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1; 9965 9966 switch (ar->running_fw->fw_file.wmi_op_version) { 9967 case ATH10K_FW_WMI_OP_VERSION_MAIN: 9968 ar->hw->wiphy->iface_combinations = ath10k_if_comb; 9969 ar->hw->wiphy->n_iface_combinations = 9970 ARRAY_SIZE(ath10k_if_comb); 9971 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC); 9972 break; 9973 case ATH10K_FW_WMI_OP_VERSION_TLV: 9974 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) { 9975 ar->hw->wiphy->iface_combinations = 9976 ath10k_tlv_qcs_if_comb; 9977 ar->hw->wiphy->n_iface_combinations = 9978 ARRAY_SIZE(ath10k_tlv_qcs_if_comb); 9979 } else { 9980 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb; 9981 ar->hw->wiphy->n_iface_combinations = 9982 ARRAY_SIZE(ath10k_tlv_if_comb); 9983 } 9984 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC); 9985 break; 9986 case ATH10K_FW_WMI_OP_VERSION_10_1: 9987 case ATH10K_FW_WMI_OP_VERSION_10_2: 9988 case ATH10K_FW_WMI_OP_VERSION_10_2_4: 9989 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb; 9990 ar->hw->wiphy->n_iface_combinations = 9991 ARRAY_SIZE(ath10k_10x_if_comb); 9992 break; 9993 case ATH10K_FW_WMI_OP_VERSION_10_4: 9994 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb; 9995 ar->hw->wiphy->n_iface_combinations = 9996 ARRAY_SIZE(ath10k_10_4_if_comb); 9997 if (test_bit(WMI_SERVICE_VDEV_DIFFERENT_BEACON_INTERVAL_SUPPORT, 9998 ar->wmi.svc_map)) { 9999 ar->hw->wiphy->iface_combinations = 10000 ath10k_10_4_bcn_int_if_comb; 10001 ar->hw->wiphy->n_iface_combinations = 10002 ARRAY_SIZE(ath10k_10_4_bcn_int_if_comb); 10003 } 10004 break; 10005 case ATH10K_FW_WMI_OP_VERSION_UNSET: 10006 case ATH10K_FW_WMI_OP_VERSION_MAX: 10007 WARN_ON(1); 10008 ret = -EINVAL; 10009 goto err_free; 10010 } 10011 10012 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) 10013 ar->hw->netdev_features = NETIF_F_HW_CSUM; 10014 10015 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) { 10016 /* Init ath dfs pattern detector */ 10017 ar->ath_common.debug_mask = ATH_DBG_DFS; 10018 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common, 10019 NL80211_DFS_UNSET); 10020 10021 if (!ar->dfs_detector) 10022 ath10k_warn(ar, "failed to initialise DFS pattern detector\n"); 10023 } 10024 10025 ret = ath10k_mac_init_rd(ar); 10026 if (ret) { 10027 ath10k_err(ar, "failed to derive regdom: %d\n", ret); 10028 goto err_dfs_detector_exit; 10029 } 10030 10031 /* Disable set_coverage_class for chipsets that do not support it. */ 10032 if (!ar->hw_params.hw_ops->set_coverage_class) 10033 ar->ops->set_coverage_class = NULL; 10034 10035 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy, 10036 ath10k_reg_notifier); 10037 if (ret) { 10038 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret); 10039 goto err_dfs_detector_exit; 10040 } 10041 10042 if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) { 10043 ar->hw->wiphy->features |= 10044 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR; 10045 } 10046 10047 ar->hw->wiphy->cipher_suites = cipher_suites; 10048 10049 /* QCA988x and QCA6174 family chips do not support CCMP-256, GCMP-128 10050 * and GCMP-256 ciphers in hardware. Fetch number of ciphers supported 10051 * from chip specific hw_param table. 10052 */ 10053 if (!ar->hw_params.n_cipher_suites || 10054 ar->hw_params.n_cipher_suites > ARRAY_SIZE(cipher_suites)) { 10055 ath10k_err(ar, "invalid hw_params.n_cipher_suites %d\n", 10056 ar->hw_params.n_cipher_suites); 10057 ar->hw_params.n_cipher_suites = 8; 10058 } 10059 ar->hw->wiphy->n_cipher_suites = ar->hw_params.n_cipher_suites; 10060 10061 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 10062 10063 ar->hw->weight_multiplier = ATH10K_AIRTIME_WEIGHT_MULTIPLIER; 10064 10065 ret = ieee80211_register_hw(ar->hw); 10066 if (ret) { 10067 ath10k_err(ar, "failed to register ieee80211: %d\n", ret); 10068 goto err_dfs_detector_exit; 10069 } 10070 10071 if (test_bit(WMI_SERVICE_PER_PACKET_SW_ENCRYPT, ar->wmi.svc_map)) { 10072 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN); 10073 ar->hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN); 10074 } 10075 10076 if (!ath_is_world_regd(&ar->ath_common.regulatory)) { 10077 ret = regulatory_hint(ar->hw->wiphy, 10078 ar->ath_common.regulatory.alpha2); 10079 if (ret) 10080 goto err_unregister; 10081 } 10082 10083 return 0; 10084 10085 err_unregister: 10086 ieee80211_unregister_hw(ar->hw); 10087 10088 err_dfs_detector_exit: 10089 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) 10090 ar->dfs_detector->exit(ar->dfs_detector); 10091 10092 err_free: 10093 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 10094 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 10095 10096 SET_IEEE80211_DEV(ar->hw, NULL); 10097 return ret; 10098 } 10099 10100 void ath10k_mac_unregister(struct ath10k *ar) 10101 { 10102 ieee80211_unregister_hw(ar->hw); 10103 10104 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) 10105 ar->dfs_detector->exit(ar->dfs_detector); 10106 10107 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 10108 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 10109 10110 SET_IEEE80211_DEV(ar->hw, NULL); 10111 } 10112