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