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_csa_is_complete(vif)) { 2023 ieee80211_csa_update_counter(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 IEEE80211_IFACE_ITER_NORMAL, 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 IEEE80211_IFACE_ITER_NORMAL, 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: /* fall through */ 2472 case 1: /* fall through */ 2473 case 2: /* fall through */ 2474 case 3: /* fall through */ 2475 case 4: /* fall through */ 2476 case 5: /* fall through */ 2477 case 6: /* fall through */ 2478 default: 2479 /* see ath10k_mac_can_set_bitrate_mask() */ 2480 WARN_ON(1); 2481 /* fall through */ 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_station_assoc(struct ath10k *ar, 3017 struct ieee80211_vif *vif, 3018 struct ieee80211_sta *sta, 3019 bool reassoc) 3020 { 3021 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3022 struct wmi_peer_assoc_complete_arg peer_arg; 3023 int ret = 0; 3024 3025 lockdep_assert_held(&ar->conf_mutex); 3026 3027 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg); 3028 if (ret) { 3029 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n", 3030 sta->addr, arvif->vdev_id, ret); 3031 return ret; 3032 } 3033 3034 ret = ath10k_wmi_peer_assoc(ar, &peer_arg); 3035 if (ret) { 3036 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n", 3037 sta->addr, arvif->vdev_id, ret); 3038 return ret; 3039 } 3040 3041 /* Re-assoc is run only to update supported rates for given station. It 3042 * doesn't make much sense to reconfigure the peer completely. 3043 */ 3044 if (!reassoc) { 3045 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr, 3046 &sta->ht_cap); 3047 if (ret) { 3048 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n", 3049 arvif->vdev_id, ret); 3050 return ret; 3051 } 3052 3053 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta); 3054 if (ret) { 3055 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n", 3056 sta->addr, arvif->vdev_id, ret); 3057 return ret; 3058 } 3059 3060 if (!sta->wme) { 3061 arvif->num_legacy_stations++; 3062 ret = ath10k_recalc_rtscts_prot(arvif); 3063 if (ret) { 3064 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n", 3065 arvif->vdev_id, ret); 3066 return ret; 3067 } 3068 } 3069 3070 /* Plumb cached keys only for static WEP */ 3071 if ((arvif->def_wep_key_idx != -1) && (!sta->tdls)) { 3072 ret = ath10k_install_peer_wep_keys(arvif, sta->addr); 3073 if (ret) { 3074 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n", 3075 arvif->vdev_id, ret); 3076 return ret; 3077 } 3078 } 3079 } 3080 3081 return ret; 3082 } 3083 3084 static int ath10k_station_disassoc(struct ath10k *ar, 3085 struct ieee80211_vif *vif, 3086 struct ieee80211_sta *sta) 3087 { 3088 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3089 int ret = 0; 3090 3091 lockdep_assert_held(&ar->conf_mutex); 3092 3093 if (!sta->wme) { 3094 arvif->num_legacy_stations--; 3095 ret = ath10k_recalc_rtscts_prot(arvif); 3096 if (ret) { 3097 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n", 3098 arvif->vdev_id, ret); 3099 return ret; 3100 } 3101 } 3102 3103 ret = ath10k_clear_peer_keys(arvif, sta->addr); 3104 if (ret) { 3105 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n", 3106 arvif->vdev_id, ret); 3107 return ret; 3108 } 3109 3110 return ret; 3111 } 3112 3113 /**************/ 3114 /* Regulatory */ 3115 /**************/ 3116 3117 static int ath10k_update_channel_list(struct ath10k *ar) 3118 { 3119 struct ieee80211_hw *hw = ar->hw; 3120 struct ieee80211_supported_band **bands; 3121 enum nl80211_band band; 3122 struct ieee80211_channel *channel; 3123 struct wmi_scan_chan_list_arg arg = {0}; 3124 struct wmi_channel_arg *ch; 3125 bool passive; 3126 int len; 3127 int ret; 3128 int i; 3129 3130 lockdep_assert_held(&ar->conf_mutex); 3131 3132 bands = hw->wiphy->bands; 3133 for (band = 0; band < NUM_NL80211_BANDS; band++) { 3134 if (!bands[band]) 3135 continue; 3136 3137 for (i = 0; i < bands[band]->n_channels; i++) { 3138 if (bands[band]->channels[i].flags & 3139 IEEE80211_CHAN_DISABLED) 3140 continue; 3141 3142 arg.n_channels++; 3143 } 3144 } 3145 3146 len = sizeof(struct wmi_channel_arg) * arg.n_channels; 3147 arg.channels = kzalloc(len, GFP_KERNEL); 3148 if (!arg.channels) 3149 return -ENOMEM; 3150 3151 ch = arg.channels; 3152 for (band = 0; band < NUM_NL80211_BANDS; band++) { 3153 if (!bands[band]) 3154 continue; 3155 3156 for (i = 0; i < bands[band]->n_channels; i++) { 3157 channel = &bands[band]->channels[i]; 3158 3159 if (channel->flags & IEEE80211_CHAN_DISABLED) 3160 continue; 3161 3162 ch->allow_ht = true; 3163 3164 /* FIXME: when should we really allow VHT? */ 3165 ch->allow_vht = true; 3166 3167 ch->allow_ibss = 3168 !(channel->flags & IEEE80211_CHAN_NO_IR); 3169 3170 ch->ht40plus = 3171 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS); 3172 3173 ch->chan_radar = 3174 !!(channel->flags & IEEE80211_CHAN_RADAR); 3175 3176 passive = channel->flags & IEEE80211_CHAN_NO_IR; 3177 ch->passive = passive; 3178 3179 /* the firmware is ignoring the "radar" flag of the 3180 * channel and is scanning actively using Probe Requests 3181 * on "Radar detection"/DFS channels which are not 3182 * marked as "available" 3183 */ 3184 ch->passive |= ch->chan_radar; 3185 3186 ch->freq = channel->center_freq; 3187 ch->band_center_freq1 = channel->center_freq; 3188 ch->min_power = 0; 3189 ch->max_power = channel->max_power * 2; 3190 ch->max_reg_power = channel->max_reg_power * 2; 3191 ch->max_antenna_gain = channel->max_antenna_gain * 2; 3192 ch->reg_class_id = 0; /* FIXME */ 3193 3194 /* FIXME: why use only legacy modes, why not any 3195 * HT/VHT modes? Would that even make any 3196 * difference? 3197 */ 3198 if (channel->band == NL80211_BAND_2GHZ) 3199 ch->mode = MODE_11G; 3200 else 3201 ch->mode = MODE_11A; 3202 3203 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN)) 3204 continue; 3205 3206 ath10k_dbg(ar, ATH10K_DBG_WMI, 3207 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n", 3208 ch - arg.channels, arg.n_channels, 3209 ch->freq, ch->max_power, ch->max_reg_power, 3210 ch->max_antenna_gain, ch->mode); 3211 3212 ch++; 3213 } 3214 } 3215 3216 ret = ath10k_wmi_scan_chan_list(ar, &arg); 3217 kfree(arg.channels); 3218 3219 return ret; 3220 } 3221 3222 static enum wmi_dfs_region 3223 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region) 3224 { 3225 switch (dfs_region) { 3226 case NL80211_DFS_UNSET: 3227 return WMI_UNINIT_DFS_DOMAIN; 3228 case NL80211_DFS_FCC: 3229 return WMI_FCC_DFS_DOMAIN; 3230 case NL80211_DFS_ETSI: 3231 return WMI_ETSI_DFS_DOMAIN; 3232 case NL80211_DFS_JP: 3233 return WMI_MKK4_DFS_DOMAIN; 3234 } 3235 return WMI_UNINIT_DFS_DOMAIN; 3236 } 3237 3238 static void ath10k_regd_update(struct ath10k *ar) 3239 { 3240 struct reg_dmn_pair_mapping *regpair; 3241 int ret; 3242 enum wmi_dfs_region wmi_dfs_reg; 3243 enum nl80211_dfs_regions nl_dfs_reg; 3244 3245 lockdep_assert_held(&ar->conf_mutex); 3246 3247 ret = ath10k_update_channel_list(ar); 3248 if (ret) 3249 ath10k_warn(ar, "failed to update channel list: %d\n", ret); 3250 3251 regpair = ar->ath_common.regulatory.regpair; 3252 3253 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) { 3254 nl_dfs_reg = ar->dfs_detector->region; 3255 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg); 3256 } else { 3257 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN; 3258 } 3259 3260 /* Target allows setting up per-band regdomain but ath_common provides 3261 * a combined one only 3262 */ 3263 ret = ath10k_wmi_pdev_set_regdomain(ar, 3264 regpair->reg_domain, 3265 regpair->reg_domain, /* 2ghz */ 3266 regpair->reg_domain, /* 5ghz */ 3267 regpair->reg_2ghz_ctl, 3268 regpair->reg_5ghz_ctl, 3269 wmi_dfs_reg); 3270 if (ret) 3271 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret); 3272 } 3273 3274 static void ath10k_mac_update_channel_list(struct ath10k *ar, 3275 struct ieee80211_supported_band *band) 3276 { 3277 int i; 3278 3279 if (ar->low_5ghz_chan && ar->high_5ghz_chan) { 3280 for (i = 0; i < band->n_channels; i++) { 3281 if (band->channels[i].center_freq < ar->low_5ghz_chan || 3282 band->channels[i].center_freq > ar->high_5ghz_chan) 3283 band->channels[i].flags |= 3284 IEEE80211_CHAN_DISABLED; 3285 } 3286 } 3287 } 3288 3289 static void ath10k_reg_notifier(struct wiphy *wiphy, 3290 struct regulatory_request *request) 3291 { 3292 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 3293 struct ath10k *ar = hw->priv; 3294 bool result; 3295 3296 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory); 3297 3298 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) { 3299 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n", 3300 request->dfs_region); 3301 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector, 3302 request->dfs_region); 3303 if (!result) 3304 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n", 3305 request->dfs_region); 3306 } 3307 3308 mutex_lock(&ar->conf_mutex); 3309 if (ar->state == ATH10K_STATE_ON) 3310 ath10k_regd_update(ar); 3311 mutex_unlock(&ar->conf_mutex); 3312 3313 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) 3314 ath10k_mac_update_channel_list(ar, 3315 ar->hw->wiphy->bands[NL80211_BAND_5GHZ]); 3316 } 3317 3318 static void ath10k_stop_radar_confirmation(struct ath10k *ar) 3319 { 3320 spin_lock_bh(&ar->data_lock); 3321 ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_STOPPED; 3322 spin_unlock_bh(&ar->data_lock); 3323 3324 cancel_work_sync(&ar->radar_confirmation_work); 3325 } 3326 3327 /***************/ 3328 /* TX handlers */ 3329 /***************/ 3330 3331 enum ath10k_mac_tx_path { 3332 ATH10K_MAC_TX_HTT, 3333 ATH10K_MAC_TX_HTT_MGMT, 3334 ATH10K_MAC_TX_WMI_MGMT, 3335 ATH10K_MAC_TX_UNKNOWN, 3336 }; 3337 3338 void ath10k_mac_tx_lock(struct ath10k *ar, int reason) 3339 { 3340 lockdep_assert_held(&ar->htt.tx_lock); 3341 3342 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX); 3343 ar->tx_paused |= BIT(reason); 3344 ieee80211_stop_queues(ar->hw); 3345 } 3346 3347 static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac, 3348 struct ieee80211_vif *vif) 3349 { 3350 struct ath10k *ar = data; 3351 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3352 3353 if (arvif->tx_paused) 3354 return; 3355 3356 ieee80211_wake_queue(ar->hw, arvif->vdev_id); 3357 } 3358 3359 void ath10k_mac_tx_unlock(struct ath10k *ar, int reason) 3360 { 3361 lockdep_assert_held(&ar->htt.tx_lock); 3362 3363 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX); 3364 ar->tx_paused &= ~BIT(reason); 3365 3366 if (ar->tx_paused) 3367 return; 3368 3369 ieee80211_iterate_active_interfaces_atomic(ar->hw, 3370 IEEE80211_IFACE_ITER_RESUME_ALL, 3371 ath10k_mac_tx_unlock_iter, 3372 ar); 3373 3374 ieee80211_wake_queue(ar->hw, ar->hw->offchannel_tx_hw_queue); 3375 } 3376 3377 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason) 3378 { 3379 struct ath10k *ar = arvif->ar; 3380 3381 lockdep_assert_held(&ar->htt.tx_lock); 3382 3383 WARN_ON(reason >= BITS_PER_LONG); 3384 arvif->tx_paused |= BIT(reason); 3385 ieee80211_stop_queue(ar->hw, arvif->vdev_id); 3386 } 3387 3388 void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason) 3389 { 3390 struct ath10k *ar = arvif->ar; 3391 3392 lockdep_assert_held(&ar->htt.tx_lock); 3393 3394 WARN_ON(reason >= BITS_PER_LONG); 3395 arvif->tx_paused &= ~BIT(reason); 3396 3397 if (ar->tx_paused) 3398 return; 3399 3400 if (arvif->tx_paused) 3401 return; 3402 3403 ieee80211_wake_queue(ar->hw, arvif->vdev_id); 3404 } 3405 3406 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif, 3407 enum wmi_tlv_tx_pause_id pause_id, 3408 enum wmi_tlv_tx_pause_action action) 3409 { 3410 struct ath10k *ar = arvif->ar; 3411 3412 lockdep_assert_held(&ar->htt.tx_lock); 3413 3414 switch (action) { 3415 case WMI_TLV_TX_PAUSE_ACTION_STOP: 3416 ath10k_mac_vif_tx_lock(arvif, pause_id); 3417 break; 3418 case WMI_TLV_TX_PAUSE_ACTION_WAKE: 3419 ath10k_mac_vif_tx_unlock(arvif, pause_id); 3420 break; 3421 default: 3422 ath10k_dbg(ar, ATH10K_DBG_BOOT, 3423 "received unknown tx pause action %d on vdev %i, ignoring\n", 3424 action, arvif->vdev_id); 3425 break; 3426 } 3427 } 3428 3429 struct ath10k_mac_tx_pause { 3430 u32 vdev_id; 3431 enum wmi_tlv_tx_pause_id pause_id; 3432 enum wmi_tlv_tx_pause_action action; 3433 }; 3434 3435 static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac, 3436 struct ieee80211_vif *vif) 3437 { 3438 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3439 struct ath10k_mac_tx_pause *arg = data; 3440 3441 if (arvif->vdev_id != arg->vdev_id) 3442 return; 3443 3444 ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action); 3445 } 3446 3447 void ath10k_mac_handle_tx_pause_vdev(struct ath10k *ar, u32 vdev_id, 3448 enum wmi_tlv_tx_pause_id pause_id, 3449 enum wmi_tlv_tx_pause_action action) 3450 { 3451 struct ath10k_mac_tx_pause arg = { 3452 .vdev_id = vdev_id, 3453 .pause_id = pause_id, 3454 .action = action, 3455 }; 3456 3457 spin_lock_bh(&ar->htt.tx_lock); 3458 ieee80211_iterate_active_interfaces_atomic(ar->hw, 3459 IEEE80211_IFACE_ITER_RESUME_ALL, 3460 ath10k_mac_handle_tx_pause_iter, 3461 &arg); 3462 spin_unlock_bh(&ar->htt.tx_lock); 3463 } 3464 3465 static enum ath10k_hw_txrx_mode 3466 ath10k_mac_tx_h_get_txmode(struct ath10k *ar, 3467 struct ieee80211_vif *vif, 3468 struct ieee80211_sta *sta, 3469 struct sk_buff *skb) 3470 { 3471 const struct ieee80211_hdr *hdr = (void *)skb->data; 3472 const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb); 3473 __le16 fc = hdr->frame_control; 3474 3475 if (!vif || vif->type == NL80211_IFTYPE_MONITOR) 3476 return ATH10K_HW_TXRX_RAW; 3477 3478 if (ieee80211_is_mgmt(fc)) 3479 return ATH10K_HW_TXRX_MGMT; 3480 3481 /* Workaround: 3482 * 3483 * NullFunc frames are mostly used to ping if a client or AP are still 3484 * reachable and responsive. This implies tx status reports must be 3485 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can 3486 * come to a conclusion that the other end disappeared and tear down 3487 * BSS connection or it can never disconnect from BSS/client (which is 3488 * the case). 3489 * 3490 * Firmware with HTT older than 3.0 delivers incorrect tx status for 3491 * NullFunc frames to driver. However there's a HTT Mgmt Tx command 3492 * which seems to deliver correct tx reports for NullFunc frames. The 3493 * downside of using it is it ignores client powersave state so it can 3494 * end up disconnecting sleeping clients in AP mode. It should fix STA 3495 * mode though because AP don't sleep. 3496 */ 3497 if (ar->htt.target_version_major < 3 && 3498 (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) && 3499 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, 3500 ar->running_fw->fw_file.fw_features)) 3501 return ATH10K_HW_TXRX_MGMT; 3502 3503 /* Workaround: 3504 * 3505 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for 3506 * NativeWifi txmode - it selects AP key instead of peer key. It seems 3507 * to work with Ethernet txmode so use it. 3508 * 3509 * FIXME: Check if raw mode works with TDLS. 3510 */ 3511 if (ieee80211_is_data_present(fc) && sta && sta->tdls) 3512 return ATH10K_HW_TXRX_ETHERNET; 3513 3514 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) || 3515 skb_cb->flags & ATH10K_SKB_F_RAW_TX) 3516 return ATH10K_HW_TXRX_RAW; 3517 3518 return ATH10K_HW_TXRX_NATIVE_WIFI; 3519 } 3520 3521 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif, 3522 struct sk_buff *skb) 3523 { 3524 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 3525 const struct ieee80211_hdr *hdr = (void *)skb->data; 3526 const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT | 3527 IEEE80211_TX_CTL_INJECTED; 3528 3529 if (!ieee80211_has_protected(hdr->frame_control)) 3530 return false; 3531 3532 if ((info->flags & mask) == mask) 3533 return false; 3534 3535 if (vif) 3536 return !((struct ath10k_vif *)vif->drv_priv)->nohwcrypt; 3537 3538 return true; 3539 } 3540 3541 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS 3542 * Control in the header. 3543 */ 3544 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb) 3545 { 3546 struct ieee80211_hdr *hdr = (void *)skb->data; 3547 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb); 3548 u8 *qos_ctl; 3549 3550 if (!ieee80211_is_data_qos(hdr->frame_control)) 3551 return; 3552 3553 qos_ctl = ieee80211_get_qos_ctl(hdr); 3554 memmove(skb->data + IEEE80211_QOS_CTL_LEN, 3555 skb->data, (void *)qos_ctl - (void *)skb->data); 3556 skb_pull(skb, IEEE80211_QOS_CTL_LEN); 3557 3558 /* Some firmware revisions don't handle sending QoS NullFunc well. 3559 * These frames are mainly used for CQM purposes so it doesn't really 3560 * matter whether QoS NullFunc or NullFunc are sent. 3561 */ 3562 hdr = (void *)skb->data; 3563 if (ieee80211_is_qos_nullfunc(hdr->frame_control)) 3564 cb->flags &= ~ATH10K_SKB_F_QOS; 3565 3566 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA); 3567 } 3568 3569 static void ath10k_tx_h_8023(struct sk_buff *skb) 3570 { 3571 struct ieee80211_hdr *hdr; 3572 struct rfc1042_hdr *rfc1042; 3573 struct ethhdr *eth; 3574 size_t hdrlen; 3575 u8 da[ETH_ALEN]; 3576 u8 sa[ETH_ALEN]; 3577 __be16 type; 3578 3579 hdr = (void *)skb->data; 3580 hdrlen = ieee80211_hdrlen(hdr->frame_control); 3581 rfc1042 = (void *)skb->data + hdrlen; 3582 3583 ether_addr_copy(da, ieee80211_get_DA(hdr)); 3584 ether_addr_copy(sa, ieee80211_get_SA(hdr)); 3585 type = rfc1042->snap_type; 3586 3587 skb_pull(skb, hdrlen + sizeof(*rfc1042)); 3588 skb_push(skb, sizeof(*eth)); 3589 3590 eth = (void *)skb->data; 3591 ether_addr_copy(eth->h_dest, da); 3592 ether_addr_copy(eth->h_source, sa); 3593 eth->h_proto = type; 3594 } 3595 3596 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, 3597 struct ieee80211_vif *vif, 3598 struct sk_buff *skb) 3599 { 3600 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 3601 struct ath10k_vif *arvif = (void *)vif->drv_priv; 3602 3603 /* This is case only for P2P_GO */ 3604 if (vif->type != NL80211_IFTYPE_AP || !vif->p2p) 3605 return; 3606 3607 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) { 3608 spin_lock_bh(&ar->data_lock); 3609 if (arvif->u.ap.noa_data) 3610 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len, 3611 GFP_ATOMIC)) 3612 skb_put_data(skb, arvif->u.ap.noa_data, 3613 arvif->u.ap.noa_len); 3614 spin_unlock_bh(&ar->data_lock); 3615 } 3616 } 3617 3618 static void ath10k_mac_tx_h_fill_cb(struct ath10k *ar, 3619 struct ieee80211_vif *vif, 3620 struct ieee80211_txq *txq, 3621 struct ieee80211_sta *sta, 3622 struct sk_buff *skb, u16 airtime) 3623 { 3624 struct ieee80211_hdr *hdr = (void *)skb->data; 3625 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb); 3626 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 3627 bool is_data = ieee80211_is_data(hdr->frame_control) || 3628 ieee80211_is_data_qos(hdr->frame_control); 3629 struct ath10k_sta *arsta; 3630 3631 cb->flags = 0; 3632 if (!ath10k_tx_h_use_hwcrypto(vif, skb)) 3633 cb->flags |= ATH10K_SKB_F_NO_HWCRYPT; 3634 3635 if (ieee80211_is_mgmt(hdr->frame_control)) 3636 cb->flags |= ATH10K_SKB_F_MGMT; 3637 3638 if (ieee80211_is_data_qos(hdr->frame_control)) 3639 cb->flags |= ATH10K_SKB_F_QOS; 3640 3641 /* Data frames encrypted in software will be posted to firmware 3642 * with tx encap mode set to RAW. Ex: Multicast traffic generated 3643 * for a specific VLAN group will always be encrypted in software. 3644 */ 3645 if (is_data && ieee80211_has_protected(hdr->frame_control) && 3646 !info->control.hw_key) { 3647 cb->flags |= ATH10K_SKB_F_NO_HWCRYPT; 3648 cb->flags |= ATH10K_SKB_F_RAW_TX; 3649 } 3650 3651 cb->vif = vif; 3652 cb->txq = txq; 3653 cb->airtime_est = airtime; 3654 if (sta) { 3655 arsta = (struct ath10k_sta *)sta->drv_priv; 3656 spin_lock_bh(&ar->data_lock); 3657 cb->ucast_cipher = arsta->ucast_cipher; 3658 spin_unlock_bh(&ar->data_lock); 3659 } 3660 } 3661 3662 bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar) 3663 { 3664 /* FIXME: Not really sure since when the behaviour changed. At some 3665 * point new firmware stopped requiring creation of peer entries for 3666 * offchannel tx (and actually creating them causes issues with wmi-htc 3667 * tx credit replenishment and reliability). Assuming it's at least 3.4 3668 * because that's when the `freq` was introduced to TX_FRM HTT command. 3669 */ 3670 return (ar->htt.target_version_major >= 3 && 3671 ar->htt.target_version_minor >= 4 && 3672 ar->running_fw->fw_file.htt_op_version == ATH10K_FW_HTT_OP_VERSION_TLV); 3673 } 3674 3675 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb) 3676 { 3677 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue; 3678 int ret = 0; 3679 3680 spin_lock_bh(&ar->data_lock); 3681 3682 if (skb_queue_len(q) == ATH10K_MAX_NUM_MGMT_PENDING) { 3683 ath10k_warn(ar, "wmi mgmt tx queue is full\n"); 3684 ret = -ENOSPC; 3685 goto unlock; 3686 } 3687 3688 __skb_queue_tail(q, skb); 3689 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work); 3690 3691 unlock: 3692 spin_unlock_bh(&ar->data_lock); 3693 3694 return ret; 3695 } 3696 3697 static enum ath10k_mac_tx_path 3698 ath10k_mac_tx_h_get_txpath(struct ath10k *ar, 3699 struct sk_buff *skb, 3700 enum ath10k_hw_txrx_mode txmode) 3701 { 3702 switch (txmode) { 3703 case ATH10K_HW_TXRX_RAW: 3704 case ATH10K_HW_TXRX_NATIVE_WIFI: 3705 case ATH10K_HW_TXRX_ETHERNET: 3706 return ATH10K_MAC_TX_HTT; 3707 case ATH10K_HW_TXRX_MGMT: 3708 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, 3709 ar->running_fw->fw_file.fw_features) || 3710 test_bit(WMI_SERVICE_MGMT_TX_WMI, 3711 ar->wmi.svc_map)) 3712 return ATH10K_MAC_TX_WMI_MGMT; 3713 else if (ar->htt.target_version_major >= 3) 3714 return ATH10K_MAC_TX_HTT; 3715 else 3716 return ATH10K_MAC_TX_HTT_MGMT; 3717 } 3718 3719 return ATH10K_MAC_TX_UNKNOWN; 3720 } 3721 3722 static int ath10k_mac_tx_submit(struct ath10k *ar, 3723 enum ath10k_hw_txrx_mode txmode, 3724 enum ath10k_mac_tx_path txpath, 3725 struct sk_buff *skb) 3726 { 3727 struct ath10k_htt *htt = &ar->htt; 3728 int ret = -EINVAL; 3729 3730 switch (txpath) { 3731 case ATH10K_MAC_TX_HTT: 3732 ret = ath10k_htt_tx(htt, txmode, skb); 3733 break; 3734 case ATH10K_MAC_TX_HTT_MGMT: 3735 ret = ath10k_htt_mgmt_tx(htt, skb); 3736 break; 3737 case ATH10K_MAC_TX_WMI_MGMT: 3738 ret = ath10k_mac_tx_wmi_mgmt(ar, skb); 3739 break; 3740 case ATH10K_MAC_TX_UNKNOWN: 3741 WARN_ON_ONCE(1); 3742 ret = -EINVAL; 3743 break; 3744 } 3745 3746 if (ret) { 3747 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n", 3748 ret); 3749 ieee80211_free_txskb(ar->hw, skb); 3750 } 3751 3752 return ret; 3753 } 3754 3755 /* This function consumes the sk_buff regardless of return value as far as 3756 * caller is concerned so no freeing is necessary afterwards. 3757 */ 3758 static int ath10k_mac_tx(struct ath10k *ar, 3759 struct ieee80211_vif *vif, 3760 enum ath10k_hw_txrx_mode txmode, 3761 enum ath10k_mac_tx_path txpath, 3762 struct sk_buff *skb, bool noque_offchan) 3763 { 3764 struct ieee80211_hw *hw = ar->hw; 3765 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 3766 const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb); 3767 int ret; 3768 3769 /* We should disable CCK RATE due to P2P */ 3770 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE) 3771 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n"); 3772 3773 switch (txmode) { 3774 case ATH10K_HW_TXRX_MGMT: 3775 case ATH10K_HW_TXRX_NATIVE_WIFI: 3776 ath10k_tx_h_nwifi(hw, skb); 3777 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb); 3778 ath10k_tx_h_seq_no(vif, skb); 3779 break; 3780 case ATH10K_HW_TXRX_ETHERNET: 3781 ath10k_tx_h_8023(skb); 3782 break; 3783 case ATH10K_HW_TXRX_RAW: 3784 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) && 3785 !(skb_cb->flags & ATH10K_SKB_F_RAW_TX)) { 3786 WARN_ON_ONCE(1); 3787 ieee80211_free_txskb(hw, skb); 3788 return -ENOTSUPP; 3789 } 3790 } 3791 3792 if (!noque_offchan && info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) { 3793 if (!ath10k_mac_tx_frm_has_freq(ar)) { 3794 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac queued offchannel skb %pK len %d\n", 3795 skb, skb->len); 3796 3797 skb_queue_tail(&ar->offchan_tx_queue, skb); 3798 ieee80211_queue_work(hw, &ar->offchan_tx_work); 3799 return 0; 3800 } 3801 } 3802 3803 ret = ath10k_mac_tx_submit(ar, txmode, txpath, skb); 3804 if (ret) { 3805 ath10k_warn(ar, "failed to submit frame: %d\n", ret); 3806 return ret; 3807 } 3808 3809 return 0; 3810 } 3811 3812 void ath10k_offchan_tx_purge(struct ath10k *ar) 3813 { 3814 struct sk_buff *skb; 3815 3816 for (;;) { 3817 skb = skb_dequeue(&ar->offchan_tx_queue); 3818 if (!skb) 3819 break; 3820 3821 ieee80211_free_txskb(ar->hw, skb); 3822 } 3823 } 3824 3825 void ath10k_offchan_tx_work(struct work_struct *work) 3826 { 3827 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work); 3828 struct ath10k_peer *peer; 3829 struct ath10k_vif *arvif; 3830 enum ath10k_hw_txrx_mode txmode; 3831 enum ath10k_mac_tx_path txpath; 3832 struct ieee80211_hdr *hdr; 3833 struct ieee80211_vif *vif; 3834 struct ieee80211_sta *sta; 3835 struct sk_buff *skb; 3836 const u8 *peer_addr; 3837 int vdev_id; 3838 int ret; 3839 unsigned long time_left; 3840 bool tmp_peer_created = false; 3841 3842 /* FW requirement: We must create a peer before FW will send out 3843 * an offchannel frame. Otherwise the frame will be stuck and 3844 * never transmitted. We delete the peer upon tx completion. 3845 * It is unlikely that a peer for offchannel tx will already be 3846 * present. However it may be in some rare cases so account for that. 3847 * Otherwise we might remove a legitimate peer and break stuff. 3848 */ 3849 3850 for (;;) { 3851 skb = skb_dequeue(&ar->offchan_tx_queue); 3852 if (!skb) 3853 break; 3854 3855 mutex_lock(&ar->conf_mutex); 3856 3857 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %pK len %d\n", 3858 skb, skb->len); 3859 3860 hdr = (struct ieee80211_hdr *)skb->data; 3861 peer_addr = ieee80211_get_DA(hdr); 3862 3863 spin_lock_bh(&ar->data_lock); 3864 vdev_id = ar->scan.vdev_id; 3865 peer = ath10k_peer_find(ar, vdev_id, peer_addr); 3866 spin_unlock_bh(&ar->data_lock); 3867 3868 if (peer) 3869 /* FIXME: should this use ath10k_warn()? */ 3870 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n", 3871 peer_addr, vdev_id); 3872 3873 if (!peer) { 3874 ret = ath10k_peer_create(ar, NULL, NULL, vdev_id, 3875 peer_addr, 3876 WMI_PEER_TYPE_DEFAULT); 3877 if (ret) 3878 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n", 3879 peer_addr, vdev_id, ret); 3880 tmp_peer_created = (ret == 0); 3881 } 3882 3883 spin_lock_bh(&ar->data_lock); 3884 reinit_completion(&ar->offchan_tx_completed); 3885 ar->offchan_tx_skb = skb; 3886 spin_unlock_bh(&ar->data_lock); 3887 3888 /* It's safe to access vif and sta - conf_mutex guarantees that 3889 * sta_state() and remove_interface() are locked exclusively 3890 * out wrt to this offchannel worker. 3891 */ 3892 arvif = ath10k_get_arvif(ar, vdev_id); 3893 if (arvif) { 3894 vif = arvif->vif; 3895 sta = ieee80211_find_sta(vif, peer_addr); 3896 } else { 3897 vif = NULL; 3898 sta = NULL; 3899 } 3900 3901 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb); 3902 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode); 3903 3904 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, true); 3905 if (ret) { 3906 ath10k_warn(ar, "failed to transmit offchannel frame: %d\n", 3907 ret); 3908 /* not serious */ 3909 } 3910 3911 time_left = 3912 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ); 3913 if (time_left == 0) 3914 ath10k_warn(ar, "timed out waiting for offchannel skb %pK, len: %d\n", 3915 skb, skb->len); 3916 3917 if (!peer && tmp_peer_created) { 3918 ret = ath10k_peer_delete(ar, vdev_id, peer_addr); 3919 if (ret) 3920 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n", 3921 peer_addr, vdev_id, ret); 3922 } 3923 3924 mutex_unlock(&ar->conf_mutex); 3925 } 3926 } 3927 3928 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar) 3929 { 3930 struct sk_buff *skb; 3931 3932 for (;;) { 3933 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue); 3934 if (!skb) 3935 break; 3936 3937 ieee80211_free_txskb(ar->hw, skb); 3938 } 3939 } 3940 3941 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work) 3942 { 3943 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work); 3944 struct sk_buff *skb; 3945 dma_addr_t paddr; 3946 int ret; 3947 3948 for (;;) { 3949 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue); 3950 if (!skb) 3951 break; 3952 3953 if (test_bit(ATH10K_FW_FEATURE_MGMT_TX_BY_REF, 3954 ar->running_fw->fw_file.fw_features)) { 3955 paddr = dma_map_single(ar->dev, skb->data, 3956 skb->len, DMA_TO_DEVICE); 3957 if (dma_mapping_error(ar->dev, paddr)) { 3958 ieee80211_free_txskb(ar->hw, skb); 3959 continue; 3960 } 3961 ret = ath10k_wmi_mgmt_tx_send(ar, skb, paddr); 3962 if (ret) { 3963 ath10k_warn(ar, "failed to transmit management frame by ref via WMI: %d\n", 3964 ret); 3965 /* remove this msdu from idr tracking */ 3966 ath10k_wmi_cleanup_mgmt_tx_send(ar, skb); 3967 3968 dma_unmap_single(ar->dev, paddr, skb->len, 3969 DMA_TO_DEVICE); 3970 ieee80211_free_txskb(ar->hw, skb); 3971 } 3972 } else { 3973 ret = ath10k_wmi_mgmt_tx(ar, skb); 3974 if (ret) { 3975 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n", 3976 ret); 3977 ieee80211_free_txskb(ar->hw, skb); 3978 } 3979 } 3980 } 3981 } 3982 3983 static void ath10k_mac_txq_init(struct ieee80211_txq *txq) 3984 { 3985 struct ath10k_txq *artxq; 3986 3987 if (!txq) 3988 return; 3989 3990 artxq = (void *)txq->drv_priv; 3991 INIT_LIST_HEAD(&artxq->list); 3992 } 3993 3994 static void ath10k_mac_txq_unref(struct ath10k *ar, struct ieee80211_txq *txq) 3995 { 3996 struct ath10k_skb_cb *cb; 3997 struct sk_buff *msdu; 3998 int msdu_id; 3999 4000 if (!txq) 4001 return; 4002 4003 spin_lock_bh(&ar->htt.tx_lock); 4004 idr_for_each_entry(&ar->htt.pending_tx, msdu, msdu_id) { 4005 cb = ATH10K_SKB_CB(msdu); 4006 if (cb->txq == txq) 4007 cb->txq = NULL; 4008 } 4009 spin_unlock_bh(&ar->htt.tx_lock); 4010 } 4011 4012 struct ieee80211_txq *ath10k_mac_txq_lookup(struct ath10k *ar, 4013 u16 peer_id, 4014 u8 tid) 4015 { 4016 struct ath10k_peer *peer; 4017 4018 lockdep_assert_held(&ar->data_lock); 4019 4020 peer = ar->peer_map[peer_id]; 4021 if (!peer) 4022 return NULL; 4023 4024 if (peer->removed) 4025 return NULL; 4026 4027 if (peer->sta) 4028 return peer->sta->txq[tid]; 4029 else if (peer->vif) 4030 return peer->vif->txq; 4031 else 4032 return NULL; 4033 } 4034 4035 static bool ath10k_mac_tx_can_push(struct ieee80211_hw *hw, 4036 struct ieee80211_txq *txq) 4037 { 4038 struct ath10k *ar = hw->priv; 4039 struct ath10k_txq *artxq = (void *)txq->drv_priv; 4040 4041 /* No need to get locks */ 4042 if (ar->htt.tx_q_state.mode == HTT_TX_MODE_SWITCH_PUSH) 4043 return true; 4044 4045 if (ar->htt.num_pending_tx < ar->htt.tx_q_state.num_push_allowed) 4046 return true; 4047 4048 if (artxq->num_fw_queued < artxq->num_push_allowed) 4049 return true; 4050 4051 return false; 4052 } 4053 4054 /* Return estimated airtime in microsecond, which is calculated using last 4055 * reported TX rate. This is just a rough estimation because host driver has no 4056 * knowledge of the actual transmit rate, retries or aggregation. If actual 4057 * airtime can be reported by firmware, then delta between estimated and actual 4058 * airtime can be adjusted from deficit. 4059 */ 4060 #define IEEE80211_ATF_OVERHEAD 100 /* IFS + some slot time */ 4061 #define IEEE80211_ATF_OVERHEAD_IFS 16 /* IFS only */ 4062 static u16 ath10k_mac_update_airtime(struct ath10k *ar, 4063 struct ieee80211_txq *txq, 4064 struct sk_buff *skb) 4065 { 4066 struct ath10k_sta *arsta; 4067 u32 pktlen; 4068 u16 airtime = 0; 4069 4070 if (!txq || !txq->sta) 4071 return airtime; 4072 4073 if (test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map)) 4074 return airtime; 4075 4076 spin_lock_bh(&ar->data_lock); 4077 arsta = (struct ath10k_sta *)txq->sta->drv_priv; 4078 4079 pktlen = skb->len + 38; /* Assume MAC header 30, SNAP 8 for most case */ 4080 if (arsta->last_tx_bitrate) { 4081 /* airtime in us, last_tx_bitrate in 100kbps */ 4082 airtime = (pktlen * 8 * (1000 / 100)) 4083 / arsta->last_tx_bitrate; 4084 /* overhead for media access time and IFS */ 4085 airtime += IEEE80211_ATF_OVERHEAD_IFS; 4086 } else { 4087 /* This is mostly for throttle excessive BC/MC frames, and the 4088 * airtime/rate doesn't need be exact. Airtime of BC/MC frames 4089 * in 2G get some discount, which helps prevent very low rate 4090 * frames from being blocked for too long. 4091 */ 4092 airtime = (pktlen * 8 * (1000 / 100)) / 60; /* 6M */ 4093 airtime += IEEE80211_ATF_OVERHEAD; 4094 } 4095 spin_unlock_bh(&ar->data_lock); 4096 4097 return airtime; 4098 } 4099 4100 int ath10k_mac_tx_push_txq(struct ieee80211_hw *hw, 4101 struct ieee80211_txq *txq) 4102 { 4103 struct ath10k *ar = hw->priv; 4104 struct ath10k_htt *htt = &ar->htt; 4105 struct ath10k_txq *artxq = (void *)txq->drv_priv; 4106 struct ieee80211_vif *vif = txq->vif; 4107 struct ieee80211_sta *sta = txq->sta; 4108 enum ath10k_hw_txrx_mode txmode; 4109 enum ath10k_mac_tx_path txpath; 4110 struct sk_buff *skb; 4111 struct ieee80211_hdr *hdr; 4112 size_t skb_len; 4113 bool is_mgmt, is_presp; 4114 int ret; 4115 u16 airtime; 4116 4117 spin_lock_bh(&ar->htt.tx_lock); 4118 ret = ath10k_htt_tx_inc_pending(htt); 4119 spin_unlock_bh(&ar->htt.tx_lock); 4120 4121 if (ret) 4122 return ret; 4123 4124 skb = ieee80211_tx_dequeue_ni(hw, txq); 4125 if (!skb) { 4126 spin_lock_bh(&ar->htt.tx_lock); 4127 ath10k_htt_tx_dec_pending(htt); 4128 spin_unlock_bh(&ar->htt.tx_lock); 4129 4130 return -ENOENT; 4131 } 4132 4133 airtime = ath10k_mac_update_airtime(ar, txq, skb); 4134 ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime); 4135 4136 skb_len = skb->len; 4137 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb); 4138 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode); 4139 is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT); 4140 4141 if (is_mgmt) { 4142 hdr = (struct ieee80211_hdr *)skb->data; 4143 is_presp = ieee80211_is_probe_resp(hdr->frame_control); 4144 4145 spin_lock_bh(&ar->htt.tx_lock); 4146 ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp); 4147 4148 if (ret) { 4149 ath10k_htt_tx_dec_pending(htt); 4150 spin_unlock_bh(&ar->htt.tx_lock); 4151 return ret; 4152 } 4153 spin_unlock_bh(&ar->htt.tx_lock); 4154 } 4155 4156 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false); 4157 if (unlikely(ret)) { 4158 ath10k_warn(ar, "failed to push frame: %d\n", ret); 4159 4160 spin_lock_bh(&ar->htt.tx_lock); 4161 ath10k_htt_tx_dec_pending(htt); 4162 if (is_mgmt) 4163 ath10k_htt_tx_mgmt_dec_pending(htt); 4164 spin_unlock_bh(&ar->htt.tx_lock); 4165 4166 return ret; 4167 } 4168 4169 spin_lock_bh(&ar->htt.tx_lock); 4170 artxq->num_fw_queued++; 4171 spin_unlock_bh(&ar->htt.tx_lock); 4172 4173 return skb_len; 4174 } 4175 4176 static int ath10k_mac_schedule_txq(struct ieee80211_hw *hw, u32 ac) 4177 { 4178 struct ieee80211_txq *txq; 4179 int ret = 0; 4180 4181 ieee80211_txq_schedule_start(hw, ac); 4182 while ((txq = ieee80211_next_txq(hw, ac))) { 4183 while (ath10k_mac_tx_can_push(hw, txq)) { 4184 ret = ath10k_mac_tx_push_txq(hw, txq); 4185 if (ret < 0) 4186 break; 4187 } 4188 ieee80211_return_txq(hw, txq, false); 4189 ath10k_htt_tx_txq_update(hw, txq); 4190 if (ret == -EBUSY) 4191 break; 4192 } 4193 ieee80211_txq_schedule_end(hw, ac); 4194 4195 return ret; 4196 } 4197 4198 void ath10k_mac_tx_push_pending(struct ath10k *ar) 4199 { 4200 struct ieee80211_hw *hw = ar->hw; 4201 u32 ac; 4202 4203 if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH) 4204 return; 4205 4206 if (ar->htt.num_pending_tx >= (ar->htt.max_num_pending_tx / 2)) 4207 return; 4208 4209 rcu_read_lock(); 4210 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 4211 if (ath10k_mac_schedule_txq(hw, ac) == -EBUSY) 4212 break; 4213 } 4214 rcu_read_unlock(); 4215 } 4216 EXPORT_SYMBOL(ath10k_mac_tx_push_pending); 4217 4218 /************/ 4219 /* Scanning */ 4220 /************/ 4221 4222 void __ath10k_scan_finish(struct ath10k *ar) 4223 { 4224 lockdep_assert_held(&ar->data_lock); 4225 4226 switch (ar->scan.state) { 4227 case ATH10K_SCAN_IDLE: 4228 break; 4229 case ATH10K_SCAN_RUNNING: 4230 case ATH10K_SCAN_ABORTING: 4231 if (!ar->scan.is_roc) { 4232 struct cfg80211_scan_info info = { 4233 .aborted = (ar->scan.state == 4234 ATH10K_SCAN_ABORTING), 4235 }; 4236 4237 ieee80211_scan_completed(ar->hw, &info); 4238 } else if (ar->scan.roc_notify) { 4239 ieee80211_remain_on_channel_expired(ar->hw); 4240 } 4241 /* fall through */ 4242 case ATH10K_SCAN_STARTING: 4243 ar->scan.state = ATH10K_SCAN_IDLE; 4244 ar->scan_channel = NULL; 4245 ar->scan.roc_freq = 0; 4246 ath10k_offchan_tx_purge(ar); 4247 cancel_delayed_work(&ar->scan.timeout); 4248 complete(&ar->scan.completed); 4249 break; 4250 } 4251 } 4252 4253 void ath10k_scan_finish(struct ath10k *ar) 4254 { 4255 spin_lock_bh(&ar->data_lock); 4256 __ath10k_scan_finish(ar); 4257 spin_unlock_bh(&ar->data_lock); 4258 } 4259 4260 static int ath10k_scan_stop(struct ath10k *ar) 4261 { 4262 struct wmi_stop_scan_arg arg = { 4263 .req_id = 1, /* FIXME */ 4264 .req_type = WMI_SCAN_STOP_ONE, 4265 .u.scan_id = ATH10K_SCAN_ID, 4266 }; 4267 int ret; 4268 4269 lockdep_assert_held(&ar->conf_mutex); 4270 4271 ret = ath10k_wmi_stop_scan(ar, &arg); 4272 if (ret) { 4273 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret); 4274 goto out; 4275 } 4276 4277 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ); 4278 if (ret == 0) { 4279 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n"); 4280 ret = -ETIMEDOUT; 4281 } else if (ret > 0) { 4282 ret = 0; 4283 } 4284 4285 out: 4286 /* Scan state should be updated upon scan completion but in case 4287 * firmware fails to deliver the event (for whatever reason) it is 4288 * desired to clean up scan state anyway. Firmware may have just 4289 * dropped the scan completion event delivery due to transport pipe 4290 * being overflown with data and/or it can recover on its own before 4291 * next scan request is submitted. 4292 */ 4293 spin_lock_bh(&ar->data_lock); 4294 if (ar->scan.state != ATH10K_SCAN_IDLE) 4295 __ath10k_scan_finish(ar); 4296 spin_unlock_bh(&ar->data_lock); 4297 4298 return ret; 4299 } 4300 4301 static void ath10k_scan_abort(struct ath10k *ar) 4302 { 4303 int ret; 4304 4305 lockdep_assert_held(&ar->conf_mutex); 4306 4307 spin_lock_bh(&ar->data_lock); 4308 4309 switch (ar->scan.state) { 4310 case ATH10K_SCAN_IDLE: 4311 /* This can happen if timeout worker kicked in and called 4312 * abortion while scan completion was being processed. 4313 */ 4314 break; 4315 case ATH10K_SCAN_STARTING: 4316 case ATH10K_SCAN_ABORTING: 4317 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n", 4318 ath10k_scan_state_str(ar->scan.state), 4319 ar->scan.state); 4320 break; 4321 case ATH10K_SCAN_RUNNING: 4322 ar->scan.state = ATH10K_SCAN_ABORTING; 4323 spin_unlock_bh(&ar->data_lock); 4324 4325 ret = ath10k_scan_stop(ar); 4326 if (ret) 4327 ath10k_warn(ar, "failed to abort scan: %d\n", ret); 4328 4329 spin_lock_bh(&ar->data_lock); 4330 break; 4331 } 4332 4333 spin_unlock_bh(&ar->data_lock); 4334 } 4335 4336 void ath10k_scan_timeout_work(struct work_struct *work) 4337 { 4338 struct ath10k *ar = container_of(work, struct ath10k, 4339 scan.timeout.work); 4340 4341 mutex_lock(&ar->conf_mutex); 4342 ath10k_scan_abort(ar); 4343 mutex_unlock(&ar->conf_mutex); 4344 } 4345 4346 static int ath10k_start_scan(struct ath10k *ar, 4347 const struct wmi_start_scan_arg *arg) 4348 { 4349 int ret; 4350 4351 lockdep_assert_held(&ar->conf_mutex); 4352 4353 ret = ath10k_wmi_start_scan(ar, arg); 4354 if (ret) 4355 return ret; 4356 4357 ret = wait_for_completion_timeout(&ar->scan.started, 1 * HZ); 4358 if (ret == 0) { 4359 ret = ath10k_scan_stop(ar); 4360 if (ret) 4361 ath10k_warn(ar, "failed to stop scan: %d\n", ret); 4362 4363 return -ETIMEDOUT; 4364 } 4365 4366 /* If we failed to start the scan, return error code at 4367 * this point. This is probably due to some issue in the 4368 * firmware, but no need to wedge the driver due to that... 4369 */ 4370 spin_lock_bh(&ar->data_lock); 4371 if (ar->scan.state == ATH10K_SCAN_IDLE) { 4372 spin_unlock_bh(&ar->data_lock); 4373 return -EINVAL; 4374 } 4375 spin_unlock_bh(&ar->data_lock); 4376 4377 return 0; 4378 } 4379 4380 /**********************/ 4381 /* mac80211 callbacks */ 4382 /**********************/ 4383 4384 static void ath10k_mac_op_tx(struct ieee80211_hw *hw, 4385 struct ieee80211_tx_control *control, 4386 struct sk_buff *skb) 4387 { 4388 struct ath10k *ar = hw->priv; 4389 struct ath10k_htt *htt = &ar->htt; 4390 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 4391 struct ieee80211_vif *vif = info->control.vif; 4392 struct ieee80211_sta *sta = control->sta; 4393 struct ieee80211_txq *txq = NULL; 4394 struct ieee80211_hdr *hdr = (void *)skb->data; 4395 enum ath10k_hw_txrx_mode txmode; 4396 enum ath10k_mac_tx_path txpath; 4397 bool is_htt; 4398 bool is_mgmt; 4399 bool is_presp; 4400 int ret; 4401 u16 airtime; 4402 4403 airtime = ath10k_mac_update_airtime(ar, txq, skb); 4404 ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime); 4405 4406 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb); 4407 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode); 4408 is_htt = (txpath == ATH10K_MAC_TX_HTT || 4409 txpath == ATH10K_MAC_TX_HTT_MGMT); 4410 is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT); 4411 4412 if (is_htt) { 4413 spin_lock_bh(&ar->htt.tx_lock); 4414 is_presp = ieee80211_is_probe_resp(hdr->frame_control); 4415 4416 ret = ath10k_htt_tx_inc_pending(htt); 4417 if (ret) { 4418 ath10k_warn(ar, "failed to increase tx pending count: %d, dropping\n", 4419 ret); 4420 spin_unlock_bh(&ar->htt.tx_lock); 4421 ieee80211_free_txskb(ar->hw, skb); 4422 return; 4423 } 4424 4425 ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp); 4426 if (ret) { 4427 ath10k_dbg(ar, ATH10K_DBG_MAC, "failed to increase tx mgmt pending count: %d, dropping\n", 4428 ret); 4429 ath10k_htt_tx_dec_pending(htt); 4430 spin_unlock_bh(&ar->htt.tx_lock); 4431 ieee80211_free_txskb(ar->hw, skb); 4432 return; 4433 } 4434 spin_unlock_bh(&ar->htt.tx_lock); 4435 } 4436 4437 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false); 4438 if (ret) { 4439 ath10k_warn(ar, "failed to transmit frame: %d\n", ret); 4440 if (is_htt) { 4441 spin_lock_bh(&ar->htt.tx_lock); 4442 ath10k_htt_tx_dec_pending(htt); 4443 if (is_mgmt) 4444 ath10k_htt_tx_mgmt_dec_pending(htt); 4445 spin_unlock_bh(&ar->htt.tx_lock); 4446 } 4447 return; 4448 } 4449 } 4450 4451 static void ath10k_mac_op_wake_tx_queue(struct ieee80211_hw *hw, 4452 struct ieee80211_txq *txq) 4453 { 4454 struct ath10k *ar = hw->priv; 4455 int ret; 4456 u8 ac; 4457 4458 ath10k_htt_tx_txq_update(hw, txq); 4459 if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH) 4460 return; 4461 4462 ac = txq->ac; 4463 ieee80211_txq_schedule_start(hw, ac); 4464 txq = ieee80211_next_txq(hw, ac); 4465 if (!txq) 4466 goto out; 4467 4468 while (ath10k_mac_tx_can_push(hw, txq)) { 4469 ret = ath10k_mac_tx_push_txq(hw, txq); 4470 if (ret < 0) 4471 break; 4472 } 4473 ieee80211_return_txq(hw, txq, false); 4474 ath10k_htt_tx_txq_update(hw, txq); 4475 out: 4476 ieee80211_txq_schedule_end(hw, ac); 4477 } 4478 4479 /* Must not be called with conf_mutex held as workers can use that also. */ 4480 void ath10k_drain_tx(struct ath10k *ar) 4481 { 4482 /* make sure rcu-protected mac80211 tx path itself is drained */ 4483 synchronize_net(); 4484 4485 ath10k_offchan_tx_purge(ar); 4486 ath10k_mgmt_over_wmi_tx_purge(ar); 4487 4488 cancel_work_sync(&ar->offchan_tx_work); 4489 cancel_work_sync(&ar->wmi_mgmt_tx_work); 4490 } 4491 4492 void ath10k_halt(struct ath10k *ar) 4493 { 4494 struct ath10k_vif *arvif; 4495 4496 lockdep_assert_held(&ar->conf_mutex); 4497 4498 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 4499 ar->filter_flags = 0; 4500 ar->monitor = false; 4501 ar->monitor_arvif = NULL; 4502 4503 if (ar->monitor_started) 4504 ath10k_monitor_stop(ar); 4505 4506 ar->monitor_started = false; 4507 ar->tx_paused = 0; 4508 4509 ath10k_scan_finish(ar); 4510 ath10k_peer_cleanup_all(ar); 4511 ath10k_stop_radar_confirmation(ar); 4512 ath10k_core_stop(ar); 4513 ath10k_hif_power_down(ar); 4514 4515 spin_lock_bh(&ar->data_lock); 4516 list_for_each_entry(arvif, &ar->arvifs, list) 4517 ath10k_mac_vif_beacon_cleanup(arvif); 4518 spin_unlock_bh(&ar->data_lock); 4519 } 4520 4521 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 4522 { 4523 struct ath10k *ar = hw->priv; 4524 4525 mutex_lock(&ar->conf_mutex); 4526 4527 *tx_ant = ar->cfg_tx_chainmask; 4528 *rx_ant = ar->cfg_rx_chainmask; 4529 4530 mutex_unlock(&ar->conf_mutex); 4531 4532 return 0; 4533 } 4534 4535 static bool ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg) 4536 { 4537 /* It is not clear that allowing gaps in chainmask 4538 * is helpful. Probably it will not do what user 4539 * is hoping for, so warn in that case. 4540 */ 4541 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0) 4542 return true; 4543 4544 ath10k_warn(ar, "mac %s antenna chainmask is invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n", 4545 dbg, cm); 4546 return false; 4547 } 4548 4549 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar) 4550 { 4551 int nsts = ar->vht_cap_info; 4552 4553 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 4554 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 4555 4556 /* If firmware does not deliver to host number of space-time 4557 * streams supported, assume it support up to 4 BF STS and return 4558 * the value for VHT CAP: nsts-1) 4559 */ 4560 if (nsts == 0) 4561 return 3; 4562 4563 return nsts; 4564 } 4565 4566 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar) 4567 { 4568 int sound_dim = ar->vht_cap_info; 4569 4570 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 4571 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 4572 4573 /* If the sounding dimension is not advertised by the firmware, 4574 * let's use a default value of 1 4575 */ 4576 if (sound_dim == 0) 4577 return 1; 4578 4579 return sound_dim; 4580 } 4581 4582 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar) 4583 { 4584 struct ieee80211_sta_vht_cap vht_cap = {0}; 4585 struct ath10k_hw_params *hw = &ar->hw_params; 4586 u16 mcs_map; 4587 u32 val; 4588 int i; 4589 4590 vht_cap.vht_supported = 1; 4591 vht_cap.cap = ar->vht_cap_info; 4592 4593 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 4594 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) { 4595 val = ath10k_mac_get_vht_cap_bf_sts(ar); 4596 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 4597 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 4598 4599 vht_cap.cap |= val; 4600 } 4601 4602 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 4603 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) { 4604 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar); 4605 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 4606 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 4607 4608 vht_cap.cap |= val; 4609 } 4610 4611 mcs_map = 0; 4612 for (i = 0; i < 8; i++) { 4613 if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i))) 4614 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 4615 else 4616 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 4617 } 4618 4619 if (ar->cfg_tx_chainmask <= 1) 4620 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC; 4621 4622 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map); 4623 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map); 4624 4625 /* If we are supporting 160Mhz or 80+80, then the NIC may be able to do 4626 * a restricted NSS for 160 or 80+80 vs what it can do for 80Mhz. Give 4627 * user-space a clue if that is the case. 4628 */ 4629 if ((vht_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) && 4630 (hw->vht160_mcs_rx_highest != 0 || 4631 hw->vht160_mcs_tx_highest != 0)) { 4632 vht_cap.vht_mcs.rx_highest = cpu_to_le16(hw->vht160_mcs_rx_highest); 4633 vht_cap.vht_mcs.tx_highest = cpu_to_le16(hw->vht160_mcs_tx_highest); 4634 } 4635 4636 return vht_cap; 4637 } 4638 4639 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar) 4640 { 4641 int i; 4642 struct ieee80211_sta_ht_cap ht_cap = {0}; 4643 4644 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED)) 4645 return ht_cap; 4646 4647 ht_cap.ht_supported = 1; 4648 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 4649 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8; 4650 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 4651 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 4652 ht_cap.cap |= 4653 WLAN_HT_CAP_SM_PS_DISABLED << IEEE80211_HT_CAP_SM_PS_SHIFT; 4654 4655 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI) 4656 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 4657 4658 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI) 4659 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 4660 4661 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) { 4662 u32 smps; 4663 4664 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 4665 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 4666 4667 ht_cap.cap |= smps; 4668 } 4669 4670 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC && (ar->cfg_tx_chainmask > 1)) 4671 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 4672 4673 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) { 4674 u32 stbc; 4675 4676 stbc = ar->ht_cap_info; 4677 stbc &= WMI_HT_CAP_RX_STBC; 4678 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 4679 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 4680 stbc &= IEEE80211_HT_CAP_RX_STBC; 4681 4682 ht_cap.cap |= stbc; 4683 } 4684 4685 if (ar->ht_cap_info & WMI_HT_CAP_LDPC || (ar->ht_cap_info & 4686 WMI_HT_CAP_RX_LDPC && (ar->ht_cap_info & WMI_HT_CAP_TX_LDPC))) 4687 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 4688 4689 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT) 4690 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 4691 4692 /* max AMSDU is implicitly taken from vht_cap_info */ 4693 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 4694 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 4695 4696 for (i = 0; i < ar->num_rf_chains; i++) { 4697 if (ar->cfg_rx_chainmask & BIT(i)) 4698 ht_cap.mcs.rx_mask[i] = 0xFF; 4699 } 4700 4701 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 4702 4703 return ht_cap; 4704 } 4705 4706 static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar) 4707 { 4708 struct ieee80211_supported_band *band; 4709 struct ieee80211_sta_vht_cap vht_cap; 4710 struct ieee80211_sta_ht_cap ht_cap; 4711 4712 ht_cap = ath10k_get_ht_cap(ar); 4713 vht_cap = ath10k_create_vht_cap(ar); 4714 4715 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) { 4716 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 4717 band->ht_cap = ht_cap; 4718 } 4719 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) { 4720 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 4721 band->ht_cap = ht_cap; 4722 band->vht_cap = vht_cap; 4723 } 4724 } 4725 4726 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant) 4727 { 4728 int ret; 4729 bool is_valid_tx_chain_mask, is_valid_rx_chain_mask; 4730 4731 lockdep_assert_held(&ar->conf_mutex); 4732 4733 is_valid_tx_chain_mask = ath10k_check_chain_mask(ar, tx_ant, "tx"); 4734 is_valid_rx_chain_mask = ath10k_check_chain_mask(ar, rx_ant, "rx"); 4735 4736 if (!is_valid_tx_chain_mask || !is_valid_rx_chain_mask) 4737 return -EINVAL; 4738 4739 ar->cfg_tx_chainmask = tx_ant; 4740 ar->cfg_rx_chainmask = rx_ant; 4741 4742 if ((ar->state != ATH10K_STATE_ON) && 4743 (ar->state != ATH10K_STATE_RESTARTED)) 4744 return 0; 4745 4746 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask, 4747 tx_ant); 4748 if (ret) { 4749 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n", 4750 ret, tx_ant); 4751 return ret; 4752 } 4753 4754 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask, 4755 rx_ant); 4756 if (ret) { 4757 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n", 4758 ret, rx_ant); 4759 return ret; 4760 } 4761 4762 /* Reload HT/VHT capability */ 4763 ath10k_mac_setup_ht_vht_cap(ar); 4764 4765 return 0; 4766 } 4767 4768 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 4769 { 4770 struct ath10k *ar = hw->priv; 4771 int ret; 4772 4773 mutex_lock(&ar->conf_mutex); 4774 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant); 4775 mutex_unlock(&ar->conf_mutex); 4776 return ret; 4777 } 4778 4779 static int __ath10k_fetch_bb_timing_dt(struct ath10k *ar, 4780 struct wmi_bb_timing_cfg_arg *bb_timing) 4781 { 4782 struct device_node *node; 4783 const char *fem_name; 4784 int ret; 4785 4786 node = ar->dev->of_node; 4787 if (!node) 4788 return -ENOENT; 4789 4790 ret = of_property_read_string_index(node, "ext-fem-name", 0, &fem_name); 4791 if (ret) 4792 return -ENOENT; 4793 4794 /* 4795 * If external Front End module used in hardware, then default base band timing 4796 * parameter cannot be used since they were fine tuned for reference hardware, 4797 * so choosing different value suitable for that external FEM. 4798 */ 4799 if (!strcmp("microsemi-lx5586", fem_name)) { 4800 bb_timing->bb_tx_timing = 0x00; 4801 bb_timing->bb_xpa_timing = 0x0101; 4802 } else { 4803 return -ENOENT; 4804 } 4805 4806 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot bb_tx_timing 0x%x bb_xpa_timing 0x%x\n", 4807 bb_timing->bb_tx_timing, bb_timing->bb_xpa_timing); 4808 return 0; 4809 } 4810 4811 static int ath10k_mac_rfkill_config(struct ath10k *ar) 4812 { 4813 u32 param; 4814 int ret; 4815 4816 if (ar->hw_values->rfkill_pin == 0) { 4817 ath10k_warn(ar, "ath10k does not support hardware rfkill with this device\n"); 4818 return -EOPNOTSUPP; 4819 } 4820 4821 ath10k_dbg(ar, ATH10K_DBG_MAC, 4822 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d", 4823 ar->hw_values->rfkill_pin, ar->hw_values->rfkill_cfg, 4824 ar->hw_values->rfkill_on_level); 4825 4826 param = FIELD_PREP(WMI_TLV_RFKILL_CFG_RADIO_LEVEL, 4827 ar->hw_values->rfkill_on_level) | 4828 FIELD_PREP(WMI_TLV_RFKILL_CFG_GPIO_PIN_NUM, 4829 ar->hw_values->rfkill_pin) | 4830 FIELD_PREP(WMI_TLV_RFKILL_CFG_PIN_AS_GPIO, 4831 ar->hw_values->rfkill_cfg); 4832 4833 ret = ath10k_wmi_pdev_set_param(ar, 4834 ar->wmi.pdev_param->rfkill_config, 4835 param); 4836 if (ret) { 4837 ath10k_warn(ar, 4838 "failed to set rfkill config 0x%x: %d\n", 4839 param, ret); 4840 return ret; 4841 } 4842 return 0; 4843 } 4844 4845 int ath10k_mac_rfkill_enable_radio(struct ath10k *ar, bool enable) 4846 { 4847 enum wmi_tlv_rfkill_enable_radio param; 4848 int ret; 4849 4850 if (enable) 4851 param = WMI_TLV_RFKILL_ENABLE_RADIO_ON; 4852 else 4853 param = WMI_TLV_RFKILL_ENABLE_RADIO_OFF; 4854 4855 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac rfkill enable %d", param); 4856 4857 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rfkill_enable, 4858 param); 4859 if (ret) { 4860 ath10k_warn(ar, "failed to set rfkill enable param %d: %d\n", 4861 param, ret); 4862 return ret; 4863 } 4864 4865 return 0; 4866 } 4867 4868 static int ath10k_start(struct ieee80211_hw *hw) 4869 { 4870 struct ath10k *ar = hw->priv; 4871 u32 param; 4872 int ret = 0; 4873 struct wmi_bb_timing_cfg_arg bb_timing = {0}; 4874 4875 /* 4876 * This makes sense only when restarting hw. It is harmless to call 4877 * unconditionally. This is necessary to make sure no HTT/WMI tx 4878 * commands will be submitted while restarting. 4879 */ 4880 ath10k_drain_tx(ar); 4881 4882 mutex_lock(&ar->conf_mutex); 4883 4884 switch (ar->state) { 4885 case ATH10K_STATE_OFF: 4886 ar->state = ATH10K_STATE_ON; 4887 break; 4888 case ATH10K_STATE_RESTARTING: 4889 ar->state = ATH10K_STATE_RESTARTED; 4890 break; 4891 case ATH10K_STATE_ON: 4892 case ATH10K_STATE_RESTARTED: 4893 case ATH10K_STATE_WEDGED: 4894 WARN_ON(1); 4895 ret = -EINVAL; 4896 goto err; 4897 case ATH10K_STATE_UTF: 4898 ret = -EBUSY; 4899 goto err; 4900 } 4901 4902 spin_lock_bh(&ar->data_lock); 4903 4904 if (ar->hw_rfkill_on) { 4905 ar->hw_rfkill_on = false; 4906 spin_unlock_bh(&ar->data_lock); 4907 goto err; 4908 } 4909 4910 spin_unlock_bh(&ar->data_lock); 4911 4912 ret = ath10k_hif_power_up(ar, ATH10K_FIRMWARE_MODE_NORMAL); 4913 if (ret) { 4914 ath10k_err(ar, "Could not init hif: %d\n", ret); 4915 goto err_off; 4916 } 4917 4918 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL, 4919 &ar->normal_mode_fw); 4920 if (ret) { 4921 ath10k_err(ar, "Could not init core: %d\n", ret); 4922 goto err_power_down; 4923 } 4924 4925 if (ar->sys_cap_info & WMI_TLV_SYS_CAP_INFO_RFKILL) { 4926 ret = ath10k_mac_rfkill_config(ar); 4927 if (ret && ret != -EOPNOTSUPP) { 4928 ath10k_warn(ar, "failed to configure rfkill: %d", ret); 4929 goto err_core_stop; 4930 } 4931 } 4932 4933 param = ar->wmi.pdev_param->pmf_qos; 4934 ret = ath10k_wmi_pdev_set_param(ar, param, 1); 4935 if (ret) { 4936 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret); 4937 goto err_core_stop; 4938 } 4939 4940 param = ar->wmi.pdev_param->dynamic_bw; 4941 ret = ath10k_wmi_pdev_set_param(ar, param, 1); 4942 if (ret) { 4943 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret); 4944 goto err_core_stop; 4945 } 4946 4947 if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) { 4948 ret = ath10k_wmi_scan_prob_req_oui(ar, ar->mac_addr); 4949 if (ret) { 4950 ath10k_err(ar, "failed to set prob req oui: %i\n", ret); 4951 goto err_core_stop; 4952 } 4953 } 4954 4955 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) { 4956 ret = ath10k_wmi_adaptive_qcs(ar, true); 4957 if (ret) { 4958 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n", 4959 ret); 4960 goto err_core_stop; 4961 } 4962 } 4963 4964 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) { 4965 param = ar->wmi.pdev_param->burst_enable; 4966 ret = ath10k_wmi_pdev_set_param(ar, param, 0); 4967 if (ret) { 4968 ath10k_warn(ar, "failed to disable burst: %d\n", ret); 4969 goto err_core_stop; 4970 } 4971 } 4972 4973 param = ar->wmi.pdev_param->idle_ps_config; 4974 ret = ath10k_wmi_pdev_set_param(ar, param, 1); 4975 if (ret && ret != -EOPNOTSUPP) { 4976 ath10k_warn(ar, "failed to enable idle_ps_config: %d\n", ret); 4977 goto err_core_stop; 4978 } 4979 4980 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask); 4981 4982 /* 4983 * By default FW set ARP frames ac to voice (6). In that case ARP 4984 * exchange is not working properly for UAPSD enabled AP. ARP requests 4985 * which arrives with access category 0 are processed by network stack 4986 * and send back with access category 0, but FW changes access category 4987 * to 6. Set ARP frames access category to best effort (0) solves 4988 * this problem. 4989 */ 4990 4991 param = ar->wmi.pdev_param->arp_ac_override; 4992 ret = ath10k_wmi_pdev_set_param(ar, param, 0); 4993 if (ret) { 4994 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n", 4995 ret); 4996 goto err_core_stop; 4997 } 4998 4999 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA, 5000 ar->running_fw->fw_file.fw_features)) { 5001 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1, 5002 WMI_CCA_DETECT_LEVEL_AUTO, 5003 WMI_CCA_DETECT_MARGIN_AUTO); 5004 if (ret) { 5005 ath10k_warn(ar, "failed to enable adaptive cca: %d\n", 5006 ret); 5007 goto err_core_stop; 5008 } 5009 } 5010 5011 param = ar->wmi.pdev_param->ani_enable; 5012 ret = ath10k_wmi_pdev_set_param(ar, param, 1); 5013 if (ret) { 5014 ath10k_warn(ar, "failed to enable ani by default: %d\n", 5015 ret); 5016 goto err_core_stop; 5017 } 5018 5019 ar->ani_enabled = true; 5020 5021 if (ath10k_peer_stats_enabled(ar)) { 5022 param = ar->wmi.pdev_param->peer_stats_update_period; 5023 ret = ath10k_wmi_pdev_set_param(ar, param, 5024 PEER_DEFAULT_STATS_UPDATE_PERIOD); 5025 if (ret) { 5026 ath10k_warn(ar, 5027 "failed to set peer stats period : %d\n", 5028 ret); 5029 goto err_core_stop; 5030 } 5031 } 5032 5033 param = ar->wmi.pdev_param->enable_btcoex; 5034 if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map) && 5035 test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM, 5036 ar->running_fw->fw_file.fw_features) && 5037 ar->coex_support) { 5038 ret = ath10k_wmi_pdev_set_param(ar, param, 0); 5039 if (ret) { 5040 ath10k_warn(ar, 5041 "failed to set btcoex param: %d\n", ret); 5042 goto err_core_stop; 5043 } 5044 clear_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags); 5045 } 5046 5047 if (test_bit(WMI_SERVICE_BB_TIMING_CONFIG_SUPPORT, ar->wmi.svc_map)) { 5048 ret = __ath10k_fetch_bb_timing_dt(ar, &bb_timing); 5049 if (!ret) { 5050 ret = ath10k_wmi_pdev_bb_timing(ar, &bb_timing); 5051 if (ret) { 5052 ath10k_warn(ar, 5053 "failed to set bb timings: %d\n", 5054 ret); 5055 goto err_core_stop; 5056 } 5057 } 5058 } 5059 5060 ar->num_started_vdevs = 0; 5061 ath10k_regd_update(ar); 5062 5063 ath10k_spectral_start(ar); 5064 ath10k_thermal_set_throttling(ar); 5065 5066 ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_IDLE; 5067 5068 mutex_unlock(&ar->conf_mutex); 5069 return 0; 5070 5071 err_core_stop: 5072 ath10k_core_stop(ar); 5073 5074 err_power_down: 5075 ath10k_hif_power_down(ar); 5076 5077 err_off: 5078 ar->state = ATH10K_STATE_OFF; 5079 5080 err: 5081 mutex_unlock(&ar->conf_mutex); 5082 return ret; 5083 } 5084 5085 static void ath10k_stop(struct ieee80211_hw *hw) 5086 { 5087 struct ath10k *ar = hw->priv; 5088 5089 ath10k_drain_tx(ar); 5090 5091 mutex_lock(&ar->conf_mutex); 5092 if (ar->state != ATH10K_STATE_OFF) { 5093 if (!ar->hw_rfkill_on) 5094 ath10k_halt(ar); 5095 ar->state = ATH10K_STATE_OFF; 5096 } 5097 mutex_unlock(&ar->conf_mutex); 5098 5099 cancel_work_sync(&ar->set_coverage_class_work); 5100 cancel_delayed_work_sync(&ar->scan.timeout); 5101 cancel_work_sync(&ar->restart_work); 5102 } 5103 5104 static int ath10k_config_ps(struct ath10k *ar) 5105 { 5106 struct ath10k_vif *arvif; 5107 int ret = 0; 5108 5109 lockdep_assert_held(&ar->conf_mutex); 5110 5111 list_for_each_entry(arvif, &ar->arvifs, list) { 5112 ret = ath10k_mac_vif_setup_ps(arvif); 5113 if (ret) { 5114 ath10k_warn(ar, "failed to setup powersave: %d\n", ret); 5115 break; 5116 } 5117 } 5118 5119 return ret; 5120 } 5121 5122 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower) 5123 { 5124 int ret; 5125 u32 param; 5126 5127 lockdep_assert_held(&ar->conf_mutex); 5128 5129 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower); 5130 5131 param = ar->wmi.pdev_param->txpower_limit2g; 5132 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2); 5133 if (ret) { 5134 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n", 5135 txpower, ret); 5136 return ret; 5137 } 5138 5139 param = ar->wmi.pdev_param->txpower_limit5g; 5140 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2); 5141 if (ret) { 5142 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n", 5143 txpower, ret); 5144 return ret; 5145 } 5146 5147 return 0; 5148 } 5149 5150 static int ath10k_mac_txpower_recalc(struct ath10k *ar) 5151 { 5152 struct ath10k_vif *arvif; 5153 int ret, txpower = -1; 5154 5155 lockdep_assert_held(&ar->conf_mutex); 5156 5157 list_for_each_entry(arvif, &ar->arvifs, list) { 5158 /* txpower not initialized yet? */ 5159 if (arvif->txpower == INT_MIN) 5160 continue; 5161 5162 if (txpower == -1) 5163 txpower = arvif->txpower; 5164 else 5165 txpower = min(txpower, arvif->txpower); 5166 } 5167 5168 if (txpower == -1) 5169 return 0; 5170 5171 ret = ath10k_mac_txpower_setup(ar, txpower); 5172 if (ret) { 5173 ath10k_warn(ar, "failed to setup tx power %d: %d\n", 5174 txpower, ret); 5175 return ret; 5176 } 5177 5178 return 0; 5179 } 5180 5181 static int ath10k_config(struct ieee80211_hw *hw, u32 changed) 5182 { 5183 struct ath10k *ar = hw->priv; 5184 struct ieee80211_conf *conf = &hw->conf; 5185 int ret = 0; 5186 5187 mutex_lock(&ar->conf_mutex); 5188 5189 if (changed & IEEE80211_CONF_CHANGE_PS) 5190 ath10k_config_ps(ar); 5191 5192 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 5193 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR; 5194 ret = ath10k_monitor_recalc(ar); 5195 if (ret) 5196 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 5197 } 5198 5199 mutex_unlock(&ar->conf_mutex); 5200 return ret; 5201 } 5202 5203 static u32 get_nss_from_chainmask(u16 chain_mask) 5204 { 5205 if ((chain_mask & 0xf) == 0xf) 5206 return 4; 5207 else if ((chain_mask & 0x7) == 0x7) 5208 return 3; 5209 else if ((chain_mask & 0x3) == 0x3) 5210 return 2; 5211 return 1; 5212 } 5213 5214 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif) 5215 { 5216 u32 value = 0; 5217 struct ath10k *ar = arvif->ar; 5218 int nsts; 5219 int sound_dim; 5220 5221 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC) 5222 return 0; 5223 5224 nsts = ath10k_mac_get_vht_cap_bf_sts(ar); 5225 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 5226 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) 5227 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET); 5228 5229 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar); 5230 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 5231 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) 5232 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET); 5233 5234 if (!value) 5235 return 0; 5236 5237 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) 5238 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 5239 5240 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) 5241 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER | 5242 WMI_VDEV_PARAM_TXBF_SU_TX_BFER); 5243 5244 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) 5245 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 5246 5247 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) 5248 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE | 5249 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE); 5250 5251 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 5252 ar->wmi.vdev_param->txbf, value); 5253 } 5254 5255 /* 5256 * TODO: 5257 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE, 5258 * because we will send mgmt frames without CCK. This requirement 5259 * for P2P_FIND/GO_NEG should be handled by checking CCK flag 5260 * in the TX packet. 5261 */ 5262 static int ath10k_add_interface(struct ieee80211_hw *hw, 5263 struct ieee80211_vif *vif) 5264 { 5265 struct ath10k *ar = hw->priv; 5266 struct ath10k_vif *arvif = (void *)vif->drv_priv; 5267 struct ath10k_peer *peer; 5268 enum wmi_sta_powersave_param param; 5269 int ret = 0; 5270 u32 value; 5271 int bit; 5272 int i; 5273 u32 vdev_param; 5274 5275 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 5276 5277 mutex_lock(&ar->conf_mutex); 5278 5279 memset(arvif, 0, sizeof(*arvif)); 5280 ath10k_mac_txq_init(vif->txq); 5281 5282 arvif->ar = ar; 5283 arvif->vif = vif; 5284 5285 INIT_LIST_HEAD(&arvif->list); 5286 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work); 5287 INIT_DELAYED_WORK(&arvif->connection_loss_work, 5288 ath10k_mac_vif_sta_connection_loss_work); 5289 5290 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) { 5291 arvif->bitrate_mask.control[i].legacy = 0xffffffff; 5292 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff, 5293 sizeof(arvif->bitrate_mask.control[i].ht_mcs)); 5294 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff, 5295 sizeof(arvif->bitrate_mask.control[i].vht_mcs)); 5296 } 5297 5298 if (ar->num_peers >= ar->max_num_peers) { 5299 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n"); 5300 ret = -ENOBUFS; 5301 goto err; 5302 } 5303 5304 if (ar->free_vdev_map == 0) { 5305 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n"); 5306 ret = -EBUSY; 5307 goto err; 5308 } 5309 bit = __ffs64(ar->free_vdev_map); 5310 5311 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n", 5312 bit, ar->free_vdev_map); 5313 5314 arvif->vdev_id = bit; 5315 arvif->vdev_subtype = 5316 ath10k_wmi_get_vdev_subtype(ar, WMI_VDEV_SUBTYPE_NONE); 5317 5318 switch (vif->type) { 5319 case NL80211_IFTYPE_P2P_DEVICE: 5320 arvif->vdev_type = WMI_VDEV_TYPE_STA; 5321 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype 5322 (ar, WMI_VDEV_SUBTYPE_P2P_DEVICE); 5323 break; 5324 case NL80211_IFTYPE_UNSPECIFIED: 5325 case NL80211_IFTYPE_STATION: 5326 arvif->vdev_type = WMI_VDEV_TYPE_STA; 5327 if (vif->p2p) 5328 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype 5329 (ar, WMI_VDEV_SUBTYPE_P2P_CLIENT); 5330 break; 5331 case NL80211_IFTYPE_ADHOC: 5332 arvif->vdev_type = WMI_VDEV_TYPE_IBSS; 5333 break; 5334 case NL80211_IFTYPE_MESH_POINT: 5335 if (test_bit(WMI_SERVICE_MESH_11S, ar->wmi.svc_map)) { 5336 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype 5337 (ar, WMI_VDEV_SUBTYPE_MESH_11S); 5338 } else if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) { 5339 ret = -EINVAL; 5340 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n"); 5341 goto err; 5342 } 5343 arvif->vdev_type = WMI_VDEV_TYPE_AP; 5344 break; 5345 case NL80211_IFTYPE_AP: 5346 arvif->vdev_type = WMI_VDEV_TYPE_AP; 5347 5348 if (vif->p2p) 5349 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype 5350 (ar, WMI_VDEV_SUBTYPE_P2P_GO); 5351 break; 5352 case NL80211_IFTYPE_MONITOR: 5353 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 5354 break; 5355 default: 5356 WARN_ON(1); 5357 break; 5358 } 5359 5360 /* Using vdev_id as queue number will make it very easy to do per-vif 5361 * tx queue locking. This shouldn't wrap due to interface combinations 5362 * but do a modulo for correctness sake and prevent using offchannel tx 5363 * queues for regular vif tx. 5364 */ 5365 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1); 5366 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 5367 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1); 5368 5369 /* Some firmware revisions don't wait for beacon tx completion before 5370 * sending another SWBA event. This could lead to hardware using old 5371 * (freed) beacon data in some cases, e.g. tx credit starvation 5372 * combined with missed TBTT. This is very very rare. 5373 * 5374 * On non-IOMMU-enabled hosts this could be a possible security issue 5375 * because hw could beacon some random data on the air. On 5376 * IOMMU-enabled hosts DMAR faults would occur in most cases and target 5377 * device would crash. 5378 * 5379 * Since there are no beacon tx completions (implicit nor explicit) 5380 * propagated to host the only workaround for this is to allocate a 5381 * DMA-coherent buffer for a lifetime of a vif and use it for all 5382 * beacon tx commands. Worst case for this approach is some beacons may 5383 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap. 5384 */ 5385 if (vif->type == NL80211_IFTYPE_ADHOC || 5386 vif->type == NL80211_IFTYPE_MESH_POINT || 5387 vif->type == NL80211_IFTYPE_AP) { 5388 arvif->beacon_buf = dma_alloc_coherent(ar->dev, 5389 IEEE80211_MAX_FRAME_LEN, 5390 &arvif->beacon_paddr, 5391 GFP_ATOMIC); 5392 if (!arvif->beacon_buf) { 5393 ret = -ENOMEM; 5394 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n", 5395 ret); 5396 goto err; 5397 } 5398 } 5399 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags)) 5400 arvif->nohwcrypt = true; 5401 5402 if (arvif->nohwcrypt && 5403 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) { 5404 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n"); 5405 goto err; 5406 } 5407 5408 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n", 5409 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype, 5410 arvif->beacon_buf ? "single-buf" : "per-skb"); 5411 5412 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type, 5413 arvif->vdev_subtype, vif->addr); 5414 if (ret) { 5415 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n", 5416 arvif->vdev_id, ret); 5417 goto err; 5418 } 5419 5420 if (test_bit(WMI_SERVICE_VDEV_DISABLE_4_ADDR_SRC_LRN_SUPPORT, 5421 ar->wmi.svc_map)) { 5422 vdev_param = ar->wmi.vdev_param->disable_4addr_src_lrn; 5423 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5424 WMI_VDEV_DISABLE_4_ADDR_SRC_LRN); 5425 if (ret && ret != -EOPNOTSUPP) { 5426 ath10k_warn(ar, "failed to disable 4addr src lrn vdev %i: %d\n", 5427 arvif->vdev_id, ret); 5428 } 5429 } 5430 5431 ar->free_vdev_map &= ~(1LL << arvif->vdev_id); 5432 spin_lock_bh(&ar->data_lock); 5433 list_add(&arvif->list, &ar->arvifs); 5434 spin_unlock_bh(&ar->data_lock); 5435 5436 /* It makes no sense to have firmware do keepalives. mac80211 already 5437 * takes care of this with idle connection polling. 5438 */ 5439 ret = ath10k_mac_vif_disable_keepalive(arvif); 5440 if (ret) { 5441 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n", 5442 arvif->vdev_id, ret); 5443 goto err_vdev_delete; 5444 } 5445 5446 arvif->def_wep_key_idx = -1; 5447 5448 vdev_param = ar->wmi.vdev_param->tx_encap_type; 5449 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5450 ATH10K_HW_TXRX_NATIVE_WIFI); 5451 /* 10.X firmware does not support this VDEV parameter. Do not warn */ 5452 if (ret && ret != -EOPNOTSUPP) { 5453 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n", 5454 arvif->vdev_id, ret); 5455 goto err_vdev_delete; 5456 } 5457 5458 /* Configuring number of spatial stream for monitor interface is causing 5459 * target assert in qca9888 and qca6174. 5460 */ 5461 if (ar->cfg_tx_chainmask && (vif->type != NL80211_IFTYPE_MONITOR)) { 5462 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask); 5463 5464 vdev_param = ar->wmi.vdev_param->nss; 5465 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5466 nss); 5467 if (ret) { 5468 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n", 5469 arvif->vdev_id, ar->cfg_tx_chainmask, nss, 5470 ret); 5471 goto err_vdev_delete; 5472 } 5473 } 5474 5475 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 5476 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 5477 ret = ath10k_peer_create(ar, vif, NULL, arvif->vdev_id, 5478 vif->addr, WMI_PEER_TYPE_DEFAULT); 5479 if (ret) { 5480 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n", 5481 arvif->vdev_id, ret); 5482 goto err_vdev_delete; 5483 } 5484 5485 spin_lock_bh(&ar->data_lock); 5486 5487 peer = ath10k_peer_find(ar, arvif->vdev_id, vif->addr); 5488 if (!peer) { 5489 ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n", 5490 vif->addr, arvif->vdev_id); 5491 spin_unlock_bh(&ar->data_lock); 5492 ret = -ENOENT; 5493 goto err_peer_delete; 5494 } 5495 5496 arvif->peer_id = find_first_bit(peer->peer_ids, 5497 ATH10K_MAX_NUM_PEER_IDS); 5498 5499 spin_unlock_bh(&ar->data_lock); 5500 } else { 5501 arvif->peer_id = HTT_INVALID_PEERID; 5502 } 5503 5504 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 5505 ret = ath10k_mac_set_kickout(arvif); 5506 if (ret) { 5507 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n", 5508 arvif->vdev_id, ret); 5509 goto err_peer_delete; 5510 } 5511 } 5512 5513 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) { 5514 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 5515 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 5516 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5517 param, value); 5518 if (ret) { 5519 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n", 5520 arvif->vdev_id, ret); 5521 goto err_peer_delete; 5522 } 5523 5524 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif); 5525 if (ret) { 5526 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n", 5527 arvif->vdev_id, ret); 5528 goto err_peer_delete; 5529 } 5530 5531 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif); 5532 if (ret) { 5533 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n", 5534 arvif->vdev_id, ret); 5535 goto err_peer_delete; 5536 } 5537 } 5538 5539 ret = ath10k_mac_set_txbf_conf(arvif); 5540 if (ret) { 5541 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n", 5542 arvif->vdev_id, ret); 5543 goto err_peer_delete; 5544 } 5545 5546 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold); 5547 if (ret) { 5548 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n", 5549 arvif->vdev_id, ret); 5550 goto err_peer_delete; 5551 } 5552 5553 arvif->txpower = vif->bss_conf.txpower; 5554 ret = ath10k_mac_txpower_recalc(ar); 5555 if (ret) { 5556 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret); 5557 goto err_peer_delete; 5558 } 5559 5560 if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) { 5561 vdev_param = ar->wmi.vdev_param->rtt_responder_role; 5562 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5563 arvif->ftm_responder); 5564 5565 /* It is harmless to not set FTM role. Do not warn */ 5566 if (ret && ret != -EOPNOTSUPP) 5567 ath10k_warn(ar, "failed to set vdev %i FTM Responder: %d\n", 5568 arvif->vdev_id, ret); 5569 } 5570 5571 if (vif->type == NL80211_IFTYPE_MONITOR) { 5572 ar->monitor_arvif = arvif; 5573 ret = ath10k_monitor_recalc(ar); 5574 if (ret) { 5575 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 5576 goto err_peer_delete; 5577 } 5578 } 5579 5580 spin_lock_bh(&ar->htt.tx_lock); 5581 if (!ar->tx_paused) 5582 ieee80211_wake_queue(ar->hw, arvif->vdev_id); 5583 spin_unlock_bh(&ar->htt.tx_lock); 5584 5585 mutex_unlock(&ar->conf_mutex); 5586 return 0; 5587 5588 err_peer_delete: 5589 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 5590 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 5591 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr); 5592 ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id, 5593 vif->addr); 5594 } 5595 5596 err_vdev_delete: 5597 ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 5598 ar->free_vdev_map |= 1LL << arvif->vdev_id; 5599 spin_lock_bh(&ar->data_lock); 5600 list_del(&arvif->list); 5601 spin_unlock_bh(&ar->data_lock); 5602 5603 err: 5604 if (arvif->beacon_buf) { 5605 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN, 5606 arvif->beacon_buf, arvif->beacon_paddr); 5607 arvif->beacon_buf = NULL; 5608 } 5609 5610 mutex_unlock(&ar->conf_mutex); 5611 5612 return ret; 5613 } 5614 5615 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif) 5616 { 5617 int i; 5618 5619 for (i = 0; i < BITS_PER_LONG; i++) 5620 ath10k_mac_vif_tx_unlock(arvif, i); 5621 } 5622 5623 static void ath10k_remove_interface(struct ieee80211_hw *hw, 5624 struct ieee80211_vif *vif) 5625 { 5626 struct ath10k *ar = hw->priv; 5627 struct ath10k_vif *arvif = (void *)vif->drv_priv; 5628 struct ath10k_peer *peer; 5629 unsigned long time_left; 5630 int ret; 5631 int i; 5632 5633 cancel_work_sync(&arvif->ap_csa_work); 5634 cancel_delayed_work_sync(&arvif->connection_loss_work); 5635 5636 mutex_lock(&ar->conf_mutex); 5637 5638 ret = ath10k_spectral_vif_stop(arvif); 5639 if (ret) 5640 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n", 5641 arvif->vdev_id, ret); 5642 5643 ar->free_vdev_map |= 1LL << arvif->vdev_id; 5644 spin_lock_bh(&ar->data_lock); 5645 list_del(&arvif->list); 5646 spin_unlock_bh(&ar->data_lock); 5647 5648 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 5649 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 5650 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id, 5651 vif->addr); 5652 if (ret) 5653 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n", 5654 arvif->vdev_id, ret); 5655 5656 ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id, 5657 vif->addr); 5658 kfree(arvif->u.ap.noa_data); 5659 } 5660 5661 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n", 5662 arvif->vdev_id); 5663 5664 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 5665 if (ret) 5666 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n", 5667 arvif->vdev_id, ret); 5668 5669 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) { 5670 time_left = wait_for_completion_timeout(&ar->vdev_delete_done, 5671 ATH10K_VDEV_DELETE_TIMEOUT_HZ); 5672 if (time_left == 0) { 5673 ath10k_warn(ar, "Timeout in receiving vdev delete response\n"); 5674 goto out; 5675 } 5676 } 5677 5678 /* Some firmware revisions don't notify host about self-peer removal 5679 * until after associated vdev is deleted. 5680 */ 5681 if (arvif->vdev_type == WMI_VDEV_TYPE_AP || 5682 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 5683 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id, 5684 vif->addr); 5685 if (ret) 5686 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n", 5687 arvif->vdev_id, ret); 5688 5689 spin_lock_bh(&ar->data_lock); 5690 ar->num_peers--; 5691 spin_unlock_bh(&ar->data_lock); 5692 } 5693 5694 spin_lock_bh(&ar->data_lock); 5695 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) { 5696 peer = ar->peer_map[i]; 5697 if (!peer) 5698 continue; 5699 5700 if (peer->vif == vif) { 5701 ath10k_warn(ar, "found vif peer %pM entry on vdev %i after it was supposedly removed\n", 5702 vif->addr, arvif->vdev_id); 5703 peer->vif = NULL; 5704 } 5705 } 5706 5707 /* Clean this up late, less opportunity for firmware to access 5708 * DMA memory we have deleted. 5709 */ 5710 ath10k_mac_vif_beacon_cleanup(arvif); 5711 spin_unlock_bh(&ar->data_lock); 5712 5713 ath10k_peer_cleanup(ar, arvif->vdev_id); 5714 ath10k_mac_txq_unref(ar, vif->txq); 5715 5716 if (vif->type == NL80211_IFTYPE_MONITOR) { 5717 ar->monitor_arvif = NULL; 5718 ret = ath10k_monitor_recalc(ar); 5719 if (ret) 5720 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 5721 } 5722 5723 ret = ath10k_mac_txpower_recalc(ar); 5724 if (ret) 5725 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret); 5726 5727 spin_lock_bh(&ar->htt.tx_lock); 5728 ath10k_mac_vif_tx_unlock_all(arvif); 5729 spin_unlock_bh(&ar->htt.tx_lock); 5730 5731 ath10k_mac_txq_unref(ar, vif->txq); 5732 5733 out: 5734 mutex_unlock(&ar->conf_mutex); 5735 } 5736 5737 /* 5738 * FIXME: Has to be verified. 5739 */ 5740 #define SUPPORTED_FILTERS \ 5741 (FIF_ALLMULTI | \ 5742 FIF_CONTROL | \ 5743 FIF_PSPOLL | \ 5744 FIF_OTHER_BSS | \ 5745 FIF_BCN_PRBRESP_PROMISC | \ 5746 FIF_PROBE_REQ | \ 5747 FIF_FCSFAIL) 5748 5749 static void ath10k_configure_filter(struct ieee80211_hw *hw, 5750 unsigned int changed_flags, 5751 unsigned int *total_flags, 5752 u64 multicast) 5753 { 5754 struct ath10k *ar = hw->priv; 5755 int ret; 5756 5757 mutex_lock(&ar->conf_mutex); 5758 5759 changed_flags &= SUPPORTED_FILTERS; 5760 *total_flags &= SUPPORTED_FILTERS; 5761 ar->filter_flags = *total_flags; 5762 5763 ret = ath10k_monitor_recalc(ar); 5764 if (ret) 5765 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret); 5766 5767 mutex_unlock(&ar->conf_mutex); 5768 } 5769 5770 static void ath10k_recalculate_mgmt_rate(struct ath10k *ar, 5771 struct ieee80211_vif *vif, 5772 struct cfg80211_chan_def *def) 5773 { 5774 struct ath10k_vif *arvif = (void *)vif->drv_priv; 5775 const struct ieee80211_supported_band *sband; 5776 u8 basic_rate_idx; 5777 int hw_rate_code; 5778 u32 vdev_param; 5779 u16 bitrate; 5780 int ret; 5781 5782 lockdep_assert_held(&ar->conf_mutex); 5783 5784 sband = ar->hw->wiphy->bands[def->chan->band]; 5785 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1; 5786 bitrate = sband->bitrates[basic_rate_idx].bitrate; 5787 5788 hw_rate_code = ath10k_mac_get_rate_hw_value(bitrate); 5789 if (hw_rate_code < 0) { 5790 ath10k_warn(ar, "bitrate not supported %d\n", bitrate); 5791 return; 5792 } 5793 5794 vdev_param = ar->wmi.vdev_param->mgmt_rate; 5795 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5796 hw_rate_code); 5797 if (ret) 5798 ath10k_warn(ar, "failed to set mgmt tx rate %d\n", ret); 5799 } 5800 5801 static void ath10k_bss_info_changed(struct ieee80211_hw *hw, 5802 struct ieee80211_vif *vif, 5803 struct ieee80211_bss_conf *info, 5804 u32 changed) 5805 { 5806 struct ath10k *ar = hw->priv; 5807 struct ath10k_vif *arvif = (void *)vif->drv_priv; 5808 struct cfg80211_chan_def def; 5809 u32 vdev_param, pdev_param, slottime, preamble; 5810 u16 bitrate, hw_value; 5811 u8 rate, rateidx; 5812 int ret = 0, mcast_rate; 5813 enum nl80211_band band; 5814 5815 mutex_lock(&ar->conf_mutex); 5816 5817 if (changed & BSS_CHANGED_IBSS) 5818 ath10k_control_ibss(arvif, info, vif->addr); 5819 5820 if (changed & BSS_CHANGED_BEACON_INT) { 5821 arvif->beacon_interval = info->beacon_int; 5822 vdev_param = ar->wmi.vdev_param->beacon_interval; 5823 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5824 arvif->beacon_interval); 5825 ath10k_dbg(ar, ATH10K_DBG_MAC, 5826 "mac vdev %d beacon_interval %d\n", 5827 arvif->vdev_id, arvif->beacon_interval); 5828 5829 if (ret) 5830 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n", 5831 arvif->vdev_id, ret); 5832 } 5833 5834 if (changed & BSS_CHANGED_BEACON) { 5835 ath10k_dbg(ar, ATH10K_DBG_MAC, 5836 "vdev %d set beacon tx mode to staggered\n", 5837 arvif->vdev_id); 5838 5839 pdev_param = ar->wmi.pdev_param->beacon_tx_mode; 5840 ret = ath10k_wmi_pdev_set_param(ar, pdev_param, 5841 WMI_BEACON_STAGGERED_MODE); 5842 if (ret) 5843 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n", 5844 arvif->vdev_id, ret); 5845 5846 ret = ath10k_mac_setup_bcn_tmpl(arvif); 5847 if (ret) 5848 ath10k_warn(ar, "failed to update beacon template: %d\n", 5849 ret); 5850 5851 if (ieee80211_vif_is_mesh(vif)) { 5852 /* mesh doesn't use SSID but firmware needs it */ 5853 strncpy(arvif->u.ap.ssid, "mesh", 5854 sizeof(arvif->u.ap.ssid)); 5855 arvif->u.ap.ssid_len = 4; 5856 } 5857 } 5858 5859 if (changed & BSS_CHANGED_AP_PROBE_RESP) { 5860 ret = ath10k_mac_setup_prb_tmpl(arvif); 5861 if (ret) 5862 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n", 5863 arvif->vdev_id, ret); 5864 } 5865 5866 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) { 5867 arvif->dtim_period = info->dtim_period; 5868 5869 ath10k_dbg(ar, ATH10K_DBG_MAC, 5870 "mac vdev %d dtim_period %d\n", 5871 arvif->vdev_id, arvif->dtim_period); 5872 5873 vdev_param = ar->wmi.vdev_param->dtim_period; 5874 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5875 arvif->dtim_period); 5876 if (ret) 5877 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n", 5878 arvif->vdev_id, ret); 5879 } 5880 5881 if (changed & BSS_CHANGED_SSID && 5882 vif->type == NL80211_IFTYPE_AP) { 5883 arvif->u.ap.ssid_len = info->ssid_len; 5884 if (info->ssid_len) 5885 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len); 5886 arvif->u.ap.hidden_ssid = info->hidden_ssid; 5887 } 5888 5889 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid)) 5890 ether_addr_copy(arvif->bssid, info->bssid); 5891 5892 if (changed & BSS_CHANGED_FTM_RESPONDER && 5893 arvif->ftm_responder != info->ftm_responder && 5894 test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) { 5895 arvif->ftm_responder = info->ftm_responder; 5896 5897 vdev_param = ar->wmi.vdev_param->rtt_responder_role; 5898 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5899 arvif->ftm_responder); 5900 5901 ath10k_dbg(ar, ATH10K_DBG_MAC, 5902 "mac vdev %d ftm_responder %d:ret %d\n", 5903 arvif->vdev_id, arvif->ftm_responder, ret); 5904 } 5905 5906 if (changed & BSS_CHANGED_BEACON_ENABLED) 5907 ath10k_control_beaconing(arvif, info); 5908 5909 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 5910 arvif->use_cts_prot = info->use_cts_prot; 5911 5912 ret = ath10k_recalc_rtscts_prot(arvif); 5913 if (ret) 5914 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n", 5915 arvif->vdev_id, ret); 5916 5917 if (ath10k_mac_can_set_cts_prot(arvif)) { 5918 ret = ath10k_mac_set_cts_prot(arvif); 5919 if (ret) 5920 ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n", 5921 arvif->vdev_id, ret); 5922 } 5923 } 5924 5925 if (changed & BSS_CHANGED_ERP_SLOT) { 5926 if (info->use_short_slot) 5927 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 5928 5929 else 5930 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 5931 5932 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n", 5933 arvif->vdev_id, slottime); 5934 5935 vdev_param = ar->wmi.vdev_param->slot_time; 5936 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5937 slottime); 5938 if (ret) 5939 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n", 5940 arvif->vdev_id, ret); 5941 } 5942 5943 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 5944 if (info->use_short_preamble) 5945 preamble = WMI_VDEV_PREAMBLE_SHORT; 5946 else 5947 preamble = WMI_VDEV_PREAMBLE_LONG; 5948 5949 ath10k_dbg(ar, ATH10K_DBG_MAC, 5950 "mac vdev %d preamble %dn", 5951 arvif->vdev_id, preamble); 5952 5953 vdev_param = ar->wmi.vdev_param->preamble; 5954 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 5955 preamble); 5956 if (ret) 5957 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n", 5958 arvif->vdev_id, ret); 5959 } 5960 5961 if (changed & BSS_CHANGED_ASSOC) { 5962 if (info->assoc) { 5963 /* Workaround: Make sure monitor vdev is not running 5964 * when associating to prevent some firmware revisions 5965 * (e.g. 10.1 and 10.2) from crashing. 5966 */ 5967 if (ar->monitor_started) 5968 ath10k_monitor_stop(ar); 5969 ath10k_bss_assoc(hw, vif, info); 5970 ath10k_monitor_recalc(ar); 5971 } else { 5972 ath10k_bss_disassoc(hw, vif); 5973 } 5974 } 5975 5976 if (changed & BSS_CHANGED_TXPOWER) { 5977 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n", 5978 arvif->vdev_id, info->txpower); 5979 5980 arvif->txpower = info->txpower; 5981 ret = ath10k_mac_txpower_recalc(ar); 5982 if (ret) 5983 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret); 5984 } 5985 5986 if (changed & BSS_CHANGED_PS) { 5987 arvif->ps = vif->bss_conf.ps; 5988 5989 ret = ath10k_config_ps(ar); 5990 if (ret) 5991 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n", 5992 arvif->vdev_id, ret); 5993 } 5994 5995 if (changed & BSS_CHANGED_MCAST_RATE && 5996 !ath10k_mac_vif_chan(arvif->vif, &def)) { 5997 band = def.chan->band; 5998 mcast_rate = vif->bss_conf.mcast_rate[band]; 5999 if (mcast_rate > 0) 6000 rateidx = mcast_rate - 1; 6001 else 6002 rateidx = ffs(vif->bss_conf.basic_rates) - 1; 6003 6004 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) 6005 rateidx += ATH10K_MAC_FIRST_OFDM_RATE_IDX; 6006 6007 bitrate = ath10k_wmi_legacy_rates[rateidx].bitrate; 6008 hw_value = ath10k_wmi_legacy_rates[rateidx].hw_value; 6009 if (ath10k_mac_bitrate_is_cck(bitrate)) 6010 preamble = WMI_RATE_PREAMBLE_CCK; 6011 else 6012 preamble = WMI_RATE_PREAMBLE_OFDM; 6013 6014 rate = ATH10K_HW_RATECODE(hw_value, 0, preamble); 6015 6016 ath10k_dbg(ar, ATH10K_DBG_MAC, 6017 "mac vdev %d mcast_rate %x\n", 6018 arvif->vdev_id, rate); 6019 6020 vdev_param = ar->wmi.vdev_param->mcast_data_rate; 6021 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 6022 vdev_param, rate); 6023 if (ret) 6024 ath10k_warn(ar, 6025 "failed to set mcast rate on vdev %i: %d\n", 6026 arvif->vdev_id, ret); 6027 6028 vdev_param = ar->wmi.vdev_param->bcast_data_rate; 6029 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 6030 vdev_param, rate); 6031 if (ret) 6032 ath10k_warn(ar, 6033 "failed to set bcast rate on vdev %i: %d\n", 6034 arvif->vdev_id, ret); 6035 } 6036 6037 if (changed & BSS_CHANGED_BASIC_RATES && 6038 !ath10k_mac_vif_chan(arvif->vif, &def)) 6039 ath10k_recalculate_mgmt_rate(ar, vif, &def); 6040 6041 mutex_unlock(&ar->conf_mutex); 6042 } 6043 6044 static void ath10k_mac_op_set_coverage_class(struct ieee80211_hw *hw, s16 value) 6045 { 6046 struct ath10k *ar = hw->priv; 6047 6048 /* This function should never be called if setting the coverage class 6049 * is not supported on this hardware. 6050 */ 6051 if (!ar->hw_params.hw_ops->set_coverage_class) { 6052 WARN_ON_ONCE(1); 6053 return; 6054 } 6055 ar->hw_params.hw_ops->set_coverage_class(ar, value); 6056 } 6057 6058 struct ath10k_mac_tdls_iter_data { 6059 u32 num_tdls_stations; 6060 struct ieee80211_vif *curr_vif; 6061 }; 6062 6063 static void ath10k_mac_tdls_vif_stations_count_iter(void *data, 6064 struct ieee80211_sta *sta) 6065 { 6066 struct ath10k_mac_tdls_iter_data *iter_data = data; 6067 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 6068 struct ieee80211_vif *sta_vif = arsta->arvif->vif; 6069 6070 if (sta->tdls && sta_vif == iter_data->curr_vif) 6071 iter_data->num_tdls_stations++; 6072 } 6073 6074 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw, 6075 struct ieee80211_vif *vif) 6076 { 6077 struct ath10k_mac_tdls_iter_data data = {}; 6078 6079 data.curr_vif = vif; 6080 6081 ieee80211_iterate_stations_atomic(hw, 6082 ath10k_mac_tdls_vif_stations_count_iter, 6083 &data); 6084 return data.num_tdls_stations; 6085 } 6086 6087 static int ath10k_hw_scan(struct ieee80211_hw *hw, 6088 struct ieee80211_vif *vif, 6089 struct ieee80211_scan_request *hw_req) 6090 { 6091 struct ath10k *ar = hw->priv; 6092 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6093 struct cfg80211_scan_request *req = &hw_req->req; 6094 struct wmi_start_scan_arg arg; 6095 int ret = 0; 6096 int i; 6097 u32 scan_timeout; 6098 6099 mutex_lock(&ar->conf_mutex); 6100 6101 if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) { 6102 ret = -EBUSY; 6103 goto exit; 6104 } 6105 6106 spin_lock_bh(&ar->data_lock); 6107 switch (ar->scan.state) { 6108 case ATH10K_SCAN_IDLE: 6109 reinit_completion(&ar->scan.started); 6110 reinit_completion(&ar->scan.completed); 6111 ar->scan.state = ATH10K_SCAN_STARTING; 6112 ar->scan.is_roc = false; 6113 ar->scan.vdev_id = arvif->vdev_id; 6114 ret = 0; 6115 break; 6116 case ATH10K_SCAN_STARTING: 6117 case ATH10K_SCAN_RUNNING: 6118 case ATH10K_SCAN_ABORTING: 6119 ret = -EBUSY; 6120 break; 6121 } 6122 spin_unlock_bh(&ar->data_lock); 6123 6124 if (ret) 6125 goto exit; 6126 6127 memset(&arg, 0, sizeof(arg)); 6128 ath10k_wmi_start_scan_init(ar, &arg); 6129 arg.vdev_id = arvif->vdev_id; 6130 arg.scan_id = ATH10K_SCAN_ID; 6131 6132 if (req->ie_len) { 6133 arg.ie_len = req->ie_len; 6134 memcpy(arg.ie, req->ie, arg.ie_len); 6135 } 6136 6137 if (req->n_ssids) { 6138 arg.n_ssids = req->n_ssids; 6139 for (i = 0; i < arg.n_ssids; i++) { 6140 arg.ssids[i].len = req->ssids[i].ssid_len; 6141 arg.ssids[i].ssid = req->ssids[i].ssid; 6142 } 6143 } else { 6144 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 6145 } 6146 6147 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 6148 arg.scan_ctrl_flags |= WMI_SCAN_ADD_SPOOFED_MAC_IN_PROBE_REQ; 6149 ether_addr_copy(arg.mac_addr.addr, req->mac_addr); 6150 ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask); 6151 } 6152 6153 if (req->n_channels) { 6154 arg.n_channels = req->n_channels; 6155 for (i = 0; i < arg.n_channels; i++) 6156 arg.channels[i] = req->channels[i]->center_freq; 6157 } 6158 6159 /* if duration is set, default dwell times will be overwritten */ 6160 if (req->duration) { 6161 arg.dwell_time_active = req->duration; 6162 arg.dwell_time_passive = req->duration; 6163 arg.burst_duration_ms = req->duration; 6164 6165 scan_timeout = min_t(u32, arg.max_rest_time * 6166 (arg.n_channels - 1) + (req->duration + 6167 ATH10K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD) * 6168 arg.n_channels, arg.max_scan_time + 200); 6169 6170 } else { 6171 /* Add a 200ms margin to account for event/command processing */ 6172 scan_timeout = arg.max_scan_time + 200; 6173 } 6174 6175 ret = ath10k_start_scan(ar, &arg); 6176 if (ret) { 6177 ath10k_warn(ar, "failed to start hw scan: %d\n", ret); 6178 spin_lock_bh(&ar->data_lock); 6179 ar->scan.state = ATH10K_SCAN_IDLE; 6180 spin_unlock_bh(&ar->data_lock); 6181 } 6182 6183 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 6184 msecs_to_jiffies(scan_timeout)); 6185 6186 exit: 6187 mutex_unlock(&ar->conf_mutex); 6188 return ret; 6189 } 6190 6191 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw, 6192 struct ieee80211_vif *vif) 6193 { 6194 struct ath10k *ar = hw->priv; 6195 6196 mutex_lock(&ar->conf_mutex); 6197 ath10k_scan_abort(ar); 6198 mutex_unlock(&ar->conf_mutex); 6199 6200 cancel_delayed_work_sync(&ar->scan.timeout); 6201 } 6202 6203 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar, 6204 struct ath10k_vif *arvif, 6205 enum set_key_cmd cmd, 6206 struct ieee80211_key_conf *key) 6207 { 6208 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid; 6209 int ret; 6210 6211 /* 10.1 firmware branch requires default key index to be set to group 6212 * key index after installing it. Otherwise FW/HW Txes corrupted 6213 * frames with multi-vif APs. This is not required for main firmware 6214 * branch (e.g. 636). 6215 * 6216 * This is also needed for 636 fw for IBSS-RSN to work more reliably. 6217 * 6218 * FIXME: It remains unknown if this is required for multi-vif STA 6219 * interfaces on 10.1. 6220 */ 6221 6222 if (arvif->vdev_type != WMI_VDEV_TYPE_AP && 6223 arvif->vdev_type != WMI_VDEV_TYPE_IBSS) 6224 return; 6225 6226 if (key->cipher == WLAN_CIPHER_SUITE_WEP40) 6227 return; 6228 6229 if (key->cipher == WLAN_CIPHER_SUITE_WEP104) 6230 return; 6231 6232 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 6233 return; 6234 6235 if (cmd != SET_KEY) 6236 return; 6237 6238 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 6239 key->keyidx); 6240 if (ret) 6241 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n", 6242 arvif->vdev_id, ret); 6243 } 6244 6245 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 6246 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 6247 struct ieee80211_key_conf *key) 6248 { 6249 struct ath10k *ar = hw->priv; 6250 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6251 struct ath10k_sta *arsta; 6252 struct ath10k_peer *peer; 6253 const u8 *peer_addr; 6254 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 || 6255 key->cipher == WLAN_CIPHER_SUITE_WEP104; 6256 int ret = 0; 6257 int ret2; 6258 u32 flags = 0; 6259 u32 flags2; 6260 6261 /* this one needs to be done in software */ 6262 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC || 6263 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 || 6264 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 || 6265 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256) 6266 return 1; 6267 6268 if (arvif->nohwcrypt) 6269 return 1; 6270 6271 if (key->keyidx > WMI_MAX_KEY_INDEX) 6272 return -ENOSPC; 6273 6274 mutex_lock(&ar->conf_mutex); 6275 6276 if (sta) { 6277 arsta = (struct ath10k_sta *)sta->drv_priv; 6278 peer_addr = sta->addr; 6279 spin_lock_bh(&ar->data_lock); 6280 arsta->ucast_cipher = key->cipher; 6281 spin_unlock_bh(&ar->data_lock); 6282 } else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) { 6283 peer_addr = vif->bss_conf.bssid; 6284 } else { 6285 peer_addr = vif->addr; 6286 } 6287 6288 key->hw_key_idx = key->keyidx; 6289 6290 if (is_wep) { 6291 if (cmd == SET_KEY) 6292 arvif->wep_keys[key->keyidx] = key; 6293 else 6294 arvif->wep_keys[key->keyidx] = NULL; 6295 } 6296 6297 /* the peer should not disappear in mid-way (unless FW goes awry) since 6298 * we already hold conf_mutex. we just make sure its there now. 6299 */ 6300 spin_lock_bh(&ar->data_lock); 6301 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 6302 spin_unlock_bh(&ar->data_lock); 6303 6304 if (!peer) { 6305 if (cmd == SET_KEY) { 6306 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n", 6307 peer_addr); 6308 ret = -EOPNOTSUPP; 6309 goto exit; 6310 } else { 6311 /* if the peer doesn't exist there is no key to disable anymore */ 6312 goto exit; 6313 } 6314 } 6315 6316 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 6317 flags |= WMI_KEY_PAIRWISE; 6318 else 6319 flags |= WMI_KEY_GROUP; 6320 6321 if (is_wep) { 6322 if (cmd == DISABLE_KEY) 6323 ath10k_clear_vdev_key(arvif, key); 6324 6325 /* When WEP keys are uploaded it's possible that there are 6326 * stations associated already (e.g. when merging) without any 6327 * keys. Static WEP needs an explicit per-peer key upload. 6328 */ 6329 if (vif->type == NL80211_IFTYPE_ADHOC && 6330 cmd == SET_KEY) 6331 ath10k_mac_vif_update_wep_key(arvif, key); 6332 6333 /* 802.1x never sets the def_wep_key_idx so each set_key() 6334 * call changes default tx key. 6335 * 6336 * Static WEP sets def_wep_key_idx via .set_default_unicast_key 6337 * after first set_key(). 6338 */ 6339 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1) 6340 flags |= WMI_KEY_TX_USAGE; 6341 } 6342 6343 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags); 6344 if (ret) { 6345 WARN_ON(ret > 0); 6346 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n", 6347 arvif->vdev_id, peer_addr, ret); 6348 goto exit; 6349 } 6350 6351 /* mac80211 sets static WEP keys as groupwise while firmware requires 6352 * them to be installed twice as both pairwise and groupwise. 6353 */ 6354 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) { 6355 flags2 = flags; 6356 flags2 &= ~WMI_KEY_GROUP; 6357 flags2 |= WMI_KEY_PAIRWISE; 6358 6359 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2); 6360 if (ret) { 6361 WARN_ON(ret > 0); 6362 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n", 6363 arvif->vdev_id, peer_addr, ret); 6364 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY, 6365 peer_addr, flags); 6366 if (ret2) { 6367 WARN_ON(ret2 > 0); 6368 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n", 6369 arvif->vdev_id, peer_addr, ret2); 6370 } 6371 goto exit; 6372 } 6373 } 6374 6375 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key); 6376 6377 spin_lock_bh(&ar->data_lock); 6378 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 6379 if (peer && cmd == SET_KEY) 6380 peer->keys[key->keyidx] = key; 6381 else if (peer && cmd == DISABLE_KEY) 6382 peer->keys[key->keyidx] = NULL; 6383 else if (peer == NULL) 6384 /* impossible unless FW goes crazy */ 6385 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr); 6386 spin_unlock_bh(&ar->data_lock); 6387 6388 if (sta && sta->tdls) 6389 ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6390 ar->wmi.peer_param->authorize, 1); 6391 else if (sta && cmd == SET_KEY && (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 6392 ath10k_wmi_peer_set_param(ar, arvif->vdev_id, peer_addr, 6393 ar->wmi.peer_param->authorize, 1); 6394 6395 exit: 6396 mutex_unlock(&ar->conf_mutex); 6397 return ret; 6398 } 6399 6400 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw, 6401 struct ieee80211_vif *vif, 6402 int keyidx) 6403 { 6404 struct ath10k *ar = hw->priv; 6405 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6406 int ret; 6407 6408 mutex_lock(&arvif->ar->conf_mutex); 6409 6410 if (arvif->ar->state != ATH10K_STATE_ON) 6411 goto unlock; 6412 6413 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n", 6414 arvif->vdev_id, keyidx); 6415 6416 ret = ath10k_wmi_vdev_set_param(arvif->ar, 6417 arvif->vdev_id, 6418 arvif->ar->wmi.vdev_param->def_keyid, 6419 keyidx); 6420 6421 if (ret) { 6422 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n", 6423 arvif->vdev_id, 6424 ret); 6425 goto unlock; 6426 } 6427 6428 arvif->def_wep_key_idx = keyidx; 6429 6430 unlock: 6431 mutex_unlock(&arvif->ar->conf_mutex); 6432 } 6433 6434 static void ath10k_sta_rc_update_wk(struct work_struct *wk) 6435 { 6436 struct ath10k *ar; 6437 struct ath10k_vif *arvif; 6438 struct ath10k_sta *arsta; 6439 struct ieee80211_sta *sta; 6440 struct cfg80211_chan_def def; 6441 enum nl80211_band band; 6442 const u8 *ht_mcs_mask; 6443 const u16 *vht_mcs_mask; 6444 u32 changed, bw, nss, smps; 6445 int err; 6446 6447 arsta = container_of(wk, struct ath10k_sta, update_wk); 6448 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 6449 arvif = arsta->arvif; 6450 ar = arvif->ar; 6451 6452 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def))) 6453 return; 6454 6455 band = def.chan->band; 6456 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 6457 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 6458 6459 spin_lock_bh(&ar->data_lock); 6460 6461 changed = arsta->changed; 6462 arsta->changed = 0; 6463 6464 bw = arsta->bw; 6465 nss = arsta->nss; 6466 smps = arsta->smps; 6467 6468 spin_unlock_bh(&ar->data_lock); 6469 6470 mutex_lock(&ar->conf_mutex); 6471 6472 nss = max_t(u32, 1, nss); 6473 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask), 6474 ath10k_mac_max_vht_nss(vht_mcs_mask))); 6475 6476 if (changed & IEEE80211_RC_BW_CHANGED) { 6477 enum wmi_phy_mode mode; 6478 6479 mode = chan_to_phymode(&def); 6480 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d phymode %d\n", 6481 sta->addr, bw, mode); 6482 6483 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6484 ar->wmi.peer_param->phymode, mode); 6485 if (err) { 6486 ath10k_warn(ar, "failed to update STA %pM peer phymode %d: %d\n", 6487 sta->addr, mode, err); 6488 goto exit; 6489 } 6490 6491 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6492 ar->wmi.peer_param->chan_width, bw); 6493 if (err) 6494 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n", 6495 sta->addr, bw, err); 6496 } 6497 6498 if (changed & IEEE80211_RC_NSS_CHANGED) { 6499 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n", 6500 sta->addr, nss); 6501 6502 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6503 ar->wmi.peer_param->nss, nss); 6504 if (err) 6505 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n", 6506 sta->addr, nss, err); 6507 } 6508 6509 if (changed & IEEE80211_RC_SMPS_CHANGED) { 6510 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n", 6511 sta->addr, smps); 6512 6513 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6514 ar->wmi.peer_param->smps_state, smps); 6515 if (err) 6516 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n", 6517 sta->addr, smps, err); 6518 } 6519 6520 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) { 6521 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates\n", 6522 sta->addr); 6523 6524 err = ath10k_station_assoc(ar, arvif->vif, sta, true); 6525 if (err) 6526 ath10k_warn(ar, "failed to reassociate station: %pM\n", 6527 sta->addr); 6528 } 6529 6530 exit: 6531 mutex_unlock(&ar->conf_mutex); 6532 } 6533 6534 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif, 6535 struct ieee80211_sta *sta) 6536 { 6537 struct ath10k *ar = arvif->ar; 6538 6539 lockdep_assert_held(&ar->conf_mutex); 6540 6541 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 6542 return 0; 6543 6544 if (ar->num_stations >= ar->max_num_stations) 6545 return -ENOBUFS; 6546 6547 ar->num_stations++; 6548 6549 return 0; 6550 } 6551 6552 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif, 6553 struct ieee80211_sta *sta) 6554 { 6555 struct ath10k *ar = arvif->ar; 6556 6557 lockdep_assert_held(&ar->conf_mutex); 6558 6559 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 6560 return; 6561 6562 ar->num_stations--; 6563 } 6564 6565 static int ath10k_sta_set_txpwr(struct ieee80211_hw *hw, 6566 struct ieee80211_vif *vif, 6567 struct ieee80211_sta *sta) 6568 { 6569 struct ath10k *ar = hw->priv; 6570 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6571 int ret = 0; 6572 s16 txpwr; 6573 6574 if (sta->txpwr.type == NL80211_TX_POWER_AUTOMATIC) { 6575 txpwr = 0; 6576 } else { 6577 txpwr = sta->txpwr.power; 6578 if (!txpwr) 6579 return -EINVAL; 6580 } 6581 6582 if (txpwr > ATH10K_TX_POWER_MAX_VAL || txpwr < ATH10K_TX_POWER_MIN_VAL) 6583 return -EINVAL; 6584 6585 mutex_lock(&ar->conf_mutex); 6586 6587 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 6588 ar->wmi.peer_param->use_fixed_power, txpwr); 6589 if (ret) { 6590 ath10k_warn(ar, "failed to set tx power for station ret: %d\n", 6591 ret); 6592 goto out; 6593 } 6594 6595 out: 6596 mutex_unlock(&ar->conf_mutex); 6597 return ret; 6598 } 6599 6600 static int ath10k_sta_state(struct ieee80211_hw *hw, 6601 struct ieee80211_vif *vif, 6602 struct ieee80211_sta *sta, 6603 enum ieee80211_sta_state old_state, 6604 enum ieee80211_sta_state new_state) 6605 { 6606 struct ath10k *ar = hw->priv; 6607 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6608 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 6609 struct ath10k_peer *peer; 6610 int ret = 0; 6611 int i; 6612 6613 if (old_state == IEEE80211_STA_NOTEXIST && 6614 new_state == IEEE80211_STA_NONE) { 6615 memset(arsta, 0, sizeof(*arsta)); 6616 arsta->arvif = arvif; 6617 arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED; 6618 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk); 6619 6620 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) 6621 ath10k_mac_txq_init(sta->txq[i]); 6622 } 6623 6624 /* cancel must be done outside the mutex to avoid deadlock */ 6625 if ((old_state == IEEE80211_STA_NONE && 6626 new_state == IEEE80211_STA_NOTEXIST)) 6627 cancel_work_sync(&arsta->update_wk); 6628 6629 mutex_lock(&ar->conf_mutex); 6630 6631 if (old_state == IEEE80211_STA_NOTEXIST && 6632 new_state == IEEE80211_STA_NONE) { 6633 /* 6634 * New station addition. 6635 */ 6636 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT; 6637 u32 num_tdls_stations; 6638 6639 ath10k_dbg(ar, ATH10K_DBG_MAC, 6640 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n", 6641 arvif->vdev_id, sta->addr, 6642 ar->num_stations + 1, ar->max_num_stations, 6643 ar->num_peers + 1, ar->max_num_peers); 6644 6645 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif); 6646 6647 if (sta->tdls) { 6648 if (num_tdls_stations >= ar->max_num_tdls_vdevs) { 6649 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n", 6650 arvif->vdev_id, 6651 ar->max_num_tdls_vdevs); 6652 ret = -ELNRNG; 6653 goto exit; 6654 } 6655 peer_type = WMI_PEER_TYPE_TDLS; 6656 } 6657 6658 ret = ath10k_mac_inc_num_stations(arvif, sta); 6659 if (ret) { 6660 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n", 6661 ar->max_num_stations); 6662 goto exit; 6663 } 6664 6665 if (ath10k_debug_is_extd_tx_stats_enabled(ar)) { 6666 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), 6667 GFP_KERNEL); 6668 if (!arsta->tx_stats) { 6669 ath10k_mac_dec_num_stations(arvif, sta); 6670 ret = -ENOMEM; 6671 goto exit; 6672 } 6673 } 6674 6675 ret = ath10k_peer_create(ar, vif, sta, arvif->vdev_id, 6676 sta->addr, peer_type); 6677 if (ret) { 6678 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n", 6679 sta->addr, arvif->vdev_id, ret); 6680 ath10k_mac_dec_num_stations(arvif, sta); 6681 kfree(arsta->tx_stats); 6682 goto exit; 6683 } 6684 6685 spin_lock_bh(&ar->data_lock); 6686 6687 peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr); 6688 if (!peer) { 6689 ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n", 6690 vif->addr, arvif->vdev_id); 6691 spin_unlock_bh(&ar->data_lock); 6692 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 6693 ath10k_mac_dec_num_stations(arvif, sta); 6694 kfree(arsta->tx_stats); 6695 ret = -ENOENT; 6696 goto exit; 6697 } 6698 6699 arsta->peer_id = find_first_bit(peer->peer_ids, 6700 ATH10K_MAX_NUM_PEER_IDS); 6701 6702 spin_unlock_bh(&ar->data_lock); 6703 6704 if (!sta->tdls) 6705 goto exit; 6706 6707 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id, 6708 WMI_TDLS_ENABLE_ACTIVE); 6709 if (ret) { 6710 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n", 6711 arvif->vdev_id, ret); 6712 ath10k_peer_delete(ar, arvif->vdev_id, 6713 sta->addr); 6714 ath10k_mac_dec_num_stations(arvif, sta); 6715 kfree(arsta->tx_stats); 6716 goto exit; 6717 } 6718 6719 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta, 6720 WMI_TDLS_PEER_STATE_PEERING); 6721 if (ret) { 6722 ath10k_warn(ar, 6723 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n", 6724 sta->addr, arvif->vdev_id, ret); 6725 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 6726 ath10k_mac_dec_num_stations(arvif, sta); 6727 kfree(arsta->tx_stats); 6728 6729 if (num_tdls_stations != 0) 6730 goto exit; 6731 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id, 6732 WMI_TDLS_DISABLE); 6733 } 6734 } else if ((old_state == IEEE80211_STA_NONE && 6735 new_state == IEEE80211_STA_NOTEXIST)) { 6736 /* 6737 * Existing station deletion. 6738 */ 6739 ath10k_dbg(ar, ATH10K_DBG_MAC, 6740 "mac vdev %d peer delete %pM sta %pK (sta gone)\n", 6741 arvif->vdev_id, sta->addr, sta); 6742 6743 if (sta->tdls) { 6744 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, 6745 sta, 6746 WMI_TDLS_PEER_STATE_TEARDOWN); 6747 if (ret) 6748 ath10k_warn(ar, "failed to update tdls peer state for %pM state %d: %i\n", 6749 sta->addr, 6750 WMI_TDLS_PEER_STATE_TEARDOWN, ret); 6751 } 6752 6753 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 6754 if (ret) 6755 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n", 6756 sta->addr, arvif->vdev_id, ret); 6757 6758 ath10k_mac_dec_num_stations(arvif, sta); 6759 6760 spin_lock_bh(&ar->data_lock); 6761 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) { 6762 peer = ar->peer_map[i]; 6763 if (!peer) 6764 continue; 6765 6766 if (peer->sta == sta) { 6767 ath10k_warn(ar, "found sta peer %pM (ptr %pK id %d) entry on vdev %i after it was supposedly removed\n", 6768 sta->addr, peer, i, arvif->vdev_id); 6769 peer->sta = NULL; 6770 6771 /* Clean up the peer object as well since we 6772 * must have failed to do this above. 6773 */ 6774 list_del(&peer->list); 6775 ar->peer_map[i] = NULL; 6776 kfree(peer); 6777 ar->num_peers--; 6778 } 6779 } 6780 spin_unlock_bh(&ar->data_lock); 6781 6782 if (ath10k_debug_is_extd_tx_stats_enabled(ar)) { 6783 kfree(arsta->tx_stats); 6784 arsta->tx_stats = NULL; 6785 } 6786 6787 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) 6788 ath10k_mac_txq_unref(ar, sta->txq[i]); 6789 6790 if (!sta->tdls) 6791 goto exit; 6792 6793 if (ath10k_mac_tdls_vif_stations_count(hw, vif)) 6794 goto exit; 6795 6796 /* This was the last tdls peer in current vif */ 6797 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id, 6798 WMI_TDLS_DISABLE); 6799 if (ret) { 6800 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n", 6801 arvif->vdev_id, ret); 6802 } 6803 } else if (old_state == IEEE80211_STA_AUTH && 6804 new_state == IEEE80211_STA_ASSOC && 6805 (vif->type == NL80211_IFTYPE_AP || 6806 vif->type == NL80211_IFTYPE_MESH_POINT || 6807 vif->type == NL80211_IFTYPE_ADHOC)) { 6808 /* 6809 * New association. 6810 */ 6811 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n", 6812 sta->addr); 6813 6814 ret = ath10k_station_assoc(ar, vif, sta, false); 6815 if (ret) 6816 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n", 6817 sta->addr, arvif->vdev_id, ret); 6818 } else if (old_state == IEEE80211_STA_ASSOC && 6819 new_state == IEEE80211_STA_AUTHORIZED && 6820 sta->tdls) { 6821 /* 6822 * Tdls station authorized. 6823 */ 6824 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n", 6825 sta->addr); 6826 6827 ret = ath10k_station_assoc(ar, vif, sta, false); 6828 if (ret) { 6829 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n", 6830 sta->addr, arvif->vdev_id, ret); 6831 goto exit; 6832 } 6833 6834 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta, 6835 WMI_TDLS_PEER_STATE_CONNECTED); 6836 if (ret) 6837 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n", 6838 sta->addr, arvif->vdev_id, ret); 6839 } else if (old_state == IEEE80211_STA_ASSOC && 6840 new_state == IEEE80211_STA_AUTH && 6841 (vif->type == NL80211_IFTYPE_AP || 6842 vif->type == NL80211_IFTYPE_MESH_POINT || 6843 vif->type == NL80211_IFTYPE_ADHOC)) { 6844 /* 6845 * Disassociation. 6846 */ 6847 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n", 6848 sta->addr); 6849 6850 ret = ath10k_station_disassoc(ar, vif, sta); 6851 if (ret) 6852 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n", 6853 sta->addr, arvif->vdev_id, ret); 6854 } 6855 exit: 6856 mutex_unlock(&ar->conf_mutex); 6857 return ret; 6858 } 6859 6860 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif, 6861 u16 ac, bool enable) 6862 { 6863 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6864 struct wmi_sta_uapsd_auto_trig_arg arg = {}; 6865 u32 prio = 0, acc = 0; 6866 u32 value = 0; 6867 int ret = 0; 6868 6869 lockdep_assert_held(&ar->conf_mutex); 6870 6871 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 6872 return 0; 6873 6874 switch (ac) { 6875 case IEEE80211_AC_VO: 6876 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 6877 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 6878 prio = 7; 6879 acc = 3; 6880 break; 6881 case IEEE80211_AC_VI: 6882 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 6883 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 6884 prio = 5; 6885 acc = 2; 6886 break; 6887 case IEEE80211_AC_BE: 6888 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 6889 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 6890 prio = 2; 6891 acc = 1; 6892 break; 6893 case IEEE80211_AC_BK: 6894 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 6895 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 6896 prio = 0; 6897 acc = 0; 6898 break; 6899 } 6900 6901 if (enable) 6902 arvif->u.sta.uapsd |= value; 6903 else 6904 arvif->u.sta.uapsd &= ~value; 6905 6906 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6907 WMI_STA_PS_PARAM_UAPSD, 6908 arvif->u.sta.uapsd); 6909 if (ret) { 6910 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret); 6911 goto exit; 6912 } 6913 6914 if (arvif->u.sta.uapsd) 6915 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 6916 else 6917 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 6918 6919 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6920 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 6921 value); 6922 if (ret) 6923 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret); 6924 6925 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif); 6926 if (ret) { 6927 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n", 6928 arvif->vdev_id, ret); 6929 return ret; 6930 } 6931 6932 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif); 6933 if (ret) { 6934 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n", 6935 arvif->vdev_id, ret); 6936 return ret; 6937 } 6938 6939 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) || 6940 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) { 6941 /* Only userspace can make an educated decision when to send 6942 * trigger frame. The following effectively disables u-UAPSD 6943 * autotrigger in firmware (which is enabled by default 6944 * provided the autotrigger service is available). 6945 */ 6946 6947 arg.wmm_ac = acc; 6948 arg.user_priority = prio; 6949 arg.service_interval = 0; 6950 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC; 6951 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC; 6952 6953 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id, 6954 arvif->bssid, &arg, 1); 6955 if (ret) { 6956 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n", 6957 ret); 6958 return ret; 6959 } 6960 } 6961 6962 exit: 6963 return ret; 6964 } 6965 6966 static int ath10k_conf_tx(struct ieee80211_hw *hw, 6967 struct ieee80211_vif *vif, u16 ac, 6968 const struct ieee80211_tx_queue_params *params) 6969 { 6970 struct ath10k *ar = hw->priv; 6971 struct ath10k_vif *arvif = (void *)vif->drv_priv; 6972 struct wmi_wmm_params_arg *p = NULL; 6973 int ret; 6974 6975 mutex_lock(&ar->conf_mutex); 6976 6977 switch (ac) { 6978 case IEEE80211_AC_VO: 6979 p = &arvif->wmm_params.ac_vo; 6980 break; 6981 case IEEE80211_AC_VI: 6982 p = &arvif->wmm_params.ac_vi; 6983 break; 6984 case IEEE80211_AC_BE: 6985 p = &arvif->wmm_params.ac_be; 6986 break; 6987 case IEEE80211_AC_BK: 6988 p = &arvif->wmm_params.ac_bk; 6989 break; 6990 } 6991 6992 if (WARN_ON(!p)) { 6993 ret = -EINVAL; 6994 goto exit; 6995 } 6996 6997 p->cwmin = params->cw_min; 6998 p->cwmax = params->cw_max; 6999 p->aifs = params->aifs; 7000 7001 /* 7002 * The channel time duration programmed in the HW is in absolute 7003 * microseconds, while mac80211 gives the txop in units of 7004 * 32 microseconds. 7005 */ 7006 p->txop = params->txop * 32; 7007 7008 if (ar->wmi.ops->gen_vdev_wmm_conf) { 7009 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id, 7010 &arvif->wmm_params); 7011 if (ret) { 7012 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n", 7013 arvif->vdev_id, ret); 7014 goto exit; 7015 } 7016 } else { 7017 /* This won't work well with multi-interface cases but it's 7018 * better than nothing. 7019 */ 7020 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params); 7021 if (ret) { 7022 ath10k_warn(ar, "failed to set wmm params: %d\n", ret); 7023 goto exit; 7024 } 7025 } 7026 7027 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 7028 if (ret) 7029 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret); 7030 7031 exit: 7032 mutex_unlock(&ar->conf_mutex); 7033 return ret; 7034 } 7035 7036 #define ATH10K_ROC_TIMEOUT_HZ (2 * HZ) 7037 7038 static int ath10k_remain_on_channel(struct ieee80211_hw *hw, 7039 struct ieee80211_vif *vif, 7040 struct ieee80211_channel *chan, 7041 int duration, 7042 enum ieee80211_roc_type type) 7043 { 7044 struct ath10k *ar = hw->priv; 7045 struct ath10k_vif *arvif = (void *)vif->drv_priv; 7046 struct wmi_start_scan_arg arg; 7047 int ret = 0; 7048 u32 scan_time_msec; 7049 7050 mutex_lock(&ar->conf_mutex); 7051 7052 if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) { 7053 ret = -EBUSY; 7054 goto exit; 7055 } 7056 7057 spin_lock_bh(&ar->data_lock); 7058 switch (ar->scan.state) { 7059 case ATH10K_SCAN_IDLE: 7060 reinit_completion(&ar->scan.started); 7061 reinit_completion(&ar->scan.completed); 7062 reinit_completion(&ar->scan.on_channel); 7063 ar->scan.state = ATH10K_SCAN_STARTING; 7064 ar->scan.is_roc = true; 7065 ar->scan.vdev_id = arvif->vdev_id; 7066 ar->scan.roc_freq = chan->center_freq; 7067 ar->scan.roc_notify = true; 7068 ret = 0; 7069 break; 7070 case ATH10K_SCAN_STARTING: 7071 case ATH10K_SCAN_RUNNING: 7072 case ATH10K_SCAN_ABORTING: 7073 ret = -EBUSY; 7074 break; 7075 } 7076 spin_unlock_bh(&ar->data_lock); 7077 7078 if (ret) 7079 goto exit; 7080 7081 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2; 7082 7083 memset(&arg, 0, sizeof(arg)); 7084 ath10k_wmi_start_scan_init(ar, &arg); 7085 arg.vdev_id = arvif->vdev_id; 7086 arg.scan_id = ATH10K_SCAN_ID; 7087 arg.n_channels = 1; 7088 arg.channels[0] = chan->center_freq; 7089 arg.dwell_time_active = scan_time_msec; 7090 arg.dwell_time_passive = scan_time_msec; 7091 arg.max_scan_time = scan_time_msec; 7092 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 7093 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ; 7094 arg.burst_duration_ms = duration; 7095 7096 ret = ath10k_start_scan(ar, &arg); 7097 if (ret) { 7098 ath10k_warn(ar, "failed to start roc scan: %d\n", ret); 7099 spin_lock_bh(&ar->data_lock); 7100 ar->scan.state = ATH10K_SCAN_IDLE; 7101 spin_unlock_bh(&ar->data_lock); 7102 goto exit; 7103 } 7104 7105 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ); 7106 if (ret == 0) { 7107 ath10k_warn(ar, "failed to switch to channel for roc scan\n"); 7108 7109 ret = ath10k_scan_stop(ar); 7110 if (ret) 7111 ath10k_warn(ar, "failed to stop scan: %d\n", ret); 7112 7113 ret = -ETIMEDOUT; 7114 goto exit; 7115 } 7116 7117 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 7118 msecs_to_jiffies(duration)); 7119 7120 ret = 0; 7121 exit: 7122 mutex_unlock(&ar->conf_mutex); 7123 return ret; 7124 } 7125 7126 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw, 7127 struct ieee80211_vif *vif) 7128 { 7129 struct ath10k *ar = hw->priv; 7130 7131 mutex_lock(&ar->conf_mutex); 7132 7133 spin_lock_bh(&ar->data_lock); 7134 ar->scan.roc_notify = false; 7135 spin_unlock_bh(&ar->data_lock); 7136 7137 ath10k_scan_abort(ar); 7138 7139 mutex_unlock(&ar->conf_mutex); 7140 7141 cancel_delayed_work_sync(&ar->scan.timeout); 7142 7143 return 0; 7144 } 7145 7146 /* 7147 * Both RTS and Fragmentation threshold are interface-specific 7148 * in ath10k, but device-specific in mac80211. 7149 */ 7150 7151 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 7152 { 7153 struct ath10k *ar = hw->priv; 7154 struct ath10k_vif *arvif; 7155 int ret = 0; 7156 7157 mutex_lock(&ar->conf_mutex); 7158 list_for_each_entry(arvif, &ar->arvifs, list) { 7159 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n", 7160 arvif->vdev_id, value); 7161 7162 ret = ath10k_mac_set_rts(arvif, value); 7163 if (ret) { 7164 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n", 7165 arvif->vdev_id, ret); 7166 break; 7167 } 7168 } 7169 mutex_unlock(&ar->conf_mutex); 7170 7171 return ret; 7172 } 7173 7174 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 7175 { 7176 /* Even though there's a WMI enum for fragmentation threshold no known 7177 * firmware actually implements it. Moreover it is not possible to rely 7178 * frame fragmentation to mac80211 because firmware clears the "more 7179 * fragments" bit in frame control making it impossible for remote 7180 * devices to reassemble frames. 7181 * 7182 * Hence implement a dummy callback just to say fragmentation isn't 7183 * supported. This effectively prevents mac80211 from doing frame 7184 * fragmentation in software. 7185 */ 7186 return -EOPNOTSUPP; 7187 } 7188 7189 void ath10k_mac_wait_tx_complete(struct ath10k *ar) 7190 { 7191 bool skip; 7192 long time_left; 7193 7194 /* mac80211 doesn't care if we really xmit queued frames or not 7195 * we'll collect those frames either way if we stop/delete vdevs 7196 */ 7197 7198 if (ar->state == ATH10K_STATE_WEDGED) 7199 return; 7200 7201 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({ 7202 bool empty; 7203 7204 spin_lock_bh(&ar->htt.tx_lock); 7205 empty = (ar->htt.num_pending_tx == 0); 7206 spin_unlock_bh(&ar->htt.tx_lock); 7207 7208 skip = (ar->state == ATH10K_STATE_WEDGED) || 7209 test_bit(ATH10K_FLAG_CRASH_FLUSH, 7210 &ar->dev_flags); 7211 7212 (empty || skip); 7213 }), ATH10K_FLUSH_TIMEOUT_HZ); 7214 7215 if (time_left == 0 || skip) 7216 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n", 7217 skip, ar->state, time_left); 7218 } 7219 7220 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 7221 u32 queues, bool drop) 7222 { 7223 struct ath10k *ar = hw->priv; 7224 struct ath10k_vif *arvif; 7225 u32 bitmap; 7226 7227 if (drop) { 7228 if (vif && vif->type == NL80211_IFTYPE_STATION) { 7229 bitmap = ~(1 << WMI_MGMT_TID); 7230 list_for_each_entry(arvif, &ar->arvifs, list) { 7231 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 7232 ath10k_wmi_peer_flush(ar, arvif->vdev_id, 7233 arvif->bssid, bitmap); 7234 } 7235 ath10k_htt_flush_tx(&ar->htt); 7236 } 7237 return; 7238 } 7239 7240 mutex_lock(&ar->conf_mutex); 7241 ath10k_mac_wait_tx_complete(ar); 7242 mutex_unlock(&ar->conf_mutex); 7243 } 7244 7245 /* TODO: Implement this function properly 7246 * For now it is needed to reply to Probe Requests in IBSS mode. 7247 * Propably we need this information from FW. 7248 */ 7249 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw) 7250 { 7251 return 1; 7252 } 7253 7254 static void ath10k_reconfig_complete(struct ieee80211_hw *hw, 7255 enum ieee80211_reconfig_type reconfig_type) 7256 { 7257 struct ath10k *ar = hw->priv; 7258 7259 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) 7260 return; 7261 7262 mutex_lock(&ar->conf_mutex); 7263 7264 /* If device failed to restart it will be in a different state, e.g. 7265 * ATH10K_STATE_WEDGED 7266 */ 7267 if (ar->state == ATH10K_STATE_RESTARTED) { 7268 ath10k_info(ar, "device successfully recovered\n"); 7269 ar->state = ATH10K_STATE_ON; 7270 ieee80211_wake_queues(ar->hw); 7271 } 7272 7273 mutex_unlock(&ar->conf_mutex); 7274 } 7275 7276 static void 7277 ath10k_mac_update_bss_chan_survey(struct ath10k *ar, 7278 struct ieee80211_channel *channel) 7279 { 7280 int ret; 7281 enum wmi_bss_survey_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ_CLEAR; 7282 7283 lockdep_assert_held(&ar->conf_mutex); 7284 7285 if (!test_bit(WMI_SERVICE_BSS_CHANNEL_INFO_64, ar->wmi.svc_map) || 7286 (ar->rx_channel != channel)) 7287 return; 7288 7289 if (ar->scan.state != ATH10K_SCAN_IDLE) { 7290 ath10k_dbg(ar, ATH10K_DBG_MAC, "ignoring bss chan info request while scanning..\n"); 7291 return; 7292 } 7293 7294 reinit_completion(&ar->bss_survey_done); 7295 7296 ret = ath10k_wmi_pdev_bss_chan_info_request(ar, type); 7297 if (ret) { 7298 ath10k_warn(ar, "failed to send pdev bss chan info request\n"); 7299 return; 7300 } 7301 7302 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ); 7303 if (!ret) { 7304 ath10k_warn(ar, "bss channel survey timed out\n"); 7305 return; 7306 } 7307 } 7308 7309 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx, 7310 struct survey_info *survey) 7311 { 7312 struct ath10k *ar = hw->priv; 7313 struct ieee80211_supported_band *sband; 7314 struct survey_info *ar_survey = &ar->survey[idx]; 7315 int ret = 0; 7316 7317 mutex_lock(&ar->conf_mutex); 7318 7319 sband = hw->wiphy->bands[NL80211_BAND_2GHZ]; 7320 if (sband && idx >= sband->n_channels) { 7321 idx -= sband->n_channels; 7322 sband = NULL; 7323 } 7324 7325 if (!sband) 7326 sband = hw->wiphy->bands[NL80211_BAND_5GHZ]; 7327 7328 if (!sband || idx >= sband->n_channels) { 7329 ret = -ENOENT; 7330 goto exit; 7331 } 7332 7333 ath10k_mac_update_bss_chan_survey(ar, &sband->channels[idx]); 7334 7335 spin_lock_bh(&ar->data_lock); 7336 memcpy(survey, ar_survey, sizeof(*survey)); 7337 spin_unlock_bh(&ar->data_lock); 7338 7339 survey->channel = &sband->channels[idx]; 7340 7341 if (ar->rx_channel == survey->channel) 7342 survey->filled |= SURVEY_INFO_IN_USE; 7343 7344 exit: 7345 mutex_unlock(&ar->conf_mutex); 7346 return ret; 7347 } 7348 7349 static bool 7350 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar, 7351 enum nl80211_band band, 7352 const struct cfg80211_bitrate_mask *mask, 7353 int *vht_num_rates) 7354 { 7355 int num_rates = 0; 7356 int i, tmp; 7357 7358 num_rates += hweight32(mask->control[band].legacy); 7359 7360 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) 7361 num_rates += hweight8(mask->control[band].ht_mcs[i]); 7362 7363 *vht_num_rates = 0; 7364 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 7365 tmp = hweight16(mask->control[band].vht_mcs[i]); 7366 num_rates += tmp; 7367 *vht_num_rates += tmp; 7368 } 7369 7370 return num_rates == 1; 7371 } 7372 7373 static bool 7374 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar, 7375 enum nl80211_band band, 7376 const struct cfg80211_bitrate_mask *mask, 7377 int *nss) 7378 { 7379 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 7380 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 7381 u8 ht_nss_mask = 0; 7382 u8 vht_nss_mask = 0; 7383 int i; 7384 7385 if (mask->control[band].legacy) 7386 return false; 7387 7388 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 7389 if (mask->control[band].ht_mcs[i] == 0) 7390 continue; 7391 else if (mask->control[band].ht_mcs[i] == 7392 sband->ht_cap.mcs.rx_mask[i]) 7393 ht_nss_mask |= BIT(i); 7394 else 7395 return false; 7396 } 7397 7398 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 7399 if (mask->control[band].vht_mcs[i] == 0) 7400 continue; 7401 else if (mask->control[band].vht_mcs[i] == 7402 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i)) 7403 vht_nss_mask |= BIT(i); 7404 else 7405 return false; 7406 } 7407 7408 if (ht_nss_mask != vht_nss_mask) 7409 return false; 7410 7411 if (ht_nss_mask == 0) 7412 return false; 7413 7414 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask) 7415 return false; 7416 7417 *nss = fls(ht_nss_mask); 7418 7419 return true; 7420 } 7421 7422 static int 7423 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar, 7424 enum nl80211_band band, 7425 const struct cfg80211_bitrate_mask *mask, 7426 u8 *rate, u8 *nss, bool vht_only) 7427 { 7428 int rate_idx; 7429 int i; 7430 u16 bitrate; 7431 u8 preamble; 7432 u8 hw_rate; 7433 7434 if (vht_only) 7435 goto next; 7436 7437 if (hweight32(mask->control[band].legacy) == 1) { 7438 rate_idx = ffs(mask->control[band].legacy) - 1; 7439 7440 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) 7441 rate_idx += ATH10K_MAC_FIRST_OFDM_RATE_IDX; 7442 7443 hw_rate = ath10k_wmi_legacy_rates[rate_idx].hw_value; 7444 bitrate = ath10k_wmi_legacy_rates[rate_idx].bitrate; 7445 7446 if (ath10k_mac_bitrate_is_cck(bitrate)) 7447 preamble = WMI_RATE_PREAMBLE_CCK; 7448 else 7449 preamble = WMI_RATE_PREAMBLE_OFDM; 7450 7451 *nss = 1; 7452 *rate = preamble << 6 | 7453 (*nss - 1) << 4 | 7454 hw_rate << 0; 7455 7456 return 0; 7457 } 7458 7459 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 7460 if (hweight8(mask->control[band].ht_mcs[i]) == 1) { 7461 *nss = i + 1; 7462 *rate = WMI_RATE_PREAMBLE_HT << 6 | 7463 (*nss - 1) << 4 | 7464 (ffs(mask->control[band].ht_mcs[i]) - 1); 7465 7466 return 0; 7467 } 7468 } 7469 7470 next: 7471 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 7472 if (hweight16(mask->control[band].vht_mcs[i]) == 1) { 7473 *nss = i + 1; 7474 *rate = WMI_RATE_PREAMBLE_VHT << 6 | 7475 (*nss - 1) << 4 | 7476 (ffs(mask->control[band].vht_mcs[i]) - 1); 7477 7478 return 0; 7479 } 7480 } 7481 7482 return -EINVAL; 7483 } 7484 7485 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif, 7486 u8 rate, u8 nss, u8 sgi, u8 ldpc) 7487 { 7488 struct ath10k *ar = arvif->ar; 7489 u32 vdev_param; 7490 int ret; 7491 7492 lockdep_assert_held(&ar->conf_mutex); 7493 7494 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n", 7495 arvif->vdev_id, rate, nss, sgi); 7496 7497 vdev_param = ar->wmi.vdev_param->fixed_rate; 7498 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate); 7499 if (ret) { 7500 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n", 7501 rate, ret); 7502 return ret; 7503 } 7504 7505 vdev_param = ar->wmi.vdev_param->nss; 7506 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss); 7507 if (ret) { 7508 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret); 7509 return ret; 7510 } 7511 7512 vdev_param = ar->wmi.vdev_param->sgi; 7513 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi); 7514 if (ret) { 7515 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret); 7516 return ret; 7517 } 7518 7519 vdev_param = ar->wmi.vdev_param->ldpc; 7520 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc); 7521 if (ret) { 7522 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret); 7523 return ret; 7524 } 7525 7526 return 0; 7527 } 7528 7529 static bool 7530 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar, 7531 enum nl80211_band band, 7532 const struct cfg80211_bitrate_mask *mask, 7533 bool allow_pfr) 7534 { 7535 int i; 7536 u16 vht_mcs; 7537 7538 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible 7539 * to express all VHT MCS rate masks. Effectively only the following 7540 * ranges can be used: none, 0-7, 0-8 and 0-9. 7541 */ 7542 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 7543 vht_mcs = mask->control[band].vht_mcs[i]; 7544 7545 switch (vht_mcs) { 7546 case 0: 7547 case BIT(8) - 1: 7548 case BIT(9) - 1: 7549 case BIT(10) - 1: 7550 break; 7551 default: 7552 if (!allow_pfr) 7553 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n"); 7554 return false; 7555 } 7556 } 7557 7558 return true; 7559 } 7560 7561 static bool ath10k_mac_set_vht_bitrate_mask_fixup(struct ath10k *ar, 7562 struct ath10k_vif *arvif, 7563 struct ieee80211_sta *sta) 7564 { 7565 int err; 7566 u8 rate = arvif->vht_pfr; 7567 7568 /* skip non vht and multiple rate peers */ 7569 if (!sta->vht_cap.vht_supported || arvif->vht_num_rates != 1) 7570 return false; 7571 7572 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 7573 WMI_PEER_PARAM_FIXED_RATE, rate); 7574 if (err) 7575 ath10k_warn(ar, "failed to enable STA %pM peer fixed rate: %d\n", 7576 sta->addr, err); 7577 7578 return true; 7579 } 7580 7581 static void ath10k_mac_set_bitrate_mask_iter(void *data, 7582 struct ieee80211_sta *sta) 7583 { 7584 struct ath10k_vif *arvif = data; 7585 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 7586 struct ath10k *ar = arvif->ar; 7587 7588 if (arsta->arvif != arvif) 7589 return; 7590 7591 if (ath10k_mac_set_vht_bitrate_mask_fixup(ar, arvif, sta)) 7592 return; 7593 7594 spin_lock_bh(&ar->data_lock); 7595 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED; 7596 spin_unlock_bh(&ar->data_lock); 7597 7598 ieee80211_queue_work(ar->hw, &arsta->update_wk); 7599 } 7600 7601 static void ath10k_mac_clr_bitrate_mask_iter(void *data, 7602 struct ieee80211_sta *sta) 7603 { 7604 struct ath10k_vif *arvif = data; 7605 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 7606 struct ath10k *ar = arvif->ar; 7607 int err; 7608 7609 /* clear vht peers only */ 7610 if (arsta->arvif != arvif || !sta->vht_cap.vht_supported) 7611 return; 7612 7613 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 7614 WMI_PEER_PARAM_FIXED_RATE, 7615 WMI_FIXED_RATE_NONE); 7616 if (err) 7617 ath10k_warn(ar, "failed to clear STA %pM peer fixed rate: %d\n", 7618 sta->addr, err); 7619 } 7620 7621 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw, 7622 struct ieee80211_vif *vif, 7623 const struct cfg80211_bitrate_mask *mask) 7624 { 7625 struct ath10k_vif *arvif = (void *)vif->drv_priv; 7626 struct cfg80211_chan_def def; 7627 struct ath10k *ar = arvif->ar; 7628 enum nl80211_band band; 7629 const u8 *ht_mcs_mask; 7630 const u16 *vht_mcs_mask; 7631 u8 rate; 7632 u8 nss; 7633 u8 sgi; 7634 u8 ldpc; 7635 int single_nss; 7636 int ret; 7637 int vht_num_rates, allow_pfr; 7638 u8 vht_pfr; 7639 bool update_bitrate_mask = true; 7640 7641 if (ath10k_mac_vif_chan(vif, &def)) 7642 return -EPERM; 7643 7644 band = def.chan->band; 7645 ht_mcs_mask = mask->control[band].ht_mcs; 7646 vht_mcs_mask = mask->control[band].vht_mcs; 7647 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC); 7648 7649 sgi = mask->control[band].gi; 7650 if (sgi == NL80211_TXRATE_FORCE_LGI) 7651 return -EINVAL; 7652 7653 allow_pfr = test_bit(ATH10K_FW_FEATURE_PEER_FIXED_RATE, 7654 ar->normal_mode_fw.fw_file.fw_features); 7655 if (allow_pfr) { 7656 mutex_lock(&ar->conf_mutex); 7657 ieee80211_iterate_stations_atomic(ar->hw, 7658 ath10k_mac_clr_bitrate_mask_iter, 7659 arvif); 7660 mutex_unlock(&ar->conf_mutex); 7661 } 7662 7663 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask, 7664 &vht_num_rates)) { 7665 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask, 7666 &rate, &nss, 7667 false); 7668 if (ret) { 7669 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n", 7670 arvif->vdev_id, ret); 7671 return ret; 7672 } 7673 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask, 7674 &single_nss)) { 7675 rate = WMI_FIXED_RATE_NONE; 7676 nss = single_nss; 7677 } else { 7678 rate = WMI_FIXED_RATE_NONE; 7679 nss = min(ar->num_rf_chains, 7680 max(ath10k_mac_max_ht_nss(ht_mcs_mask), 7681 ath10k_mac_max_vht_nss(vht_mcs_mask))); 7682 7683 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask, 7684 allow_pfr)) { 7685 u8 vht_nss; 7686 7687 if (!allow_pfr || vht_num_rates != 1) 7688 return -EINVAL; 7689 7690 /* Reach here, firmware supports peer fixed rate and has 7691 * single vht rate, and don't update vif birate_mask, as 7692 * the rate only for specific peer. 7693 */ 7694 ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask, 7695 &vht_pfr, 7696 &vht_nss, 7697 true); 7698 update_bitrate_mask = false; 7699 } else { 7700 vht_pfr = 0; 7701 } 7702 7703 mutex_lock(&ar->conf_mutex); 7704 7705 if (update_bitrate_mask) 7706 arvif->bitrate_mask = *mask; 7707 arvif->vht_num_rates = vht_num_rates; 7708 arvif->vht_pfr = vht_pfr; 7709 ieee80211_iterate_stations_atomic(ar->hw, 7710 ath10k_mac_set_bitrate_mask_iter, 7711 arvif); 7712 7713 mutex_unlock(&ar->conf_mutex); 7714 } 7715 7716 mutex_lock(&ar->conf_mutex); 7717 7718 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc); 7719 if (ret) { 7720 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n", 7721 arvif->vdev_id, ret); 7722 goto exit; 7723 } 7724 7725 exit: 7726 mutex_unlock(&ar->conf_mutex); 7727 7728 return ret; 7729 } 7730 7731 static void ath10k_sta_rc_update(struct ieee80211_hw *hw, 7732 struct ieee80211_vif *vif, 7733 struct ieee80211_sta *sta, 7734 u32 changed) 7735 { 7736 struct ath10k *ar = hw->priv; 7737 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 7738 struct ath10k_vif *arvif = (void *)vif->drv_priv; 7739 struct ath10k_peer *peer; 7740 u32 bw, smps; 7741 7742 spin_lock_bh(&ar->data_lock); 7743 7744 peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr); 7745 if (!peer) { 7746 spin_unlock_bh(&ar->data_lock); 7747 ath10k_warn(ar, "mac sta rc update failed to find peer %pM on vdev %i\n", 7748 sta->addr, arvif->vdev_id); 7749 return; 7750 } 7751 7752 ath10k_dbg(ar, ATH10K_DBG_MAC, 7753 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 7754 sta->addr, changed, sta->bandwidth, sta->rx_nss, 7755 sta->smps_mode); 7756 7757 if (changed & IEEE80211_RC_BW_CHANGED) { 7758 bw = WMI_PEER_CHWIDTH_20MHZ; 7759 7760 switch (sta->bandwidth) { 7761 case IEEE80211_STA_RX_BW_20: 7762 bw = WMI_PEER_CHWIDTH_20MHZ; 7763 break; 7764 case IEEE80211_STA_RX_BW_40: 7765 bw = WMI_PEER_CHWIDTH_40MHZ; 7766 break; 7767 case IEEE80211_STA_RX_BW_80: 7768 bw = WMI_PEER_CHWIDTH_80MHZ; 7769 break; 7770 case IEEE80211_STA_RX_BW_160: 7771 bw = WMI_PEER_CHWIDTH_160MHZ; 7772 break; 7773 default: 7774 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n", 7775 sta->bandwidth, sta->addr); 7776 bw = WMI_PEER_CHWIDTH_20MHZ; 7777 break; 7778 } 7779 7780 arsta->bw = bw; 7781 } 7782 7783 if (changed & IEEE80211_RC_NSS_CHANGED) 7784 arsta->nss = sta->rx_nss; 7785 7786 if (changed & IEEE80211_RC_SMPS_CHANGED) { 7787 smps = WMI_PEER_SMPS_PS_NONE; 7788 7789 switch (sta->smps_mode) { 7790 case IEEE80211_SMPS_AUTOMATIC: 7791 case IEEE80211_SMPS_OFF: 7792 smps = WMI_PEER_SMPS_PS_NONE; 7793 break; 7794 case IEEE80211_SMPS_STATIC: 7795 smps = WMI_PEER_SMPS_STATIC; 7796 break; 7797 case IEEE80211_SMPS_DYNAMIC: 7798 smps = WMI_PEER_SMPS_DYNAMIC; 7799 break; 7800 case IEEE80211_SMPS_NUM_MODES: 7801 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n", 7802 sta->smps_mode, sta->addr); 7803 smps = WMI_PEER_SMPS_PS_NONE; 7804 break; 7805 } 7806 7807 arsta->smps = smps; 7808 } 7809 7810 arsta->changed |= changed; 7811 7812 spin_unlock_bh(&ar->data_lock); 7813 7814 ieee80211_queue_work(hw, &arsta->update_wk); 7815 } 7816 7817 static void ath10k_offset_tsf(struct ieee80211_hw *hw, 7818 struct ieee80211_vif *vif, s64 tsf_offset) 7819 { 7820 struct ath10k *ar = hw->priv; 7821 struct ath10k_vif *arvif = (void *)vif->drv_priv; 7822 u32 offset, vdev_param; 7823 int ret; 7824 7825 if (tsf_offset < 0) { 7826 vdev_param = ar->wmi.vdev_param->dec_tsf; 7827 offset = -tsf_offset; 7828 } else { 7829 vdev_param = ar->wmi.vdev_param->inc_tsf; 7830 offset = tsf_offset; 7831 } 7832 7833 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 7834 vdev_param, offset); 7835 7836 if (ret && ret != -EOPNOTSUPP) 7837 ath10k_warn(ar, "failed to set tsf offset %d cmd %d: %d\n", 7838 offset, vdev_param, ret); 7839 } 7840 7841 static int ath10k_ampdu_action(struct ieee80211_hw *hw, 7842 struct ieee80211_vif *vif, 7843 struct ieee80211_ampdu_params *params) 7844 { 7845 struct ath10k *ar = hw->priv; 7846 struct ath10k_vif *arvif = (void *)vif->drv_priv; 7847 struct ieee80211_sta *sta = params->sta; 7848 enum ieee80211_ampdu_mlme_action action = params->action; 7849 u16 tid = params->tid; 7850 7851 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n", 7852 arvif->vdev_id, sta->addr, tid, action); 7853 7854 switch (action) { 7855 case IEEE80211_AMPDU_RX_START: 7856 case IEEE80211_AMPDU_RX_STOP: 7857 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session 7858 * creation/removal. Do we need to verify this? 7859 */ 7860 return 0; 7861 case IEEE80211_AMPDU_TX_START: 7862 case IEEE80211_AMPDU_TX_STOP_CONT: 7863 case IEEE80211_AMPDU_TX_STOP_FLUSH: 7864 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 7865 case IEEE80211_AMPDU_TX_OPERATIONAL: 7866 /* Firmware offloads Tx aggregation entirely so deny mac80211 7867 * Tx aggregation requests. 7868 */ 7869 return -EOPNOTSUPP; 7870 } 7871 7872 return -EINVAL; 7873 } 7874 7875 static void 7876 ath10k_mac_update_rx_channel(struct ath10k *ar, 7877 struct ieee80211_chanctx_conf *ctx, 7878 struct ieee80211_vif_chanctx_switch *vifs, 7879 int n_vifs) 7880 { 7881 struct cfg80211_chan_def *def = NULL; 7882 7883 /* Both locks are required because ar->rx_channel is modified. This 7884 * allows readers to hold either lock. 7885 */ 7886 lockdep_assert_held(&ar->conf_mutex); 7887 lockdep_assert_held(&ar->data_lock); 7888 7889 WARN_ON(ctx && vifs); 7890 WARN_ON(vifs && !n_vifs); 7891 7892 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are 7893 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each 7894 * ppdu on Rx may reduce performance on low-end systems. It should be 7895 * possible to make tables/hashmaps to speed the lookup up (be vary of 7896 * cpu data cache lines though regarding sizes) but to keep the initial 7897 * implementation simple and less intrusive fallback to the slow lookup 7898 * only for multi-channel cases. Single-channel cases will remain to 7899 * use the old channel derival and thus performance should not be 7900 * affected much. 7901 */ 7902 rcu_read_lock(); 7903 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) { 7904 ieee80211_iter_chan_contexts_atomic(ar->hw, 7905 ath10k_mac_get_any_chandef_iter, 7906 &def); 7907 7908 if (vifs) 7909 def = &vifs[0].new_ctx->def; 7910 7911 ar->rx_channel = def->chan; 7912 } else if ((ctx && ath10k_mac_num_chanctxs(ar) == 0) || 7913 (ctx && (ar->state == ATH10K_STATE_RESTARTED))) { 7914 /* During driver restart due to firmware assert, since mac80211 7915 * already has valid channel context for given radio, channel 7916 * context iteration return num_chanctx > 0. So fix rx_channel 7917 * when restart is in progress. 7918 */ 7919 ar->rx_channel = ctx->def.chan; 7920 } else { 7921 ar->rx_channel = NULL; 7922 } 7923 rcu_read_unlock(); 7924 } 7925 7926 static void 7927 ath10k_mac_update_vif_chan(struct ath10k *ar, 7928 struct ieee80211_vif_chanctx_switch *vifs, 7929 int n_vifs) 7930 { 7931 struct ath10k_vif *arvif; 7932 int ret; 7933 int i; 7934 7935 lockdep_assert_held(&ar->conf_mutex); 7936 7937 /* First stop monitor interface. Some FW versions crash if there's a 7938 * lone monitor interface. 7939 */ 7940 if (ar->monitor_started) 7941 ath10k_monitor_stop(ar); 7942 7943 for (i = 0; i < n_vifs; i++) { 7944 arvif = (void *)vifs[i].vif->drv_priv; 7945 7946 ath10k_dbg(ar, ATH10K_DBG_MAC, 7947 "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n", 7948 arvif->vdev_id, 7949 vifs[i].old_ctx->def.chan->center_freq, 7950 vifs[i].new_ctx->def.chan->center_freq, 7951 vifs[i].old_ctx->def.width, 7952 vifs[i].new_ctx->def.width); 7953 7954 if (WARN_ON(!arvif->is_started)) 7955 continue; 7956 7957 if (WARN_ON(!arvif->is_up)) 7958 continue; 7959 7960 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 7961 if (ret) { 7962 ath10k_warn(ar, "failed to down vdev %d: %d\n", 7963 arvif->vdev_id, ret); 7964 continue; 7965 } 7966 } 7967 7968 /* All relevant vdevs are downed and associated channel resources 7969 * should be available for the channel switch now. 7970 */ 7971 7972 spin_lock_bh(&ar->data_lock); 7973 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs); 7974 spin_unlock_bh(&ar->data_lock); 7975 7976 for (i = 0; i < n_vifs; i++) { 7977 arvif = (void *)vifs[i].vif->drv_priv; 7978 7979 if (WARN_ON(!arvif->is_started)) 7980 continue; 7981 7982 if (WARN_ON(!arvif->is_up)) 7983 continue; 7984 7985 ret = ath10k_mac_setup_bcn_tmpl(arvif); 7986 if (ret) 7987 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n", 7988 ret); 7989 7990 ret = ath10k_mac_setup_prb_tmpl(arvif); 7991 if (ret) 7992 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n", 7993 ret); 7994 7995 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def); 7996 if (ret) { 7997 ath10k_warn(ar, "failed to restart vdev %d: %d\n", 7998 arvif->vdev_id, ret); 7999 continue; 8000 } 8001 8002 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 8003 arvif->bssid); 8004 if (ret) { 8005 ath10k_warn(ar, "failed to bring vdev up %d: %d\n", 8006 arvif->vdev_id, ret); 8007 continue; 8008 } 8009 } 8010 8011 ath10k_monitor_recalc(ar); 8012 } 8013 8014 static int 8015 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw, 8016 struct ieee80211_chanctx_conf *ctx) 8017 { 8018 struct ath10k *ar = hw->priv; 8019 8020 ath10k_dbg(ar, ATH10K_DBG_MAC, 8021 "mac chanctx add freq %hu width %d ptr %pK\n", 8022 ctx->def.chan->center_freq, ctx->def.width, ctx); 8023 8024 mutex_lock(&ar->conf_mutex); 8025 8026 spin_lock_bh(&ar->data_lock); 8027 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0); 8028 spin_unlock_bh(&ar->data_lock); 8029 8030 ath10k_recalc_radar_detection(ar); 8031 ath10k_monitor_recalc(ar); 8032 8033 mutex_unlock(&ar->conf_mutex); 8034 8035 return 0; 8036 } 8037 8038 static void 8039 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw, 8040 struct ieee80211_chanctx_conf *ctx) 8041 { 8042 struct ath10k *ar = hw->priv; 8043 8044 ath10k_dbg(ar, ATH10K_DBG_MAC, 8045 "mac chanctx remove freq %hu width %d ptr %pK\n", 8046 ctx->def.chan->center_freq, ctx->def.width, ctx); 8047 8048 mutex_lock(&ar->conf_mutex); 8049 8050 spin_lock_bh(&ar->data_lock); 8051 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0); 8052 spin_unlock_bh(&ar->data_lock); 8053 8054 ath10k_recalc_radar_detection(ar); 8055 ath10k_monitor_recalc(ar); 8056 8057 mutex_unlock(&ar->conf_mutex); 8058 } 8059 8060 struct ath10k_mac_change_chanctx_arg { 8061 struct ieee80211_chanctx_conf *ctx; 8062 struct ieee80211_vif_chanctx_switch *vifs; 8063 int n_vifs; 8064 int next_vif; 8065 }; 8066 8067 static void 8068 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac, 8069 struct ieee80211_vif *vif) 8070 { 8071 struct ath10k_mac_change_chanctx_arg *arg = data; 8072 8073 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx) 8074 return; 8075 8076 arg->n_vifs++; 8077 } 8078 8079 static void 8080 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac, 8081 struct ieee80211_vif *vif) 8082 { 8083 struct ath10k_mac_change_chanctx_arg *arg = data; 8084 struct ieee80211_chanctx_conf *ctx; 8085 8086 ctx = rcu_access_pointer(vif->chanctx_conf); 8087 if (ctx != arg->ctx) 8088 return; 8089 8090 if (WARN_ON(arg->next_vif == arg->n_vifs)) 8091 return; 8092 8093 arg->vifs[arg->next_vif].vif = vif; 8094 arg->vifs[arg->next_vif].old_ctx = ctx; 8095 arg->vifs[arg->next_vif].new_ctx = ctx; 8096 arg->next_vif++; 8097 } 8098 8099 static void 8100 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw, 8101 struct ieee80211_chanctx_conf *ctx, 8102 u32 changed) 8103 { 8104 struct ath10k *ar = hw->priv; 8105 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx }; 8106 8107 mutex_lock(&ar->conf_mutex); 8108 8109 ath10k_dbg(ar, ATH10K_DBG_MAC, 8110 "mac chanctx change freq %hu width %d ptr %pK changed %x\n", 8111 ctx->def.chan->center_freq, ctx->def.width, ctx, changed); 8112 8113 /* This shouldn't really happen because channel switching should use 8114 * switch_vif_chanctx(). 8115 */ 8116 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL)) 8117 goto unlock; 8118 8119 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) { 8120 ieee80211_iterate_active_interfaces_atomic( 8121 hw, 8122 IEEE80211_IFACE_ITER_NORMAL, 8123 ath10k_mac_change_chanctx_cnt_iter, 8124 &arg); 8125 if (arg.n_vifs == 0) 8126 goto radar; 8127 8128 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), 8129 GFP_KERNEL); 8130 if (!arg.vifs) 8131 goto radar; 8132 8133 ieee80211_iterate_active_interfaces_atomic( 8134 hw, 8135 IEEE80211_IFACE_ITER_NORMAL, 8136 ath10k_mac_change_chanctx_fill_iter, 8137 &arg); 8138 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs); 8139 kfree(arg.vifs); 8140 } 8141 8142 radar: 8143 ath10k_recalc_radar_detection(ar); 8144 8145 /* FIXME: How to configure Rx chains properly? */ 8146 8147 /* No other actions are actually necessary. Firmware maintains channel 8148 * definitions per vdev internally and there's no host-side channel 8149 * context abstraction to configure, e.g. channel width. 8150 */ 8151 8152 unlock: 8153 mutex_unlock(&ar->conf_mutex); 8154 } 8155 8156 static int 8157 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw, 8158 struct ieee80211_vif *vif, 8159 struct ieee80211_chanctx_conf *ctx) 8160 { 8161 struct ath10k *ar = hw->priv; 8162 struct ath10k_vif *arvif = (void *)vif->drv_priv; 8163 int ret; 8164 8165 mutex_lock(&ar->conf_mutex); 8166 8167 ath10k_dbg(ar, ATH10K_DBG_MAC, 8168 "mac chanctx assign ptr %pK vdev_id %i\n", 8169 ctx, arvif->vdev_id); 8170 8171 if (WARN_ON(arvif->is_started)) { 8172 mutex_unlock(&ar->conf_mutex); 8173 return -EBUSY; 8174 } 8175 8176 ret = ath10k_vdev_start(arvif, &ctx->def); 8177 if (ret) { 8178 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n", 8179 arvif->vdev_id, vif->addr, 8180 ctx->def.chan->center_freq, ret); 8181 goto err; 8182 } 8183 8184 arvif->is_started = true; 8185 8186 ret = ath10k_mac_vif_setup_ps(arvif); 8187 if (ret) { 8188 ath10k_warn(ar, "failed to update vdev %i ps: %d\n", 8189 arvif->vdev_id, ret); 8190 goto err_stop; 8191 } 8192 8193 if (vif->type == NL80211_IFTYPE_MONITOR) { 8194 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr); 8195 if (ret) { 8196 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n", 8197 arvif->vdev_id, ret); 8198 goto err_stop; 8199 } 8200 8201 arvif->is_up = true; 8202 } 8203 8204 if (ath10k_mac_can_set_cts_prot(arvif)) { 8205 ret = ath10k_mac_set_cts_prot(arvif); 8206 if (ret) 8207 ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n", 8208 arvif->vdev_id, ret); 8209 } 8210 8211 if (ath10k_peer_stats_enabled(ar) && 8212 ar->hw_params.tx_stats_over_pktlog) { 8213 ar->pktlog_filter |= ATH10K_PKTLOG_PEER_STATS; 8214 ret = ath10k_wmi_pdev_pktlog_enable(ar, 8215 ar->pktlog_filter); 8216 if (ret) { 8217 ath10k_warn(ar, "failed to enable pktlog %d\n", ret); 8218 goto err_stop; 8219 } 8220 } 8221 8222 mutex_unlock(&ar->conf_mutex); 8223 return 0; 8224 8225 err_stop: 8226 ath10k_vdev_stop(arvif); 8227 arvif->is_started = false; 8228 ath10k_mac_vif_setup_ps(arvif); 8229 8230 err: 8231 mutex_unlock(&ar->conf_mutex); 8232 return ret; 8233 } 8234 8235 static void 8236 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 8237 struct ieee80211_vif *vif, 8238 struct ieee80211_chanctx_conf *ctx) 8239 { 8240 struct ath10k *ar = hw->priv; 8241 struct ath10k_vif *arvif = (void *)vif->drv_priv; 8242 int ret; 8243 8244 mutex_lock(&ar->conf_mutex); 8245 8246 ath10k_dbg(ar, ATH10K_DBG_MAC, 8247 "mac chanctx unassign ptr %pK vdev_id %i\n", 8248 ctx, arvif->vdev_id); 8249 8250 WARN_ON(!arvif->is_started); 8251 8252 if (vif->type == NL80211_IFTYPE_MONITOR) { 8253 WARN_ON(!arvif->is_up); 8254 8255 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 8256 if (ret) 8257 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n", 8258 arvif->vdev_id, ret); 8259 8260 arvif->is_up = false; 8261 } 8262 8263 ret = ath10k_vdev_stop(arvif); 8264 if (ret) 8265 ath10k_warn(ar, "failed to stop vdev %i: %d\n", 8266 arvif->vdev_id, ret); 8267 8268 arvif->is_started = false; 8269 8270 mutex_unlock(&ar->conf_mutex); 8271 } 8272 8273 static int 8274 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw, 8275 struct ieee80211_vif_chanctx_switch *vifs, 8276 int n_vifs, 8277 enum ieee80211_chanctx_switch_mode mode) 8278 { 8279 struct ath10k *ar = hw->priv; 8280 8281 mutex_lock(&ar->conf_mutex); 8282 8283 ath10k_dbg(ar, ATH10K_DBG_MAC, 8284 "mac chanctx switch n_vifs %d mode %d\n", 8285 n_vifs, mode); 8286 ath10k_mac_update_vif_chan(ar, vifs, n_vifs); 8287 8288 mutex_unlock(&ar->conf_mutex); 8289 return 0; 8290 } 8291 8292 static void ath10k_mac_op_sta_pre_rcu_remove(struct ieee80211_hw *hw, 8293 struct ieee80211_vif *vif, 8294 struct ieee80211_sta *sta) 8295 { 8296 struct ath10k *ar; 8297 struct ath10k_peer *peer; 8298 8299 ar = hw->priv; 8300 8301 list_for_each_entry(peer, &ar->peers, list) 8302 if (peer->sta == sta) 8303 peer->removed = true; 8304 } 8305 8306 /* HT MCS parameters with Nss = 1 */ 8307 static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss1[] = { 8308 /* MCS L20 L40 S20 S40 */ 8309 {0, { 65, 135, 72, 150} }, 8310 {1, { 130, 270, 144, 300} }, 8311 {2, { 195, 405, 217, 450} }, 8312 {3, { 260, 540, 289, 600} }, 8313 {4, { 390, 810, 433, 900} }, 8314 {5, { 520, 1080, 578, 1200} }, 8315 {6, { 585, 1215, 650, 1350} }, 8316 {7, { 650, 1350, 722, 1500} } 8317 }; 8318 8319 /* HT MCS parameters with Nss = 2 */ 8320 static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss2[] = { 8321 /* MCS L20 L40 S20 S40 */ 8322 {0, {130, 270, 144, 300} }, 8323 {1, {260, 540, 289, 600} }, 8324 {2, {390, 810, 433, 900} }, 8325 {3, {520, 1080, 578, 1200} }, 8326 {4, {780, 1620, 867, 1800} }, 8327 {5, {1040, 2160, 1156, 2400} }, 8328 {6, {1170, 2430, 1300, 2700} }, 8329 {7, {1300, 2700, 1444, 3000} } 8330 }; 8331 8332 /* MCS parameters with Nss = 1 */ 8333 static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss1[] = { 8334 /* MCS L80 S80 L40 S40 L20 S20 */ 8335 {0, {293, 325}, {135, 150}, {65, 72} }, 8336 {1, {585, 650}, {270, 300}, {130, 144} }, 8337 {2, {878, 975}, {405, 450}, {195, 217} }, 8338 {3, {1170, 1300}, {540, 600}, {260, 289} }, 8339 {4, {1755, 1950}, {810, 900}, {390, 433} }, 8340 {5, {2340, 2600}, {1080, 1200}, {520, 578} }, 8341 {6, {2633, 2925}, {1215, 1350}, {585, 650} }, 8342 {7, {2925, 3250}, {1350, 1500}, {650, 722} }, 8343 {8, {3510, 3900}, {1620, 1800}, {780, 867} }, 8344 {9, {3900, 4333}, {1800, 2000}, {780, 867} } 8345 }; 8346 8347 /*MCS parameters with Nss = 2 */ 8348 static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss2[] = { 8349 /* MCS L80 S80 L40 S40 L20 S20 */ 8350 {0, {585, 650}, {270, 300}, {130, 144} }, 8351 {1, {1170, 1300}, {540, 600}, {260, 289} }, 8352 {2, {1755, 1950}, {810, 900}, {390, 433} }, 8353 {3, {2340, 2600}, {1080, 1200}, {520, 578} }, 8354 {4, {3510, 3900}, {1620, 1800}, {780, 867} }, 8355 {5, {4680, 5200}, {2160, 2400}, {1040, 1156} }, 8356 {6, {5265, 5850}, {2430, 2700}, {1170, 1300} }, 8357 {7, {5850, 6500}, {2700, 3000}, {1300, 1444} }, 8358 {8, {7020, 7800}, {3240, 3600}, {1560, 1733} }, 8359 {9, {7800, 8667}, {3600, 4000}, {1560, 1733} } 8360 }; 8361 8362 static void ath10k_mac_get_rate_flags_ht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs, 8363 u8 *flags, u8 *bw) 8364 { 8365 struct ath10k_index_ht_data_rate_type *mcs_rate; 8366 8367 mcs_rate = (struct ath10k_index_ht_data_rate_type *) 8368 ((nss == 1) ? &supported_ht_mcs_rate_nss1 : 8369 &supported_ht_mcs_rate_nss2); 8370 8371 if (rate == mcs_rate[mcs].supported_rate[0]) { 8372 *bw = RATE_INFO_BW_20; 8373 } else if (rate == mcs_rate[mcs].supported_rate[1]) { 8374 *bw |= RATE_INFO_BW_40; 8375 } else if (rate == mcs_rate[mcs].supported_rate[2]) { 8376 *bw |= RATE_INFO_BW_20; 8377 *flags |= RATE_INFO_FLAGS_SHORT_GI; 8378 } else if (rate == mcs_rate[mcs].supported_rate[3]) { 8379 *bw |= RATE_INFO_BW_40; 8380 *flags |= RATE_INFO_FLAGS_SHORT_GI; 8381 } else { 8382 ath10k_warn(ar, "invalid ht params rate %d 100kbps nss %d mcs %d", 8383 rate, nss, mcs); 8384 } 8385 } 8386 8387 static void ath10k_mac_get_rate_flags_vht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs, 8388 u8 *flags, u8 *bw) 8389 { 8390 struct ath10k_index_vht_data_rate_type *mcs_rate; 8391 8392 mcs_rate = (struct ath10k_index_vht_data_rate_type *) 8393 ((nss == 1) ? &supported_vht_mcs_rate_nss1 : 8394 &supported_vht_mcs_rate_nss2); 8395 8396 if (rate == mcs_rate[mcs].supported_VHT80_rate[0]) { 8397 *bw = RATE_INFO_BW_80; 8398 } else if (rate == mcs_rate[mcs].supported_VHT80_rate[1]) { 8399 *bw = RATE_INFO_BW_80; 8400 *flags |= RATE_INFO_FLAGS_SHORT_GI; 8401 } else if (rate == mcs_rate[mcs].supported_VHT40_rate[0]) { 8402 *bw = RATE_INFO_BW_40; 8403 } else if (rate == mcs_rate[mcs].supported_VHT40_rate[1]) { 8404 *bw = RATE_INFO_BW_40; 8405 *flags |= RATE_INFO_FLAGS_SHORT_GI; 8406 } else if (rate == mcs_rate[mcs].supported_VHT20_rate[0]) { 8407 *bw = RATE_INFO_BW_20; 8408 } else if (rate == mcs_rate[mcs].supported_VHT20_rate[1]) { 8409 *bw = RATE_INFO_BW_20; 8410 *flags |= RATE_INFO_FLAGS_SHORT_GI; 8411 } else { 8412 ath10k_warn(ar, "invalid vht params rate %d 100kbps nss %d mcs %d", 8413 rate, nss, mcs); 8414 } 8415 } 8416 8417 static void ath10k_mac_get_rate_flags(struct ath10k *ar, u32 rate, 8418 enum ath10k_phy_mode mode, u8 nss, u8 mcs, 8419 u8 *flags, u8 *bw) 8420 { 8421 if (mode == ATH10K_PHY_MODE_HT) { 8422 *flags = RATE_INFO_FLAGS_MCS; 8423 ath10k_mac_get_rate_flags_ht(ar, rate, nss, mcs, flags, bw); 8424 } else if (mode == ATH10K_PHY_MODE_VHT) { 8425 *flags = RATE_INFO_FLAGS_VHT_MCS; 8426 ath10k_mac_get_rate_flags_vht(ar, rate, nss, mcs, flags, bw); 8427 } 8428 } 8429 8430 static void ath10k_mac_parse_bitrate(struct ath10k *ar, u32 rate_code, 8431 u32 bitrate_kbps, struct rate_info *rate) 8432 { 8433 enum ath10k_phy_mode mode = ATH10K_PHY_MODE_LEGACY; 8434 enum wmi_rate_preamble preamble = WMI_TLV_GET_HW_RC_PREAM_V1(rate_code); 8435 u8 nss = WMI_TLV_GET_HW_RC_NSS_V1(rate_code) + 1; 8436 u8 mcs = WMI_TLV_GET_HW_RC_RATE_V1(rate_code); 8437 u8 flags = 0, bw = 0; 8438 8439 if (preamble == WMI_RATE_PREAMBLE_HT) 8440 mode = ATH10K_PHY_MODE_HT; 8441 else if (preamble == WMI_RATE_PREAMBLE_VHT) 8442 mode = ATH10K_PHY_MODE_VHT; 8443 8444 ath10k_mac_get_rate_flags(ar, bitrate_kbps / 100, mode, nss, mcs, &flags, &bw); 8445 8446 ath10k_dbg(ar, ATH10K_DBG_MAC, 8447 "mac parse bitrate preamble %d mode %d nss %d mcs %d flags %x bw %d\n", 8448 preamble, mode, nss, mcs, flags, bw); 8449 8450 rate->flags = flags; 8451 rate->bw = bw; 8452 rate->legacy = bitrate_kbps / 100; 8453 rate->nss = nss; 8454 rate->mcs = mcs; 8455 } 8456 8457 static void ath10k_mac_sta_get_peer_stats_info(struct ath10k *ar, 8458 struct ieee80211_sta *sta, 8459 struct station_info *sinfo) 8460 { 8461 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 8462 struct ath10k_peer *peer; 8463 unsigned long time_left; 8464 int ret; 8465 8466 if (!(ar->hw_params.supports_peer_stats_info && 8467 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA)) 8468 return; 8469 8470 spin_lock_bh(&ar->data_lock); 8471 peer = ath10k_peer_find(ar, arsta->arvif->vdev_id, sta->addr); 8472 spin_unlock_bh(&ar->data_lock); 8473 if (!peer) 8474 return; 8475 8476 reinit_completion(&ar->peer_stats_info_complete); 8477 8478 ret = ath10k_wmi_request_peer_stats_info(ar, 8479 arsta->arvif->vdev_id, 8480 WMI_REQUEST_ONE_PEER_STATS_INFO, 8481 arsta->arvif->bssid, 8482 0); 8483 if (ret && ret != -EOPNOTSUPP) { 8484 ath10k_warn(ar, "could not request peer stats info: %d\n", ret); 8485 return; 8486 } 8487 8488 time_left = wait_for_completion_timeout(&ar->peer_stats_info_complete, 3 * HZ); 8489 if (time_left == 0) { 8490 ath10k_warn(ar, "timed out waiting peer stats info\n"); 8491 return; 8492 } 8493 8494 if (arsta->rx_rate_code != 0 && arsta->rx_bitrate_kbps != 0) { 8495 ath10k_mac_parse_bitrate(ar, arsta->rx_rate_code, 8496 arsta->rx_bitrate_kbps, 8497 &sinfo->rxrate); 8498 8499 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE); 8500 arsta->rx_rate_code = 0; 8501 arsta->rx_bitrate_kbps = 0; 8502 } 8503 8504 if (arsta->tx_rate_code != 0 && arsta->tx_bitrate_kbps != 0) { 8505 ath10k_mac_parse_bitrate(ar, arsta->tx_rate_code, 8506 arsta->tx_bitrate_kbps, 8507 &sinfo->txrate); 8508 8509 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 8510 arsta->tx_rate_code = 0; 8511 arsta->tx_bitrate_kbps = 0; 8512 } 8513 } 8514 8515 static void ath10k_sta_statistics(struct ieee80211_hw *hw, 8516 struct ieee80211_vif *vif, 8517 struct ieee80211_sta *sta, 8518 struct station_info *sinfo) 8519 { 8520 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 8521 struct ath10k *ar = arsta->arvif->ar; 8522 8523 if (!ath10k_peer_stats_enabled(ar)) 8524 return; 8525 8526 ath10k_debug_fw_stats_request(ar); 8527 8528 sinfo->rx_duration = arsta->rx_duration; 8529 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION); 8530 8531 if (!arsta->txrate.legacy && !arsta->txrate.nss) 8532 return; 8533 8534 if (arsta->txrate.legacy) { 8535 sinfo->txrate.legacy = arsta->txrate.legacy; 8536 } else { 8537 sinfo->txrate.mcs = arsta->txrate.mcs; 8538 sinfo->txrate.nss = arsta->txrate.nss; 8539 sinfo->txrate.bw = arsta->txrate.bw; 8540 } 8541 sinfo->txrate.flags = arsta->txrate.flags; 8542 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 8543 8544 if (ar->htt.disable_tx_comp) { 8545 sinfo->tx_retries = arsta->tx_retries; 8546 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES); 8547 sinfo->tx_failed = arsta->tx_failed; 8548 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED); 8549 } 8550 8551 ath10k_mac_sta_get_peer_stats_info(ar, sta, sinfo); 8552 } 8553 8554 static const struct ieee80211_ops ath10k_ops = { 8555 .tx = ath10k_mac_op_tx, 8556 .wake_tx_queue = ath10k_mac_op_wake_tx_queue, 8557 .start = ath10k_start, 8558 .stop = ath10k_stop, 8559 .config = ath10k_config, 8560 .add_interface = ath10k_add_interface, 8561 .remove_interface = ath10k_remove_interface, 8562 .configure_filter = ath10k_configure_filter, 8563 .bss_info_changed = ath10k_bss_info_changed, 8564 .set_coverage_class = ath10k_mac_op_set_coverage_class, 8565 .hw_scan = ath10k_hw_scan, 8566 .cancel_hw_scan = ath10k_cancel_hw_scan, 8567 .set_key = ath10k_set_key, 8568 .set_default_unicast_key = ath10k_set_default_unicast_key, 8569 .sta_state = ath10k_sta_state, 8570 .sta_set_txpwr = ath10k_sta_set_txpwr, 8571 .conf_tx = ath10k_conf_tx, 8572 .remain_on_channel = ath10k_remain_on_channel, 8573 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel, 8574 .set_rts_threshold = ath10k_set_rts_threshold, 8575 .set_frag_threshold = ath10k_mac_op_set_frag_threshold, 8576 .flush = ath10k_flush, 8577 .tx_last_beacon = ath10k_tx_last_beacon, 8578 .set_antenna = ath10k_set_antenna, 8579 .get_antenna = ath10k_get_antenna, 8580 .reconfig_complete = ath10k_reconfig_complete, 8581 .get_survey = ath10k_get_survey, 8582 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask, 8583 .sta_rc_update = ath10k_sta_rc_update, 8584 .offset_tsf = ath10k_offset_tsf, 8585 .ampdu_action = ath10k_ampdu_action, 8586 .get_et_sset_count = ath10k_debug_get_et_sset_count, 8587 .get_et_stats = ath10k_debug_get_et_stats, 8588 .get_et_strings = ath10k_debug_get_et_strings, 8589 .add_chanctx = ath10k_mac_op_add_chanctx, 8590 .remove_chanctx = ath10k_mac_op_remove_chanctx, 8591 .change_chanctx = ath10k_mac_op_change_chanctx, 8592 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx, 8593 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx, 8594 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx, 8595 .sta_pre_rcu_remove = ath10k_mac_op_sta_pre_rcu_remove, 8596 .sta_statistics = ath10k_sta_statistics, 8597 8598 CFG80211_TESTMODE_CMD(ath10k_tm_cmd) 8599 8600 #ifdef CONFIG_PM 8601 .suspend = ath10k_wow_op_suspend, 8602 .resume = ath10k_wow_op_resume, 8603 .set_wakeup = ath10k_wow_op_set_wakeup, 8604 #endif 8605 #ifdef CONFIG_MAC80211_DEBUGFS 8606 .sta_add_debugfs = ath10k_sta_add_debugfs, 8607 #endif 8608 }; 8609 8610 #define CHAN2G(_channel, _freq, _flags) { \ 8611 .band = NL80211_BAND_2GHZ, \ 8612 .hw_value = (_channel), \ 8613 .center_freq = (_freq), \ 8614 .flags = (_flags), \ 8615 .max_antenna_gain = 0, \ 8616 .max_power = 30, \ 8617 } 8618 8619 #define CHAN5G(_channel, _freq, _flags) { \ 8620 .band = NL80211_BAND_5GHZ, \ 8621 .hw_value = (_channel), \ 8622 .center_freq = (_freq), \ 8623 .flags = (_flags), \ 8624 .max_antenna_gain = 0, \ 8625 .max_power = 30, \ 8626 } 8627 8628 static const struct ieee80211_channel ath10k_2ghz_channels[] = { 8629 CHAN2G(1, 2412, 0), 8630 CHAN2G(2, 2417, 0), 8631 CHAN2G(3, 2422, 0), 8632 CHAN2G(4, 2427, 0), 8633 CHAN2G(5, 2432, 0), 8634 CHAN2G(6, 2437, 0), 8635 CHAN2G(7, 2442, 0), 8636 CHAN2G(8, 2447, 0), 8637 CHAN2G(9, 2452, 0), 8638 CHAN2G(10, 2457, 0), 8639 CHAN2G(11, 2462, 0), 8640 CHAN2G(12, 2467, 0), 8641 CHAN2G(13, 2472, 0), 8642 CHAN2G(14, 2484, 0), 8643 }; 8644 8645 static const struct ieee80211_channel ath10k_5ghz_channels[] = { 8646 CHAN5G(36, 5180, 0), 8647 CHAN5G(40, 5200, 0), 8648 CHAN5G(44, 5220, 0), 8649 CHAN5G(48, 5240, 0), 8650 CHAN5G(52, 5260, 0), 8651 CHAN5G(56, 5280, 0), 8652 CHAN5G(60, 5300, 0), 8653 CHAN5G(64, 5320, 0), 8654 CHAN5G(100, 5500, 0), 8655 CHAN5G(104, 5520, 0), 8656 CHAN5G(108, 5540, 0), 8657 CHAN5G(112, 5560, 0), 8658 CHAN5G(116, 5580, 0), 8659 CHAN5G(120, 5600, 0), 8660 CHAN5G(124, 5620, 0), 8661 CHAN5G(128, 5640, 0), 8662 CHAN5G(132, 5660, 0), 8663 CHAN5G(136, 5680, 0), 8664 CHAN5G(140, 5700, 0), 8665 CHAN5G(144, 5720, 0), 8666 CHAN5G(149, 5745, 0), 8667 CHAN5G(153, 5765, 0), 8668 CHAN5G(157, 5785, 0), 8669 CHAN5G(161, 5805, 0), 8670 CHAN5G(165, 5825, 0), 8671 CHAN5G(169, 5845, 0), 8672 CHAN5G(173, 5865, 0), 8673 /* If you add more, you may need to change ATH10K_MAX_5G_CHAN */ 8674 /* And you will definitely need to change ATH10K_NUM_CHANS in core.h */ 8675 }; 8676 8677 struct ath10k *ath10k_mac_create(size_t priv_size) 8678 { 8679 struct ieee80211_hw *hw; 8680 struct ieee80211_ops *ops; 8681 struct ath10k *ar; 8682 8683 ops = kmemdup(&ath10k_ops, sizeof(ath10k_ops), GFP_KERNEL); 8684 if (!ops) 8685 return NULL; 8686 8687 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, ops); 8688 if (!hw) { 8689 kfree(ops); 8690 return NULL; 8691 } 8692 8693 ar = hw->priv; 8694 ar->hw = hw; 8695 ar->ops = ops; 8696 8697 return ar; 8698 } 8699 8700 void ath10k_mac_destroy(struct ath10k *ar) 8701 { 8702 struct ieee80211_ops *ops = ar->ops; 8703 8704 ieee80211_free_hw(ar->hw); 8705 kfree(ops); 8706 } 8707 8708 static const struct ieee80211_iface_limit ath10k_if_limits[] = { 8709 { 8710 .max = 8, 8711 .types = BIT(NL80211_IFTYPE_STATION) 8712 | BIT(NL80211_IFTYPE_P2P_CLIENT) 8713 }, 8714 { 8715 .max = 3, 8716 .types = BIT(NL80211_IFTYPE_P2P_GO) 8717 }, 8718 { 8719 .max = 1, 8720 .types = BIT(NL80211_IFTYPE_P2P_DEVICE) 8721 }, 8722 { 8723 .max = 7, 8724 .types = BIT(NL80211_IFTYPE_AP) 8725 #ifdef CONFIG_MAC80211_MESH 8726 | BIT(NL80211_IFTYPE_MESH_POINT) 8727 #endif 8728 }, 8729 }; 8730 8731 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = { 8732 { 8733 .max = 8, 8734 .types = BIT(NL80211_IFTYPE_AP) 8735 #ifdef CONFIG_MAC80211_MESH 8736 | BIT(NL80211_IFTYPE_MESH_POINT) 8737 #endif 8738 }, 8739 { 8740 .max = 1, 8741 .types = BIT(NL80211_IFTYPE_STATION) 8742 }, 8743 }; 8744 8745 static const struct ieee80211_iface_combination ath10k_if_comb[] = { 8746 { 8747 .limits = ath10k_if_limits, 8748 .n_limits = ARRAY_SIZE(ath10k_if_limits), 8749 .max_interfaces = 8, 8750 .num_different_channels = 1, 8751 .beacon_int_infra_match = true, 8752 }, 8753 }; 8754 8755 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = { 8756 { 8757 .limits = ath10k_10x_if_limits, 8758 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits), 8759 .max_interfaces = 8, 8760 .num_different_channels = 1, 8761 .beacon_int_infra_match = true, 8762 .beacon_int_min_gcd = 1, 8763 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 8764 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 8765 BIT(NL80211_CHAN_WIDTH_20) | 8766 BIT(NL80211_CHAN_WIDTH_40) | 8767 BIT(NL80211_CHAN_WIDTH_80), 8768 #endif 8769 }, 8770 }; 8771 8772 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = { 8773 { 8774 .max = 2, 8775 .types = BIT(NL80211_IFTYPE_STATION), 8776 }, 8777 { 8778 .max = 2, 8779 .types = BIT(NL80211_IFTYPE_AP) | 8780 #ifdef CONFIG_MAC80211_MESH 8781 BIT(NL80211_IFTYPE_MESH_POINT) | 8782 #endif 8783 BIT(NL80211_IFTYPE_P2P_CLIENT) | 8784 BIT(NL80211_IFTYPE_P2P_GO), 8785 }, 8786 { 8787 .max = 1, 8788 .types = BIT(NL80211_IFTYPE_P2P_DEVICE), 8789 }, 8790 }; 8791 8792 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = { 8793 { 8794 .max = 2, 8795 .types = BIT(NL80211_IFTYPE_STATION), 8796 }, 8797 { 8798 .max = 2, 8799 .types = BIT(NL80211_IFTYPE_P2P_CLIENT), 8800 }, 8801 { 8802 .max = 1, 8803 .types = BIT(NL80211_IFTYPE_AP) | 8804 #ifdef CONFIG_MAC80211_MESH 8805 BIT(NL80211_IFTYPE_MESH_POINT) | 8806 #endif 8807 BIT(NL80211_IFTYPE_P2P_GO), 8808 }, 8809 { 8810 .max = 1, 8811 .types = BIT(NL80211_IFTYPE_P2P_DEVICE), 8812 }, 8813 }; 8814 8815 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = { 8816 { 8817 .max = 1, 8818 .types = BIT(NL80211_IFTYPE_STATION), 8819 }, 8820 { 8821 .max = 1, 8822 .types = BIT(NL80211_IFTYPE_ADHOC), 8823 }, 8824 }; 8825 8826 /* FIXME: This is not thouroughly tested. These combinations may over- or 8827 * underestimate hw/fw capabilities. 8828 */ 8829 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = { 8830 { 8831 .limits = ath10k_tlv_if_limit, 8832 .num_different_channels = 1, 8833 .max_interfaces = 4, 8834 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit), 8835 }, 8836 { 8837 .limits = ath10k_tlv_if_limit_ibss, 8838 .num_different_channels = 1, 8839 .max_interfaces = 2, 8840 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss), 8841 }, 8842 }; 8843 8844 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = { 8845 { 8846 .limits = ath10k_tlv_if_limit, 8847 .num_different_channels = 1, 8848 .max_interfaces = 4, 8849 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit), 8850 }, 8851 { 8852 .limits = ath10k_tlv_qcs_if_limit, 8853 .num_different_channels = 2, 8854 .max_interfaces = 4, 8855 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit), 8856 }, 8857 { 8858 .limits = ath10k_tlv_if_limit_ibss, 8859 .num_different_channels = 1, 8860 .max_interfaces = 2, 8861 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss), 8862 }, 8863 }; 8864 8865 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = { 8866 { 8867 .max = 1, 8868 .types = BIT(NL80211_IFTYPE_STATION), 8869 }, 8870 { 8871 .max = 16, 8872 .types = BIT(NL80211_IFTYPE_AP) 8873 #ifdef CONFIG_MAC80211_MESH 8874 | BIT(NL80211_IFTYPE_MESH_POINT) 8875 #endif 8876 }, 8877 }; 8878 8879 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = { 8880 { 8881 .limits = ath10k_10_4_if_limits, 8882 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits), 8883 .max_interfaces = 16, 8884 .num_different_channels = 1, 8885 .beacon_int_infra_match = true, 8886 .beacon_int_min_gcd = 1, 8887 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 8888 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 8889 BIT(NL80211_CHAN_WIDTH_20) | 8890 BIT(NL80211_CHAN_WIDTH_40) | 8891 BIT(NL80211_CHAN_WIDTH_80) | 8892 BIT(NL80211_CHAN_WIDTH_80P80) | 8893 BIT(NL80211_CHAN_WIDTH_160), 8894 #endif 8895 }, 8896 }; 8897 8898 static const struct 8899 ieee80211_iface_combination ath10k_10_4_bcn_int_if_comb[] = { 8900 { 8901 .limits = ath10k_10_4_if_limits, 8902 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits), 8903 .max_interfaces = 16, 8904 .num_different_channels = 1, 8905 .beacon_int_infra_match = true, 8906 .beacon_int_min_gcd = 100, 8907 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 8908 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 8909 BIT(NL80211_CHAN_WIDTH_20) | 8910 BIT(NL80211_CHAN_WIDTH_40) | 8911 BIT(NL80211_CHAN_WIDTH_80) | 8912 BIT(NL80211_CHAN_WIDTH_80P80) | 8913 BIT(NL80211_CHAN_WIDTH_160), 8914 #endif 8915 }, 8916 }; 8917 8918 static void ath10k_get_arvif_iter(void *data, u8 *mac, 8919 struct ieee80211_vif *vif) 8920 { 8921 struct ath10k_vif_iter *arvif_iter = data; 8922 struct ath10k_vif *arvif = (void *)vif->drv_priv; 8923 8924 if (arvif->vdev_id == arvif_iter->vdev_id) 8925 arvif_iter->arvif = arvif; 8926 } 8927 8928 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id) 8929 { 8930 struct ath10k_vif_iter arvif_iter; 8931 u32 flags; 8932 8933 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter)); 8934 arvif_iter.vdev_id = vdev_id; 8935 8936 flags = IEEE80211_IFACE_ITER_RESUME_ALL; 8937 ieee80211_iterate_active_interfaces_atomic(ar->hw, 8938 flags, 8939 ath10k_get_arvif_iter, 8940 &arvif_iter); 8941 if (!arvif_iter.arvif) { 8942 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id); 8943 return NULL; 8944 } 8945 8946 return arvif_iter.arvif; 8947 } 8948 8949 #define WRD_METHOD "WRDD" 8950 #define WRDD_WIFI (0x07) 8951 8952 static u32 ath10k_mac_wrdd_get_mcc(struct ath10k *ar, union acpi_object *wrdd) 8953 { 8954 union acpi_object *mcc_pkg; 8955 union acpi_object *domain_type; 8956 union acpi_object *mcc_value; 8957 u32 i; 8958 8959 if (wrdd->type != ACPI_TYPE_PACKAGE || 8960 wrdd->package.count < 2 || 8961 wrdd->package.elements[0].type != ACPI_TYPE_INTEGER || 8962 wrdd->package.elements[0].integer.value != 0) { 8963 ath10k_warn(ar, "ignoring malformed/unsupported wrdd structure\n"); 8964 return 0; 8965 } 8966 8967 for (i = 1; i < wrdd->package.count; ++i) { 8968 mcc_pkg = &wrdd->package.elements[i]; 8969 8970 if (mcc_pkg->type != ACPI_TYPE_PACKAGE) 8971 continue; 8972 if (mcc_pkg->package.count < 2) 8973 continue; 8974 if (mcc_pkg->package.elements[0].type != ACPI_TYPE_INTEGER || 8975 mcc_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) 8976 continue; 8977 8978 domain_type = &mcc_pkg->package.elements[0]; 8979 if (domain_type->integer.value != WRDD_WIFI) 8980 continue; 8981 8982 mcc_value = &mcc_pkg->package.elements[1]; 8983 return mcc_value->integer.value; 8984 } 8985 return 0; 8986 } 8987 8988 static int ath10k_mac_get_wrdd_regulatory(struct ath10k *ar, u16 *rd) 8989 { 8990 acpi_handle root_handle; 8991 acpi_handle handle; 8992 struct acpi_buffer wrdd = {ACPI_ALLOCATE_BUFFER, NULL}; 8993 acpi_status status; 8994 u32 alpha2_code; 8995 char alpha2[3]; 8996 8997 root_handle = ACPI_HANDLE(ar->dev); 8998 if (!root_handle) 8999 return -EOPNOTSUPP; 9000 9001 status = acpi_get_handle(root_handle, (acpi_string)WRD_METHOD, &handle); 9002 if (ACPI_FAILURE(status)) { 9003 ath10k_dbg(ar, ATH10K_DBG_BOOT, 9004 "failed to get wrd method %d\n", status); 9005 return -EIO; 9006 } 9007 9008 status = acpi_evaluate_object(handle, NULL, NULL, &wrdd); 9009 if (ACPI_FAILURE(status)) { 9010 ath10k_dbg(ar, ATH10K_DBG_BOOT, 9011 "failed to call wrdc %d\n", status); 9012 return -EIO; 9013 } 9014 9015 alpha2_code = ath10k_mac_wrdd_get_mcc(ar, wrdd.pointer); 9016 kfree(wrdd.pointer); 9017 if (!alpha2_code) 9018 return -EIO; 9019 9020 alpha2[0] = (alpha2_code >> 8) & 0xff; 9021 alpha2[1] = (alpha2_code >> 0) & 0xff; 9022 alpha2[2] = '\0'; 9023 9024 ath10k_dbg(ar, ATH10K_DBG_BOOT, 9025 "regulatory hint from WRDD (alpha2-code): %s\n", alpha2); 9026 9027 *rd = ath_regd_find_country_by_name(alpha2); 9028 if (*rd == 0xffff) 9029 return -EIO; 9030 9031 *rd |= COUNTRY_ERD_FLAG; 9032 return 0; 9033 } 9034 9035 static int ath10k_mac_init_rd(struct ath10k *ar) 9036 { 9037 int ret; 9038 u16 rd; 9039 9040 ret = ath10k_mac_get_wrdd_regulatory(ar, &rd); 9041 if (ret) { 9042 ath10k_dbg(ar, ATH10K_DBG_BOOT, 9043 "fallback to eeprom programmed regulatory settings\n"); 9044 rd = ar->hw_eeprom_rd; 9045 } 9046 9047 ar->ath_common.regulatory.current_rd = rd; 9048 return 0; 9049 } 9050 9051 int ath10k_mac_register(struct ath10k *ar) 9052 { 9053 static const u32 cipher_suites[] = { 9054 WLAN_CIPHER_SUITE_WEP40, 9055 WLAN_CIPHER_SUITE_WEP104, 9056 WLAN_CIPHER_SUITE_TKIP, 9057 WLAN_CIPHER_SUITE_CCMP, 9058 9059 /* Do not add hardware supported ciphers before this line. 9060 * Allow software encryption for all chips. Don't forget to 9061 * update n_cipher_suites below. 9062 */ 9063 WLAN_CIPHER_SUITE_AES_CMAC, 9064 WLAN_CIPHER_SUITE_BIP_CMAC_256, 9065 WLAN_CIPHER_SUITE_BIP_GMAC_128, 9066 WLAN_CIPHER_SUITE_BIP_GMAC_256, 9067 9068 /* Only QCA99x0 and QCA4019 varients support GCMP-128, GCMP-256 9069 * and CCMP-256 in hardware. 9070 */ 9071 WLAN_CIPHER_SUITE_GCMP, 9072 WLAN_CIPHER_SUITE_GCMP_256, 9073 WLAN_CIPHER_SUITE_CCMP_256, 9074 }; 9075 struct ieee80211_supported_band *band; 9076 void *channels; 9077 int ret; 9078 9079 if (!is_valid_ether_addr(ar->mac_addr)) { 9080 ath10k_warn(ar, "invalid MAC address; choosing random\n"); 9081 eth_random_addr(ar->mac_addr); 9082 } 9083 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 9084 9085 SET_IEEE80211_DEV(ar->hw, ar->dev); 9086 9087 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) + 9088 ARRAY_SIZE(ath10k_5ghz_channels)) != 9089 ATH10K_NUM_CHANS); 9090 9091 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) { 9092 channels = kmemdup(ath10k_2ghz_channels, 9093 sizeof(ath10k_2ghz_channels), 9094 GFP_KERNEL); 9095 if (!channels) { 9096 ret = -ENOMEM; 9097 goto err_free; 9098 } 9099 9100 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 9101 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels); 9102 band->channels = channels; 9103 9104 if (ar->hw_params.cck_rate_map_rev2) { 9105 band->n_bitrates = ath10k_g_rates_rev2_size; 9106 band->bitrates = ath10k_g_rates_rev2; 9107 } else { 9108 band->n_bitrates = ath10k_g_rates_size; 9109 band->bitrates = ath10k_g_rates; 9110 } 9111 9112 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band; 9113 } 9114 9115 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) { 9116 channels = kmemdup(ath10k_5ghz_channels, 9117 sizeof(ath10k_5ghz_channels), 9118 GFP_KERNEL); 9119 if (!channels) { 9120 ret = -ENOMEM; 9121 goto err_free; 9122 } 9123 9124 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 9125 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels); 9126 band->channels = channels; 9127 band->n_bitrates = ath10k_a_rates_size; 9128 band->bitrates = ath10k_a_rates; 9129 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band; 9130 } 9131 9132 wiphy_read_of_freq_limits(ar->hw->wiphy); 9133 ath10k_mac_setup_ht_vht_cap(ar); 9134 9135 ar->hw->wiphy->interface_modes = 9136 BIT(NL80211_IFTYPE_STATION) | 9137 BIT(NL80211_IFTYPE_AP) | 9138 BIT(NL80211_IFTYPE_MESH_POINT); 9139 9140 ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask; 9141 ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask; 9142 9143 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->normal_mode_fw.fw_file.fw_features)) 9144 ar->hw->wiphy->interface_modes |= 9145 BIT(NL80211_IFTYPE_P2P_DEVICE) | 9146 BIT(NL80211_IFTYPE_P2P_CLIENT) | 9147 BIT(NL80211_IFTYPE_P2P_GO); 9148 9149 ieee80211_hw_set(ar->hw, SIGNAL_DBM); 9150 9151 if (!test_bit(ATH10K_FW_FEATURE_NO_PS, 9152 ar->running_fw->fw_file.fw_features)) { 9153 ieee80211_hw_set(ar->hw, SUPPORTS_PS); 9154 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS); 9155 } 9156 9157 ieee80211_hw_set(ar->hw, MFP_CAPABLE); 9158 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS); 9159 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL); 9160 ieee80211_hw_set(ar->hw, AP_LINK_PS); 9161 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT); 9162 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT); 9163 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR); 9164 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK); 9165 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF); 9166 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA); 9167 ieee80211_hw_set(ar->hw, QUEUE_CONTROL); 9168 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG); 9169 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK); 9170 9171 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) 9172 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL); 9173 9174 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS; 9175 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 9176 9177 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 9178 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS; 9179 9180 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) { 9181 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION); 9182 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW); 9183 } 9184 9185 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 9186 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 9187 9188 if (test_bit(WMI_SERVICE_NLO, ar->wmi.svc_map)) { 9189 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS; 9190 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS; 9191 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH; 9192 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS; 9193 ar->hw->wiphy->max_sched_scan_plan_interval = 9194 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT; 9195 ar->hw->wiphy->max_sched_scan_plan_iterations = 9196 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS; 9197 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR; 9198 } 9199 9200 ar->hw->vif_data_size = sizeof(struct ath10k_vif); 9201 ar->hw->sta_data_size = sizeof(struct ath10k_sta); 9202 ar->hw->txq_data_size = sizeof(struct ath10k_txq); 9203 9204 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL; 9205 9206 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) { 9207 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD; 9208 9209 /* Firmware delivers WPS/P2P Probe Requests frames to driver so 9210 * that userspace (e.g. wpa_supplicant/hostapd) can generate 9211 * correct Probe Responses. This is more of a hack advert.. 9212 */ 9213 ar->hw->wiphy->probe_resp_offload |= 9214 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS | 9215 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 | 9216 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P; 9217 } 9218 9219 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map) || 9220 test_bit(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY, ar->wmi.svc_map)) { 9221 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS; 9222 if (test_bit(WMI_SERVICE_TDLS_WIDER_BANDWIDTH, ar->wmi.svc_map)) 9223 ieee80211_hw_set(ar->hw, TDLS_WIDER_BW); 9224 } 9225 9226 if (test_bit(WMI_SERVICE_TDLS_UAPSD_BUFFER_STA, ar->wmi.svc_map)) 9227 ieee80211_hw_set(ar->hw, SUPPORTS_TDLS_BUFFER_STA); 9228 9229 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 9230 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 9231 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 9232 9233 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 9234 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 9235 NL80211_FEATURE_AP_SCAN; 9236 9237 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations; 9238 9239 ret = ath10k_wow_init(ar); 9240 if (ret) { 9241 ath10k_warn(ar, "failed to init wow: %d\n", ret); 9242 goto err_free; 9243 } 9244 9245 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS); 9246 wiphy_ext_feature_set(ar->hw->wiphy, 9247 NL80211_EXT_FEATURE_SET_SCAN_DWELL); 9248 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_AQL); 9249 9250 if (test_bit(WMI_SERVICE_TX_DATA_ACK_RSSI, ar->wmi.svc_map) || 9251 test_bit(WMI_SERVICE_HTT_MGMT_TX_COMP_VALID_FLAGS, ar->wmi.svc_map)) 9252 wiphy_ext_feature_set(ar->hw->wiphy, 9253 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT); 9254 9255 if (ath10k_peer_stats_enabled(ar) || 9256 test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map)) 9257 wiphy_ext_feature_set(ar->hw->wiphy, 9258 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS); 9259 9260 if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) 9261 wiphy_ext_feature_set(ar->hw->wiphy, 9262 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER); 9263 9264 if (test_bit(WMI_SERVICE_TX_PWR_PER_PEER, ar->wmi.svc_map)) 9265 wiphy_ext_feature_set(ar->hw->wiphy, 9266 NL80211_EXT_FEATURE_STA_TX_PWR); 9267 /* 9268 * on LL hardware queues are managed entirely by the FW 9269 * so we only advertise to mac we can do the queues thing 9270 */ 9271 ar->hw->queues = IEEE80211_MAX_QUEUES; 9272 9273 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is 9274 * something that vdev_ids can't reach so that we don't stop the queue 9275 * accidentally. 9276 */ 9277 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1; 9278 9279 switch (ar->running_fw->fw_file.wmi_op_version) { 9280 case ATH10K_FW_WMI_OP_VERSION_MAIN: 9281 ar->hw->wiphy->iface_combinations = ath10k_if_comb; 9282 ar->hw->wiphy->n_iface_combinations = 9283 ARRAY_SIZE(ath10k_if_comb); 9284 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC); 9285 break; 9286 case ATH10K_FW_WMI_OP_VERSION_TLV: 9287 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) { 9288 ar->hw->wiphy->iface_combinations = 9289 ath10k_tlv_qcs_if_comb; 9290 ar->hw->wiphy->n_iface_combinations = 9291 ARRAY_SIZE(ath10k_tlv_qcs_if_comb); 9292 } else { 9293 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb; 9294 ar->hw->wiphy->n_iface_combinations = 9295 ARRAY_SIZE(ath10k_tlv_if_comb); 9296 } 9297 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC); 9298 break; 9299 case ATH10K_FW_WMI_OP_VERSION_10_1: 9300 case ATH10K_FW_WMI_OP_VERSION_10_2: 9301 case ATH10K_FW_WMI_OP_VERSION_10_2_4: 9302 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb; 9303 ar->hw->wiphy->n_iface_combinations = 9304 ARRAY_SIZE(ath10k_10x_if_comb); 9305 break; 9306 case ATH10K_FW_WMI_OP_VERSION_10_4: 9307 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb; 9308 ar->hw->wiphy->n_iface_combinations = 9309 ARRAY_SIZE(ath10k_10_4_if_comb); 9310 if (test_bit(WMI_SERVICE_VDEV_DIFFERENT_BEACON_INTERVAL_SUPPORT, 9311 ar->wmi.svc_map)) { 9312 ar->hw->wiphy->iface_combinations = 9313 ath10k_10_4_bcn_int_if_comb; 9314 ar->hw->wiphy->n_iface_combinations = 9315 ARRAY_SIZE(ath10k_10_4_bcn_int_if_comb); 9316 } 9317 break; 9318 case ATH10K_FW_WMI_OP_VERSION_UNSET: 9319 case ATH10K_FW_WMI_OP_VERSION_MAX: 9320 WARN_ON(1); 9321 ret = -EINVAL; 9322 goto err_free; 9323 } 9324 9325 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) 9326 ar->hw->netdev_features = NETIF_F_HW_CSUM; 9327 9328 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) { 9329 /* Init ath dfs pattern detector */ 9330 ar->ath_common.debug_mask = ATH_DBG_DFS; 9331 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common, 9332 NL80211_DFS_UNSET); 9333 9334 if (!ar->dfs_detector) 9335 ath10k_warn(ar, "failed to initialise DFS pattern detector\n"); 9336 } 9337 9338 ret = ath10k_mac_init_rd(ar); 9339 if (ret) { 9340 ath10k_err(ar, "failed to derive regdom: %d\n", ret); 9341 goto err_dfs_detector_exit; 9342 } 9343 9344 /* Disable set_coverage_class for chipsets that do not support it. */ 9345 if (!ar->hw_params.hw_ops->set_coverage_class) 9346 ar->ops->set_coverage_class = NULL; 9347 9348 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy, 9349 ath10k_reg_notifier); 9350 if (ret) { 9351 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret); 9352 goto err_dfs_detector_exit; 9353 } 9354 9355 if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) { 9356 ar->hw->wiphy->features |= 9357 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR; 9358 } 9359 9360 ar->hw->wiphy->cipher_suites = cipher_suites; 9361 9362 /* QCA988x and QCA6174 family chips do not support CCMP-256, GCMP-128 9363 * and GCMP-256 ciphers in hardware. Fetch number of ciphers supported 9364 * from chip specific hw_param table. 9365 */ 9366 if (!ar->hw_params.n_cipher_suites || 9367 ar->hw_params.n_cipher_suites > ARRAY_SIZE(cipher_suites)) { 9368 ath10k_err(ar, "invalid hw_params.n_cipher_suites %d\n", 9369 ar->hw_params.n_cipher_suites); 9370 ar->hw_params.n_cipher_suites = 8; 9371 } 9372 ar->hw->wiphy->n_cipher_suites = ar->hw_params.n_cipher_suites; 9373 9374 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 9375 9376 ar->hw->weight_multiplier = ATH10K_AIRTIME_WEIGHT_MULTIPLIER; 9377 9378 ret = ieee80211_register_hw(ar->hw); 9379 if (ret) { 9380 ath10k_err(ar, "failed to register ieee80211: %d\n", ret); 9381 goto err_dfs_detector_exit; 9382 } 9383 9384 if (test_bit(WMI_SERVICE_PER_PACKET_SW_ENCRYPT, ar->wmi.svc_map)) { 9385 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN); 9386 ar->hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN); 9387 } 9388 9389 if (!ath_is_world_regd(&ar->ath_common.regulatory)) { 9390 ret = regulatory_hint(ar->hw->wiphy, 9391 ar->ath_common.regulatory.alpha2); 9392 if (ret) 9393 goto err_unregister; 9394 } 9395 9396 return 0; 9397 9398 err_unregister: 9399 ieee80211_unregister_hw(ar->hw); 9400 9401 err_dfs_detector_exit: 9402 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) 9403 ar->dfs_detector->exit(ar->dfs_detector); 9404 9405 err_free: 9406 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 9407 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 9408 9409 SET_IEEE80211_DEV(ar->hw, NULL); 9410 return ret; 9411 } 9412 9413 void ath10k_mac_unregister(struct ath10k *ar) 9414 { 9415 ieee80211_unregister_hw(ar->hw); 9416 9417 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) 9418 ar->dfs_detector->exit(ar->dfs_detector); 9419 9420 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 9421 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 9422 9423 SET_IEEE80211_DEV(ar->hw, NULL); 9424 } 9425