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