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