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