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