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