1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. 4 * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. 5 */ 6 7 #include <net/mac80211.h> 8 #include <linux/etherdevice.h> 9 #include <linux/bitfield.h> 10 #include <linux/inetdevice.h> 11 #include <net/if_inet6.h> 12 #include <net/ipv6.h> 13 14 #include "mac.h" 15 #include "core.h" 16 #include "debug.h" 17 #include "wmi.h" 18 #include "hw.h" 19 #include "dp_tx.h" 20 #include "dp_rx.h" 21 #include "testmode.h" 22 #include "peer.h" 23 #include "debugfs_sta.h" 24 #include "hif.h" 25 #include "wow.h" 26 27 #define CHAN2G(_channel, _freq, _flags) { \ 28 .band = NL80211_BAND_2GHZ, \ 29 .hw_value = (_channel), \ 30 .center_freq = (_freq), \ 31 .flags = (_flags), \ 32 .max_antenna_gain = 0, \ 33 .max_power = 30, \ 34 } 35 36 #define CHAN5G(_channel, _freq, _flags) { \ 37 .band = NL80211_BAND_5GHZ, \ 38 .hw_value = (_channel), \ 39 .center_freq = (_freq), \ 40 .flags = (_flags), \ 41 .max_antenna_gain = 0, \ 42 .max_power = 30, \ 43 } 44 45 #define CHAN6G(_channel, _freq, _flags) { \ 46 .band = NL80211_BAND_6GHZ, \ 47 .hw_value = (_channel), \ 48 .center_freq = (_freq), \ 49 .flags = (_flags), \ 50 .max_antenna_gain = 0, \ 51 .max_power = 30, \ 52 } 53 54 static const struct ieee80211_channel ath11k_2ghz_channels[] = { 55 CHAN2G(1, 2412, 0), 56 CHAN2G(2, 2417, 0), 57 CHAN2G(3, 2422, 0), 58 CHAN2G(4, 2427, 0), 59 CHAN2G(5, 2432, 0), 60 CHAN2G(6, 2437, 0), 61 CHAN2G(7, 2442, 0), 62 CHAN2G(8, 2447, 0), 63 CHAN2G(9, 2452, 0), 64 CHAN2G(10, 2457, 0), 65 CHAN2G(11, 2462, 0), 66 CHAN2G(12, 2467, 0), 67 CHAN2G(13, 2472, 0), 68 CHAN2G(14, 2484, 0), 69 }; 70 71 static const struct ieee80211_channel ath11k_5ghz_channels[] = { 72 CHAN5G(36, 5180, 0), 73 CHAN5G(40, 5200, 0), 74 CHAN5G(44, 5220, 0), 75 CHAN5G(48, 5240, 0), 76 CHAN5G(52, 5260, 0), 77 CHAN5G(56, 5280, 0), 78 CHAN5G(60, 5300, 0), 79 CHAN5G(64, 5320, 0), 80 CHAN5G(100, 5500, 0), 81 CHAN5G(104, 5520, 0), 82 CHAN5G(108, 5540, 0), 83 CHAN5G(112, 5560, 0), 84 CHAN5G(116, 5580, 0), 85 CHAN5G(120, 5600, 0), 86 CHAN5G(124, 5620, 0), 87 CHAN5G(128, 5640, 0), 88 CHAN5G(132, 5660, 0), 89 CHAN5G(136, 5680, 0), 90 CHAN5G(140, 5700, 0), 91 CHAN5G(144, 5720, 0), 92 CHAN5G(149, 5745, 0), 93 CHAN5G(153, 5765, 0), 94 CHAN5G(157, 5785, 0), 95 CHAN5G(161, 5805, 0), 96 CHAN5G(165, 5825, 0), 97 CHAN5G(169, 5845, 0), 98 CHAN5G(173, 5865, 0), 99 }; 100 101 static const struct ieee80211_channel ath11k_6ghz_channels[] = { 102 CHAN6G(1, 5955, 0), 103 CHAN6G(5, 5975, 0), 104 CHAN6G(9, 5995, 0), 105 CHAN6G(13, 6015, 0), 106 CHAN6G(17, 6035, 0), 107 CHAN6G(21, 6055, 0), 108 CHAN6G(25, 6075, 0), 109 CHAN6G(29, 6095, 0), 110 CHAN6G(33, 6115, 0), 111 CHAN6G(37, 6135, 0), 112 CHAN6G(41, 6155, 0), 113 CHAN6G(45, 6175, 0), 114 CHAN6G(49, 6195, 0), 115 CHAN6G(53, 6215, 0), 116 CHAN6G(57, 6235, 0), 117 CHAN6G(61, 6255, 0), 118 CHAN6G(65, 6275, 0), 119 CHAN6G(69, 6295, 0), 120 CHAN6G(73, 6315, 0), 121 CHAN6G(77, 6335, 0), 122 CHAN6G(81, 6355, 0), 123 CHAN6G(85, 6375, 0), 124 CHAN6G(89, 6395, 0), 125 CHAN6G(93, 6415, 0), 126 CHAN6G(97, 6435, 0), 127 CHAN6G(101, 6455, 0), 128 CHAN6G(105, 6475, 0), 129 CHAN6G(109, 6495, 0), 130 CHAN6G(113, 6515, 0), 131 CHAN6G(117, 6535, 0), 132 CHAN6G(121, 6555, 0), 133 CHAN6G(125, 6575, 0), 134 CHAN6G(129, 6595, 0), 135 CHAN6G(133, 6615, 0), 136 CHAN6G(137, 6635, 0), 137 CHAN6G(141, 6655, 0), 138 CHAN6G(145, 6675, 0), 139 CHAN6G(149, 6695, 0), 140 CHAN6G(153, 6715, 0), 141 CHAN6G(157, 6735, 0), 142 CHAN6G(161, 6755, 0), 143 CHAN6G(165, 6775, 0), 144 CHAN6G(169, 6795, 0), 145 CHAN6G(173, 6815, 0), 146 CHAN6G(177, 6835, 0), 147 CHAN6G(181, 6855, 0), 148 CHAN6G(185, 6875, 0), 149 CHAN6G(189, 6895, 0), 150 CHAN6G(193, 6915, 0), 151 CHAN6G(197, 6935, 0), 152 CHAN6G(201, 6955, 0), 153 CHAN6G(205, 6975, 0), 154 CHAN6G(209, 6995, 0), 155 CHAN6G(213, 7015, 0), 156 CHAN6G(217, 7035, 0), 157 CHAN6G(221, 7055, 0), 158 CHAN6G(225, 7075, 0), 159 CHAN6G(229, 7095, 0), 160 CHAN6G(233, 7115, 0), 161 162 /* new addition in IEEE Std 802.11ax-2021 */ 163 CHAN6G(2, 5935, 0), 164 }; 165 166 static struct ieee80211_rate ath11k_legacy_rates[] = { 167 { .bitrate = 10, 168 .hw_value = ATH11K_HW_RATE_CCK_LP_1M }, 169 { .bitrate = 20, 170 .hw_value = ATH11K_HW_RATE_CCK_LP_2M, 171 .hw_value_short = ATH11K_HW_RATE_CCK_SP_2M, 172 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 173 { .bitrate = 55, 174 .hw_value = ATH11K_HW_RATE_CCK_LP_5_5M, 175 .hw_value_short = ATH11K_HW_RATE_CCK_SP_5_5M, 176 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 177 { .bitrate = 110, 178 .hw_value = ATH11K_HW_RATE_CCK_LP_11M, 179 .hw_value_short = ATH11K_HW_RATE_CCK_SP_11M, 180 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 181 182 { .bitrate = 60, .hw_value = ATH11K_HW_RATE_OFDM_6M }, 183 { .bitrate = 90, .hw_value = ATH11K_HW_RATE_OFDM_9M }, 184 { .bitrate = 120, .hw_value = ATH11K_HW_RATE_OFDM_12M }, 185 { .bitrate = 180, .hw_value = ATH11K_HW_RATE_OFDM_18M }, 186 { .bitrate = 240, .hw_value = ATH11K_HW_RATE_OFDM_24M }, 187 { .bitrate = 360, .hw_value = ATH11K_HW_RATE_OFDM_36M }, 188 { .bitrate = 480, .hw_value = ATH11K_HW_RATE_OFDM_48M }, 189 { .bitrate = 540, .hw_value = ATH11K_HW_RATE_OFDM_54M }, 190 }; 191 192 static const int 193 ath11k_phymodes[NUM_NL80211_BANDS][ATH11K_CHAN_WIDTH_NUM] = { 194 [NL80211_BAND_2GHZ] = { 195 [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN, 196 [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN, 197 [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20_2G, 198 [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20_2G, 199 [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40_2G, 200 [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80_2G, 201 [NL80211_CHAN_WIDTH_80P80] = MODE_UNKNOWN, 202 [NL80211_CHAN_WIDTH_160] = MODE_UNKNOWN, 203 }, 204 [NL80211_BAND_5GHZ] = { 205 [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN, 206 [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN, 207 [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20, 208 [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20, 209 [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40, 210 [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80, 211 [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160, 212 [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80, 213 }, 214 [NL80211_BAND_6GHZ] = { 215 [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN, 216 [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN, 217 [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20, 218 [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20, 219 [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40, 220 [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80, 221 [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160, 222 [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80, 223 }, 224 225 }; 226 227 const struct htt_rx_ring_tlv_filter ath11k_mac_mon_status_filter_default = { 228 .rx_filter = HTT_RX_FILTER_TLV_FLAGS_MPDU_START | 229 HTT_RX_FILTER_TLV_FLAGS_PPDU_END | 230 HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE, 231 .pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0, 232 .pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1, 233 .pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2, 234 .pkt_filter_flags3 = HTT_RX_FP_DATA_FILTER_FLASG3 | 235 HTT_RX_FP_CTRL_FILTER_FLASG3 236 }; 237 238 #define ATH11K_MAC_FIRST_OFDM_RATE_IDX 4 239 #define ath11k_g_rates ath11k_legacy_rates 240 #define ath11k_g_rates_size (ARRAY_SIZE(ath11k_legacy_rates)) 241 #define ath11k_a_rates (ath11k_legacy_rates + 4) 242 #define ath11k_a_rates_size (ARRAY_SIZE(ath11k_legacy_rates) - 4) 243 244 #define ATH11K_MAC_SCAN_TIMEOUT_MSECS 200 /* in msecs */ 245 246 static const u32 ath11k_smps_map[] = { 247 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC, 248 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC, 249 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE, 250 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE, 251 }; 252 253 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw, 254 struct ieee80211_vif *vif); 255 256 enum nl80211_he_ru_alloc ath11k_mac_phy_he_ru_to_nl80211_he_ru_alloc(u16 ru_phy) 257 { 258 enum nl80211_he_ru_alloc ret; 259 260 switch (ru_phy) { 261 case RU_26: 262 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26; 263 break; 264 case RU_52: 265 ret = NL80211_RATE_INFO_HE_RU_ALLOC_52; 266 break; 267 case RU_106: 268 ret = NL80211_RATE_INFO_HE_RU_ALLOC_106; 269 break; 270 case RU_242: 271 ret = NL80211_RATE_INFO_HE_RU_ALLOC_242; 272 break; 273 case RU_484: 274 ret = NL80211_RATE_INFO_HE_RU_ALLOC_484; 275 break; 276 case RU_996: 277 ret = NL80211_RATE_INFO_HE_RU_ALLOC_996; 278 break; 279 default: 280 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26; 281 break; 282 } 283 284 return ret; 285 } 286 287 enum nl80211_he_ru_alloc ath11k_mac_he_ru_tones_to_nl80211_he_ru_alloc(u16 ru_tones) 288 { 289 enum nl80211_he_ru_alloc ret; 290 291 switch (ru_tones) { 292 case 26: 293 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26; 294 break; 295 case 52: 296 ret = NL80211_RATE_INFO_HE_RU_ALLOC_52; 297 break; 298 case 106: 299 ret = NL80211_RATE_INFO_HE_RU_ALLOC_106; 300 break; 301 case 242: 302 ret = NL80211_RATE_INFO_HE_RU_ALLOC_242; 303 break; 304 case 484: 305 ret = NL80211_RATE_INFO_HE_RU_ALLOC_484; 306 break; 307 case 996: 308 ret = NL80211_RATE_INFO_HE_RU_ALLOC_996; 309 break; 310 case (996 * 2): 311 ret = NL80211_RATE_INFO_HE_RU_ALLOC_2x996; 312 break; 313 default: 314 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26; 315 break; 316 } 317 318 return ret; 319 } 320 321 enum nl80211_he_gi ath11k_mac_he_gi_to_nl80211_he_gi(u8 sgi) 322 { 323 enum nl80211_he_gi ret; 324 325 switch (sgi) { 326 case RX_MSDU_START_SGI_0_8_US: 327 ret = NL80211_RATE_INFO_HE_GI_0_8; 328 break; 329 case RX_MSDU_START_SGI_1_6_US: 330 ret = NL80211_RATE_INFO_HE_GI_1_6; 331 break; 332 case RX_MSDU_START_SGI_3_2_US: 333 ret = NL80211_RATE_INFO_HE_GI_3_2; 334 break; 335 default: 336 ret = NL80211_RATE_INFO_HE_GI_0_8; 337 break; 338 } 339 340 return ret; 341 } 342 343 u8 ath11k_mac_bw_to_mac80211_bw(u8 bw) 344 { 345 u8 ret = 0; 346 347 switch (bw) { 348 case ATH11K_BW_20: 349 ret = RATE_INFO_BW_20; 350 break; 351 case ATH11K_BW_40: 352 ret = RATE_INFO_BW_40; 353 break; 354 case ATH11K_BW_80: 355 ret = RATE_INFO_BW_80; 356 break; 357 case ATH11K_BW_160: 358 ret = RATE_INFO_BW_160; 359 break; 360 } 361 362 return ret; 363 } 364 365 enum ath11k_supported_bw ath11k_mac_mac80211_bw_to_ath11k_bw(enum rate_info_bw bw) 366 { 367 switch (bw) { 368 case RATE_INFO_BW_20: 369 return ATH11K_BW_20; 370 case RATE_INFO_BW_40: 371 return ATH11K_BW_40; 372 case RATE_INFO_BW_80: 373 return ATH11K_BW_80; 374 case RATE_INFO_BW_160: 375 return ATH11K_BW_160; 376 default: 377 return ATH11K_BW_20; 378 } 379 } 380 381 int ath11k_mac_hw_ratecode_to_legacy_rate(u8 hw_rc, u8 preamble, u8 *rateidx, 382 u16 *rate) 383 { 384 /* As default, it is OFDM rates */ 385 int i = ATH11K_MAC_FIRST_OFDM_RATE_IDX; 386 int max_rates_idx = ath11k_g_rates_size; 387 388 if (preamble == WMI_RATE_PREAMBLE_CCK) { 389 hw_rc &= ~ATH11k_HW_RATECODE_CCK_SHORT_PREAM_MASK; 390 i = 0; 391 max_rates_idx = ATH11K_MAC_FIRST_OFDM_RATE_IDX; 392 } 393 394 while (i < max_rates_idx) { 395 if (hw_rc == ath11k_legacy_rates[i].hw_value) { 396 *rateidx = i; 397 *rate = ath11k_legacy_rates[i].bitrate; 398 return 0; 399 } 400 i++; 401 } 402 403 return -EINVAL; 404 } 405 406 static int get_num_chains(u32 mask) 407 { 408 int num_chains = 0; 409 410 while (mask) { 411 if (mask & BIT(0)) 412 num_chains++; 413 mask >>= 1; 414 } 415 416 return num_chains; 417 } 418 419 u8 ath11k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband, 420 u32 bitrate) 421 { 422 int i; 423 424 for (i = 0; i < sband->n_bitrates; i++) 425 if (sband->bitrates[i].bitrate == bitrate) 426 return i; 427 428 return 0; 429 } 430 431 static u32 432 ath11k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN]) 433 { 434 int nss; 435 436 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--) 437 if (ht_mcs_mask[nss]) 438 return nss + 1; 439 440 return 1; 441 } 442 443 static u32 444 ath11k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX]) 445 { 446 int nss; 447 448 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--) 449 if (vht_mcs_mask[nss]) 450 return nss + 1; 451 452 return 1; 453 } 454 455 static u32 456 ath11k_mac_max_he_nss(const u16 he_mcs_mask[NL80211_HE_NSS_MAX]) 457 { 458 int nss; 459 460 for (nss = NL80211_HE_NSS_MAX - 1; nss >= 0; nss--) 461 if (he_mcs_mask[nss]) 462 return nss + 1; 463 464 return 1; 465 } 466 467 static u8 ath11k_parse_mpdudensity(u8 mpdudensity) 468 { 469 /* 802.11n D2.0 defined values for "Minimum MPDU Start Spacing": 470 * 0 for no restriction 471 * 1 for 1/4 us 472 * 2 for 1/2 us 473 * 3 for 1 us 474 * 4 for 2 us 475 * 5 for 4 us 476 * 6 for 8 us 477 * 7 for 16 us 478 */ 479 switch (mpdudensity) { 480 case 0: 481 return 0; 482 case 1: 483 case 2: 484 case 3: 485 /* Our lower layer calculations limit our precision to 486 * 1 microsecond 487 */ 488 return 1; 489 case 4: 490 return 2; 491 case 5: 492 return 4; 493 case 6: 494 return 8; 495 case 7: 496 return 16; 497 default: 498 return 0; 499 } 500 } 501 502 static int ath11k_mac_vif_chan(struct ieee80211_vif *vif, 503 struct cfg80211_chan_def *def) 504 { 505 struct ieee80211_chanctx_conf *conf; 506 507 rcu_read_lock(); 508 conf = rcu_dereference(vif->chanctx_conf); 509 if (!conf) { 510 rcu_read_unlock(); 511 return -ENOENT; 512 } 513 514 *def = conf->def; 515 rcu_read_unlock(); 516 517 return 0; 518 } 519 520 static bool ath11k_mac_bitrate_is_cck(int bitrate) 521 { 522 switch (bitrate) { 523 case 10: 524 case 20: 525 case 55: 526 case 110: 527 return true; 528 } 529 530 return false; 531 } 532 533 u8 ath11k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband, 534 u8 hw_rate, bool cck) 535 { 536 const struct ieee80211_rate *rate; 537 int i; 538 539 for (i = 0; i < sband->n_bitrates; i++) { 540 rate = &sband->bitrates[i]; 541 542 if (ath11k_mac_bitrate_is_cck(rate->bitrate) != cck) 543 continue; 544 545 if (rate->hw_value == hw_rate) 546 return i; 547 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE && 548 rate->hw_value_short == hw_rate) 549 return i; 550 } 551 552 return 0; 553 } 554 555 static u8 ath11k_mac_bitrate_to_rate(int bitrate) 556 { 557 return DIV_ROUND_UP(bitrate, 5) | 558 (ath11k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0); 559 } 560 561 static void ath11k_get_arvif_iter(void *data, u8 *mac, 562 struct ieee80211_vif *vif) 563 { 564 struct ath11k_vif_iter *arvif_iter = data; 565 struct ath11k_vif *arvif = (void *)vif->drv_priv; 566 567 if (arvif->vdev_id == arvif_iter->vdev_id) 568 arvif_iter->arvif = arvif; 569 } 570 571 struct ath11k_vif *ath11k_mac_get_arvif(struct ath11k *ar, u32 vdev_id) 572 { 573 struct ath11k_vif_iter arvif_iter; 574 u32 flags; 575 576 memset(&arvif_iter, 0, sizeof(struct ath11k_vif_iter)); 577 arvif_iter.vdev_id = vdev_id; 578 579 flags = IEEE80211_IFACE_ITER_RESUME_ALL; 580 ieee80211_iterate_active_interfaces_atomic(ar->hw, 581 flags, 582 ath11k_get_arvif_iter, 583 &arvif_iter); 584 if (!arvif_iter.arvif) { 585 ath11k_warn(ar->ab, "No VIF found for vdev %d\n", vdev_id); 586 return NULL; 587 } 588 589 return arvif_iter.arvif; 590 } 591 592 struct ath11k_vif *ath11k_mac_get_arvif_by_vdev_id(struct ath11k_base *ab, 593 u32 vdev_id) 594 { 595 int i; 596 struct ath11k_pdev *pdev; 597 struct ath11k_vif *arvif; 598 599 for (i = 0; i < ab->num_radios; i++) { 600 pdev = rcu_dereference(ab->pdevs_active[i]); 601 if (pdev && pdev->ar && 602 (pdev->ar->allocated_vdev_map & (1LL << vdev_id))) { 603 arvif = ath11k_mac_get_arvif(pdev->ar, vdev_id); 604 if (arvif) 605 return arvif; 606 } 607 } 608 609 return NULL; 610 } 611 612 struct ath11k *ath11k_mac_get_ar_by_vdev_id(struct ath11k_base *ab, u32 vdev_id) 613 { 614 int i; 615 struct ath11k_pdev *pdev; 616 617 for (i = 0; i < ab->num_radios; i++) { 618 pdev = rcu_dereference(ab->pdevs_active[i]); 619 if (pdev && pdev->ar) { 620 if (pdev->ar->allocated_vdev_map & (1LL << vdev_id)) 621 return pdev->ar; 622 } 623 } 624 625 return NULL; 626 } 627 628 struct ath11k *ath11k_mac_get_ar_by_pdev_id(struct ath11k_base *ab, u32 pdev_id) 629 { 630 int i; 631 struct ath11k_pdev *pdev; 632 633 if (ab->hw_params.single_pdev_only) { 634 pdev = rcu_dereference(ab->pdevs_active[0]); 635 return pdev ? pdev->ar : NULL; 636 } 637 638 if (WARN_ON(pdev_id > ab->num_radios)) 639 return NULL; 640 641 for (i = 0; i < ab->num_radios; i++) { 642 pdev = rcu_dereference(ab->pdevs_active[i]); 643 644 if (pdev && pdev->pdev_id == pdev_id) 645 return (pdev->ar ? pdev->ar : NULL); 646 } 647 648 return NULL; 649 } 650 651 struct ath11k_vif *ath11k_mac_get_vif_up(struct ath11k_base *ab) 652 { 653 struct ath11k *ar; 654 struct ath11k_pdev *pdev; 655 struct ath11k_vif *arvif; 656 int i; 657 658 for (i = 0; i < ab->num_radios; i++) { 659 pdev = &ab->pdevs[i]; 660 ar = pdev->ar; 661 list_for_each_entry(arvif, &ar->arvifs, list) { 662 if (arvif->is_up) 663 return arvif; 664 } 665 } 666 667 return NULL; 668 } 669 670 static bool ath11k_mac_band_match(enum nl80211_band band1, enum WMI_HOST_WLAN_BAND band2) 671 { 672 return (((band1 == NL80211_BAND_2GHZ) && (band2 & WMI_HOST_WLAN_2G_CAP)) || 673 (((band1 == NL80211_BAND_5GHZ) || (band1 == NL80211_BAND_6GHZ)) && 674 (band2 & WMI_HOST_WLAN_5G_CAP))); 675 } 676 677 u8 ath11k_mac_get_target_pdev_id_from_vif(struct ath11k_vif *arvif) 678 { 679 struct ath11k *ar = arvif->ar; 680 struct ath11k_base *ab = ar->ab; 681 struct ieee80211_vif *vif = arvif->vif; 682 struct cfg80211_chan_def def; 683 enum nl80211_band band; 684 u8 pdev_id = ab->target_pdev_ids[0].pdev_id; 685 int i; 686 687 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 688 return pdev_id; 689 690 band = def.chan->band; 691 692 for (i = 0; i < ab->target_pdev_count; i++) { 693 if (ath11k_mac_band_match(band, ab->target_pdev_ids[i].supported_bands)) 694 return ab->target_pdev_ids[i].pdev_id; 695 } 696 697 return pdev_id; 698 } 699 700 u8 ath11k_mac_get_target_pdev_id(struct ath11k *ar) 701 { 702 struct ath11k_vif *arvif; 703 704 arvif = ath11k_mac_get_vif_up(ar->ab); 705 706 if (arvif) 707 return ath11k_mac_get_target_pdev_id_from_vif(arvif); 708 else 709 return ar->ab->target_pdev_ids[0].pdev_id; 710 } 711 712 static void ath11k_pdev_caps_update(struct ath11k *ar) 713 { 714 struct ath11k_base *ab = ar->ab; 715 716 ar->max_tx_power = ab->target_caps.hw_max_tx_power; 717 718 /* FIXME Set min_tx_power to ab->target_caps.hw_min_tx_power. 719 * But since the received value in svcrdy is same as hw_max_tx_power, 720 * we can set ar->min_tx_power to 0 currently until 721 * this is fixed in firmware 722 */ 723 ar->min_tx_power = 0; 724 725 ar->txpower_limit_2g = ar->max_tx_power; 726 ar->txpower_limit_5g = ar->max_tx_power; 727 ar->txpower_scale = WMI_HOST_TP_SCALE_MAX; 728 } 729 730 static int ath11k_mac_txpower_recalc(struct ath11k *ar) 731 { 732 struct ath11k_pdev *pdev = ar->pdev; 733 struct ath11k_vif *arvif; 734 int ret, txpower = -1; 735 u32 param; 736 737 lockdep_assert_held(&ar->conf_mutex); 738 739 list_for_each_entry(arvif, &ar->arvifs, list) { 740 if (arvif->txpower <= 0) 741 continue; 742 743 if (txpower == -1) 744 txpower = arvif->txpower; 745 else 746 txpower = min(txpower, arvif->txpower); 747 } 748 749 if (txpower == -1) 750 return 0; 751 752 /* txpwr is set as 2 units per dBm in FW*/ 753 txpower = min_t(u32, max_t(u32, ar->min_tx_power, txpower), 754 ar->max_tx_power) * 2; 755 756 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower to set in hw %d\n", 757 txpower / 2); 758 759 if ((pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) && 760 ar->txpower_limit_2g != txpower) { 761 param = WMI_PDEV_PARAM_TXPOWER_LIMIT2G; 762 ret = ath11k_wmi_pdev_set_param(ar, param, 763 txpower, ar->pdev->pdev_id); 764 if (ret) 765 goto fail; 766 ar->txpower_limit_2g = txpower; 767 } 768 769 if ((pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) && 770 ar->txpower_limit_5g != txpower) { 771 param = WMI_PDEV_PARAM_TXPOWER_LIMIT5G; 772 ret = ath11k_wmi_pdev_set_param(ar, param, 773 txpower, ar->pdev->pdev_id); 774 if (ret) 775 goto fail; 776 ar->txpower_limit_5g = txpower; 777 } 778 779 return 0; 780 781 fail: 782 ath11k_warn(ar->ab, "failed to recalc txpower limit %d using pdev param %d: %d\n", 783 txpower / 2, param, ret); 784 return ret; 785 } 786 787 static int ath11k_recalc_rtscts_prot(struct ath11k_vif *arvif) 788 { 789 struct ath11k *ar = arvif->ar; 790 u32 vdev_param, rts_cts = 0; 791 int ret; 792 793 lockdep_assert_held(&ar->conf_mutex); 794 795 vdev_param = WMI_VDEV_PARAM_ENABLE_RTSCTS; 796 797 /* Enable RTS/CTS protection for sw retries (when legacy stations 798 * are in BSS) or by default only for second rate series. 799 * TODO: Check if we need to enable CTS 2 Self in any case 800 */ 801 rts_cts = WMI_USE_RTS_CTS; 802 803 if (arvif->num_legacy_stations > 0) 804 rts_cts |= WMI_RTSCTS_ACROSS_SW_RETRIES << 4; 805 else 806 rts_cts |= WMI_RTSCTS_FOR_SECOND_RATESERIES << 4; 807 808 /* Need not send duplicate param value to firmware */ 809 if (arvif->rtscts_prot_mode == rts_cts) 810 return 0; 811 812 arvif->rtscts_prot_mode = rts_cts; 813 814 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %d recalc rts/cts prot %d\n", 815 arvif->vdev_id, rts_cts); 816 817 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 818 vdev_param, rts_cts); 819 if (ret) 820 ath11k_warn(ar->ab, "failed to recalculate rts/cts prot for vdev %d: %d\n", 821 arvif->vdev_id, ret); 822 823 return ret; 824 } 825 826 static int ath11k_mac_set_kickout(struct ath11k_vif *arvif) 827 { 828 struct ath11k *ar = arvif->ar; 829 u32 param; 830 int ret; 831 832 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_STA_KICKOUT_TH, 833 ATH11K_KICKOUT_THRESHOLD, 834 ar->pdev->pdev_id); 835 if (ret) { 836 ath11k_warn(ar->ab, "failed to set kickout threshold on vdev %i: %d\n", 837 arvif->vdev_id, ret); 838 return ret; 839 } 840 841 param = WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS; 842 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, 843 ATH11K_KEEPALIVE_MIN_IDLE); 844 if (ret) { 845 ath11k_warn(ar->ab, "failed to set keepalive minimum idle time on vdev %i: %d\n", 846 arvif->vdev_id, ret); 847 return ret; 848 } 849 850 param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS; 851 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, 852 ATH11K_KEEPALIVE_MAX_IDLE); 853 if (ret) { 854 ath11k_warn(ar->ab, "failed to set keepalive maximum idle time on vdev %i: %d\n", 855 arvif->vdev_id, ret); 856 return ret; 857 } 858 859 param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS; 860 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, 861 ATH11K_KEEPALIVE_MAX_UNRESPONSIVE); 862 if (ret) { 863 ath11k_warn(ar->ab, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n", 864 arvif->vdev_id, ret); 865 return ret; 866 } 867 868 return 0; 869 } 870 871 void ath11k_mac_peer_cleanup_all(struct ath11k *ar) 872 { 873 struct ath11k_peer *peer, *tmp; 874 struct ath11k_base *ab = ar->ab; 875 876 lockdep_assert_held(&ar->conf_mutex); 877 878 mutex_lock(&ab->tbl_mtx_lock); 879 spin_lock_bh(&ab->base_lock); 880 list_for_each_entry_safe(peer, tmp, &ab->peers, list) { 881 ath11k_peer_rx_tid_cleanup(ar, peer); 882 ath11k_peer_rhash_delete(ab, peer); 883 list_del(&peer->list); 884 kfree(peer); 885 } 886 spin_unlock_bh(&ab->base_lock); 887 mutex_unlock(&ab->tbl_mtx_lock); 888 889 ar->num_peers = 0; 890 ar->num_stations = 0; 891 } 892 893 static inline int ath11k_mac_vdev_setup_sync(struct ath11k *ar) 894 { 895 lockdep_assert_held(&ar->conf_mutex); 896 897 if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags)) 898 return -ESHUTDOWN; 899 900 if (!wait_for_completion_timeout(&ar->vdev_setup_done, 901 ATH11K_VDEV_SETUP_TIMEOUT_HZ)) 902 return -ETIMEDOUT; 903 904 return ar->last_wmi_vdev_start_status ? -EINVAL : 0; 905 } 906 907 static void 908 ath11k_mac_get_any_chandef_iter(struct ieee80211_hw *hw, 909 struct ieee80211_chanctx_conf *conf, 910 void *data) 911 { 912 struct cfg80211_chan_def **def = data; 913 914 *def = &conf->def; 915 } 916 917 static int ath11k_mac_monitor_vdev_start(struct ath11k *ar, int vdev_id, 918 struct cfg80211_chan_def *chandef) 919 { 920 struct ieee80211_channel *channel; 921 struct wmi_vdev_start_req_arg arg = {}; 922 int ret; 923 924 lockdep_assert_held(&ar->conf_mutex); 925 926 channel = chandef->chan; 927 928 arg.vdev_id = vdev_id; 929 arg.channel.freq = channel->center_freq; 930 arg.channel.band_center_freq1 = chandef->center_freq1; 931 arg.channel.band_center_freq2 = chandef->center_freq2; 932 933 arg.channel.mode = ath11k_phymodes[chandef->chan->band][chandef->width]; 934 arg.channel.chan_radar = !!(channel->flags & IEEE80211_CHAN_RADAR); 935 936 arg.channel.min_power = 0; 937 arg.channel.max_power = channel->max_power; 938 arg.channel.max_reg_power = channel->max_reg_power; 939 arg.channel.max_antenna_gain = channel->max_antenna_gain; 940 941 arg.pref_tx_streams = ar->num_tx_chains; 942 arg.pref_rx_streams = ar->num_rx_chains; 943 944 arg.channel.passive = !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR); 945 946 reinit_completion(&ar->vdev_setup_done); 947 reinit_completion(&ar->vdev_delete_done); 948 949 ret = ath11k_wmi_vdev_start(ar, &arg, false); 950 if (ret) { 951 ath11k_warn(ar->ab, "failed to request monitor vdev %i start: %d\n", 952 vdev_id, ret); 953 return ret; 954 } 955 956 ret = ath11k_mac_vdev_setup_sync(ar); 957 if (ret) { 958 ath11k_warn(ar->ab, "failed to synchronize setup for monitor vdev %i start: %d\n", 959 vdev_id, ret); 960 return ret; 961 } 962 963 ret = ath11k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr); 964 if (ret) { 965 ath11k_warn(ar->ab, "failed to put up monitor vdev %i: %d\n", 966 vdev_id, ret); 967 goto vdev_stop; 968 } 969 970 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %i started\n", 971 vdev_id); 972 973 return 0; 974 975 vdev_stop: 976 reinit_completion(&ar->vdev_setup_done); 977 978 ret = ath11k_wmi_vdev_stop(ar, vdev_id); 979 if (ret) { 980 ath11k_warn(ar->ab, "failed to stop monitor vdev %i after start failure: %d\n", 981 vdev_id, ret); 982 return ret; 983 } 984 985 ret = ath11k_mac_vdev_setup_sync(ar); 986 if (ret) { 987 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i stop: %d\n", 988 vdev_id, ret); 989 return ret; 990 } 991 992 return -EIO; 993 } 994 995 static int ath11k_mac_monitor_vdev_stop(struct ath11k *ar) 996 { 997 int ret; 998 999 lockdep_assert_held(&ar->conf_mutex); 1000 1001 reinit_completion(&ar->vdev_setup_done); 1002 1003 ret = ath11k_wmi_vdev_stop(ar, ar->monitor_vdev_id); 1004 if (ret) { 1005 ath11k_warn(ar->ab, "failed to request monitor vdev %i stop: %d\n", 1006 ar->monitor_vdev_id, ret); 1007 return ret; 1008 } 1009 1010 ret = ath11k_mac_vdev_setup_sync(ar); 1011 if (ret) { 1012 ath11k_warn(ar->ab, "failed to synchronize monitor vdev %i stop: %d\n", 1013 ar->monitor_vdev_id, ret); 1014 return ret; 1015 } 1016 1017 ret = ath11k_wmi_vdev_down(ar, ar->monitor_vdev_id); 1018 if (ret) { 1019 ath11k_warn(ar->ab, "failed to put down monitor vdev %i: %d\n", 1020 ar->monitor_vdev_id, ret); 1021 return ret; 1022 } 1023 1024 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %i stopped\n", 1025 ar->monitor_vdev_id); 1026 1027 return 0; 1028 } 1029 1030 static int ath11k_mac_monitor_vdev_create(struct ath11k *ar) 1031 { 1032 struct ath11k_pdev *pdev = ar->pdev; 1033 struct vdev_create_params param = {}; 1034 int bit, ret; 1035 u8 tmp_addr[6] = {0}; 1036 u16 nss; 1037 1038 lockdep_assert_held(&ar->conf_mutex); 1039 1040 if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) 1041 return 0; 1042 1043 if (ar->ab->free_vdev_map == 0) { 1044 ath11k_warn(ar->ab, "failed to find free vdev id for monitor vdev\n"); 1045 return -ENOMEM; 1046 } 1047 1048 bit = __ffs64(ar->ab->free_vdev_map); 1049 1050 ar->monitor_vdev_id = bit; 1051 1052 param.if_id = ar->monitor_vdev_id; 1053 param.type = WMI_VDEV_TYPE_MONITOR; 1054 param.subtype = WMI_VDEV_SUBTYPE_NONE; 1055 param.pdev_id = pdev->pdev_id; 1056 1057 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) { 1058 param.chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains; 1059 param.chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains; 1060 } 1061 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) { 1062 param.chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains; 1063 param.chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains; 1064 } 1065 1066 ret = ath11k_wmi_vdev_create(ar, tmp_addr, ¶m); 1067 if (ret) { 1068 ath11k_warn(ar->ab, "failed to request monitor vdev %i creation: %d\n", 1069 ar->monitor_vdev_id, ret); 1070 ar->monitor_vdev_id = -1; 1071 return ret; 1072 } 1073 1074 nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1; 1075 ret = ath11k_wmi_vdev_set_param_cmd(ar, ar->monitor_vdev_id, 1076 WMI_VDEV_PARAM_NSS, nss); 1077 if (ret) { 1078 ath11k_warn(ar->ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n", 1079 ar->monitor_vdev_id, ar->cfg_tx_chainmask, nss, ret); 1080 goto err_vdev_del; 1081 } 1082 1083 ret = ath11k_mac_txpower_recalc(ar); 1084 if (ret) { 1085 ath11k_warn(ar->ab, "failed to recalc txpower for monitor vdev %d: %d\n", 1086 ar->monitor_vdev_id, ret); 1087 goto err_vdev_del; 1088 } 1089 1090 ar->allocated_vdev_map |= 1LL << ar->monitor_vdev_id; 1091 ar->ab->free_vdev_map &= ~(1LL << ar->monitor_vdev_id); 1092 ar->num_created_vdevs++; 1093 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 1094 1095 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %d created\n", 1096 ar->monitor_vdev_id); 1097 1098 return 0; 1099 1100 err_vdev_del: 1101 ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id); 1102 ar->monitor_vdev_id = -1; 1103 return ret; 1104 } 1105 1106 static int ath11k_mac_monitor_vdev_delete(struct ath11k *ar) 1107 { 1108 int ret; 1109 unsigned long time_left; 1110 1111 lockdep_assert_held(&ar->conf_mutex); 1112 1113 if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) 1114 return 0; 1115 1116 reinit_completion(&ar->vdev_delete_done); 1117 1118 ret = ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id); 1119 if (ret) { 1120 ath11k_warn(ar->ab, "failed to request wmi monitor vdev %i removal: %d\n", 1121 ar->monitor_vdev_id, ret); 1122 return ret; 1123 } 1124 1125 time_left = wait_for_completion_timeout(&ar->vdev_delete_done, 1126 ATH11K_VDEV_DELETE_TIMEOUT_HZ); 1127 if (time_left == 0) { 1128 ath11k_warn(ar->ab, "Timeout in receiving vdev delete response\n"); 1129 } else { 1130 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %d deleted\n", 1131 ar->monitor_vdev_id); 1132 1133 ar->allocated_vdev_map &= ~(1LL << ar->monitor_vdev_id); 1134 ar->ab->free_vdev_map |= 1LL << (ar->monitor_vdev_id); 1135 ar->num_created_vdevs--; 1136 ar->monitor_vdev_id = -1; 1137 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 1138 } 1139 1140 return ret; 1141 } 1142 1143 static int ath11k_mac_monitor_start(struct ath11k *ar) 1144 { 1145 struct cfg80211_chan_def *chandef = NULL; 1146 int ret; 1147 1148 lockdep_assert_held(&ar->conf_mutex); 1149 1150 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) 1151 return 0; 1152 1153 ieee80211_iter_chan_contexts_atomic(ar->hw, 1154 ath11k_mac_get_any_chandef_iter, 1155 &chandef); 1156 if (!chandef) 1157 return 0; 1158 1159 ret = ath11k_mac_monitor_vdev_start(ar, ar->monitor_vdev_id, chandef); 1160 if (ret) { 1161 ath11k_warn(ar->ab, "failed to start monitor vdev: %d\n", ret); 1162 ath11k_mac_monitor_vdev_delete(ar); 1163 return ret; 1164 } 1165 1166 set_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags); 1167 1168 ar->num_started_vdevs++; 1169 ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, false); 1170 if (ret) { 1171 ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during start: %d", 1172 ret); 1173 return ret; 1174 } 1175 1176 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor started\n"); 1177 1178 return 0; 1179 } 1180 1181 static int ath11k_mac_monitor_stop(struct ath11k *ar) 1182 { 1183 int ret; 1184 1185 lockdep_assert_held(&ar->conf_mutex); 1186 1187 if (!test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) 1188 return 0; 1189 1190 ret = ath11k_mac_monitor_vdev_stop(ar); 1191 if (ret) { 1192 ath11k_warn(ar->ab, "failed to stop monitor vdev: %d\n", ret); 1193 return ret; 1194 } 1195 1196 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags); 1197 ar->num_started_vdevs--; 1198 1199 ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, true); 1200 if (ret) { 1201 ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during stop: %d", 1202 ret); 1203 return ret; 1204 } 1205 1206 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor stopped ret %d\n", ret); 1207 1208 return 0; 1209 } 1210 1211 static int ath11k_mac_vif_setup_ps(struct ath11k_vif *arvif) 1212 { 1213 struct ath11k *ar = arvif->ar; 1214 struct ieee80211_vif *vif = arvif->vif; 1215 struct ieee80211_conf *conf = &ar->hw->conf; 1216 enum wmi_sta_powersave_param param; 1217 enum wmi_sta_ps_mode psmode; 1218 int ret; 1219 int timeout; 1220 bool enable_ps; 1221 1222 lockdep_assert_held(&arvif->ar->conf_mutex); 1223 1224 if (arvif->vif->type != NL80211_IFTYPE_STATION) 1225 return 0; 1226 1227 enable_ps = arvif->ps; 1228 1229 if (!arvif->is_started) { 1230 /* mac80211 can update vif powersave state while disconnected. 1231 * Firmware doesn't behave nicely and consumes more power than 1232 * necessary if PS is disabled on a non-started vdev. Hence 1233 * force-enable PS for non-running vdevs. 1234 */ 1235 psmode = WMI_STA_PS_MODE_ENABLED; 1236 } else if (enable_ps) { 1237 psmode = WMI_STA_PS_MODE_ENABLED; 1238 param = WMI_STA_PS_PARAM_INACTIVITY_TIME; 1239 1240 timeout = conf->dynamic_ps_timeout; 1241 if (timeout == 0) { 1242 /* firmware doesn't like 0 */ 1243 timeout = ieee80211_tu_to_usec(vif->bss_conf.beacon_int) / 1000; 1244 } 1245 1246 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, 1247 timeout); 1248 if (ret) { 1249 ath11k_warn(ar->ab, "failed to set inactivity time for vdev %d: %i\n", 1250 arvif->vdev_id, ret); 1251 return ret; 1252 } 1253 } else { 1254 psmode = WMI_STA_PS_MODE_DISABLED; 1255 } 1256 1257 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %d psmode %s\n", 1258 arvif->vdev_id, psmode ? "enable" : "disable"); 1259 1260 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, psmode); 1261 if (ret) { 1262 ath11k_warn(ar->ab, "failed to set sta power save mode %d for vdev %d: %d\n", 1263 psmode, arvif->vdev_id, ret); 1264 return ret; 1265 } 1266 1267 return 0; 1268 } 1269 1270 static int ath11k_mac_config_ps(struct ath11k *ar) 1271 { 1272 struct ath11k_vif *arvif; 1273 int ret = 0; 1274 1275 lockdep_assert_held(&ar->conf_mutex); 1276 1277 list_for_each_entry(arvif, &ar->arvifs, list) { 1278 ret = ath11k_mac_vif_setup_ps(arvif); 1279 if (ret) { 1280 ath11k_warn(ar->ab, "failed to setup powersave: %d\n", ret); 1281 break; 1282 } 1283 } 1284 1285 return ret; 1286 } 1287 1288 static int ath11k_mac_op_config(struct ieee80211_hw *hw, u32 changed) 1289 { 1290 struct ath11k *ar = hw->priv; 1291 struct ieee80211_conf *conf = &hw->conf; 1292 int ret = 0; 1293 1294 mutex_lock(&ar->conf_mutex); 1295 1296 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 1297 if (conf->flags & IEEE80211_CONF_MONITOR) { 1298 set_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags); 1299 1300 if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, 1301 &ar->monitor_flags)) 1302 goto out; 1303 1304 ret = ath11k_mac_monitor_vdev_create(ar); 1305 if (ret) { 1306 ath11k_warn(ar->ab, "failed to create monitor vdev: %d", 1307 ret); 1308 goto out; 1309 } 1310 1311 ret = ath11k_mac_monitor_start(ar); 1312 if (ret) { 1313 ath11k_warn(ar->ab, "failed to start monitor: %d", 1314 ret); 1315 goto err_mon_del; 1316 } 1317 } else { 1318 clear_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags); 1319 1320 if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, 1321 &ar->monitor_flags)) 1322 goto out; 1323 1324 ret = ath11k_mac_monitor_stop(ar); 1325 if (ret) { 1326 ath11k_warn(ar->ab, "failed to stop monitor: %d", 1327 ret); 1328 goto out; 1329 } 1330 1331 ret = ath11k_mac_monitor_vdev_delete(ar); 1332 if (ret) { 1333 ath11k_warn(ar->ab, "failed to delete monitor vdev: %d", 1334 ret); 1335 goto out; 1336 } 1337 } 1338 } 1339 1340 out: 1341 mutex_unlock(&ar->conf_mutex); 1342 return ret; 1343 1344 err_mon_del: 1345 ath11k_mac_monitor_vdev_delete(ar); 1346 mutex_unlock(&ar->conf_mutex); 1347 return ret; 1348 } 1349 1350 static int ath11k_mac_setup_bcn_tmpl(struct ath11k_vif *arvif) 1351 { 1352 struct ath11k *ar = arvif->ar; 1353 struct ath11k_base *ab = ar->ab; 1354 struct ieee80211_hw *hw = ar->hw; 1355 struct ieee80211_vif *vif = arvif->vif; 1356 struct ieee80211_mutable_offsets offs = {}; 1357 struct sk_buff *bcn; 1358 struct ieee80211_mgmt *mgmt; 1359 u8 *ies; 1360 int ret; 1361 1362 if (arvif->vdev_type != WMI_VDEV_TYPE_AP) 1363 return 0; 1364 1365 bcn = ieee80211_beacon_get_template(hw, vif, &offs); 1366 if (!bcn) { 1367 ath11k_warn(ab, "failed to get beacon template from mac80211\n"); 1368 return -EPERM; 1369 } 1370 1371 ies = bcn->data + ieee80211_get_hdrlen_from_skb(bcn); 1372 ies += sizeof(mgmt->u.beacon); 1373 1374 if (cfg80211_find_ie(WLAN_EID_RSN, ies, (skb_tail_pointer(bcn) - ies))) 1375 arvif->rsnie_present = true; 1376 else 1377 arvif->rsnie_present = false; 1378 1379 if (cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, 1380 WLAN_OUI_TYPE_MICROSOFT_WPA, 1381 ies, (skb_tail_pointer(bcn) - ies))) 1382 arvif->wpaie_present = true; 1383 else 1384 arvif->wpaie_present = false; 1385 1386 ret = ath11k_wmi_bcn_tmpl(ar, arvif->vdev_id, &offs, bcn); 1387 1388 kfree_skb(bcn); 1389 1390 if (ret) 1391 ath11k_warn(ab, "failed to submit beacon template command: %d\n", 1392 ret); 1393 1394 return ret; 1395 } 1396 1397 void ath11k_mac_bcn_tx_event(struct ath11k_vif *arvif) 1398 { 1399 struct ieee80211_vif *vif = arvif->vif; 1400 1401 if (!vif->color_change_active && !arvif->bcca_zero_sent) 1402 return; 1403 1404 if (vif->color_change_active && ieee80211_beacon_cntdwn_is_complete(vif)) { 1405 arvif->bcca_zero_sent = true; 1406 ieee80211_color_change_finish(vif); 1407 return; 1408 } 1409 1410 arvif->bcca_zero_sent = false; 1411 1412 if (vif->color_change_active) 1413 ieee80211_beacon_update_cntdwn(vif); 1414 ath11k_mac_setup_bcn_tmpl(arvif); 1415 } 1416 1417 static void ath11k_control_beaconing(struct ath11k_vif *arvif, 1418 struct ieee80211_bss_conf *info) 1419 { 1420 struct ath11k *ar = arvif->ar; 1421 int ret = 0; 1422 1423 lockdep_assert_held(&arvif->ar->conf_mutex); 1424 1425 if (!info->enable_beacon) { 1426 ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id); 1427 if (ret) 1428 ath11k_warn(ar->ab, "failed to down vdev_id %i: %d\n", 1429 arvif->vdev_id, ret); 1430 1431 arvif->is_up = false; 1432 return; 1433 } 1434 1435 /* Install the beacon template to the FW */ 1436 ret = ath11k_mac_setup_bcn_tmpl(arvif); 1437 if (ret) { 1438 ath11k_warn(ar->ab, "failed to update bcn tmpl during vdev up: %d\n", 1439 ret); 1440 return; 1441 } 1442 1443 arvif->tx_seq_no = 0x1000; 1444 1445 arvif->aid = 0; 1446 1447 ether_addr_copy(arvif->bssid, info->bssid); 1448 1449 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 1450 arvif->bssid); 1451 if (ret) { 1452 ath11k_warn(ar->ab, "failed to bring up vdev %d: %i\n", 1453 arvif->vdev_id, ret); 1454 return; 1455 } 1456 1457 arvif->is_up = true; 1458 1459 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id); 1460 } 1461 1462 static void ath11k_mac_handle_beacon_iter(void *data, u8 *mac, 1463 struct ieee80211_vif *vif) 1464 { 1465 struct sk_buff *skb = data; 1466 struct ieee80211_mgmt *mgmt = (void *)skb->data; 1467 struct ath11k_vif *arvif = (void *)vif->drv_priv; 1468 1469 if (vif->type != NL80211_IFTYPE_STATION) 1470 return; 1471 1472 if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid)) 1473 return; 1474 1475 cancel_delayed_work(&arvif->connection_loss_work); 1476 } 1477 1478 void ath11k_mac_handle_beacon(struct ath11k *ar, struct sk_buff *skb) 1479 { 1480 ieee80211_iterate_active_interfaces_atomic(ar->hw, 1481 IEEE80211_IFACE_ITER_NORMAL, 1482 ath11k_mac_handle_beacon_iter, 1483 skb); 1484 } 1485 1486 static void ath11k_mac_handle_beacon_miss_iter(void *data, u8 *mac, 1487 struct ieee80211_vif *vif) 1488 { 1489 u32 *vdev_id = data; 1490 struct ath11k_vif *arvif = (void *)vif->drv_priv; 1491 struct ath11k *ar = arvif->ar; 1492 struct ieee80211_hw *hw = ar->hw; 1493 1494 if (arvif->vdev_id != *vdev_id) 1495 return; 1496 1497 if (!arvif->is_up) 1498 return; 1499 1500 ieee80211_beacon_loss(vif); 1501 1502 /* Firmware doesn't report beacon loss events repeatedly. If AP probe 1503 * (done by mac80211) succeeds but beacons do not resume then it 1504 * doesn't make sense to continue operation. Queue connection loss work 1505 * which can be cancelled when beacon is received. 1506 */ 1507 ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work, 1508 ATH11K_CONNECTION_LOSS_HZ); 1509 } 1510 1511 void ath11k_mac_handle_beacon_miss(struct ath11k *ar, u32 vdev_id) 1512 { 1513 ieee80211_iterate_active_interfaces_atomic(ar->hw, 1514 IEEE80211_IFACE_ITER_NORMAL, 1515 ath11k_mac_handle_beacon_miss_iter, 1516 &vdev_id); 1517 } 1518 1519 static void ath11k_mac_vif_sta_connection_loss_work(struct work_struct *work) 1520 { 1521 struct ath11k_vif *arvif = container_of(work, struct ath11k_vif, 1522 connection_loss_work.work); 1523 struct ieee80211_vif *vif = arvif->vif; 1524 1525 if (!arvif->is_up) 1526 return; 1527 1528 ieee80211_connection_loss(vif); 1529 } 1530 1531 static void ath11k_peer_assoc_h_basic(struct ath11k *ar, 1532 struct ieee80211_vif *vif, 1533 struct ieee80211_sta *sta, 1534 struct peer_assoc_params *arg) 1535 { 1536 struct ath11k_vif *arvif = (void *)vif->drv_priv; 1537 u32 aid; 1538 1539 lockdep_assert_held(&ar->conf_mutex); 1540 1541 if (vif->type == NL80211_IFTYPE_STATION) 1542 aid = vif->bss_conf.aid; 1543 else 1544 aid = sta->aid; 1545 1546 ether_addr_copy(arg->peer_mac, sta->addr); 1547 arg->vdev_id = arvif->vdev_id; 1548 arg->peer_associd = aid; 1549 arg->auth_flag = true; 1550 /* TODO: STA WAR in ath10k for listen interval required? */ 1551 arg->peer_listen_intval = ar->hw->conf.listen_interval; 1552 arg->peer_nss = 1; 1553 arg->peer_caps = vif->bss_conf.assoc_capability; 1554 } 1555 1556 static void ath11k_peer_assoc_h_crypto(struct ath11k *ar, 1557 struct ieee80211_vif *vif, 1558 struct ieee80211_sta *sta, 1559 struct peer_assoc_params *arg) 1560 { 1561 struct ieee80211_bss_conf *info = &vif->bss_conf; 1562 struct cfg80211_chan_def def; 1563 struct cfg80211_bss *bss; 1564 struct ath11k_vif *arvif = (struct ath11k_vif *)vif->drv_priv; 1565 const u8 *rsnie = NULL; 1566 const u8 *wpaie = NULL; 1567 1568 lockdep_assert_held(&ar->conf_mutex); 1569 1570 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 1571 return; 1572 1573 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0, 1574 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY); 1575 1576 if (arvif->rsnie_present || arvif->wpaie_present) { 1577 arg->need_ptk_4_way = true; 1578 if (arvif->wpaie_present) 1579 arg->need_gtk_2_way = true; 1580 } else if (bss) { 1581 const struct cfg80211_bss_ies *ies; 1582 1583 rcu_read_lock(); 1584 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN); 1585 1586 ies = rcu_dereference(bss->ies); 1587 1588 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, 1589 WLAN_OUI_TYPE_MICROSOFT_WPA, 1590 ies->data, 1591 ies->len); 1592 rcu_read_unlock(); 1593 cfg80211_put_bss(ar->hw->wiphy, bss); 1594 } 1595 1596 /* FIXME: base on RSN IE/WPA IE is a correct idea? */ 1597 if (rsnie || wpaie) { 1598 ath11k_dbg(ar->ab, ATH11K_DBG_WMI, 1599 "%s: rsn ie found\n", __func__); 1600 arg->need_ptk_4_way = true; 1601 } 1602 1603 if (wpaie) { 1604 ath11k_dbg(ar->ab, ATH11K_DBG_WMI, 1605 "%s: wpa ie found\n", __func__); 1606 arg->need_gtk_2_way = true; 1607 } 1608 1609 if (sta->mfp) { 1610 /* TODO: Need to check if FW supports PMF? */ 1611 arg->is_pmf_enabled = true; 1612 } 1613 1614 /* TODO: safe_mode_enabled (bypass 4-way handshake) flag req? */ 1615 } 1616 1617 static void ath11k_peer_assoc_h_rates(struct ath11k *ar, 1618 struct ieee80211_vif *vif, 1619 struct ieee80211_sta *sta, 1620 struct peer_assoc_params *arg) 1621 { 1622 struct ath11k_vif *arvif = (void *)vif->drv_priv; 1623 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates; 1624 struct cfg80211_chan_def def; 1625 const struct ieee80211_supported_band *sband; 1626 const struct ieee80211_rate *rates; 1627 enum nl80211_band band; 1628 u32 ratemask; 1629 u8 rate; 1630 int i; 1631 1632 lockdep_assert_held(&ar->conf_mutex); 1633 1634 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 1635 return; 1636 1637 band = def.chan->band; 1638 sband = ar->hw->wiphy->bands[band]; 1639 ratemask = sta->deflink.supp_rates[band]; 1640 ratemask &= arvif->bitrate_mask.control[band].legacy; 1641 rates = sband->bitrates; 1642 1643 rateset->num_rates = 0; 1644 1645 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) { 1646 if (!(ratemask & 1)) 1647 continue; 1648 1649 rate = ath11k_mac_bitrate_to_rate(rates->bitrate); 1650 rateset->rates[rateset->num_rates] = rate; 1651 rateset->num_rates++; 1652 } 1653 } 1654 1655 static bool 1656 ath11k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN]) 1657 { 1658 int nss; 1659 1660 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++) 1661 if (ht_mcs_mask[nss]) 1662 return false; 1663 1664 return true; 1665 } 1666 1667 static bool 1668 ath11k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[]) 1669 { 1670 int nss; 1671 1672 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) 1673 if (vht_mcs_mask[nss]) 1674 return false; 1675 1676 return true; 1677 } 1678 1679 static void ath11k_peer_assoc_h_ht(struct ath11k *ar, 1680 struct ieee80211_vif *vif, 1681 struct ieee80211_sta *sta, 1682 struct peer_assoc_params *arg) 1683 { 1684 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap; 1685 struct ath11k_vif *arvif = (void *)vif->drv_priv; 1686 struct cfg80211_chan_def def; 1687 enum nl80211_band band; 1688 const u8 *ht_mcs_mask; 1689 int i, n; 1690 u8 max_nss; 1691 u32 stbc; 1692 1693 lockdep_assert_held(&ar->conf_mutex); 1694 1695 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 1696 return; 1697 1698 if (!ht_cap->ht_supported) 1699 return; 1700 1701 band = def.chan->band; 1702 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 1703 1704 if (ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) 1705 return; 1706 1707 arg->ht_flag = true; 1708 1709 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + 1710 ht_cap->ampdu_factor)) - 1; 1711 1712 arg->peer_mpdu_density = 1713 ath11k_parse_mpdudensity(ht_cap->ampdu_density); 1714 1715 arg->peer_ht_caps = ht_cap->cap; 1716 arg->peer_rate_caps |= WMI_HOST_RC_HT_FLAG; 1717 1718 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING) 1719 arg->ldpc_flag = true; 1720 1721 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) { 1722 arg->bw_40 = true; 1723 arg->peer_rate_caps |= WMI_HOST_RC_CW40_FLAG; 1724 } 1725 1726 /* As firmware handles this two flags (IEEE80211_HT_CAP_SGI_20 1727 * and IEEE80211_HT_CAP_SGI_40) for enabling SGI, we reset 1728 * both flags if guard interval is Default GI 1729 */ 1730 if (arvif->bitrate_mask.control[band].gi == NL80211_TXRATE_DEFAULT_GI) 1731 arg->peer_ht_caps &= ~(IEEE80211_HT_CAP_SGI_20 | 1732 IEEE80211_HT_CAP_SGI_40); 1733 1734 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) { 1735 if (ht_cap->cap & (IEEE80211_HT_CAP_SGI_20 | 1736 IEEE80211_HT_CAP_SGI_40)) 1737 arg->peer_rate_caps |= WMI_HOST_RC_SGI_FLAG; 1738 } 1739 1740 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) { 1741 arg->peer_rate_caps |= WMI_HOST_RC_TX_STBC_FLAG; 1742 arg->stbc_flag = true; 1743 } 1744 1745 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) { 1746 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC; 1747 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT; 1748 stbc = stbc << WMI_HOST_RC_RX_STBC_FLAG_S; 1749 arg->peer_rate_caps |= stbc; 1750 arg->stbc_flag = true; 1751 } 1752 1753 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2]) 1754 arg->peer_rate_caps |= WMI_HOST_RC_TS_FLAG; 1755 else if (ht_cap->mcs.rx_mask[1]) 1756 arg->peer_rate_caps |= WMI_HOST_RC_DS_FLAG; 1757 1758 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++) 1759 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) && 1760 (ht_mcs_mask[i / 8] & BIT(i % 8))) { 1761 max_nss = (i / 8) + 1; 1762 arg->peer_ht_rates.rates[n++] = i; 1763 } 1764 1765 /* This is a workaround for HT-enabled STAs which break the spec 1766 * and have no HT capabilities RX mask (no HT RX MCS map). 1767 * 1768 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS), 1769 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs. 1770 * 1771 * Firmware asserts if such situation occurs. 1772 */ 1773 if (n == 0) { 1774 arg->peer_ht_rates.num_rates = 8; 1775 for (i = 0; i < arg->peer_ht_rates.num_rates; i++) 1776 arg->peer_ht_rates.rates[i] = i; 1777 } else { 1778 arg->peer_ht_rates.num_rates = n; 1779 arg->peer_nss = min(sta->deflink.rx_nss, max_nss); 1780 } 1781 1782 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n", 1783 arg->peer_mac, 1784 arg->peer_ht_rates.num_rates, 1785 arg->peer_nss); 1786 } 1787 1788 static int ath11k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss) 1789 { 1790 switch ((mcs_map >> (2 * nss)) & 0x3) { 1791 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1; 1792 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1; 1793 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1; 1794 } 1795 return 0; 1796 } 1797 1798 static u16 1799 ath11k_peer_assoc_h_vht_limit(u16 tx_mcs_set, 1800 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX]) 1801 { 1802 int idx_limit; 1803 int nss; 1804 u16 mcs_map; 1805 u16 mcs; 1806 1807 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) { 1808 mcs_map = ath11k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) & 1809 vht_mcs_limit[nss]; 1810 1811 if (mcs_map) 1812 idx_limit = fls(mcs_map) - 1; 1813 else 1814 idx_limit = -1; 1815 1816 switch (idx_limit) { 1817 case 0: 1818 case 1: 1819 case 2: 1820 case 3: 1821 case 4: 1822 case 5: 1823 case 6: 1824 case 7: 1825 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7; 1826 break; 1827 case 8: 1828 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8; 1829 break; 1830 case 9: 1831 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9; 1832 break; 1833 default: 1834 WARN_ON(1); 1835 fallthrough; 1836 case -1: 1837 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED; 1838 break; 1839 } 1840 1841 tx_mcs_set &= ~(0x3 << (nss * 2)); 1842 tx_mcs_set |= mcs << (nss * 2); 1843 } 1844 1845 return tx_mcs_set; 1846 } 1847 1848 static u8 ath11k_get_nss_160mhz(struct ath11k *ar, 1849 u8 max_nss) 1850 { 1851 u8 nss_ratio_info = ar->pdev->cap.nss_ratio_info; 1852 u8 max_sup_nss = 0; 1853 1854 switch (nss_ratio_info) { 1855 case WMI_NSS_RATIO_1BY2_NSS: 1856 max_sup_nss = max_nss >> 1; 1857 break; 1858 case WMI_NSS_RATIO_3BY4_NSS: 1859 ath11k_warn(ar->ab, "WMI_NSS_RATIO_3BY4_NSS not supported\n"); 1860 break; 1861 case WMI_NSS_RATIO_1_NSS: 1862 max_sup_nss = max_nss; 1863 break; 1864 case WMI_NSS_RATIO_2_NSS: 1865 ath11k_warn(ar->ab, "WMI_NSS_RATIO_2_NSS not supported\n"); 1866 break; 1867 default: 1868 ath11k_warn(ar->ab, "invalid nss ratio received from firmware: %d\n", 1869 nss_ratio_info); 1870 break; 1871 } 1872 1873 return max_sup_nss; 1874 } 1875 1876 static void ath11k_peer_assoc_h_vht(struct ath11k *ar, 1877 struct ieee80211_vif *vif, 1878 struct ieee80211_sta *sta, 1879 struct peer_assoc_params *arg) 1880 { 1881 const struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap; 1882 struct ath11k_vif *arvif = (void *)vif->drv_priv; 1883 struct cfg80211_chan_def def; 1884 enum nl80211_band band; 1885 u16 *vht_mcs_mask; 1886 u8 ampdu_factor; 1887 u8 max_nss, vht_mcs; 1888 int i, vht_nss, nss_idx; 1889 bool user_rate_valid = true; 1890 u32 rx_nss, tx_nss, nss_160; 1891 1892 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 1893 return; 1894 1895 if (!vht_cap->vht_supported) 1896 return; 1897 1898 band = def.chan->band; 1899 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 1900 1901 if (ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) 1902 return; 1903 1904 arg->vht_flag = true; 1905 1906 /* TODO: similar flags required? */ 1907 arg->vht_capable = true; 1908 1909 if (def.chan->band == NL80211_BAND_2GHZ) 1910 arg->vht_ng_flag = true; 1911 1912 arg->peer_vht_caps = vht_cap->cap; 1913 1914 ampdu_factor = (vht_cap->cap & 1915 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >> 1916 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT; 1917 1918 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to 1919 * zero in VHT IE. Using it would result in degraded throughput. 1920 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep 1921 * it if VHT max_mpdu is smaller. 1922 */ 1923 arg->peer_max_mpdu = max(arg->peer_max_mpdu, 1924 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR + 1925 ampdu_factor)) - 1); 1926 1927 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80) 1928 arg->bw_80 = true; 1929 1930 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) 1931 arg->bw_160 = true; 1932 1933 vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask); 1934 1935 if (vht_nss > sta->deflink.rx_nss) { 1936 user_rate_valid = false; 1937 for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) { 1938 if (vht_mcs_mask[nss_idx]) { 1939 user_rate_valid = true; 1940 break; 1941 } 1942 } 1943 } 1944 1945 if (!user_rate_valid) { 1946 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac setting vht range mcs value to peer supported nss %d for peer %pM\n", 1947 sta->deflink.rx_nss, sta->addr); 1948 vht_mcs_mask[sta->deflink.rx_nss - 1] = vht_mcs_mask[vht_nss - 1]; 1949 } 1950 1951 /* Calculate peer NSS capability from VHT capabilities if STA 1952 * supports VHT. 1953 */ 1954 for (i = 0, max_nss = 0, vht_mcs = 0; i < NL80211_VHT_NSS_MAX; i++) { 1955 vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >> 1956 (2 * i) & 3; 1957 1958 if (vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED && 1959 vht_mcs_mask[i]) 1960 max_nss = i + 1; 1961 } 1962 arg->peer_nss = min(sta->deflink.rx_nss, max_nss); 1963 arg->rx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.rx_highest); 1964 arg->rx_mcs_set = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map); 1965 arg->tx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.tx_highest); 1966 arg->tx_mcs_set = ath11k_peer_assoc_h_vht_limit( 1967 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask); 1968 1969 /* In IPQ8074 platform, VHT mcs rate 10 and 11 is enabled by default. 1970 * VHT mcs rate 10 and 11 is not suppoerted in 11ac standard. 1971 * so explicitly disable the VHT MCS rate 10 and 11 in 11ac mode. 1972 */ 1973 arg->tx_mcs_set &= ~IEEE80211_VHT_MCS_SUPPORT_0_11_MASK; 1974 arg->tx_mcs_set |= IEEE80211_DISABLE_VHT_MCS_SUPPORT_0_11; 1975 1976 if ((arg->tx_mcs_set & IEEE80211_VHT_MCS_NOT_SUPPORTED) == 1977 IEEE80211_VHT_MCS_NOT_SUPPORTED) 1978 arg->peer_vht_caps &= ~IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE; 1979 1980 /* TODO: Check */ 1981 arg->tx_max_mcs_nss = 0xFF; 1982 1983 if (arg->peer_phymode == MODE_11AC_VHT160 || 1984 arg->peer_phymode == MODE_11AC_VHT80_80) { 1985 tx_nss = ath11k_get_nss_160mhz(ar, max_nss); 1986 rx_nss = min(arg->peer_nss, tx_nss); 1987 arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE; 1988 1989 if (!rx_nss) { 1990 ath11k_warn(ar->ab, "invalid max_nss\n"); 1991 return; 1992 } 1993 1994 if (arg->peer_phymode == MODE_11AC_VHT160) 1995 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1); 1996 else 1997 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1); 1998 1999 arg->peer_bw_rxnss_override |= nss_160; 2000 } 2001 2002 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 2003 "mac vht peer %pM max_mpdu %d flags 0x%x nss_override 0x%x\n", 2004 sta->addr, arg->peer_max_mpdu, arg->peer_flags, 2005 arg->peer_bw_rxnss_override); 2006 } 2007 2008 static int ath11k_mac_get_max_he_mcs_map(u16 mcs_map, int nss) 2009 { 2010 switch ((mcs_map >> (2 * nss)) & 0x3) { 2011 case IEEE80211_HE_MCS_SUPPORT_0_7: return BIT(8) - 1; 2012 case IEEE80211_HE_MCS_SUPPORT_0_9: return BIT(10) - 1; 2013 case IEEE80211_HE_MCS_SUPPORT_0_11: return BIT(12) - 1; 2014 } 2015 return 0; 2016 } 2017 2018 static u16 ath11k_peer_assoc_h_he_limit(u16 tx_mcs_set, 2019 const u16 he_mcs_limit[NL80211_HE_NSS_MAX]) 2020 { 2021 int idx_limit; 2022 int nss; 2023 u16 mcs_map; 2024 u16 mcs; 2025 2026 for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++) { 2027 mcs_map = ath11k_mac_get_max_he_mcs_map(tx_mcs_set, nss) & 2028 he_mcs_limit[nss]; 2029 2030 if (mcs_map) 2031 idx_limit = fls(mcs_map) - 1; 2032 else 2033 idx_limit = -1; 2034 2035 switch (idx_limit) { 2036 case 0 ... 7: 2037 mcs = IEEE80211_HE_MCS_SUPPORT_0_7; 2038 break; 2039 case 8: 2040 case 9: 2041 mcs = IEEE80211_HE_MCS_SUPPORT_0_9; 2042 break; 2043 case 10: 2044 case 11: 2045 mcs = IEEE80211_HE_MCS_SUPPORT_0_11; 2046 break; 2047 default: 2048 WARN_ON(1); 2049 fallthrough; 2050 case -1: 2051 mcs = IEEE80211_HE_MCS_NOT_SUPPORTED; 2052 break; 2053 } 2054 2055 tx_mcs_set &= ~(0x3 << (nss * 2)); 2056 tx_mcs_set |= mcs << (nss * 2); 2057 } 2058 2059 return tx_mcs_set; 2060 } 2061 2062 static bool 2063 ath11k_peer_assoc_h_he_masked(const u16 he_mcs_mask[NL80211_HE_NSS_MAX]) 2064 { 2065 int nss; 2066 2067 for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++) 2068 if (he_mcs_mask[nss]) 2069 return false; 2070 2071 return true; 2072 } 2073 2074 static void ath11k_peer_assoc_h_he(struct ath11k *ar, 2075 struct ieee80211_vif *vif, 2076 struct ieee80211_sta *sta, 2077 struct peer_assoc_params *arg) 2078 { 2079 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2080 struct cfg80211_chan_def def; 2081 const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap; 2082 enum nl80211_band band; 2083 u16 *he_mcs_mask; 2084 u8 max_nss, he_mcs; 2085 u16 he_tx_mcs = 0, v = 0; 2086 int i, he_nss, nss_idx; 2087 bool user_rate_valid = true; 2088 u32 rx_nss, tx_nss, nss_160; 2089 u8 ampdu_factor, rx_mcs_80, rx_mcs_160; 2090 u16 mcs_160_map, mcs_80_map; 2091 bool support_160; 2092 2093 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 2094 return; 2095 2096 if (!he_cap->has_he) 2097 return; 2098 2099 band = def.chan->band; 2100 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs; 2101 2102 if (ath11k_peer_assoc_h_he_masked(he_mcs_mask)) 2103 return; 2104 2105 arg->he_flag = true; 2106 support_160 = !!(he_cap->he_cap_elem.phy_cap_info[0] & 2107 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G); 2108 2109 /* Supported HE-MCS and NSS Set of peer he_cap is intersection with self he_cp */ 2110 mcs_160_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160); 2111 mcs_80_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80); 2112 2113 if (support_160) { 2114 for (i = 7; i >= 0; i--) { 2115 u8 mcs_160 = (mcs_160_map >> (2 * i)) & 3; 2116 2117 if (mcs_160 != IEEE80211_VHT_MCS_NOT_SUPPORTED) { 2118 rx_mcs_160 = i + 1; 2119 break; 2120 } 2121 } 2122 } 2123 2124 for (i = 7; i >= 0; i--) { 2125 u8 mcs_80 = (mcs_80_map >> (2 * i)) & 3; 2126 2127 if (mcs_80 != IEEE80211_VHT_MCS_NOT_SUPPORTED) { 2128 rx_mcs_80 = i + 1; 2129 break; 2130 } 2131 } 2132 2133 if (support_160) 2134 max_nss = min(rx_mcs_80, rx_mcs_160); 2135 else 2136 max_nss = rx_mcs_80; 2137 2138 arg->peer_nss = min(sta->deflink.rx_nss, max_nss); 2139 2140 memcpy_and_pad(&arg->peer_he_cap_macinfo, 2141 sizeof(arg->peer_he_cap_macinfo), 2142 he_cap->he_cap_elem.mac_cap_info, 2143 sizeof(he_cap->he_cap_elem.mac_cap_info), 2144 0); 2145 memcpy_and_pad(&arg->peer_he_cap_phyinfo, 2146 sizeof(arg->peer_he_cap_phyinfo), 2147 he_cap->he_cap_elem.phy_cap_info, 2148 sizeof(he_cap->he_cap_elem.phy_cap_info), 2149 0); 2150 arg->peer_he_ops = vif->bss_conf.he_oper.params; 2151 2152 /* the top most byte is used to indicate BSS color info */ 2153 arg->peer_he_ops &= 0xffffff; 2154 2155 /* As per section 26.6.1 11ax Draft5.0, if the Max AMPDU Exponent Extension 2156 * in HE cap is zero, use the arg->peer_max_mpdu as calculated while parsing 2157 * VHT caps(if VHT caps is present) or HT caps (if VHT caps is not present). 2158 * 2159 * For non-zero value of Max AMPDU Extponent Extension in HE MAC caps, 2160 * if a HE STA sends VHT cap and HE cap IE in assoc request then, use 2161 * MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length. 2162 * If a HE STA that does not send VHT cap, but HE and HT cap in assoc 2163 * request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu 2164 * length. 2165 */ 2166 ampdu_factor = u8_get_bits(he_cap->he_cap_elem.mac_cap_info[3], 2167 IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK); 2168 2169 if (ampdu_factor) { 2170 if (sta->deflink.vht_cap.vht_supported) 2171 arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR + 2172 ampdu_factor)) - 1; 2173 else if (sta->deflink.ht_cap.ht_supported) 2174 arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR + 2175 ampdu_factor)) - 1; 2176 } 2177 2178 if (he_cap->he_cap_elem.phy_cap_info[6] & 2179 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) { 2180 int bit = 7; 2181 int nss, ru; 2182 2183 arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0] & 2184 IEEE80211_PPE_THRES_NSS_MASK; 2185 arg->peer_ppet.ru_bit_mask = 2186 (he_cap->ppe_thres[0] & 2187 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >> 2188 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS; 2189 2190 for (nss = 0; nss <= arg->peer_ppet.numss_m1; nss++) { 2191 for (ru = 0; ru < 4; ru++) { 2192 u32 val = 0; 2193 int i; 2194 2195 if ((arg->peer_ppet.ru_bit_mask & BIT(ru)) == 0) 2196 continue; 2197 for (i = 0; i < 6; i++) { 2198 val >>= 1; 2199 val |= ((he_cap->ppe_thres[bit / 8] >> 2200 (bit % 8)) & 0x1) << 5; 2201 bit++; 2202 } 2203 arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |= 2204 val << (ru * 6); 2205 } 2206 } 2207 } 2208 2209 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_RES) 2210 arg->twt_responder = true; 2211 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_REQ) 2212 arg->twt_requester = true; 2213 2214 he_nss = ath11k_mac_max_he_nss(he_mcs_mask); 2215 2216 if (he_nss > sta->deflink.rx_nss) { 2217 user_rate_valid = false; 2218 for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) { 2219 if (he_mcs_mask[nss_idx]) { 2220 user_rate_valid = true; 2221 break; 2222 } 2223 } 2224 } 2225 2226 if (!user_rate_valid) { 2227 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac setting he range mcs value to peer supported nss %d for peer %pM\n", 2228 sta->deflink.rx_nss, sta->addr); 2229 he_mcs_mask[sta->deflink.rx_nss - 1] = he_mcs_mask[he_nss - 1]; 2230 } 2231 2232 switch (sta->deflink.bandwidth) { 2233 case IEEE80211_STA_RX_BW_160: 2234 if (he_cap->he_cap_elem.phy_cap_info[0] & 2235 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) { 2236 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80); 2237 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask); 2238 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v; 2239 2240 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80p80); 2241 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v; 2242 2243 arg->peer_he_mcs_count++; 2244 he_tx_mcs = v; 2245 } 2246 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160); 2247 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v; 2248 2249 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_160); 2250 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask); 2251 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v; 2252 2253 arg->peer_he_mcs_count++; 2254 if (!he_tx_mcs) 2255 he_tx_mcs = v; 2256 fallthrough; 2257 2258 default: 2259 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80); 2260 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v; 2261 2262 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80); 2263 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask); 2264 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v; 2265 2266 arg->peer_he_mcs_count++; 2267 if (!he_tx_mcs) 2268 he_tx_mcs = v; 2269 break; 2270 } 2271 2272 /* Calculate peer NSS capability from HE capabilities if STA 2273 * supports HE. 2274 */ 2275 for (i = 0, max_nss = 0, he_mcs = 0; i < NL80211_HE_NSS_MAX; i++) { 2276 he_mcs = he_tx_mcs >> (2 * i) & 3; 2277 2278 /* In case of fixed rates, MCS Range in he_tx_mcs might have 2279 * unsupported range, with he_mcs_mask set, so check either of them 2280 * to find nss. 2281 */ 2282 if (he_mcs != IEEE80211_HE_MCS_NOT_SUPPORTED || 2283 he_mcs_mask[i]) 2284 max_nss = i + 1; 2285 } 2286 arg->peer_nss = min(sta->deflink.rx_nss, max_nss); 2287 2288 if (arg->peer_phymode == MODE_11AX_HE160 || 2289 arg->peer_phymode == MODE_11AX_HE80_80) { 2290 tx_nss = ath11k_get_nss_160mhz(ar, max_nss); 2291 rx_nss = min(arg->peer_nss, tx_nss); 2292 arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE; 2293 2294 if (!rx_nss) { 2295 ath11k_warn(ar->ab, "invalid max_nss\n"); 2296 return; 2297 } 2298 2299 if (arg->peer_phymode == MODE_11AX_HE160) 2300 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1); 2301 else 2302 nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1); 2303 2304 arg->peer_bw_rxnss_override |= nss_160; 2305 } 2306 2307 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 2308 "mac he peer %pM nss %d mcs cnt %d nss_override 0x%x\n", 2309 sta->addr, arg->peer_nss, 2310 arg->peer_he_mcs_count, 2311 arg->peer_bw_rxnss_override); 2312 } 2313 2314 static void ath11k_peer_assoc_h_he_6ghz(struct ath11k *ar, 2315 struct ieee80211_vif *vif, 2316 struct ieee80211_sta *sta, 2317 struct peer_assoc_params *arg) 2318 { 2319 const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap; 2320 struct cfg80211_chan_def def; 2321 enum nl80211_band band; 2322 u8 ampdu_factor; 2323 2324 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 2325 return; 2326 2327 band = def.chan->band; 2328 2329 if (!arg->he_flag || band != NL80211_BAND_6GHZ || !sta->deflink.he_6ghz_capa.capa) 2330 return; 2331 2332 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2333 arg->bw_40 = true; 2334 2335 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80) 2336 arg->bw_80 = true; 2337 2338 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) 2339 arg->bw_160 = true; 2340 2341 arg->peer_he_caps_6ghz = le16_to_cpu(sta->deflink.he_6ghz_capa.capa); 2342 arg->peer_mpdu_density = 2343 ath11k_parse_mpdudensity(FIELD_GET(IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START, 2344 arg->peer_he_caps_6ghz)); 2345 2346 /* From IEEE Std 802.11ax-2021 - Section 10.12.2: An HE STA shall be capable of 2347 * receiving A-MPDU where the A-MPDU pre-EOF padding length is up to the value 2348 * indicated by the Maximum A-MPDU Length Exponent Extension field in the HE 2349 * Capabilities element and the Maximum A-MPDU Length Exponent field in HE 6 GHz 2350 * Band Capabilities element in the 6 GHz band. 2351 * 2352 * Here, we are extracting the Max A-MPDU Exponent Extension from HE caps and 2353 * factor is the Maximum A-MPDU Length Exponent from HE 6 GHZ Band capability. 2354 */ 2355 ampdu_factor = FIELD_GET(IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK, 2356 he_cap->he_cap_elem.mac_cap_info[3]) + 2357 FIELD_GET(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, 2358 arg->peer_he_caps_6ghz); 2359 2360 arg->peer_max_mpdu = (1u << (IEEE80211_HE_6GHZ_MAX_AMPDU_FACTOR + 2361 ampdu_factor)) - 1; 2362 } 2363 2364 static void ath11k_peer_assoc_h_smps(struct ieee80211_sta *sta, 2365 struct peer_assoc_params *arg) 2366 { 2367 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap; 2368 int smps; 2369 2370 if (!ht_cap->ht_supported && !sta->deflink.he_6ghz_capa.capa) 2371 return; 2372 2373 if (ht_cap->ht_supported) { 2374 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 2375 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 2376 } else { 2377 smps = le16_get_bits(sta->deflink.he_6ghz_capa.capa, 2378 IEEE80211_HE_6GHZ_CAP_SM_PS); 2379 } 2380 2381 switch (smps) { 2382 case WLAN_HT_CAP_SM_PS_STATIC: 2383 arg->static_mimops_flag = true; 2384 break; 2385 case WLAN_HT_CAP_SM_PS_DYNAMIC: 2386 arg->dynamic_mimops_flag = true; 2387 break; 2388 case WLAN_HT_CAP_SM_PS_DISABLED: 2389 arg->spatial_mux_flag = true; 2390 break; 2391 default: 2392 break; 2393 } 2394 } 2395 2396 static void ath11k_peer_assoc_h_qos(struct ath11k *ar, 2397 struct ieee80211_vif *vif, 2398 struct ieee80211_sta *sta, 2399 struct peer_assoc_params *arg) 2400 { 2401 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2402 2403 switch (arvif->vdev_type) { 2404 case WMI_VDEV_TYPE_AP: 2405 if (sta->wme) { 2406 /* TODO: Check WME vs QoS */ 2407 arg->is_wme_set = true; 2408 arg->qos_flag = true; 2409 } 2410 2411 if (sta->wme && sta->uapsd_queues) { 2412 /* TODO: Check WME vs QoS */ 2413 arg->is_wme_set = true; 2414 arg->apsd_flag = true; 2415 arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG; 2416 } 2417 break; 2418 case WMI_VDEV_TYPE_STA: 2419 if (sta->wme) { 2420 arg->is_wme_set = true; 2421 arg->qos_flag = true; 2422 } 2423 break; 2424 default: 2425 break; 2426 } 2427 2428 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM qos %d\n", 2429 sta->addr, arg->qos_flag); 2430 } 2431 2432 static int ath11k_peer_assoc_qos_ap(struct ath11k *ar, 2433 struct ath11k_vif *arvif, 2434 struct ieee80211_sta *sta) 2435 { 2436 struct ap_ps_params params; 2437 u32 max_sp; 2438 u32 uapsd; 2439 int ret; 2440 2441 lockdep_assert_held(&ar->conf_mutex); 2442 2443 params.vdev_id = arvif->vdev_id; 2444 2445 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n", 2446 sta->uapsd_queues, sta->max_sp); 2447 2448 uapsd = 0; 2449 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) 2450 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN | 2451 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN; 2452 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) 2453 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN | 2454 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN; 2455 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) 2456 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN | 2457 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN; 2458 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) 2459 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN | 2460 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN; 2461 2462 max_sp = 0; 2463 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP) 2464 max_sp = sta->max_sp; 2465 2466 params.param = WMI_AP_PS_PEER_PARAM_UAPSD; 2467 params.value = uapsd; 2468 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms); 2469 if (ret) 2470 goto err; 2471 2472 params.param = WMI_AP_PS_PEER_PARAM_MAX_SP; 2473 params.value = max_sp; 2474 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms); 2475 if (ret) 2476 goto err; 2477 2478 /* TODO revisit during testing */ 2479 params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE; 2480 params.value = DISABLE_SIFS_RESPONSE_TRIGGER; 2481 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms); 2482 if (ret) 2483 goto err; 2484 2485 params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD; 2486 params.value = DISABLE_SIFS_RESPONSE_TRIGGER; 2487 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms); 2488 if (ret) 2489 goto err; 2490 2491 return 0; 2492 2493 err: 2494 ath11k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n", 2495 params.param, arvif->vdev_id, ret); 2496 return ret; 2497 } 2498 2499 static bool ath11k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta) 2500 { 2501 return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >> 2502 ATH11K_MAC_FIRST_OFDM_RATE_IDX; 2503 } 2504 2505 static enum wmi_phy_mode ath11k_mac_get_phymode_vht(struct ath11k *ar, 2506 struct ieee80211_sta *sta) 2507 { 2508 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) { 2509 switch (sta->deflink.vht_cap.cap & 2510 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) { 2511 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ: 2512 return MODE_11AC_VHT160; 2513 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ: 2514 return MODE_11AC_VHT80_80; 2515 default: 2516 /* not sure if this is a valid case? */ 2517 return MODE_11AC_VHT160; 2518 } 2519 } 2520 2521 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80) 2522 return MODE_11AC_VHT80; 2523 2524 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2525 return MODE_11AC_VHT40; 2526 2527 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20) 2528 return MODE_11AC_VHT20; 2529 2530 return MODE_UNKNOWN; 2531 } 2532 2533 static enum wmi_phy_mode ath11k_mac_get_phymode_he(struct ath11k *ar, 2534 struct ieee80211_sta *sta) 2535 { 2536 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) { 2537 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] & 2538 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) 2539 return MODE_11AX_HE160; 2540 else if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] & 2541 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 2542 return MODE_11AX_HE80_80; 2543 /* not sure if this is a valid case? */ 2544 return MODE_11AX_HE160; 2545 } 2546 2547 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80) 2548 return MODE_11AX_HE80; 2549 2550 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2551 return MODE_11AX_HE40; 2552 2553 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20) 2554 return MODE_11AX_HE20; 2555 2556 return MODE_UNKNOWN; 2557 } 2558 2559 static void ath11k_peer_assoc_h_phymode(struct ath11k *ar, 2560 struct ieee80211_vif *vif, 2561 struct ieee80211_sta *sta, 2562 struct peer_assoc_params *arg) 2563 { 2564 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2565 struct cfg80211_chan_def def; 2566 enum nl80211_band band; 2567 const u8 *ht_mcs_mask; 2568 const u16 *vht_mcs_mask; 2569 const u16 *he_mcs_mask; 2570 enum wmi_phy_mode phymode = MODE_UNKNOWN; 2571 2572 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 2573 return; 2574 2575 band = def.chan->band; 2576 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 2577 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 2578 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs; 2579 2580 switch (band) { 2581 case NL80211_BAND_2GHZ: 2582 if (sta->deflink.he_cap.has_he && 2583 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) { 2584 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80) 2585 phymode = MODE_11AX_HE80_2G; 2586 else if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2587 phymode = MODE_11AX_HE40_2G; 2588 else 2589 phymode = MODE_11AX_HE20_2G; 2590 } else if (sta->deflink.vht_cap.vht_supported && 2591 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2592 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2593 phymode = MODE_11AC_VHT40; 2594 else 2595 phymode = MODE_11AC_VHT20; 2596 } else if (sta->deflink.ht_cap.ht_supported && 2597 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2598 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2599 phymode = MODE_11NG_HT40; 2600 else 2601 phymode = MODE_11NG_HT20; 2602 } else if (ath11k_mac_sta_has_ofdm_only(sta)) { 2603 phymode = MODE_11G; 2604 } else { 2605 phymode = MODE_11B; 2606 } 2607 break; 2608 case NL80211_BAND_5GHZ: 2609 case NL80211_BAND_6GHZ: 2610 /* Check HE first */ 2611 if (sta->deflink.he_cap.has_he && 2612 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) { 2613 phymode = ath11k_mac_get_phymode_he(ar, sta); 2614 } else if (sta->deflink.vht_cap.vht_supported && 2615 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2616 phymode = ath11k_mac_get_phymode_vht(ar, sta); 2617 } else if (sta->deflink.ht_cap.ht_supported && 2618 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2619 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) 2620 phymode = MODE_11NA_HT40; 2621 else 2622 phymode = MODE_11NA_HT20; 2623 } else { 2624 phymode = MODE_11A; 2625 } 2626 break; 2627 default: 2628 break; 2629 } 2630 2631 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM phymode %s\n", 2632 sta->addr, ath11k_wmi_phymode_str(phymode)); 2633 2634 arg->peer_phymode = phymode; 2635 WARN_ON(phymode == MODE_UNKNOWN); 2636 } 2637 2638 static void ath11k_peer_assoc_prepare(struct ath11k *ar, 2639 struct ieee80211_vif *vif, 2640 struct ieee80211_sta *sta, 2641 struct peer_assoc_params *arg, 2642 bool reassoc) 2643 { 2644 struct ath11k_sta *arsta; 2645 2646 lockdep_assert_held(&ar->conf_mutex); 2647 2648 arsta = (struct ath11k_sta *)sta->drv_priv; 2649 2650 memset(arg, 0, sizeof(*arg)); 2651 2652 reinit_completion(&ar->peer_assoc_done); 2653 2654 arg->peer_new_assoc = !reassoc; 2655 ath11k_peer_assoc_h_basic(ar, vif, sta, arg); 2656 ath11k_peer_assoc_h_crypto(ar, vif, sta, arg); 2657 ath11k_peer_assoc_h_rates(ar, vif, sta, arg); 2658 ath11k_peer_assoc_h_phymode(ar, vif, sta, arg); 2659 ath11k_peer_assoc_h_ht(ar, vif, sta, arg); 2660 ath11k_peer_assoc_h_vht(ar, vif, sta, arg); 2661 ath11k_peer_assoc_h_he(ar, vif, sta, arg); 2662 ath11k_peer_assoc_h_he_6ghz(ar, vif, sta, arg); 2663 ath11k_peer_assoc_h_qos(ar, vif, sta, arg); 2664 ath11k_peer_assoc_h_smps(sta, arg); 2665 2666 arsta->peer_nss = arg->peer_nss; 2667 2668 /* TODO: amsdu_disable req? */ 2669 } 2670 2671 static int ath11k_setup_peer_smps(struct ath11k *ar, struct ath11k_vif *arvif, 2672 const u8 *addr, 2673 const struct ieee80211_sta_ht_cap *ht_cap, 2674 u16 he_6ghz_capa) 2675 { 2676 int smps; 2677 2678 if (!ht_cap->ht_supported && !he_6ghz_capa) 2679 return 0; 2680 2681 if (ht_cap->ht_supported) { 2682 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 2683 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 2684 } else { 2685 smps = FIELD_GET(IEEE80211_HE_6GHZ_CAP_SM_PS, he_6ghz_capa); 2686 } 2687 2688 if (smps >= ARRAY_SIZE(ath11k_smps_map)) 2689 return -EINVAL; 2690 2691 return ath11k_wmi_set_peer_param(ar, addr, arvif->vdev_id, 2692 WMI_PEER_MIMO_PS_STATE, 2693 ath11k_smps_map[smps]); 2694 } 2695 2696 static void ath11k_bss_assoc(struct ieee80211_hw *hw, 2697 struct ieee80211_vif *vif, 2698 struct ieee80211_bss_conf *bss_conf) 2699 { 2700 struct ath11k *ar = hw->priv; 2701 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2702 struct peer_assoc_params peer_arg; 2703 struct ieee80211_sta *ap_sta; 2704 struct ath11k_peer *peer; 2705 bool is_auth = false; 2706 int ret; 2707 2708 lockdep_assert_held(&ar->conf_mutex); 2709 2710 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n", 2711 arvif->vdev_id, arvif->bssid, arvif->aid); 2712 2713 rcu_read_lock(); 2714 2715 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid); 2716 if (!ap_sta) { 2717 ath11k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n", 2718 bss_conf->bssid, arvif->vdev_id); 2719 rcu_read_unlock(); 2720 return; 2721 } 2722 2723 ath11k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false); 2724 2725 rcu_read_unlock(); 2726 2727 peer_arg.is_assoc = true; 2728 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 2729 if (ret) { 2730 ath11k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n", 2731 bss_conf->bssid, arvif->vdev_id, ret); 2732 return; 2733 } 2734 2735 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 2736 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 2737 bss_conf->bssid, arvif->vdev_id); 2738 return; 2739 } 2740 2741 ret = ath11k_setup_peer_smps(ar, arvif, bss_conf->bssid, 2742 &ap_sta->deflink.ht_cap, 2743 le16_to_cpu(ap_sta->deflink.he_6ghz_capa.capa)); 2744 if (ret) { 2745 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n", 2746 arvif->vdev_id, ret); 2747 return; 2748 } 2749 2750 WARN_ON(arvif->is_up); 2751 2752 arvif->aid = bss_conf->aid; 2753 ether_addr_copy(arvif->bssid, bss_conf->bssid); 2754 2755 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid); 2756 if (ret) { 2757 ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n", 2758 arvif->vdev_id, ret); 2759 return; 2760 } 2761 2762 arvif->is_up = true; 2763 arvif->rekey_data.enable_offload = false; 2764 2765 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 2766 "mac vdev %d up (associated) bssid %pM aid %d\n", 2767 arvif->vdev_id, bss_conf->bssid, bss_conf->aid); 2768 2769 spin_lock_bh(&ar->ab->base_lock); 2770 2771 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid); 2772 if (peer && peer->is_authorized) 2773 is_auth = true; 2774 2775 spin_unlock_bh(&ar->ab->base_lock); 2776 2777 if (is_auth) { 2778 ret = ath11k_wmi_set_peer_param(ar, arvif->bssid, 2779 arvif->vdev_id, 2780 WMI_PEER_AUTHORIZE, 2781 1); 2782 if (ret) 2783 ath11k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret); 2784 } 2785 2786 ret = ath11k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id, 2787 &bss_conf->he_obss_pd); 2788 if (ret) 2789 ath11k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n", 2790 arvif->vdev_id, ret); 2791 2792 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2793 WMI_VDEV_PARAM_DTIM_POLICY, 2794 WMI_DTIM_POLICY_STICK); 2795 if (ret) 2796 ath11k_warn(ar->ab, "failed to set vdev %d dtim policy: %d\n", 2797 arvif->vdev_id, ret); 2798 2799 ath11k_mac_11d_scan_stop_all(ar->ab); 2800 } 2801 2802 static void ath11k_bss_disassoc(struct ieee80211_hw *hw, 2803 struct ieee80211_vif *vif) 2804 { 2805 struct ath11k *ar = hw->priv; 2806 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2807 int ret; 2808 2809 lockdep_assert_held(&ar->conf_mutex); 2810 2811 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n", 2812 arvif->vdev_id, arvif->bssid); 2813 2814 ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id); 2815 if (ret) 2816 ath11k_warn(ar->ab, "failed to down vdev %i: %d\n", 2817 arvif->vdev_id, ret); 2818 2819 arvif->is_up = false; 2820 2821 memset(&arvif->rekey_data, 0, sizeof(arvif->rekey_data)); 2822 2823 cancel_delayed_work_sync(&arvif->connection_loss_work); 2824 } 2825 2826 static u32 ath11k_mac_get_rate_hw_value(int bitrate) 2827 { 2828 u32 preamble; 2829 u16 hw_value; 2830 int rate; 2831 size_t i; 2832 2833 if (ath11k_mac_bitrate_is_cck(bitrate)) 2834 preamble = WMI_RATE_PREAMBLE_CCK; 2835 else 2836 preamble = WMI_RATE_PREAMBLE_OFDM; 2837 2838 for (i = 0; i < ARRAY_SIZE(ath11k_legacy_rates); i++) { 2839 if (ath11k_legacy_rates[i].bitrate != bitrate) 2840 continue; 2841 2842 hw_value = ath11k_legacy_rates[i].hw_value; 2843 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble); 2844 2845 return rate; 2846 } 2847 2848 return -EINVAL; 2849 } 2850 2851 static void ath11k_recalculate_mgmt_rate(struct ath11k *ar, 2852 struct ieee80211_vif *vif, 2853 struct cfg80211_chan_def *def) 2854 { 2855 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2856 const struct ieee80211_supported_band *sband; 2857 u8 basic_rate_idx; 2858 int hw_rate_code; 2859 u32 vdev_param; 2860 u16 bitrate; 2861 int ret; 2862 2863 lockdep_assert_held(&ar->conf_mutex); 2864 2865 sband = ar->hw->wiphy->bands[def->chan->band]; 2866 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1; 2867 bitrate = sband->bitrates[basic_rate_idx].bitrate; 2868 2869 hw_rate_code = ath11k_mac_get_rate_hw_value(bitrate); 2870 if (hw_rate_code < 0) { 2871 ath11k_warn(ar->ab, "bitrate not supported %d\n", bitrate); 2872 return; 2873 } 2874 2875 vdev_param = WMI_VDEV_PARAM_MGMT_RATE; 2876 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 2877 hw_rate_code); 2878 if (ret) 2879 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret); 2880 2881 /* For WCN6855, firmware will clear this param when vdev starts, hence 2882 * cache it here so that we can reconfigure it once vdev starts. 2883 */ 2884 ar->hw_rate_code = hw_rate_code; 2885 2886 vdev_param = WMI_VDEV_PARAM_BEACON_RATE; 2887 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 2888 hw_rate_code); 2889 if (ret) 2890 ath11k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret); 2891 } 2892 2893 static int ath11k_mac_fils_discovery(struct ath11k_vif *arvif, 2894 struct ieee80211_bss_conf *info) 2895 { 2896 struct ath11k *ar = arvif->ar; 2897 struct sk_buff *tmpl; 2898 int ret; 2899 u32 interval; 2900 bool unsol_bcast_probe_resp_enabled = false; 2901 2902 if (info->fils_discovery.max_interval) { 2903 interval = info->fils_discovery.max_interval; 2904 2905 tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif); 2906 if (tmpl) 2907 ret = ath11k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id, 2908 tmpl); 2909 } else if (info->unsol_bcast_probe_resp_interval) { 2910 unsol_bcast_probe_resp_enabled = 1; 2911 interval = info->unsol_bcast_probe_resp_interval; 2912 2913 tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw, 2914 arvif->vif); 2915 if (tmpl) 2916 ret = ath11k_wmi_probe_resp_tmpl(ar, arvif->vdev_id, 2917 tmpl); 2918 } else { /* Disable */ 2919 return ath11k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false); 2920 } 2921 2922 if (!tmpl) { 2923 ath11k_warn(ar->ab, 2924 "mac vdev %i failed to retrieve %s template\n", 2925 arvif->vdev_id, (unsol_bcast_probe_resp_enabled ? 2926 "unsolicited broadcast probe response" : 2927 "FILS discovery")); 2928 return -EPERM; 2929 } 2930 kfree_skb(tmpl); 2931 2932 if (!ret) 2933 ret = ath11k_wmi_fils_discovery(ar, arvif->vdev_id, interval, 2934 unsol_bcast_probe_resp_enabled); 2935 2936 return ret; 2937 } 2938 2939 static int ath11k_mac_config_obss_pd(struct ath11k *ar, 2940 struct ieee80211_he_obss_pd *he_obss_pd) 2941 { 2942 u32 bitmap[2], param_id, param_val, pdev_id; 2943 int ret; 2944 s8 non_srg_th = 0, srg_th = 0; 2945 2946 pdev_id = ar->pdev->pdev_id; 2947 2948 /* Set and enable SRG/non-SRG OBSS PD Threshold */ 2949 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD; 2950 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) { 2951 ret = ath11k_wmi_pdev_set_param(ar, param_id, 0, pdev_id); 2952 if (ret) 2953 ath11k_warn(ar->ab, 2954 "failed to set obss_pd_threshold for pdev: %u\n", 2955 pdev_id); 2956 return ret; 2957 } 2958 2959 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 2960 "mac obss pd sr_ctrl %x non_srg_thres %u srg_max %u\n", 2961 he_obss_pd->sr_ctrl, he_obss_pd->non_srg_max_offset, 2962 he_obss_pd->max_offset); 2963 2964 param_val = 0; 2965 2966 if (he_obss_pd->sr_ctrl & 2967 IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) { 2968 non_srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD; 2969 } else { 2970 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT) 2971 non_srg_th = (ATH11K_OBSS_PD_MAX_THRESHOLD + 2972 he_obss_pd->non_srg_max_offset); 2973 else 2974 non_srg_th = ATH11K_OBSS_PD_NON_SRG_MAX_THRESHOLD; 2975 2976 param_val |= ATH11K_OBSS_PD_NON_SRG_EN; 2977 } 2978 2979 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) { 2980 srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD + he_obss_pd->max_offset; 2981 param_val |= ATH11K_OBSS_PD_SRG_EN; 2982 } 2983 2984 if (test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT, 2985 ar->ab->wmi_ab.svc_map)) { 2986 param_val |= ATH11K_OBSS_PD_THRESHOLD_IN_DBM; 2987 param_val |= FIELD_PREP(GENMASK(15, 8), srg_th); 2988 } else { 2989 non_srg_th -= ATH11K_DEFAULT_NOISE_FLOOR; 2990 /* SRG not supported and threshold in dB */ 2991 param_val &= ~(ATH11K_OBSS_PD_SRG_EN | 2992 ATH11K_OBSS_PD_THRESHOLD_IN_DBM); 2993 } 2994 2995 param_val |= (non_srg_th & GENMASK(7, 0)); 2996 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 2997 if (ret) { 2998 ath11k_warn(ar->ab, 2999 "failed to set obss_pd_threshold for pdev: %u\n", 3000 pdev_id); 3001 return ret; 3002 } 3003 3004 /* Enable OBSS PD for all access category */ 3005 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC; 3006 param_val = 0xf; 3007 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 3008 if (ret) { 3009 ath11k_warn(ar->ab, 3010 "failed to set obss_pd_per_ac for pdev: %u\n", 3011 pdev_id); 3012 return ret; 3013 } 3014 3015 /* Set SR Prohibit */ 3016 param_id = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT; 3017 param_val = !!(he_obss_pd->sr_ctrl & 3018 IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED); 3019 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 3020 if (ret) { 3021 ath11k_warn(ar->ab, "failed to set sr_prohibit for pdev: %u\n", 3022 pdev_id); 3023 return ret; 3024 } 3025 3026 if (!test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT, 3027 ar->ab->wmi_ab.svc_map)) 3028 return 0; 3029 3030 /* Set SRG BSS Color Bitmap */ 3031 memcpy(bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap)); 3032 ret = ath11k_wmi_pdev_set_srg_bss_color_bitmap(ar, bitmap); 3033 if (ret) { 3034 ath11k_warn(ar->ab, 3035 "failed to set bss_color_bitmap for pdev: %u\n", 3036 pdev_id); 3037 return ret; 3038 } 3039 3040 /* Set SRG Partial BSSID Bitmap */ 3041 memcpy(bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap)); 3042 ret = ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(ar, bitmap); 3043 if (ret) { 3044 ath11k_warn(ar->ab, 3045 "failed to set partial_bssid_bitmap for pdev: %u\n", 3046 pdev_id); 3047 return ret; 3048 } 3049 3050 memset(bitmap, 0xff, sizeof(bitmap)); 3051 3052 /* Enable all BSS Colors for SRG */ 3053 ret = ath11k_wmi_pdev_srg_obss_color_enable_bitmap(ar, bitmap); 3054 if (ret) { 3055 ath11k_warn(ar->ab, 3056 "failed to set srg_color_en_bitmap pdev: %u\n", 3057 pdev_id); 3058 return ret; 3059 } 3060 3061 /* Enable all patial BSSID mask for SRG */ 3062 ret = ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, bitmap); 3063 if (ret) { 3064 ath11k_warn(ar->ab, 3065 "failed to set srg_bssid_en_bitmap pdev: %u\n", 3066 pdev_id); 3067 return ret; 3068 } 3069 3070 /* Enable all BSS Colors for non-SRG */ 3071 ret = ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, bitmap); 3072 if (ret) { 3073 ath11k_warn(ar->ab, 3074 "failed to set non_srg_color_en_bitmap pdev: %u\n", 3075 pdev_id); 3076 return ret; 3077 } 3078 3079 /* Enable all patial BSSID mask for non-SRG */ 3080 ret = ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, bitmap); 3081 if (ret) { 3082 ath11k_warn(ar->ab, 3083 "failed to set non_srg_bssid_en_bitmap pdev: %u\n", 3084 pdev_id); 3085 return ret; 3086 } 3087 3088 return 0; 3089 } 3090 3091 static void ath11k_mac_op_bss_info_changed(struct ieee80211_hw *hw, 3092 struct ieee80211_vif *vif, 3093 struct ieee80211_bss_conf *info, 3094 u32 changed) 3095 { 3096 struct ath11k *ar = hw->priv; 3097 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3098 struct cfg80211_chan_def def; 3099 u32 param_id, param_value; 3100 enum nl80211_band band; 3101 u32 vdev_param; 3102 int mcast_rate; 3103 u32 preamble; 3104 u16 hw_value; 3105 u16 bitrate; 3106 int ret = 0; 3107 u8 rateidx; 3108 u32 rate; 3109 u32 ipv4_cnt; 3110 3111 mutex_lock(&ar->conf_mutex); 3112 3113 if (changed & BSS_CHANGED_BEACON_INT) { 3114 arvif->beacon_interval = info->beacon_int; 3115 3116 param_id = WMI_VDEV_PARAM_BEACON_INTERVAL; 3117 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3118 param_id, 3119 arvif->beacon_interval); 3120 if (ret) 3121 ath11k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n", 3122 arvif->vdev_id); 3123 else 3124 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3125 "Beacon interval: %d set for VDEV: %d\n", 3126 arvif->beacon_interval, arvif->vdev_id); 3127 } 3128 3129 if (changed & BSS_CHANGED_BEACON) { 3130 param_id = WMI_PDEV_PARAM_BEACON_TX_MODE; 3131 param_value = WMI_BEACON_STAGGERED_MODE; 3132 ret = ath11k_wmi_pdev_set_param(ar, param_id, 3133 param_value, ar->pdev->pdev_id); 3134 if (ret) 3135 ath11k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n", 3136 arvif->vdev_id); 3137 else 3138 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3139 "Set staggered beacon mode for VDEV: %d\n", 3140 arvif->vdev_id); 3141 3142 if (!arvif->do_not_send_tmpl || !arvif->bcca_zero_sent) { 3143 ret = ath11k_mac_setup_bcn_tmpl(arvif); 3144 if (ret) 3145 ath11k_warn(ar->ab, "failed to update bcn template: %d\n", 3146 ret); 3147 } 3148 3149 if (arvif->bcca_zero_sent) 3150 arvif->do_not_send_tmpl = true; 3151 else 3152 arvif->do_not_send_tmpl = false; 3153 3154 if (vif->bss_conf.he_support) { 3155 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3156 WMI_VDEV_PARAM_BA_MODE, 3157 WMI_BA_MODE_BUFFER_SIZE_256); 3158 if (ret) 3159 ath11k_warn(ar->ab, 3160 "failed to set BA BUFFER SIZE 256 for vdev: %d\n", 3161 arvif->vdev_id); 3162 else 3163 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3164 "Set BA BUFFER SIZE 256 for VDEV: %d\n", 3165 arvif->vdev_id); 3166 } 3167 } 3168 3169 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) { 3170 arvif->dtim_period = info->dtim_period; 3171 3172 param_id = WMI_VDEV_PARAM_DTIM_PERIOD; 3173 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3174 param_id, 3175 arvif->dtim_period); 3176 3177 if (ret) 3178 ath11k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n", 3179 arvif->vdev_id, ret); 3180 else 3181 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3182 "DTIM period: %d set for VDEV: %d\n", 3183 arvif->dtim_period, arvif->vdev_id); 3184 } 3185 3186 if (changed & BSS_CHANGED_SSID && 3187 vif->type == NL80211_IFTYPE_AP) { 3188 arvif->u.ap.ssid_len = info->ssid_len; 3189 if (info->ssid_len) 3190 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len); 3191 arvif->u.ap.hidden_ssid = info->hidden_ssid; 3192 } 3193 3194 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid)) 3195 ether_addr_copy(arvif->bssid, info->bssid); 3196 3197 if (changed & BSS_CHANGED_BEACON_ENABLED) { 3198 ath11k_control_beaconing(arvif, info); 3199 3200 if (arvif->is_up && vif->bss_conf.he_support && 3201 vif->bss_conf.he_oper.params) { 3202 param_id = WMI_VDEV_PARAM_HEOPS_0_31; 3203 param_value = vif->bss_conf.he_oper.params; 3204 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3205 param_id, param_value); 3206 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3207 "he oper param: %x set for VDEV: %d\n", 3208 param_value, arvif->vdev_id); 3209 3210 if (ret) 3211 ath11k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n", 3212 param_value, arvif->vdev_id, ret); 3213 } 3214 } 3215 3216 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 3217 u32 cts_prot; 3218 3219 cts_prot = !!(info->use_cts_prot); 3220 param_id = WMI_VDEV_PARAM_PROTECTION_MODE; 3221 3222 if (arvif->is_started) { 3223 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3224 param_id, cts_prot); 3225 if (ret) 3226 ath11k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n", 3227 arvif->vdev_id); 3228 else 3229 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n", 3230 cts_prot, arvif->vdev_id); 3231 } else { 3232 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n"); 3233 } 3234 } 3235 3236 if (changed & BSS_CHANGED_ERP_SLOT) { 3237 u32 slottime; 3238 3239 if (info->use_short_slot) 3240 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 3241 3242 else 3243 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 3244 3245 param_id = WMI_VDEV_PARAM_SLOT_TIME; 3246 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3247 param_id, slottime); 3248 if (ret) 3249 ath11k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n", 3250 arvif->vdev_id); 3251 else 3252 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3253 "Set slottime: %d for VDEV: %d\n", 3254 slottime, arvif->vdev_id); 3255 } 3256 3257 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 3258 u32 preamble; 3259 3260 if (info->use_short_preamble) 3261 preamble = WMI_VDEV_PREAMBLE_SHORT; 3262 else 3263 preamble = WMI_VDEV_PREAMBLE_LONG; 3264 3265 param_id = WMI_VDEV_PARAM_PREAMBLE; 3266 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3267 param_id, preamble); 3268 if (ret) 3269 ath11k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n", 3270 arvif->vdev_id); 3271 else 3272 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3273 "Set preamble: %d for VDEV: %d\n", 3274 preamble, arvif->vdev_id); 3275 } 3276 3277 if (changed & BSS_CHANGED_ASSOC) { 3278 if (info->assoc) 3279 ath11k_bss_assoc(hw, vif, info); 3280 else 3281 ath11k_bss_disassoc(hw, vif); 3282 } 3283 3284 if (changed & BSS_CHANGED_TXPOWER) { 3285 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev_id %i txpower %d\n", 3286 arvif->vdev_id, info->txpower); 3287 3288 arvif->txpower = info->txpower; 3289 ath11k_mac_txpower_recalc(ar); 3290 } 3291 3292 if (changed & BSS_CHANGED_PS && 3293 ar->ab->hw_params.supports_sta_ps) { 3294 arvif->ps = vif->bss_conf.ps; 3295 3296 ret = ath11k_mac_config_ps(ar); 3297 if (ret) 3298 ath11k_warn(ar->ab, "failed to setup ps on vdev %i: %d\n", 3299 arvif->vdev_id, ret); 3300 } 3301 3302 if (changed & BSS_CHANGED_MCAST_RATE && 3303 !ath11k_mac_vif_chan(arvif->vif, &def)) { 3304 band = def.chan->band; 3305 mcast_rate = vif->bss_conf.mcast_rate[band]; 3306 3307 if (mcast_rate > 0) 3308 rateidx = mcast_rate - 1; 3309 else 3310 rateidx = ffs(vif->bss_conf.basic_rates) - 1; 3311 3312 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) 3313 rateidx += ATH11K_MAC_FIRST_OFDM_RATE_IDX; 3314 3315 bitrate = ath11k_legacy_rates[rateidx].bitrate; 3316 hw_value = ath11k_legacy_rates[rateidx].hw_value; 3317 3318 if (ath11k_mac_bitrate_is_cck(bitrate)) 3319 preamble = WMI_RATE_PREAMBLE_CCK; 3320 else 3321 preamble = WMI_RATE_PREAMBLE_OFDM; 3322 3323 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble); 3324 3325 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3326 "mac vdev %d mcast_rate %x\n", 3327 arvif->vdev_id, rate); 3328 3329 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE; 3330 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3331 vdev_param, rate); 3332 if (ret) 3333 ath11k_warn(ar->ab, 3334 "failed to set mcast rate on vdev %i: %d\n", 3335 arvif->vdev_id, ret); 3336 3337 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE; 3338 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3339 vdev_param, rate); 3340 if (ret) 3341 ath11k_warn(ar->ab, 3342 "failed to set bcast rate on vdev %i: %d\n", 3343 arvif->vdev_id, ret); 3344 } 3345 3346 if (changed & BSS_CHANGED_BASIC_RATES && 3347 !ath11k_mac_vif_chan(arvif->vif, &def)) 3348 ath11k_recalculate_mgmt_rate(ar, vif, &def); 3349 3350 if (changed & BSS_CHANGED_TWT) { 3351 if (info->twt_requester || info->twt_responder) 3352 ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id); 3353 else 3354 ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id); 3355 } 3356 3357 if (changed & BSS_CHANGED_HE_OBSS_PD) 3358 ath11k_mac_config_obss_pd(ar, &info->he_obss_pd); 3359 3360 if (changed & BSS_CHANGED_HE_BSS_COLOR) { 3361 if (vif->type == NL80211_IFTYPE_AP) { 3362 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd( 3363 ar, arvif->vdev_id, info->he_bss_color.color, 3364 ATH11K_BSS_COLOR_COLLISION_DETECTION_AP_PERIOD_MS, 3365 info->he_bss_color.enabled); 3366 if (ret) 3367 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n", 3368 arvif->vdev_id, ret); 3369 3370 param_id = WMI_VDEV_PARAM_BSS_COLOR; 3371 if (info->he_bss_color.enabled) 3372 param_value = info->he_bss_color.color << 3373 IEEE80211_HE_OPERATION_BSS_COLOR_OFFSET; 3374 else 3375 param_value = IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED; 3376 3377 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3378 param_id, 3379 param_value); 3380 if (ret) 3381 ath11k_warn(ar->ab, 3382 "failed to set bss color param on vdev %i: %d\n", 3383 arvif->vdev_id, ret); 3384 3385 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3386 "bss color param 0x%x set on vdev %i\n", 3387 param_value, arvif->vdev_id); 3388 } else if (vif->type == NL80211_IFTYPE_STATION) { 3389 ret = ath11k_wmi_send_bss_color_change_enable_cmd(ar, 3390 arvif->vdev_id, 3391 1); 3392 if (ret) 3393 ath11k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n", 3394 arvif->vdev_id, ret); 3395 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd( 3396 ar, arvif->vdev_id, 0, 3397 ATH11K_BSS_COLOR_COLLISION_DETECTION_STA_PERIOD_MS, 1); 3398 if (ret) 3399 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n", 3400 arvif->vdev_id, ret); 3401 } 3402 } 3403 3404 if (changed & BSS_CHANGED_FILS_DISCOVERY || 3405 changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP) 3406 ath11k_mac_fils_discovery(arvif, info); 3407 3408 if (changed & BSS_CHANGED_ARP_FILTER) { 3409 ipv4_cnt = min(info->arp_addr_cnt, ATH11K_IPV4_MAX_COUNT); 3410 memcpy(arvif->arp_ns_offload.ipv4_addr, info->arp_addr_list, 3411 ipv4_cnt * sizeof(u32)); 3412 memcpy(arvif->arp_ns_offload.mac_addr, vif->addr, ETH_ALEN); 3413 arvif->arp_ns_offload.ipv4_count = ipv4_cnt; 3414 3415 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n", 3416 info->arp_addr_cnt, 3417 vif->addr, arvif->arp_ns_offload.ipv4_addr); 3418 } 3419 3420 mutex_unlock(&ar->conf_mutex); 3421 } 3422 3423 void __ath11k_mac_scan_finish(struct ath11k *ar) 3424 { 3425 lockdep_assert_held(&ar->data_lock); 3426 3427 switch (ar->scan.state) { 3428 case ATH11K_SCAN_IDLE: 3429 break; 3430 case ATH11K_SCAN_RUNNING: 3431 case ATH11K_SCAN_ABORTING: 3432 if (ar->scan.is_roc && ar->scan.roc_notify) 3433 ieee80211_remain_on_channel_expired(ar->hw); 3434 fallthrough; 3435 case ATH11K_SCAN_STARTING: 3436 if (!ar->scan.is_roc) { 3437 struct cfg80211_scan_info info = { 3438 .aborted = ((ar->scan.state == 3439 ATH11K_SCAN_ABORTING) || 3440 (ar->scan.state == 3441 ATH11K_SCAN_STARTING)), 3442 }; 3443 3444 ieee80211_scan_completed(ar->hw, &info); 3445 } 3446 3447 ar->scan.state = ATH11K_SCAN_IDLE; 3448 ar->scan_channel = NULL; 3449 ar->scan.roc_freq = 0; 3450 cancel_delayed_work(&ar->scan.timeout); 3451 complete(&ar->scan.completed); 3452 break; 3453 } 3454 } 3455 3456 void ath11k_mac_scan_finish(struct ath11k *ar) 3457 { 3458 spin_lock_bh(&ar->data_lock); 3459 __ath11k_mac_scan_finish(ar); 3460 spin_unlock_bh(&ar->data_lock); 3461 } 3462 3463 static int ath11k_scan_stop(struct ath11k *ar) 3464 { 3465 struct scan_cancel_param arg = { 3466 .req_type = WLAN_SCAN_CANCEL_SINGLE, 3467 .scan_id = ATH11K_SCAN_ID, 3468 }; 3469 int ret; 3470 3471 lockdep_assert_held(&ar->conf_mutex); 3472 3473 /* TODO: Fill other STOP Params */ 3474 arg.pdev_id = ar->pdev->pdev_id; 3475 3476 ret = ath11k_wmi_send_scan_stop_cmd(ar, &arg); 3477 if (ret) { 3478 ath11k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret); 3479 goto out; 3480 } 3481 3482 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ); 3483 if (ret == 0) { 3484 ath11k_warn(ar->ab, 3485 "failed to receive scan abort comple: timed out\n"); 3486 ret = -ETIMEDOUT; 3487 } else if (ret > 0) { 3488 ret = 0; 3489 } 3490 3491 out: 3492 /* Scan state should be updated upon scan completion but in case 3493 * firmware fails to deliver the event (for whatever reason) it is 3494 * desired to clean up scan state anyway. Firmware may have just 3495 * dropped the scan completion event delivery due to transport pipe 3496 * being overflown with data and/or it can recover on its own before 3497 * next scan request is submitted. 3498 */ 3499 spin_lock_bh(&ar->data_lock); 3500 if (ar->scan.state != ATH11K_SCAN_IDLE) 3501 __ath11k_mac_scan_finish(ar); 3502 spin_unlock_bh(&ar->data_lock); 3503 3504 return ret; 3505 } 3506 3507 static void ath11k_scan_abort(struct ath11k *ar) 3508 { 3509 int ret; 3510 3511 lockdep_assert_held(&ar->conf_mutex); 3512 3513 spin_lock_bh(&ar->data_lock); 3514 3515 switch (ar->scan.state) { 3516 case ATH11K_SCAN_IDLE: 3517 /* This can happen if timeout worker kicked in and called 3518 * abortion while scan completion was being processed. 3519 */ 3520 break; 3521 case ATH11K_SCAN_STARTING: 3522 case ATH11K_SCAN_ABORTING: 3523 ath11k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n", 3524 ar->scan.state); 3525 break; 3526 case ATH11K_SCAN_RUNNING: 3527 ar->scan.state = ATH11K_SCAN_ABORTING; 3528 spin_unlock_bh(&ar->data_lock); 3529 3530 ret = ath11k_scan_stop(ar); 3531 if (ret) 3532 ath11k_warn(ar->ab, "failed to abort scan: %d\n", ret); 3533 3534 spin_lock_bh(&ar->data_lock); 3535 break; 3536 } 3537 3538 spin_unlock_bh(&ar->data_lock); 3539 } 3540 3541 static void ath11k_scan_timeout_work(struct work_struct *work) 3542 { 3543 struct ath11k *ar = container_of(work, struct ath11k, 3544 scan.timeout.work); 3545 3546 mutex_lock(&ar->conf_mutex); 3547 ath11k_scan_abort(ar); 3548 mutex_unlock(&ar->conf_mutex); 3549 } 3550 3551 static int ath11k_start_scan(struct ath11k *ar, 3552 struct scan_req_params *arg) 3553 { 3554 int ret; 3555 unsigned long timeout = 1 * HZ; 3556 3557 lockdep_assert_held(&ar->conf_mutex); 3558 3559 if (ath11k_spectral_get_mode(ar) == ATH11K_SPECTRAL_BACKGROUND) 3560 ath11k_spectral_reset_buffer(ar); 3561 3562 ret = ath11k_wmi_send_scan_start_cmd(ar, arg); 3563 if (ret) 3564 return ret; 3565 3566 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) { 3567 timeout = 5 * HZ; 3568 3569 if (ar->supports_6ghz) 3570 timeout += 5 * HZ; 3571 } 3572 3573 ret = wait_for_completion_timeout(&ar->scan.started, timeout); 3574 if (ret == 0) { 3575 ret = ath11k_scan_stop(ar); 3576 if (ret) 3577 ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret); 3578 3579 return -ETIMEDOUT; 3580 } 3581 3582 /* If we failed to start the scan, return error code at 3583 * this point. This is probably due to some issue in the 3584 * firmware, but no need to wedge the driver due to that... 3585 */ 3586 spin_lock_bh(&ar->data_lock); 3587 if (ar->scan.state == ATH11K_SCAN_IDLE) { 3588 spin_unlock_bh(&ar->data_lock); 3589 return -EINVAL; 3590 } 3591 spin_unlock_bh(&ar->data_lock); 3592 3593 return 0; 3594 } 3595 3596 static int ath11k_mac_op_hw_scan(struct ieee80211_hw *hw, 3597 struct ieee80211_vif *vif, 3598 struct ieee80211_scan_request *hw_req) 3599 { 3600 struct ath11k *ar = hw->priv; 3601 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3602 struct cfg80211_scan_request *req = &hw_req->req; 3603 struct scan_req_params arg; 3604 int ret = 0; 3605 int i; 3606 3607 mutex_lock(&ar->conf_mutex); 3608 3609 spin_lock_bh(&ar->data_lock); 3610 switch (ar->scan.state) { 3611 case ATH11K_SCAN_IDLE: 3612 reinit_completion(&ar->scan.started); 3613 reinit_completion(&ar->scan.completed); 3614 ar->scan.state = ATH11K_SCAN_STARTING; 3615 ar->scan.is_roc = false; 3616 ar->scan.vdev_id = arvif->vdev_id; 3617 ret = 0; 3618 break; 3619 case ATH11K_SCAN_STARTING: 3620 case ATH11K_SCAN_RUNNING: 3621 case ATH11K_SCAN_ABORTING: 3622 ret = -EBUSY; 3623 break; 3624 } 3625 spin_unlock_bh(&ar->data_lock); 3626 3627 if (ret) 3628 goto exit; 3629 3630 memset(&arg, 0, sizeof(arg)); 3631 ath11k_wmi_start_scan_init(ar, &arg); 3632 arg.vdev_id = arvif->vdev_id; 3633 arg.scan_id = ATH11K_SCAN_ID; 3634 3635 if (req->ie_len) { 3636 arg.extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL); 3637 if (!arg.extraie.ptr) { 3638 ret = -ENOMEM; 3639 goto exit; 3640 } 3641 arg.extraie.len = req->ie_len; 3642 } 3643 3644 if (req->n_ssids) { 3645 arg.num_ssids = req->n_ssids; 3646 for (i = 0; i < arg.num_ssids; i++) { 3647 arg.ssid[i].length = req->ssids[i].ssid_len; 3648 memcpy(&arg.ssid[i].ssid, req->ssids[i].ssid, 3649 req->ssids[i].ssid_len); 3650 } 3651 } else { 3652 arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE; 3653 } 3654 3655 if (req->n_channels) { 3656 arg.num_chan = req->n_channels; 3657 arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list), 3658 GFP_KERNEL); 3659 3660 if (!arg.chan_list) { 3661 ret = -ENOMEM; 3662 goto exit; 3663 } 3664 3665 for (i = 0; i < arg.num_chan; i++) 3666 arg.chan_list[i] = req->channels[i]->center_freq; 3667 } 3668 3669 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 3670 arg.scan_f_add_spoofed_mac_in_probe = 1; 3671 ether_addr_copy(arg.mac_addr.addr, req->mac_addr); 3672 ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask); 3673 } 3674 3675 ret = ath11k_start_scan(ar, &arg); 3676 if (ret) { 3677 ath11k_warn(ar->ab, "failed to start hw scan: %d\n", ret); 3678 spin_lock_bh(&ar->data_lock); 3679 ar->scan.state = ATH11K_SCAN_IDLE; 3680 spin_unlock_bh(&ar->data_lock); 3681 } 3682 3683 /* Add a 200ms margin to account for event/command processing */ 3684 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 3685 msecs_to_jiffies(arg.max_scan_time + 3686 ATH11K_MAC_SCAN_TIMEOUT_MSECS)); 3687 3688 exit: 3689 kfree(arg.chan_list); 3690 3691 if (req->ie_len) 3692 kfree(arg.extraie.ptr); 3693 3694 mutex_unlock(&ar->conf_mutex); 3695 3696 if (ar->state_11d == ATH11K_11D_PREPARING) 3697 ath11k_mac_11d_scan_start(ar, arvif->vdev_id); 3698 3699 return ret; 3700 } 3701 3702 static void ath11k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw, 3703 struct ieee80211_vif *vif) 3704 { 3705 struct ath11k *ar = hw->priv; 3706 3707 mutex_lock(&ar->conf_mutex); 3708 ath11k_scan_abort(ar); 3709 mutex_unlock(&ar->conf_mutex); 3710 3711 cancel_delayed_work_sync(&ar->scan.timeout); 3712 } 3713 3714 static int ath11k_install_key(struct ath11k_vif *arvif, 3715 struct ieee80211_key_conf *key, 3716 enum set_key_cmd cmd, 3717 const u8 *macaddr, u32 flags) 3718 { 3719 int ret; 3720 struct ath11k *ar = arvif->ar; 3721 struct wmi_vdev_install_key_arg arg = { 3722 .vdev_id = arvif->vdev_id, 3723 .key_idx = key->keyidx, 3724 .key_len = key->keylen, 3725 .key_data = key->key, 3726 .key_flags = flags, 3727 .macaddr = macaddr, 3728 }; 3729 3730 lockdep_assert_held(&arvif->ar->conf_mutex); 3731 3732 reinit_completion(&ar->install_key_done); 3733 3734 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags)) 3735 return 0; 3736 3737 if (cmd == DISABLE_KEY) { 3738 arg.key_cipher = WMI_CIPHER_NONE; 3739 arg.key_data = NULL; 3740 goto install; 3741 } 3742 3743 switch (key->cipher) { 3744 case WLAN_CIPHER_SUITE_CCMP: 3745 arg.key_cipher = WMI_CIPHER_AES_CCM; 3746 /* TODO: Re-check if flag is valid */ 3747 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT; 3748 break; 3749 case WLAN_CIPHER_SUITE_TKIP: 3750 arg.key_cipher = WMI_CIPHER_TKIP; 3751 arg.key_txmic_len = 8; 3752 arg.key_rxmic_len = 8; 3753 break; 3754 case WLAN_CIPHER_SUITE_CCMP_256: 3755 arg.key_cipher = WMI_CIPHER_AES_CCM; 3756 break; 3757 case WLAN_CIPHER_SUITE_GCMP: 3758 case WLAN_CIPHER_SUITE_GCMP_256: 3759 arg.key_cipher = WMI_CIPHER_AES_GCM; 3760 break; 3761 default: 3762 ath11k_warn(ar->ab, "cipher %d is not supported\n", key->cipher); 3763 return -EOPNOTSUPP; 3764 } 3765 3766 if (test_bit(ATH11K_FLAG_RAW_MODE, &ar->ab->dev_flags)) 3767 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV | 3768 IEEE80211_KEY_FLAG_RESERVE_TAILROOM; 3769 3770 install: 3771 ret = ath11k_wmi_vdev_install_key(arvif->ar, &arg); 3772 3773 if (ret) 3774 return ret; 3775 3776 if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ)) 3777 return -ETIMEDOUT; 3778 3779 return ar->install_key_status ? -EINVAL : 0; 3780 } 3781 3782 static int ath11k_clear_peer_keys(struct ath11k_vif *arvif, 3783 const u8 *addr) 3784 { 3785 struct ath11k *ar = arvif->ar; 3786 struct ath11k_base *ab = ar->ab; 3787 struct ath11k_peer *peer; 3788 int first_errno = 0; 3789 int ret; 3790 int i; 3791 u32 flags = 0; 3792 3793 lockdep_assert_held(&ar->conf_mutex); 3794 3795 spin_lock_bh(&ab->base_lock); 3796 peer = ath11k_peer_find(ab, arvif->vdev_id, addr); 3797 spin_unlock_bh(&ab->base_lock); 3798 3799 if (!peer) 3800 return -ENOENT; 3801 3802 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 3803 if (!peer->keys[i]) 3804 continue; 3805 3806 /* key flags are not required to delete the key */ 3807 ret = ath11k_install_key(arvif, peer->keys[i], 3808 DISABLE_KEY, addr, flags); 3809 if (ret < 0 && first_errno == 0) 3810 first_errno = ret; 3811 3812 if (ret < 0) 3813 ath11k_warn(ab, "failed to remove peer key %d: %d\n", 3814 i, ret); 3815 3816 spin_lock_bh(&ab->base_lock); 3817 peer->keys[i] = NULL; 3818 spin_unlock_bh(&ab->base_lock); 3819 } 3820 3821 return first_errno; 3822 } 3823 3824 static int ath11k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 3825 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 3826 struct ieee80211_key_conf *key) 3827 { 3828 struct ath11k *ar = hw->priv; 3829 struct ath11k_base *ab = ar->ab; 3830 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3831 struct ath11k_peer *peer; 3832 struct ath11k_sta *arsta; 3833 const u8 *peer_addr; 3834 int ret = 0; 3835 u32 flags = 0; 3836 3837 /* BIP needs to be done in software */ 3838 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC || 3839 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 || 3840 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 || 3841 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256) 3842 return 1; 3843 3844 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags)) 3845 return 1; 3846 3847 if (key->keyidx > WMI_MAX_KEY_INDEX) 3848 return -ENOSPC; 3849 3850 mutex_lock(&ar->conf_mutex); 3851 3852 if (sta) 3853 peer_addr = sta->addr; 3854 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 3855 peer_addr = vif->bss_conf.bssid; 3856 else 3857 peer_addr = vif->addr; 3858 3859 key->hw_key_idx = key->keyidx; 3860 3861 /* the peer should not disappear in mid-way (unless FW goes awry) since 3862 * we already hold conf_mutex. we just make sure its there now. 3863 */ 3864 spin_lock_bh(&ab->base_lock); 3865 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr); 3866 3867 /* flush the fragments cache during key (re)install to 3868 * ensure all frags in the new frag list belong to the same key. 3869 */ 3870 if (peer && sta && cmd == SET_KEY) 3871 ath11k_peer_frags_flush(ar, peer); 3872 spin_unlock_bh(&ab->base_lock); 3873 3874 if (!peer) { 3875 if (cmd == SET_KEY) { 3876 ath11k_warn(ab, "cannot install key for non-existent peer %pM\n", 3877 peer_addr); 3878 ret = -EOPNOTSUPP; 3879 goto exit; 3880 } else { 3881 /* if the peer doesn't exist there is no key to disable 3882 * anymore 3883 */ 3884 goto exit; 3885 } 3886 } 3887 3888 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 3889 flags |= WMI_KEY_PAIRWISE; 3890 else 3891 flags |= WMI_KEY_GROUP; 3892 3893 ret = ath11k_install_key(arvif, key, cmd, peer_addr, flags); 3894 if (ret) { 3895 ath11k_warn(ab, "ath11k_install_key failed (%d)\n", ret); 3896 goto exit; 3897 } 3898 3899 ret = ath11k_dp_peer_rx_pn_replay_config(arvif, peer_addr, cmd, key); 3900 if (ret) { 3901 ath11k_warn(ab, "failed to offload PN replay detection %d\n", ret); 3902 goto exit; 3903 } 3904 3905 spin_lock_bh(&ab->base_lock); 3906 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr); 3907 if (peer && cmd == SET_KEY) { 3908 peer->keys[key->keyidx] = key; 3909 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) { 3910 peer->ucast_keyidx = key->keyidx; 3911 peer->sec_type = ath11k_dp_tx_get_encrypt_type(key->cipher); 3912 } else { 3913 peer->mcast_keyidx = key->keyidx; 3914 peer->sec_type_grp = ath11k_dp_tx_get_encrypt_type(key->cipher); 3915 } 3916 } else if (peer && cmd == DISABLE_KEY) { 3917 peer->keys[key->keyidx] = NULL; 3918 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 3919 peer->ucast_keyidx = 0; 3920 else 3921 peer->mcast_keyidx = 0; 3922 } else if (!peer) 3923 /* impossible unless FW goes crazy */ 3924 ath11k_warn(ab, "peer %pM disappeared!\n", peer_addr); 3925 3926 if (sta) { 3927 arsta = (struct ath11k_sta *)sta->drv_priv; 3928 3929 switch (key->cipher) { 3930 case WLAN_CIPHER_SUITE_TKIP: 3931 case WLAN_CIPHER_SUITE_CCMP: 3932 case WLAN_CIPHER_SUITE_CCMP_256: 3933 case WLAN_CIPHER_SUITE_GCMP: 3934 case WLAN_CIPHER_SUITE_GCMP_256: 3935 if (cmd == SET_KEY) 3936 arsta->pn_type = HAL_PN_TYPE_WPA; 3937 else 3938 arsta->pn_type = HAL_PN_TYPE_NONE; 3939 break; 3940 default: 3941 arsta->pn_type = HAL_PN_TYPE_NONE; 3942 break; 3943 } 3944 } 3945 3946 spin_unlock_bh(&ab->base_lock); 3947 3948 exit: 3949 mutex_unlock(&ar->conf_mutex); 3950 return ret; 3951 } 3952 3953 static int 3954 ath11k_mac_bitrate_mask_num_vht_rates(struct ath11k *ar, 3955 enum nl80211_band band, 3956 const struct cfg80211_bitrate_mask *mask) 3957 { 3958 int num_rates = 0; 3959 int i; 3960 3961 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) 3962 num_rates += hweight16(mask->control[band].vht_mcs[i]); 3963 3964 return num_rates; 3965 } 3966 3967 static int 3968 ath11k_mac_bitrate_mask_num_he_rates(struct ath11k *ar, 3969 enum nl80211_band band, 3970 const struct cfg80211_bitrate_mask *mask) 3971 { 3972 int num_rates = 0; 3973 int i; 3974 3975 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) 3976 num_rates += hweight16(mask->control[band].he_mcs[i]); 3977 3978 return num_rates; 3979 } 3980 3981 static int 3982 ath11k_mac_set_peer_vht_fixed_rate(struct ath11k_vif *arvif, 3983 struct ieee80211_sta *sta, 3984 const struct cfg80211_bitrate_mask *mask, 3985 enum nl80211_band band) 3986 { 3987 struct ath11k *ar = arvif->ar; 3988 u8 vht_rate, nss; 3989 u32 rate_code; 3990 int ret, i; 3991 3992 lockdep_assert_held(&ar->conf_mutex); 3993 3994 nss = 0; 3995 3996 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 3997 if (hweight16(mask->control[band].vht_mcs[i]) == 1) { 3998 nss = i + 1; 3999 vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1; 4000 } 4001 } 4002 4003 if (!nss) { 4004 ath11k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM", 4005 sta->addr); 4006 return -EINVAL; 4007 } 4008 4009 /* Avoid updating invalid nss as fixed rate*/ 4010 if (nss > sta->deflink.rx_nss) 4011 return -EINVAL; 4012 4013 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4014 "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates", 4015 sta->addr); 4016 4017 rate_code = ATH11K_HW_RATE_CODE(vht_rate, nss - 1, 4018 WMI_RATE_PREAMBLE_VHT); 4019 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4020 arvif->vdev_id, 4021 WMI_PEER_PARAM_FIXED_RATE, 4022 rate_code); 4023 if (ret) 4024 ath11k_warn(ar->ab, 4025 "failed to update STA %pM Fixed Rate %d: %d\n", 4026 sta->addr, rate_code, ret); 4027 4028 return ret; 4029 } 4030 4031 static int 4032 ath11k_mac_set_peer_he_fixed_rate(struct ath11k_vif *arvif, 4033 struct ieee80211_sta *sta, 4034 const struct cfg80211_bitrate_mask *mask, 4035 enum nl80211_band band) 4036 { 4037 struct ath11k *ar = arvif->ar; 4038 u8 he_rate, nss; 4039 u32 rate_code; 4040 int ret, i; 4041 4042 lockdep_assert_held(&ar->conf_mutex); 4043 4044 nss = 0; 4045 4046 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) { 4047 if (hweight16(mask->control[band].he_mcs[i]) == 1) { 4048 nss = i + 1; 4049 he_rate = ffs(mask->control[band].he_mcs[i]) - 1; 4050 } 4051 } 4052 4053 if (!nss) { 4054 ath11k_warn(ar->ab, "No single he fixed rate found to set for %pM", 4055 sta->addr); 4056 return -EINVAL; 4057 } 4058 4059 /* Avoid updating invalid nss as fixed rate */ 4060 if (nss > sta->deflink.rx_nss) 4061 return -EINVAL; 4062 4063 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4064 "mac setting fixed he rate for peer %pM, device will not switch to any other selected rates", 4065 sta->addr); 4066 4067 rate_code = ATH11K_HW_RATE_CODE(he_rate, nss - 1, 4068 WMI_RATE_PREAMBLE_HE); 4069 4070 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4071 arvif->vdev_id, 4072 WMI_PEER_PARAM_FIXED_RATE, 4073 rate_code); 4074 if (ret) 4075 ath11k_warn(ar->ab, 4076 "failed to update sta %pM fixed rate %d: %d\n", 4077 sta->addr, rate_code, ret); 4078 4079 return ret; 4080 } 4081 4082 static int ath11k_station_assoc(struct ath11k *ar, 4083 struct ieee80211_vif *vif, 4084 struct ieee80211_sta *sta, 4085 bool reassoc) 4086 { 4087 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4088 struct peer_assoc_params peer_arg; 4089 int ret = 0; 4090 struct cfg80211_chan_def def; 4091 enum nl80211_band band; 4092 struct cfg80211_bitrate_mask *mask; 4093 u8 num_vht_rates, num_he_rates; 4094 4095 lockdep_assert_held(&ar->conf_mutex); 4096 4097 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 4098 return -EPERM; 4099 4100 band = def.chan->band; 4101 mask = &arvif->bitrate_mask; 4102 4103 ath11k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc); 4104 4105 peer_arg.is_assoc = true; 4106 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4107 if (ret) { 4108 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 4109 sta->addr, arvif->vdev_id, ret); 4110 return ret; 4111 } 4112 4113 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 4114 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4115 sta->addr, arvif->vdev_id); 4116 return -ETIMEDOUT; 4117 } 4118 4119 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask); 4120 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask); 4121 4122 /* If single VHT/HE rate is configured (by set_bitrate_mask()), 4123 * peer_assoc will disable VHT/HE. This is now enabled by a peer specific 4124 * fixed param. 4125 * Note that all other rates and NSS will be disabled for this peer. 4126 */ 4127 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) { 4128 ret = ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 4129 band); 4130 if (ret) 4131 return ret; 4132 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) { 4133 ret = ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask, 4134 band); 4135 if (ret) 4136 return ret; 4137 } 4138 4139 /* Re-assoc is run only to update supported rates for given station. It 4140 * doesn't make much sense to reconfigure the peer completely. 4141 */ 4142 if (reassoc) 4143 return 0; 4144 4145 ret = ath11k_setup_peer_smps(ar, arvif, sta->addr, 4146 &sta->deflink.ht_cap, 4147 le16_to_cpu(sta->deflink.he_6ghz_capa.capa)); 4148 if (ret) { 4149 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n", 4150 arvif->vdev_id, ret); 4151 return ret; 4152 } 4153 4154 if (!sta->wme) { 4155 arvif->num_legacy_stations++; 4156 ret = ath11k_recalc_rtscts_prot(arvif); 4157 if (ret) 4158 return ret; 4159 } 4160 4161 if (sta->wme && sta->uapsd_queues) { 4162 ret = ath11k_peer_assoc_qos_ap(ar, arvif, sta); 4163 if (ret) { 4164 ath11k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n", 4165 sta->addr, arvif->vdev_id, ret); 4166 return ret; 4167 } 4168 } 4169 4170 return 0; 4171 } 4172 4173 static int ath11k_station_disassoc(struct ath11k *ar, 4174 struct ieee80211_vif *vif, 4175 struct ieee80211_sta *sta) 4176 { 4177 struct ath11k_vif *arvif = (void *)vif->drv_priv; 4178 int ret = 0; 4179 4180 lockdep_assert_held(&ar->conf_mutex); 4181 4182 if (!sta->wme) { 4183 arvif->num_legacy_stations--; 4184 ret = ath11k_recalc_rtscts_prot(arvif); 4185 if (ret) 4186 return ret; 4187 } 4188 4189 ret = ath11k_clear_peer_keys(arvif, sta->addr); 4190 if (ret) { 4191 ath11k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n", 4192 arvif->vdev_id, ret); 4193 return ret; 4194 } 4195 return 0; 4196 } 4197 4198 static void ath11k_sta_rc_update_wk(struct work_struct *wk) 4199 { 4200 struct ath11k *ar; 4201 struct ath11k_vif *arvif; 4202 struct ath11k_sta *arsta; 4203 struct ieee80211_sta *sta; 4204 struct cfg80211_chan_def def; 4205 enum nl80211_band band; 4206 const u8 *ht_mcs_mask; 4207 const u16 *vht_mcs_mask; 4208 const u16 *he_mcs_mask; 4209 u32 changed, bw, nss, smps; 4210 int err, num_vht_rates, num_he_rates; 4211 const struct cfg80211_bitrate_mask *mask; 4212 struct peer_assoc_params peer_arg; 4213 4214 arsta = container_of(wk, struct ath11k_sta, update_wk); 4215 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 4216 arvif = arsta->arvif; 4217 ar = arvif->ar; 4218 4219 if (WARN_ON(ath11k_mac_vif_chan(arvif->vif, &def))) 4220 return; 4221 4222 band = def.chan->band; 4223 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 4224 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 4225 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs; 4226 4227 spin_lock_bh(&ar->data_lock); 4228 4229 changed = arsta->changed; 4230 arsta->changed = 0; 4231 4232 bw = arsta->bw; 4233 nss = arsta->nss; 4234 smps = arsta->smps; 4235 4236 spin_unlock_bh(&ar->data_lock); 4237 4238 mutex_lock(&ar->conf_mutex); 4239 4240 nss = max_t(u32, 1, nss); 4241 nss = min(nss, max(max(ath11k_mac_max_ht_nss(ht_mcs_mask), 4242 ath11k_mac_max_vht_nss(vht_mcs_mask)), 4243 ath11k_mac_max_he_nss(he_mcs_mask))); 4244 4245 if (changed & IEEE80211_RC_BW_CHANGED) { 4246 /* Send peer assoc command before set peer bandwidth param to 4247 * avoid the mismatch between the peer phymode and the peer 4248 * bandwidth. 4249 */ 4250 ath11k_peer_assoc_prepare(ar, arvif->vif, sta, &peer_arg, true); 4251 4252 peer_arg.is_assoc = false; 4253 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4254 if (err) { 4255 ath11k_warn(ar->ab, "failed to send peer assoc for STA %pM vdev %i: %d\n", 4256 sta->addr, arvif->vdev_id, err); 4257 } else if (wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 4258 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4259 WMI_PEER_CHWIDTH, bw); 4260 if (err) 4261 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n", 4262 sta->addr, bw, err); 4263 } else { 4264 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4265 sta->addr, arvif->vdev_id); 4266 } 4267 } 4268 4269 if (changed & IEEE80211_RC_NSS_CHANGED) { 4270 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM nss %d\n", 4271 sta->addr, nss); 4272 4273 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4274 WMI_PEER_NSS, nss); 4275 if (err) 4276 ath11k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n", 4277 sta->addr, nss, err); 4278 } 4279 4280 if (changed & IEEE80211_RC_SMPS_CHANGED) { 4281 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM smps %d\n", 4282 sta->addr, smps); 4283 4284 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4285 WMI_PEER_MIMO_PS_STATE, smps); 4286 if (err) 4287 ath11k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n", 4288 sta->addr, smps, err); 4289 } 4290 4291 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) { 4292 mask = &arvif->bitrate_mask; 4293 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, 4294 mask); 4295 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, 4296 mask); 4297 4298 /* Peer_assoc_prepare will reject vht rates in 4299 * bitrate_mask if its not available in range format and 4300 * sets vht tx_rateset as unsupported. So multiple VHT MCS 4301 * setting(eg. MCS 4,5,6) per peer is not supported here. 4302 * But, Single rate in VHT mask can be set as per-peer 4303 * fixed rate. But even if any HT rates are configured in 4304 * the bitrate mask, device will not switch to those rates 4305 * when per-peer Fixed rate is set. 4306 * TODO: Check RATEMASK_CMDID to support auto rates selection 4307 * across HT/VHT and for multiple VHT MCS support. 4308 */ 4309 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) { 4310 ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 4311 band); 4312 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) { 4313 ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask, 4314 band); 4315 } else { 4316 /* If the peer is non-VHT/HE or no fixed VHT/HE rate 4317 * is provided in the new bitrate mask we set the 4318 * other rates using peer_assoc command. Also clear 4319 * the peer fixed rate settings as it has higher proprity 4320 * than peer assoc 4321 */ 4322 err = ath11k_wmi_set_peer_param(ar, sta->addr, 4323 arvif->vdev_id, 4324 WMI_PEER_PARAM_FIXED_RATE, 4325 WMI_FIXED_RATE_NONE); 4326 if (err) 4327 ath11k_warn(ar->ab, 4328 "failed to disable peer fixed rate for sta %pM: %d\n", 4329 sta->addr, err); 4330 4331 ath11k_peer_assoc_prepare(ar, arvif->vif, sta, 4332 &peer_arg, true); 4333 4334 peer_arg.is_assoc = false; 4335 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4336 if (err) 4337 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 4338 sta->addr, arvif->vdev_id, err); 4339 4340 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) 4341 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4342 sta->addr, arvif->vdev_id); 4343 } 4344 } 4345 4346 mutex_unlock(&ar->conf_mutex); 4347 } 4348 4349 static void ath11k_sta_set_4addr_wk(struct work_struct *wk) 4350 { 4351 struct ath11k *ar; 4352 struct ath11k_vif *arvif; 4353 struct ath11k_sta *arsta; 4354 struct ieee80211_sta *sta; 4355 int ret = 0; 4356 4357 arsta = container_of(wk, struct ath11k_sta, set_4addr_wk); 4358 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 4359 arvif = arsta->arvif; 4360 ar = arvif->ar; 4361 4362 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4363 "setting USE_4ADDR for peer %pM\n", sta->addr); 4364 4365 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4366 arvif->vdev_id, 4367 WMI_PEER_USE_4ADDR, 1); 4368 4369 if (ret) 4370 ath11k_warn(ar->ab, "failed to set peer %pM 4addr capability: %d\n", 4371 sta->addr, ret); 4372 } 4373 4374 static int ath11k_mac_inc_num_stations(struct ath11k_vif *arvif, 4375 struct ieee80211_sta *sta) 4376 { 4377 struct ath11k *ar = arvif->ar; 4378 4379 lockdep_assert_held(&ar->conf_mutex); 4380 4381 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 4382 return 0; 4383 4384 if (ar->num_stations >= ar->max_num_stations) 4385 return -ENOBUFS; 4386 4387 ar->num_stations++; 4388 4389 return 0; 4390 } 4391 4392 static void ath11k_mac_dec_num_stations(struct ath11k_vif *arvif, 4393 struct ieee80211_sta *sta) 4394 { 4395 struct ath11k *ar = arvif->ar; 4396 4397 lockdep_assert_held(&ar->conf_mutex); 4398 4399 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 4400 return; 4401 4402 ar->num_stations--; 4403 } 4404 4405 static int ath11k_mac_station_add(struct ath11k *ar, 4406 struct ieee80211_vif *vif, 4407 struct ieee80211_sta *sta) 4408 { 4409 struct ath11k_base *ab = ar->ab; 4410 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4411 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 4412 struct peer_create_params peer_param; 4413 int ret; 4414 4415 lockdep_assert_held(&ar->conf_mutex); 4416 4417 ret = ath11k_mac_inc_num_stations(arvif, sta); 4418 if (ret) { 4419 ath11k_warn(ab, "refusing to associate station: too many connected already (%d)\n", 4420 ar->max_num_stations); 4421 goto exit; 4422 } 4423 4424 arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL); 4425 if (!arsta->rx_stats) { 4426 ret = -ENOMEM; 4427 goto dec_num_station; 4428 } 4429 4430 peer_param.vdev_id = arvif->vdev_id; 4431 peer_param.peer_addr = sta->addr; 4432 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 4433 4434 ret = ath11k_peer_create(ar, arvif, sta, &peer_param); 4435 if (ret) { 4436 ath11k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n", 4437 sta->addr, arvif->vdev_id); 4438 goto free_rx_stats; 4439 } 4440 4441 ath11k_dbg(ab, ATH11K_DBG_MAC, "Added peer: %pM for VDEV: %d\n", 4442 sta->addr, arvif->vdev_id); 4443 4444 if (ath11k_debugfs_is_extd_tx_stats_enabled(ar)) { 4445 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), GFP_KERNEL); 4446 if (!arsta->tx_stats) { 4447 ret = -ENOMEM; 4448 goto free_peer; 4449 } 4450 } 4451 4452 if (ieee80211_vif_is_mesh(vif)) { 4453 ath11k_dbg(ab, ATH11K_DBG_MAC, 4454 "setting USE_4ADDR for mesh STA %pM\n", sta->addr); 4455 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4456 arvif->vdev_id, 4457 WMI_PEER_USE_4ADDR, 1); 4458 if (ret) { 4459 ath11k_warn(ab, "failed to set mesh STA %pM 4addr capability: %d\n", 4460 sta->addr, ret); 4461 goto free_tx_stats; 4462 } 4463 } 4464 4465 ret = ath11k_dp_peer_setup(ar, arvif->vdev_id, sta->addr); 4466 if (ret) { 4467 ath11k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n", 4468 sta->addr, arvif->vdev_id, ret); 4469 goto free_tx_stats; 4470 } 4471 4472 if (ab->hw_params.vdev_start_delay && 4473 !arvif->is_started && 4474 arvif->vdev_type != WMI_VDEV_TYPE_AP) { 4475 ret = ath11k_start_vdev_delay(ar->hw, vif); 4476 if (ret) { 4477 ath11k_warn(ab, "failed to delay vdev start: %d\n", ret); 4478 goto free_tx_stats; 4479 } 4480 } 4481 4482 return 0; 4483 4484 free_tx_stats: 4485 kfree(arsta->tx_stats); 4486 arsta->tx_stats = NULL; 4487 free_peer: 4488 ath11k_peer_delete(ar, arvif->vdev_id, sta->addr); 4489 free_rx_stats: 4490 kfree(arsta->rx_stats); 4491 arsta->rx_stats = NULL; 4492 dec_num_station: 4493 ath11k_mac_dec_num_stations(arvif, sta); 4494 exit: 4495 return ret; 4496 } 4497 4498 static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw, 4499 struct ieee80211_vif *vif, 4500 struct ieee80211_sta *sta, 4501 enum ieee80211_sta_state old_state, 4502 enum ieee80211_sta_state new_state) 4503 { 4504 struct ath11k *ar = hw->priv; 4505 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4506 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 4507 struct ath11k_peer *peer; 4508 int ret = 0; 4509 4510 /* cancel must be done outside the mutex to avoid deadlock */ 4511 if ((old_state == IEEE80211_STA_NONE && 4512 new_state == IEEE80211_STA_NOTEXIST)) { 4513 cancel_work_sync(&arsta->update_wk); 4514 cancel_work_sync(&arsta->set_4addr_wk); 4515 } 4516 4517 mutex_lock(&ar->conf_mutex); 4518 4519 if (old_state == IEEE80211_STA_NOTEXIST && 4520 new_state == IEEE80211_STA_NONE) { 4521 memset(arsta, 0, sizeof(*arsta)); 4522 arsta->arvif = arvif; 4523 INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk); 4524 INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk); 4525 4526 ret = ath11k_mac_station_add(ar, vif, sta); 4527 if (ret) 4528 ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n", 4529 sta->addr, arvif->vdev_id); 4530 } else if ((old_state == IEEE80211_STA_NONE && 4531 new_state == IEEE80211_STA_NOTEXIST)) { 4532 bool skip_peer_delete = ar->ab->hw_params.vdev_start_delay && 4533 vif->type == NL80211_IFTYPE_STATION; 4534 4535 ath11k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr); 4536 4537 if (!skip_peer_delete) { 4538 ret = ath11k_peer_delete(ar, arvif->vdev_id, sta->addr); 4539 if (ret) 4540 ath11k_warn(ar->ab, 4541 "Failed to delete peer: %pM for VDEV: %d\n", 4542 sta->addr, arvif->vdev_id); 4543 else 4544 ath11k_dbg(ar->ab, 4545 ATH11K_DBG_MAC, 4546 "Removed peer: %pM for VDEV: %d\n", 4547 sta->addr, arvif->vdev_id); 4548 } 4549 4550 ath11k_mac_dec_num_stations(arvif, sta); 4551 mutex_lock(&ar->ab->tbl_mtx_lock); 4552 spin_lock_bh(&ar->ab->base_lock); 4553 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4554 if (skip_peer_delete && peer) { 4555 peer->sta = NULL; 4556 } else if (peer && peer->sta == sta) { 4557 ath11k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n", 4558 vif->addr, arvif->vdev_id); 4559 ath11k_peer_rhash_delete(ar->ab, peer); 4560 peer->sta = NULL; 4561 list_del(&peer->list); 4562 kfree(peer); 4563 ar->num_peers--; 4564 } 4565 spin_unlock_bh(&ar->ab->base_lock); 4566 mutex_unlock(&ar->ab->tbl_mtx_lock); 4567 4568 kfree(arsta->tx_stats); 4569 arsta->tx_stats = NULL; 4570 4571 kfree(arsta->rx_stats); 4572 arsta->rx_stats = NULL; 4573 } else if (old_state == IEEE80211_STA_AUTH && 4574 new_state == IEEE80211_STA_ASSOC && 4575 (vif->type == NL80211_IFTYPE_AP || 4576 vif->type == NL80211_IFTYPE_MESH_POINT || 4577 vif->type == NL80211_IFTYPE_ADHOC)) { 4578 ret = ath11k_station_assoc(ar, vif, sta, false); 4579 if (ret) 4580 ath11k_warn(ar->ab, "Failed to associate station: %pM\n", 4581 sta->addr); 4582 } else if (old_state == IEEE80211_STA_ASSOC && 4583 new_state == IEEE80211_STA_AUTHORIZED) { 4584 spin_lock_bh(&ar->ab->base_lock); 4585 4586 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4587 if (peer) 4588 peer->is_authorized = true; 4589 4590 spin_unlock_bh(&ar->ab->base_lock); 4591 4592 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) { 4593 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4594 arvif->vdev_id, 4595 WMI_PEER_AUTHORIZE, 4596 1); 4597 if (ret) 4598 ath11k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n", 4599 sta->addr, arvif->vdev_id, ret); 4600 } 4601 } else if (old_state == IEEE80211_STA_AUTHORIZED && 4602 new_state == IEEE80211_STA_ASSOC) { 4603 spin_lock_bh(&ar->ab->base_lock); 4604 4605 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4606 if (peer) 4607 peer->is_authorized = false; 4608 4609 spin_unlock_bh(&ar->ab->base_lock); 4610 } else if (old_state == IEEE80211_STA_ASSOC && 4611 new_state == IEEE80211_STA_AUTH && 4612 (vif->type == NL80211_IFTYPE_AP || 4613 vif->type == NL80211_IFTYPE_MESH_POINT || 4614 vif->type == NL80211_IFTYPE_ADHOC)) { 4615 ret = ath11k_station_disassoc(ar, vif, sta); 4616 if (ret) 4617 ath11k_warn(ar->ab, "Failed to disassociate station: %pM\n", 4618 sta->addr); 4619 } 4620 4621 mutex_unlock(&ar->conf_mutex); 4622 return ret; 4623 } 4624 4625 static int ath11k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw, 4626 struct ieee80211_vif *vif, 4627 struct ieee80211_sta *sta) 4628 { 4629 struct ath11k *ar = hw->priv; 4630 struct ath11k_vif *arvif = (void *)vif->drv_priv; 4631 int ret = 0; 4632 s16 txpwr; 4633 4634 if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) { 4635 txpwr = 0; 4636 } else { 4637 txpwr = sta->deflink.txpwr.power; 4638 if (!txpwr) 4639 return -EINVAL; 4640 } 4641 4642 if (txpwr > ATH11K_TX_POWER_MAX_VAL || txpwr < ATH11K_TX_POWER_MIN_VAL) 4643 return -EINVAL; 4644 4645 mutex_lock(&ar->conf_mutex); 4646 4647 ret = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4648 WMI_PEER_USE_FIXED_PWR, txpwr); 4649 if (ret) { 4650 ath11k_warn(ar->ab, "failed to set tx power for station ret: %d\n", 4651 ret); 4652 goto out; 4653 } 4654 4655 out: 4656 mutex_unlock(&ar->conf_mutex); 4657 return ret; 4658 } 4659 4660 static void ath11k_mac_op_sta_set_4addr(struct ieee80211_hw *hw, 4661 struct ieee80211_vif *vif, 4662 struct ieee80211_sta *sta, bool enabled) 4663 { 4664 struct ath11k *ar = hw->priv; 4665 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 4666 4667 if (enabled && !arsta->use_4addr_set) { 4668 ieee80211_queue_work(ar->hw, &arsta->set_4addr_wk); 4669 arsta->use_4addr_set = true; 4670 } 4671 } 4672 4673 static void ath11k_mac_op_sta_rc_update(struct ieee80211_hw *hw, 4674 struct ieee80211_vif *vif, 4675 struct ieee80211_sta *sta, 4676 u32 changed) 4677 { 4678 struct ath11k *ar = hw->priv; 4679 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 4680 struct ath11k_vif *arvif = (void *)vif->drv_priv; 4681 struct ath11k_peer *peer; 4682 u32 bw, smps; 4683 4684 spin_lock_bh(&ar->ab->base_lock); 4685 4686 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4687 if (!peer) { 4688 spin_unlock_bh(&ar->ab->base_lock); 4689 ath11k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n", 4690 sta->addr, arvif->vdev_id); 4691 return; 4692 } 4693 4694 spin_unlock_bh(&ar->ab->base_lock); 4695 4696 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4697 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 4698 sta->addr, changed, sta->deflink.bandwidth, 4699 sta->deflink.rx_nss, 4700 sta->smps_mode); 4701 4702 spin_lock_bh(&ar->data_lock); 4703 4704 if (changed & IEEE80211_RC_BW_CHANGED) { 4705 bw = WMI_PEER_CHWIDTH_20MHZ; 4706 4707 switch (sta->deflink.bandwidth) { 4708 case IEEE80211_STA_RX_BW_20: 4709 bw = WMI_PEER_CHWIDTH_20MHZ; 4710 break; 4711 case IEEE80211_STA_RX_BW_40: 4712 bw = WMI_PEER_CHWIDTH_40MHZ; 4713 break; 4714 case IEEE80211_STA_RX_BW_80: 4715 bw = WMI_PEER_CHWIDTH_80MHZ; 4716 break; 4717 case IEEE80211_STA_RX_BW_160: 4718 bw = WMI_PEER_CHWIDTH_160MHZ; 4719 break; 4720 default: 4721 ath11k_warn(ar->ab, "Invalid bandwidth %d in rc update for %pM\n", 4722 sta->deflink.bandwidth, sta->addr); 4723 bw = WMI_PEER_CHWIDTH_20MHZ; 4724 break; 4725 } 4726 4727 arsta->bw = bw; 4728 } 4729 4730 if (changed & IEEE80211_RC_NSS_CHANGED) 4731 arsta->nss = sta->deflink.rx_nss; 4732 4733 if (changed & IEEE80211_RC_SMPS_CHANGED) { 4734 smps = WMI_PEER_SMPS_PS_NONE; 4735 4736 switch (sta->smps_mode) { 4737 case IEEE80211_SMPS_AUTOMATIC: 4738 case IEEE80211_SMPS_OFF: 4739 smps = WMI_PEER_SMPS_PS_NONE; 4740 break; 4741 case IEEE80211_SMPS_STATIC: 4742 smps = WMI_PEER_SMPS_STATIC; 4743 break; 4744 case IEEE80211_SMPS_DYNAMIC: 4745 smps = WMI_PEER_SMPS_DYNAMIC; 4746 break; 4747 default: 4748 ath11k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n", 4749 sta->smps_mode, sta->addr); 4750 smps = WMI_PEER_SMPS_PS_NONE; 4751 break; 4752 } 4753 4754 arsta->smps = smps; 4755 } 4756 4757 arsta->changed |= changed; 4758 4759 spin_unlock_bh(&ar->data_lock); 4760 4761 ieee80211_queue_work(hw, &arsta->update_wk); 4762 } 4763 4764 static int ath11k_conf_tx_uapsd(struct ath11k *ar, struct ieee80211_vif *vif, 4765 u16 ac, bool enable) 4766 { 4767 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4768 u32 value = 0; 4769 int ret = 0; 4770 4771 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 4772 return 0; 4773 4774 switch (ac) { 4775 case IEEE80211_AC_VO: 4776 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 4777 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 4778 break; 4779 case IEEE80211_AC_VI: 4780 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 4781 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 4782 break; 4783 case IEEE80211_AC_BE: 4784 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 4785 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 4786 break; 4787 case IEEE80211_AC_BK: 4788 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 4789 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 4790 break; 4791 } 4792 4793 if (enable) 4794 arvif->u.sta.uapsd |= value; 4795 else 4796 arvif->u.sta.uapsd &= ~value; 4797 4798 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 4799 WMI_STA_PS_PARAM_UAPSD, 4800 arvif->u.sta.uapsd); 4801 if (ret) { 4802 ath11k_warn(ar->ab, "could not set uapsd params %d\n", ret); 4803 goto exit; 4804 } 4805 4806 if (arvif->u.sta.uapsd) 4807 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 4808 else 4809 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 4810 4811 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 4812 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 4813 value); 4814 if (ret) 4815 ath11k_warn(ar->ab, "could not set rx wake param %d\n", ret); 4816 4817 exit: 4818 return ret; 4819 } 4820 4821 static int ath11k_mac_op_conf_tx(struct ieee80211_hw *hw, 4822 struct ieee80211_vif *vif, u16 ac, 4823 const struct ieee80211_tx_queue_params *params) 4824 { 4825 struct ath11k *ar = hw->priv; 4826 struct ath11k_vif *arvif = (void *)vif->drv_priv; 4827 struct wmi_wmm_params_arg *p = NULL; 4828 int ret; 4829 4830 mutex_lock(&ar->conf_mutex); 4831 4832 switch (ac) { 4833 case IEEE80211_AC_VO: 4834 p = &arvif->wmm_params.ac_vo; 4835 break; 4836 case IEEE80211_AC_VI: 4837 p = &arvif->wmm_params.ac_vi; 4838 break; 4839 case IEEE80211_AC_BE: 4840 p = &arvif->wmm_params.ac_be; 4841 break; 4842 case IEEE80211_AC_BK: 4843 p = &arvif->wmm_params.ac_bk; 4844 break; 4845 } 4846 4847 if (WARN_ON(!p)) { 4848 ret = -EINVAL; 4849 goto exit; 4850 } 4851 4852 p->cwmin = params->cw_min; 4853 p->cwmax = params->cw_max; 4854 p->aifs = params->aifs; 4855 p->txop = params->txop; 4856 4857 ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id, 4858 &arvif->wmm_params); 4859 if (ret) { 4860 ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret); 4861 goto exit; 4862 } 4863 4864 ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 4865 4866 if (ret) 4867 ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret); 4868 4869 exit: 4870 mutex_unlock(&ar->conf_mutex); 4871 return ret; 4872 } 4873 4874 static struct ieee80211_sta_ht_cap 4875 ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask) 4876 { 4877 int i; 4878 struct ieee80211_sta_ht_cap ht_cap = {0}; 4879 u32 ar_vht_cap = ar->pdev->cap.vht_cap; 4880 4881 if (!(ar_ht_cap & WMI_HT_CAP_ENABLED)) 4882 return ht_cap; 4883 4884 ht_cap.ht_supported = 1; 4885 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 4886 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE; 4887 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 4888 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 4889 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT; 4890 4891 if (ar_ht_cap & WMI_HT_CAP_HT20_SGI) 4892 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 4893 4894 if (ar_ht_cap & WMI_HT_CAP_HT40_SGI) 4895 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 4896 4897 if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) { 4898 u32 smps; 4899 4900 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 4901 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 4902 4903 ht_cap.cap |= smps; 4904 } 4905 4906 if (ar_ht_cap & WMI_HT_CAP_TX_STBC) 4907 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 4908 4909 if (ar_ht_cap & WMI_HT_CAP_RX_STBC) { 4910 u32 stbc; 4911 4912 stbc = ar_ht_cap; 4913 stbc &= WMI_HT_CAP_RX_STBC; 4914 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 4915 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 4916 stbc &= IEEE80211_HT_CAP_RX_STBC; 4917 4918 ht_cap.cap |= stbc; 4919 } 4920 4921 if (ar_ht_cap & WMI_HT_CAP_RX_LDPC) 4922 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 4923 4924 if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT) 4925 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 4926 4927 if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 4928 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 4929 4930 for (i = 0; i < ar->num_rx_chains; i++) { 4931 if (rate_cap_rx_chainmask & BIT(i)) 4932 ht_cap.mcs.rx_mask[i] = 0xFF; 4933 } 4934 4935 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 4936 4937 return ht_cap; 4938 } 4939 4940 static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif) 4941 { 4942 u32 value = 0; 4943 struct ath11k *ar = arvif->ar; 4944 int nsts; 4945 int sound_dim; 4946 u32 vht_cap = ar->pdev->cap.vht_cap; 4947 u32 vdev_param = WMI_VDEV_PARAM_TXBF; 4948 4949 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) { 4950 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 4951 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 4952 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET); 4953 } 4954 4955 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) { 4956 sound_dim = vht_cap & 4957 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 4958 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 4959 if (sound_dim > (ar->num_tx_chains - 1)) 4960 sound_dim = ar->num_tx_chains - 1; 4961 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET); 4962 } 4963 4964 if (!value) 4965 return 0; 4966 4967 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) { 4968 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 4969 4970 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) && 4971 arvif->vdev_type == WMI_VDEV_TYPE_AP) 4972 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER; 4973 } 4974 4975 /* TODO: SUBFEE not validated in HK, disable here until validated? */ 4976 4977 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) { 4978 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 4979 4980 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) && 4981 arvif->vdev_type == WMI_VDEV_TYPE_STA) 4982 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE; 4983 } 4984 4985 return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 4986 vdev_param, value); 4987 } 4988 4989 static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap) 4990 { 4991 bool subfer, subfee; 4992 int sound_dim = 0; 4993 4994 subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)); 4995 subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)); 4996 4997 if (ar->num_tx_chains < 2) { 4998 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE); 4999 subfer = false; 5000 } 5001 5002 /* If SU Beaformer is not set, then disable MU Beamformer Capability */ 5003 if (!subfer) 5004 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE); 5005 5006 /* If SU Beaformee is not set, then disable MU Beamformee Capability */ 5007 if (!subfee) 5008 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE); 5009 5010 sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK); 5011 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 5012 *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 5013 5014 /* TODO: Need to check invalid STS and Sound_dim values set by FW? */ 5015 5016 /* Enable Sounding Dimension Field only if SU BF is enabled */ 5017 if (subfer) { 5018 if (sound_dim > (ar->num_tx_chains - 1)) 5019 sound_dim = ar->num_tx_chains - 1; 5020 5021 sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 5022 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 5023 *vht_cap |= sound_dim; 5024 } 5025 5026 /* Use the STS advertised by FW unless SU Beamformee is not supported*/ 5027 if (!subfee) 5028 *vht_cap &= ~(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK); 5029 } 5030 5031 static struct ieee80211_sta_vht_cap 5032 ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask, 5033 u32 rate_cap_rx_chainmask) 5034 { 5035 struct ieee80211_sta_vht_cap vht_cap = {0}; 5036 u16 txmcs_map, rxmcs_map; 5037 int i; 5038 5039 vht_cap.vht_supported = 1; 5040 vht_cap.cap = ar->pdev->cap.vht_cap; 5041 5042 if (ar->pdev->cap.nss_ratio_enabled) 5043 vht_cap.vht_mcs.tx_highest |= 5044 cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE); 5045 5046 ath11k_set_vht_txbf_cap(ar, &vht_cap.cap); 5047 5048 rxmcs_map = 0; 5049 txmcs_map = 0; 5050 for (i = 0; i < 8; i++) { 5051 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i)) 5052 txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 5053 else 5054 txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 5055 5056 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i)) 5057 rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 5058 else 5059 rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 5060 } 5061 5062 if (rate_cap_tx_chainmask <= 1) 5063 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC; 5064 5065 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map); 5066 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map); 5067 5068 return vht_cap; 5069 } 5070 5071 static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar, 5072 struct ath11k_pdev_cap *cap, 5073 u32 *ht_cap_info) 5074 { 5075 struct ieee80211_supported_band *band; 5076 u32 rate_cap_tx_chainmask; 5077 u32 rate_cap_rx_chainmask; 5078 u32 ht_cap; 5079 5080 rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift; 5081 rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift; 5082 5083 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 5084 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 5085 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info; 5086 if (ht_cap_info) 5087 *ht_cap_info = ht_cap; 5088 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap, 5089 rate_cap_rx_chainmask); 5090 } 5091 5092 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 5093 (ar->ab->hw_params.single_pdev_only || 5094 !ar->supports_6ghz)) { 5095 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 5096 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info; 5097 if (ht_cap_info) 5098 *ht_cap_info = ht_cap; 5099 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap, 5100 rate_cap_rx_chainmask); 5101 band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask, 5102 rate_cap_rx_chainmask); 5103 } 5104 } 5105 5106 static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant) 5107 { 5108 /* TODO: Check the request chainmask against the supported 5109 * chainmask table which is advertised in extented_service_ready event 5110 */ 5111 5112 return 0; 5113 } 5114 5115 static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet, 5116 u8 *he_ppet) 5117 { 5118 int nss, ru; 5119 u8 bit = 7; 5120 5121 he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK; 5122 he_ppet[0] |= (fw_ppet->ru_bit_mask << 5123 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) & 5124 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK; 5125 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) { 5126 for (ru = 0; ru < 4; ru++) { 5127 u8 val; 5128 int i; 5129 5130 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0) 5131 continue; 5132 val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) & 5133 0x3f; 5134 val = ((val >> 3) & 0x7) | ((val & 0x7) << 3); 5135 for (i = 5; i >= 0; i--) { 5136 he_ppet[bit / 8] |= 5137 ((val >> i) & 0x1) << ((bit % 8)); 5138 bit++; 5139 } 5140 } 5141 } 5142 } 5143 5144 static void 5145 ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem) 5146 { 5147 u8 m; 5148 5149 m = IEEE80211_HE_MAC_CAP0_TWT_RES | 5150 IEEE80211_HE_MAC_CAP0_TWT_REQ; 5151 he_cap_elem->mac_cap_info[0] &= ~m; 5152 5153 m = IEEE80211_HE_MAC_CAP2_TRS | 5154 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 5155 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 5156 he_cap_elem->mac_cap_info[2] &= ~m; 5157 5158 m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED | 5159 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 5160 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 5161 he_cap_elem->mac_cap_info[3] &= ~m; 5162 5163 m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG | 5164 IEEE80211_HE_MAC_CAP4_BQR; 5165 he_cap_elem->mac_cap_info[4] &= ~m; 5166 5167 m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION | 5168 IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU | 5169 IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING | 5170 IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX; 5171 he_cap_elem->mac_cap_info[5] &= ~m; 5172 5173 m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO | 5174 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO; 5175 he_cap_elem->phy_cap_info[2] &= ~m; 5176 5177 m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU | 5178 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK | 5179 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK; 5180 he_cap_elem->phy_cap_info[3] &= ~m; 5181 5182 m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER; 5183 he_cap_elem->phy_cap_info[4] &= ~m; 5184 5185 m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK; 5186 he_cap_elem->phy_cap_info[5] &= ~m; 5187 5188 m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU | 5189 IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB | 5190 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB | 5191 IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO; 5192 he_cap_elem->phy_cap_info[6] &= ~m; 5193 5194 m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR | 5195 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP | 5196 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ | 5197 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ; 5198 he_cap_elem->phy_cap_info[7] &= ~m; 5199 5200 m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI | 5201 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G | 5202 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU | 5203 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU; 5204 he_cap_elem->phy_cap_info[8] &= ~m; 5205 5206 m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM | 5207 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK | 5208 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU | 5209 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU | 5210 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB | 5211 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB; 5212 he_cap_elem->phy_cap_info[9] &= ~m; 5213 } 5214 5215 static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap, 5216 struct ath11k_band_cap *bcap) 5217 { 5218 u8 val; 5219 5220 bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE; 5221 if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 5222 bcap->he_6ghz_capa |= 5223 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS, 5224 WLAN_HT_CAP_SM_PS_DYNAMIC); 5225 else 5226 bcap->he_6ghz_capa |= 5227 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS, 5228 WLAN_HT_CAP_SM_PS_DISABLED); 5229 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK, 5230 pcap->vht_cap); 5231 bcap->he_6ghz_capa |= 5232 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val); 5233 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap); 5234 bcap->he_6ghz_capa |= 5235 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val); 5236 if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN) 5237 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS; 5238 if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN) 5239 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS; 5240 5241 return cpu_to_le16(bcap->he_6ghz_capa); 5242 } 5243 5244 static int ath11k_mac_copy_he_cap(struct ath11k *ar, 5245 struct ath11k_pdev_cap *cap, 5246 struct ieee80211_sband_iftype_data *data, 5247 int band) 5248 { 5249 int i, idx = 0; 5250 5251 for (i = 0; i < NUM_NL80211_IFTYPES; i++) { 5252 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap; 5253 struct ath11k_band_cap *band_cap = &cap->band[band]; 5254 struct ieee80211_he_cap_elem *he_cap_elem = 5255 &he_cap->he_cap_elem; 5256 5257 switch (i) { 5258 case NL80211_IFTYPE_STATION: 5259 case NL80211_IFTYPE_AP: 5260 case NL80211_IFTYPE_MESH_POINT: 5261 break; 5262 5263 default: 5264 continue; 5265 } 5266 5267 data[idx].types_mask = BIT(i); 5268 he_cap->has_he = true; 5269 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info, 5270 sizeof(he_cap_elem->mac_cap_info)); 5271 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info, 5272 sizeof(he_cap_elem->phy_cap_info)); 5273 5274 he_cap_elem->mac_cap_info[1] &= 5275 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK; 5276 5277 he_cap_elem->phy_cap_info[5] &= 5278 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK; 5279 he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1; 5280 5281 switch (i) { 5282 case NL80211_IFTYPE_AP: 5283 he_cap_elem->phy_cap_info[3] &= 5284 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK; 5285 he_cap_elem->phy_cap_info[9] |= 5286 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU; 5287 break; 5288 case NL80211_IFTYPE_STATION: 5289 he_cap_elem->mac_cap_info[0] &= 5290 ~IEEE80211_HE_MAC_CAP0_TWT_RES; 5291 he_cap_elem->mac_cap_info[0] |= 5292 IEEE80211_HE_MAC_CAP0_TWT_REQ; 5293 he_cap_elem->phy_cap_info[9] |= 5294 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU; 5295 break; 5296 case NL80211_IFTYPE_MESH_POINT: 5297 ath11k_mac_filter_he_cap_mesh(he_cap_elem); 5298 break; 5299 } 5300 5301 he_cap->he_mcs_nss_supp.rx_mcs_80 = 5302 cpu_to_le16(band_cap->he_mcs & 0xffff); 5303 he_cap->he_mcs_nss_supp.tx_mcs_80 = 5304 cpu_to_le16(band_cap->he_mcs & 0xffff); 5305 he_cap->he_mcs_nss_supp.rx_mcs_160 = 5306 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5307 he_cap->he_mcs_nss_supp.tx_mcs_160 = 5308 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5309 he_cap->he_mcs_nss_supp.rx_mcs_80p80 = 5310 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5311 he_cap->he_mcs_nss_supp.tx_mcs_80p80 = 5312 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5313 5314 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres)); 5315 if (he_cap_elem->phy_cap_info[6] & 5316 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) 5317 ath11k_gen_ppe_thresh(&band_cap->he_ppet, 5318 he_cap->ppe_thres); 5319 5320 if (band == NL80211_BAND_6GHZ) { 5321 data[idx].he_6ghz_capa.capa = 5322 ath11k_mac_setup_he_6ghz_cap(cap, band_cap); 5323 } 5324 idx++; 5325 } 5326 5327 return idx; 5328 } 5329 5330 static void ath11k_mac_setup_he_cap(struct ath11k *ar, 5331 struct ath11k_pdev_cap *cap) 5332 { 5333 struct ieee80211_supported_band *band; 5334 int count; 5335 5336 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 5337 count = ath11k_mac_copy_he_cap(ar, cap, 5338 ar->mac.iftype[NL80211_BAND_2GHZ], 5339 NL80211_BAND_2GHZ); 5340 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 5341 band->iftype_data = ar->mac.iftype[NL80211_BAND_2GHZ]; 5342 band->n_iftype_data = count; 5343 } 5344 5345 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) { 5346 count = ath11k_mac_copy_he_cap(ar, cap, 5347 ar->mac.iftype[NL80211_BAND_5GHZ], 5348 NL80211_BAND_5GHZ); 5349 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 5350 band->iftype_data = ar->mac.iftype[NL80211_BAND_5GHZ]; 5351 band->n_iftype_data = count; 5352 } 5353 5354 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 5355 ar->supports_6ghz) { 5356 count = ath11k_mac_copy_he_cap(ar, cap, 5357 ar->mac.iftype[NL80211_BAND_6GHZ], 5358 NL80211_BAND_6GHZ); 5359 band = &ar->mac.sbands[NL80211_BAND_6GHZ]; 5360 band->iftype_data = ar->mac.iftype[NL80211_BAND_6GHZ]; 5361 band->n_iftype_data = count; 5362 } 5363 } 5364 5365 static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant) 5366 { 5367 int ret; 5368 5369 lockdep_assert_held(&ar->conf_mutex); 5370 5371 if (ath11k_check_chain_mask(ar, tx_ant, true)) 5372 return -EINVAL; 5373 5374 if (ath11k_check_chain_mask(ar, rx_ant, false)) 5375 return -EINVAL; 5376 5377 ar->cfg_tx_chainmask = tx_ant; 5378 ar->cfg_rx_chainmask = rx_ant; 5379 5380 if (ar->state != ATH11K_STATE_ON && 5381 ar->state != ATH11K_STATE_RESTARTED) 5382 return 0; 5383 5384 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK, 5385 tx_ant, ar->pdev->pdev_id); 5386 if (ret) { 5387 ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n", 5388 ret, tx_ant); 5389 return ret; 5390 } 5391 5392 ar->num_tx_chains = get_num_chains(tx_ant); 5393 5394 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK, 5395 rx_ant, ar->pdev->pdev_id); 5396 if (ret) { 5397 ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n", 5398 ret, rx_ant); 5399 return ret; 5400 } 5401 5402 ar->num_rx_chains = get_num_chains(rx_ant); 5403 5404 /* Reload HT/VHT/HE capability */ 5405 ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL); 5406 ath11k_mac_setup_he_cap(ar, &ar->pdev->cap); 5407 5408 return 0; 5409 } 5410 5411 static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb) 5412 { 5413 int num_mgmt; 5414 5415 ieee80211_free_txskb(ar->hw, skb); 5416 5417 num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx); 5418 5419 if (num_mgmt < 0) 5420 WARN_ON_ONCE(1); 5421 5422 if (!num_mgmt) 5423 wake_up(&ar->txmgmt_empty_waitq); 5424 } 5425 5426 static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id) 5427 { 5428 struct sk_buff *msdu; 5429 struct ieee80211_tx_info *info; 5430 5431 spin_lock_bh(&ar->txmgmt_idr_lock); 5432 msdu = idr_remove(&ar->txmgmt_idr, buf_id); 5433 spin_unlock_bh(&ar->txmgmt_idr_lock); 5434 5435 if (!msdu) 5436 return; 5437 5438 dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len, 5439 DMA_TO_DEVICE); 5440 5441 info = IEEE80211_SKB_CB(msdu); 5442 memset(&info->status, 0, sizeof(info->status)); 5443 5444 ath11k_mgmt_over_wmi_tx_drop(ar, msdu); 5445 } 5446 5447 int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx) 5448 { 5449 struct ath11k *ar = ctx; 5450 5451 ath11k_mac_tx_mgmt_free(ar, buf_id); 5452 5453 return 0; 5454 } 5455 5456 static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx) 5457 { 5458 struct ieee80211_vif *vif = ctx; 5459 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb); 5460 struct ath11k *ar = skb_cb->ar; 5461 5462 if (skb_cb->vif == vif) 5463 ath11k_mac_tx_mgmt_free(ar, buf_id); 5464 5465 return 0; 5466 } 5467 5468 static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif, 5469 struct sk_buff *skb) 5470 { 5471 struct ath11k_base *ab = ar->ab; 5472 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 5473 struct ieee80211_tx_info *info; 5474 dma_addr_t paddr; 5475 int buf_id; 5476 int ret; 5477 5478 ATH11K_SKB_CB(skb)->ar = ar; 5479 5480 spin_lock_bh(&ar->txmgmt_idr_lock); 5481 buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0, 5482 ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC); 5483 spin_unlock_bh(&ar->txmgmt_idr_lock); 5484 5485 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 5486 "mac tx mgmt frame, buf id %d\n", buf_id); 5487 5488 if (buf_id < 0) 5489 return -ENOSPC; 5490 5491 info = IEEE80211_SKB_CB(skb); 5492 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) { 5493 if ((ieee80211_is_action(hdr->frame_control) || 5494 ieee80211_is_deauth(hdr->frame_control) || 5495 ieee80211_is_disassoc(hdr->frame_control)) && 5496 ieee80211_has_protected(hdr->frame_control)) { 5497 skb_put(skb, IEEE80211_CCMP_MIC_LEN); 5498 } 5499 } 5500 5501 paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE); 5502 if (dma_mapping_error(ab->dev, paddr)) { 5503 ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n"); 5504 ret = -EIO; 5505 goto err_free_idr; 5506 } 5507 5508 ATH11K_SKB_CB(skb)->paddr = paddr; 5509 5510 ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb); 5511 if (ret) { 5512 ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret); 5513 goto err_unmap_buf; 5514 } 5515 5516 return 0; 5517 5518 err_unmap_buf: 5519 dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr, 5520 skb->len, DMA_TO_DEVICE); 5521 err_free_idr: 5522 spin_lock_bh(&ar->txmgmt_idr_lock); 5523 idr_remove(&ar->txmgmt_idr, buf_id); 5524 spin_unlock_bh(&ar->txmgmt_idr_lock); 5525 5526 return ret; 5527 } 5528 5529 static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar) 5530 { 5531 struct sk_buff *skb; 5532 5533 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) 5534 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 5535 } 5536 5537 static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work) 5538 { 5539 struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work); 5540 struct ath11k_skb_cb *skb_cb; 5541 struct ath11k_vif *arvif; 5542 struct sk_buff *skb; 5543 int ret; 5544 5545 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) { 5546 skb_cb = ATH11K_SKB_CB(skb); 5547 if (!skb_cb->vif) { 5548 ath11k_warn(ar->ab, "no vif found for mgmt frame\n"); 5549 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 5550 continue; 5551 } 5552 5553 arvif = ath11k_vif_to_arvif(skb_cb->vif); 5554 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id) && 5555 arvif->is_started) { 5556 ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb); 5557 if (ret) { 5558 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n", 5559 arvif->vdev_id, ret); 5560 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 5561 } else { 5562 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 5563 "mac tx mgmt frame, vdev_id %d\n", 5564 arvif->vdev_id); 5565 } 5566 } else { 5567 ath11k_warn(ar->ab, 5568 "dropping mgmt frame for vdev %d, is_started %d\n", 5569 arvif->vdev_id, 5570 arvif->is_started); 5571 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 5572 } 5573 } 5574 } 5575 5576 static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb, 5577 bool is_prb_rsp) 5578 { 5579 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue; 5580 5581 if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags)) 5582 return -ESHUTDOWN; 5583 5584 /* Drop probe response packets when the pending management tx 5585 * count has reached a certain threshold, so as to prioritize 5586 * other mgmt packets like auth and assoc to be sent on time 5587 * for establishing successful connections. 5588 */ 5589 if (is_prb_rsp && 5590 atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) { 5591 ath11k_warn(ar->ab, 5592 "dropping probe response as pending queue is almost full\n"); 5593 return -ENOSPC; 5594 } 5595 5596 if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) { 5597 ath11k_warn(ar->ab, "mgmt tx queue is full\n"); 5598 return -ENOSPC; 5599 } 5600 5601 skb_queue_tail(q, skb); 5602 atomic_inc(&ar->num_pending_mgmt_tx); 5603 queue_work(ar->ab->workqueue_aux, &ar->wmi_mgmt_tx_work); 5604 5605 return 0; 5606 } 5607 5608 int ath11k_mac_rfkill_config(struct ath11k *ar) 5609 { 5610 struct ath11k_base *ab = ar->ab; 5611 u32 param; 5612 int ret; 5613 5614 if (ab->hw_params.rfkill_pin == 0) 5615 return -EOPNOTSUPP; 5616 5617 ath11k_dbg(ab, ATH11K_DBG_MAC, 5618 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d", 5619 ab->hw_params.rfkill_pin, ab->hw_params.rfkill_cfg, 5620 ab->hw_params.rfkill_on_level); 5621 5622 param = FIELD_PREP(WMI_RFKILL_CFG_RADIO_LEVEL, 5623 ab->hw_params.rfkill_on_level) | 5624 FIELD_PREP(WMI_RFKILL_CFG_GPIO_PIN_NUM, 5625 ab->hw_params.rfkill_pin) | 5626 FIELD_PREP(WMI_RFKILL_CFG_PIN_AS_GPIO, 5627 ab->hw_params.rfkill_cfg); 5628 5629 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_HW_RFKILL_CONFIG, 5630 param, ar->pdev->pdev_id); 5631 if (ret) { 5632 ath11k_warn(ab, 5633 "failed to set rfkill config 0x%x: %d\n", 5634 param, ret); 5635 return ret; 5636 } 5637 5638 return 0; 5639 } 5640 5641 int ath11k_mac_rfkill_enable_radio(struct ath11k *ar, bool enable) 5642 { 5643 enum wmi_rfkill_enable_radio param; 5644 int ret; 5645 5646 if (enable) 5647 param = WMI_RFKILL_ENABLE_RADIO_ON; 5648 else 5649 param = WMI_RFKILL_ENABLE_RADIO_OFF; 5650 5651 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac %d rfkill enable %d", 5652 ar->pdev_idx, param); 5653 5654 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RFKILL_ENABLE, 5655 param, ar->pdev->pdev_id); 5656 if (ret) { 5657 ath11k_warn(ar->ab, "failed to set rfkill enable param %d: %d\n", 5658 param, ret); 5659 return ret; 5660 } 5661 5662 return 0; 5663 } 5664 5665 static void ath11k_mac_op_tx(struct ieee80211_hw *hw, 5666 struct ieee80211_tx_control *control, 5667 struct sk_buff *skb) 5668 { 5669 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb); 5670 struct ath11k *ar = hw->priv; 5671 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 5672 struct ieee80211_vif *vif = info->control.vif; 5673 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 5674 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 5675 struct ieee80211_key_conf *key = info->control.hw_key; 5676 struct ath11k_sta *arsta = NULL; 5677 u32 info_flags = info->flags; 5678 bool is_prb_rsp; 5679 int ret; 5680 5681 memset(skb_cb, 0, sizeof(*skb_cb)); 5682 skb_cb->vif = vif; 5683 5684 if (key) { 5685 skb_cb->cipher = key->cipher; 5686 skb_cb->flags |= ATH11K_SKB_CIPHER_SET; 5687 } 5688 5689 if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) { 5690 skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP; 5691 } else if (ieee80211_is_mgmt(hdr->frame_control)) { 5692 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control); 5693 ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp); 5694 if (ret) { 5695 ath11k_warn(ar->ab, "failed to queue management frame %d\n", 5696 ret); 5697 ieee80211_free_txskb(ar->hw, skb); 5698 } 5699 return; 5700 } 5701 5702 if (control->sta) 5703 arsta = (struct ath11k_sta *)control->sta->drv_priv; 5704 5705 ret = ath11k_dp_tx(ar, arvif, arsta, skb); 5706 if (unlikely(ret)) { 5707 ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret); 5708 ieee80211_free_txskb(ar->hw, skb); 5709 } 5710 } 5711 5712 void ath11k_mac_drain_tx(struct ath11k *ar) 5713 { 5714 /* make sure rcu-protected mac80211 tx path itself is drained */ 5715 synchronize_net(); 5716 5717 cancel_work_sync(&ar->wmi_mgmt_tx_work); 5718 ath11k_mgmt_over_wmi_tx_purge(ar); 5719 } 5720 5721 static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable) 5722 { 5723 struct htt_rx_ring_tlv_filter tlv_filter = {0}; 5724 struct ath11k_base *ab = ar->ab; 5725 int i, ret = 0; 5726 u32 ring_id; 5727 5728 if (enable) { 5729 tlv_filter = ath11k_mac_mon_status_filter_default; 5730 if (ath11k_debugfs_rx_filter(ar)) 5731 tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar); 5732 } 5733 5734 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) { 5735 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id; 5736 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id, 5737 ar->dp.mac_id + i, 5738 HAL_RXDMA_MONITOR_STATUS, 5739 DP_RX_BUFFER_SIZE, 5740 &tlv_filter); 5741 } 5742 5743 if (enable && !ar->ab->hw_params.rxdma1_enable) 5744 mod_timer(&ar->ab->mon_reap_timer, jiffies + 5745 msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL)); 5746 5747 return ret; 5748 } 5749 5750 static void ath11k_mac_wait_reconfigure(struct ath11k_base *ab) 5751 { 5752 int recovery_start_count; 5753 5754 if (!ab->is_reset) 5755 return; 5756 5757 recovery_start_count = atomic_inc_return(&ab->recovery_start_count); 5758 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery start count %d\n", recovery_start_count); 5759 5760 if (recovery_start_count == ab->num_radios) { 5761 complete(&ab->recovery_start); 5762 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery started success\n"); 5763 } 5764 5765 ath11k_dbg(ab, ATH11K_DBG_MAC, "waiting reconfigure...\n"); 5766 5767 wait_for_completion_timeout(&ab->reconfigure_complete, 5768 ATH11K_RECONFIGURE_TIMEOUT_HZ); 5769 } 5770 5771 static int ath11k_mac_op_start(struct ieee80211_hw *hw) 5772 { 5773 struct ath11k *ar = hw->priv; 5774 struct ath11k_base *ab = ar->ab; 5775 struct ath11k_pdev *pdev = ar->pdev; 5776 int ret; 5777 5778 ath11k_mac_drain_tx(ar); 5779 mutex_lock(&ar->conf_mutex); 5780 5781 switch (ar->state) { 5782 case ATH11K_STATE_OFF: 5783 ar->state = ATH11K_STATE_ON; 5784 break; 5785 case ATH11K_STATE_RESTARTING: 5786 ar->state = ATH11K_STATE_RESTARTED; 5787 ath11k_mac_wait_reconfigure(ab); 5788 break; 5789 case ATH11K_STATE_RESTARTED: 5790 case ATH11K_STATE_WEDGED: 5791 case ATH11K_STATE_ON: 5792 WARN_ON(1); 5793 ret = -EINVAL; 5794 goto err; 5795 } 5796 5797 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 5798 1, pdev->pdev_id); 5799 5800 if (ret) { 5801 ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret); 5802 goto err; 5803 } 5804 5805 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1, 5806 pdev->pdev_id); 5807 if (ret) { 5808 ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret); 5809 goto err; 5810 } 5811 5812 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) { 5813 ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr); 5814 if (ret) { 5815 ath11k_err(ab, "failed to set prob req oui: %i\n", ret); 5816 goto err; 5817 } 5818 } 5819 5820 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE, 5821 0, pdev->pdev_id); 5822 if (ret) { 5823 ath11k_err(ab, "failed to set ac override for ARP: %d\n", 5824 ret); 5825 goto err; 5826 } 5827 5828 ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id); 5829 if (ret) { 5830 ath11k_err(ab, "failed to offload radar detection: %d\n", 5831 ret); 5832 goto err; 5833 } 5834 5835 ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar, 5836 HTT_PPDU_STATS_TAG_DEFAULT); 5837 if (ret) { 5838 ath11k_err(ab, "failed to req ppdu stats: %d\n", ret); 5839 goto err; 5840 } 5841 5842 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE, 5843 1, pdev->pdev_id); 5844 5845 if (ret) { 5846 ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret); 5847 goto err; 5848 } 5849 5850 __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask); 5851 5852 /* TODO: Do we need to enable ANI? */ 5853 5854 ath11k_reg_update_chan_list(ar, false); 5855 5856 ar->num_started_vdevs = 0; 5857 ar->num_created_vdevs = 0; 5858 ar->num_peers = 0; 5859 ar->allocated_vdev_map = 0; 5860 5861 /* Configure monitor status ring with default rx_filter to get rx status 5862 * such as rssi, rx_duration. 5863 */ 5864 ret = ath11k_mac_config_mon_status_default(ar, true); 5865 if (ret) { 5866 ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n", 5867 ret); 5868 goto err; 5869 } 5870 5871 /* Configure the hash seed for hash based reo dest ring selection */ 5872 ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id); 5873 5874 /* allow device to enter IMPS */ 5875 if (ab->hw_params.idle_ps) { 5876 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG, 5877 1, pdev->pdev_id); 5878 if (ret) { 5879 ath11k_err(ab, "failed to enable idle ps: %d\n", ret); 5880 goto err; 5881 } 5882 } 5883 5884 mutex_unlock(&ar->conf_mutex); 5885 5886 rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx], 5887 &ab->pdevs[ar->pdev_idx]); 5888 5889 return 0; 5890 5891 err: 5892 ar->state = ATH11K_STATE_OFF; 5893 mutex_unlock(&ar->conf_mutex); 5894 5895 return ret; 5896 } 5897 5898 static void ath11k_mac_op_stop(struct ieee80211_hw *hw) 5899 { 5900 struct ath11k *ar = hw->priv; 5901 struct htt_ppdu_stats_info *ppdu_stats, *tmp; 5902 int ret; 5903 5904 ath11k_mac_drain_tx(ar); 5905 5906 mutex_lock(&ar->conf_mutex); 5907 ret = ath11k_mac_config_mon_status_default(ar, false); 5908 if (ret) 5909 ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n", 5910 ret); 5911 5912 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags); 5913 ar->state = ATH11K_STATE_OFF; 5914 mutex_unlock(&ar->conf_mutex); 5915 5916 cancel_delayed_work_sync(&ar->scan.timeout); 5917 cancel_work_sync(&ar->regd_update_work); 5918 cancel_work_sync(&ar->ab->update_11d_work); 5919 cancel_work_sync(&ar->ab->rfkill_work); 5920 5921 if (ar->state_11d == ATH11K_11D_PREPARING) { 5922 ar->state_11d = ATH11K_11D_IDLE; 5923 complete(&ar->completed_11d_scan); 5924 } 5925 5926 spin_lock_bh(&ar->data_lock); 5927 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) { 5928 list_del(&ppdu_stats->list); 5929 kfree(ppdu_stats); 5930 } 5931 spin_unlock_bh(&ar->data_lock); 5932 5933 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL); 5934 5935 synchronize_rcu(); 5936 5937 atomic_set(&ar->num_pending_mgmt_tx, 0); 5938 } 5939 5940 static void 5941 ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif, 5942 struct vdev_create_params *params) 5943 { 5944 struct ath11k *ar = arvif->ar; 5945 struct ath11k_pdev *pdev = ar->pdev; 5946 5947 params->if_id = arvif->vdev_id; 5948 params->type = arvif->vdev_type; 5949 params->subtype = arvif->vdev_subtype; 5950 params->pdev_id = pdev->pdev_id; 5951 5952 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) { 5953 params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains; 5954 params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains; 5955 } 5956 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) { 5957 params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains; 5958 params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains; 5959 } 5960 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP && 5961 ar->supports_6ghz) { 5962 params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains; 5963 params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains; 5964 } 5965 } 5966 5967 static u32 5968 ath11k_mac_prepare_he_mode(struct ath11k_pdev *pdev, u32 viftype) 5969 { 5970 struct ath11k_pdev_cap *pdev_cap = &pdev->cap; 5971 struct ath11k_band_cap *cap_band = NULL; 5972 u32 *hecap_phy_ptr = NULL; 5973 u32 hemode = 0; 5974 5975 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) 5976 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ]; 5977 else 5978 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ]; 5979 5980 hecap_phy_ptr = &cap_band->he_cap_phy_info[0]; 5981 5982 hemode = FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE) | 5983 FIELD_PREP(HE_MODE_SU_TX_BFER, HECAP_PHY_SUBFMR_GET(hecap_phy_ptr)) | 5984 FIELD_PREP(HE_MODE_UL_MUMIMO, HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr)); 5985 5986 /* TODO WDS and other modes */ 5987 if (viftype == NL80211_IFTYPE_AP) { 5988 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFER, 5989 HECAP_PHY_MUBFMR_GET(hecap_phy_ptr)) | 5990 FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) | 5991 FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE); 5992 } else { 5993 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFEE, HE_MU_BFEE_ENABLE); 5994 } 5995 5996 return hemode; 5997 } 5998 5999 static int ath11k_set_he_mu_sounding_mode(struct ath11k *ar, 6000 struct ath11k_vif *arvif) 6001 { 6002 u32 param_id, param_value; 6003 struct ath11k_base *ab = ar->ab; 6004 int ret = 0; 6005 6006 param_id = WMI_VDEV_PARAM_SET_HEMU_MODE; 6007 param_value = ath11k_mac_prepare_he_mode(ar->pdev, arvif->vif->type); 6008 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6009 param_id, param_value); 6010 if (ret) { 6011 ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n", 6012 arvif->vdev_id, ret, param_value); 6013 return ret; 6014 } 6015 param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE; 6016 param_value = 6017 FIELD_PREP(HE_VHT_SOUNDING_MODE, HE_VHT_SOUNDING_MODE_ENABLE) | 6018 FIELD_PREP(HE_TRIG_NONTRIG_SOUNDING_MODE, 6019 HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE); 6020 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6021 param_id, param_value); 6022 if (ret) { 6023 ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d\n", 6024 arvif->vdev_id, ret); 6025 return ret; 6026 } 6027 return ret; 6028 } 6029 6030 static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw, 6031 struct ieee80211_vif *vif) 6032 { 6033 struct ath11k *ar = hw->priv; 6034 struct ath11k_base *ab = ar->ab; 6035 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 6036 u32 param_id, param_value; 6037 int ret; 6038 6039 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE; 6040 if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET || 6041 (vif->type != NL80211_IFTYPE_STATION && 6042 vif->type != NL80211_IFTYPE_AP)) 6043 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED | 6044 IEEE80211_OFFLOAD_DECAP_ENABLED); 6045 6046 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED) 6047 param_value = ATH11K_HW_TXRX_ETHERNET; 6048 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) 6049 param_value = ATH11K_HW_TXRX_RAW; 6050 else 6051 param_value = ATH11K_HW_TXRX_NATIVE_WIFI; 6052 6053 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6054 param_id, param_value); 6055 if (ret) { 6056 ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n", 6057 arvif->vdev_id, ret); 6058 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED; 6059 } 6060 6061 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE; 6062 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED) 6063 param_value = ATH11K_HW_TXRX_ETHERNET; 6064 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) 6065 param_value = ATH11K_HW_TXRX_RAW; 6066 else 6067 param_value = ATH11K_HW_TXRX_NATIVE_WIFI; 6068 6069 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6070 param_id, param_value); 6071 if (ret) { 6072 ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n", 6073 arvif->vdev_id, ret); 6074 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED; 6075 } 6076 } 6077 6078 static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab) 6079 { 6080 struct ath11k *ar; 6081 struct ath11k_pdev *pdev; 6082 struct ath11k_vif *arvif; 6083 int i; 6084 6085 for (i = 0; i < ab->num_radios; i++) { 6086 pdev = &ab->pdevs[i]; 6087 ar = pdev->ar; 6088 list_for_each_entry(arvif, &ar->arvifs, list) { 6089 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP) 6090 return true; 6091 } 6092 } 6093 return false; 6094 } 6095 6096 void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id) 6097 { 6098 struct wmi_11d_scan_start_params param; 6099 int ret; 6100 6101 mutex_lock(&ar->ab->vdev_id_11d_lock); 6102 6103 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev id for 11d scan %d\n", 6104 ar->vdev_id_11d_scan); 6105 6106 if (ar->regdom_set_by_user) 6107 goto fin; 6108 6109 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) 6110 goto fin; 6111 6112 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) 6113 goto fin; 6114 6115 if (ath11k_mac_vif_ap_active_any(ar->ab)) 6116 goto fin; 6117 6118 param.vdev_id = vdev_id; 6119 param.start_interval_msec = 0; 6120 param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL; 6121 6122 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac start 11d scan\n"); 6123 6124 ret = ath11k_wmi_send_11d_scan_start_cmd(ar, ¶m); 6125 if (ret) { 6126 ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n", 6127 vdev_id, ret); 6128 } else { 6129 ar->vdev_id_11d_scan = vdev_id; 6130 if (ar->state_11d == ATH11K_11D_PREPARING) 6131 ar->state_11d = ATH11K_11D_RUNNING; 6132 } 6133 6134 fin: 6135 if (ar->state_11d == ATH11K_11D_PREPARING) { 6136 ar->state_11d = ATH11K_11D_IDLE; 6137 complete(&ar->completed_11d_scan); 6138 } 6139 6140 mutex_unlock(&ar->ab->vdev_id_11d_lock); 6141 } 6142 6143 void ath11k_mac_11d_scan_stop(struct ath11k *ar) 6144 { 6145 int ret; 6146 u32 vdev_id; 6147 6148 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) 6149 return; 6150 6151 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d scan\n"); 6152 6153 mutex_lock(&ar->ab->vdev_id_11d_lock); 6154 6155 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d vdev id %d\n", 6156 ar->vdev_id_11d_scan); 6157 6158 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) { 6159 vdev_id = ar->vdev_id_11d_scan; 6160 6161 ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id); 6162 if (ret) { 6163 ath11k_warn(ar->ab, 6164 "failed to stopt 11d scan vdev %d ret: %d\n", 6165 vdev_id, ret); 6166 } else { 6167 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID; 6168 ar->state_11d = ATH11K_11D_IDLE; 6169 complete(&ar->completed_11d_scan); 6170 } 6171 } 6172 mutex_unlock(&ar->ab->vdev_id_11d_lock); 6173 } 6174 6175 void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab) 6176 { 6177 struct ath11k *ar; 6178 struct ath11k_pdev *pdev; 6179 int i; 6180 6181 ath11k_dbg(ab, ATH11K_DBG_MAC, "mac stop soc 11d scan\n"); 6182 6183 for (i = 0; i < ab->num_radios; i++) { 6184 pdev = &ab->pdevs[i]; 6185 ar = pdev->ar; 6186 6187 ath11k_mac_11d_scan_stop(ar); 6188 } 6189 } 6190 6191 static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw, 6192 struct ieee80211_vif *vif) 6193 { 6194 struct ath11k *ar = hw->priv; 6195 struct ath11k_base *ab = ar->ab; 6196 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 6197 struct vdev_create_params vdev_param = {0}; 6198 struct peer_create_params peer_param; 6199 u32 param_id, param_value; 6200 u16 nss; 6201 int i; 6202 int ret, fbret; 6203 int bit; 6204 6205 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 6206 6207 mutex_lock(&ar->conf_mutex); 6208 6209 if (vif->type == NL80211_IFTYPE_AP && 6210 ar->num_peers > (ar->max_num_peers - 1)) { 6211 ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n"); 6212 ret = -ENOBUFS; 6213 goto err; 6214 } 6215 6216 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) { 6217 ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n", 6218 ar->num_created_vdevs, TARGET_NUM_VDEVS(ab)); 6219 ret = -EBUSY; 6220 goto err; 6221 } 6222 6223 memset(arvif, 0, sizeof(*arvif)); 6224 6225 arvif->ar = ar; 6226 arvif->vif = vif; 6227 6228 INIT_LIST_HEAD(&arvif->list); 6229 INIT_DELAYED_WORK(&arvif->connection_loss_work, 6230 ath11k_mac_vif_sta_connection_loss_work); 6231 6232 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) { 6233 arvif->bitrate_mask.control[i].legacy = 0xffffffff; 6234 arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI; 6235 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff, 6236 sizeof(arvif->bitrate_mask.control[i].ht_mcs)); 6237 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff, 6238 sizeof(arvif->bitrate_mask.control[i].vht_mcs)); 6239 memset(arvif->bitrate_mask.control[i].he_mcs, 0xff, 6240 sizeof(arvif->bitrate_mask.control[i].he_mcs)); 6241 } 6242 6243 bit = __ffs64(ab->free_vdev_map); 6244 6245 arvif->vdev_id = bit; 6246 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 6247 6248 switch (vif->type) { 6249 case NL80211_IFTYPE_UNSPECIFIED: 6250 case NL80211_IFTYPE_STATION: 6251 arvif->vdev_type = WMI_VDEV_TYPE_STA; 6252 break; 6253 case NL80211_IFTYPE_MESH_POINT: 6254 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S; 6255 fallthrough; 6256 case NL80211_IFTYPE_AP: 6257 arvif->vdev_type = WMI_VDEV_TYPE_AP; 6258 break; 6259 case NL80211_IFTYPE_MONITOR: 6260 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 6261 ar->monitor_vdev_id = bit; 6262 break; 6263 default: 6264 WARN_ON(1); 6265 break; 6266 } 6267 6268 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac add interface id %d type %d subtype %d map %llx\n", 6269 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype, 6270 ab->free_vdev_map); 6271 6272 vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1); 6273 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 6274 vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1); 6275 6276 ath11k_mac_setup_vdev_create_params(arvif, &vdev_param); 6277 6278 ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param); 6279 if (ret) { 6280 ath11k_warn(ab, "failed to create WMI vdev %d: %d\n", 6281 arvif->vdev_id, ret); 6282 goto err; 6283 } 6284 6285 ar->num_created_vdevs++; 6286 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n", 6287 vif->addr, arvif->vdev_id); 6288 ar->allocated_vdev_map |= 1LL << arvif->vdev_id; 6289 ab->free_vdev_map &= ~(1LL << arvif->vdev_id); 6290 6291 spin_lock_bh(&ar->data_lock); 6292 list_add(&arvif->list, &ar->arvifs); 6293 spin_unlock_bh(&ar->data_lock); 6294 6295 ath11k_mac_op_update_vif_offload(hw, vif); 6296 6297 nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1; 6298 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6299 WMI_VDEV_PARAM_NSS, nss); 6300 if (ret) { 6301 ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n", 6302 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret); 6303 goto err_vdev_del; 6304 } 6305 6306 switch (arvif->vdev_type) { 6307 case WMI_VDEV_TYPE_AP: 6308 peer_param.vdev_id = arvif->vdev_id; 6309 peer_param.peer_addr = vif->addr; 6310 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 6311 ret = ath11k_peer_create(ar, arvif, NULL, &peer_param); 6312 if (ret) { 6313 ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n", 6314 arvif->vdev_id, ret); 6315 goto err_vdev_del; 6316 } 6317 6318 ret = ath11k_mac_set_kickout(arvif); 6319 if (ret) { 6320 ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n", 6321 arvif->vdev_id, ret); 6322 goto err_peer_del; 6323 } 6324 6325 ath11k_mac_11d_scan_stop_all(ar->ab); 6326 break; 6327 case WMI_VDEV_TYPE_STA: 6328 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 6329 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 6330 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6331 param_id, param_value); 6332 if (ret) { 6333 ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n", 6334 arvif->vdev_id, ret); 6335 goto err_peer_del; 6336 } 6337 6338 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 6339 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 6340 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6341 param_id, param_value); 6342 if (ret) { 6343 ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n", 6344 arvif->vdev_id, ret); 6345 goto err_peer_del; 6346 } 6347 6348 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT; 6349 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 6350 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6351 param_id, param_value); 6352 if (ret) { 6353 ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n", 6354 arvif->vdev_id, ret); 6355 goto err_peer_del; 6356 } 6357 6358 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, 6359 WMI_STA_PS_MODE_DISABLED); 6360 if (ret) { 6361 ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n", 6362 arvif->vdev_id, ret); 6363 goto err_peer_del; 6364 } 6365 6366 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map)) { 6367 reinit_completion(&ar->completed_11d_scan); 6368 ar->state_11d = ATH11K_11D_PREPARING; 6369 } 6370 break; 6371 case WMI_VDEV_TYPE_MONITOR: 6372 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 6373 break; 6374 default: 6375 break; 6376 } 6377 6378 arvif->txpower = vif->bss_conf.txpower; 6379 ret = ath11k_mac_txpower_recalc(ar); 6380 if (ret) 6381 goto err_peer_del; 6382 6383 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 6384 param_value = ar->hw->wiphy->rts_threshold; 6385 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6386 param_id, param_value); 6387 if (ret) { 6388 ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n", 6389 arvif->vdev_id, ret); 6390 } 6391 6392 ath11k_dp_vdev_tx_attach(ar, arvif); 6393 6394 if (vif->type != NL80211_IFTYPE_MONITOR && 6395 test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) { 6396 ret = ath11k_mac_monitor_vdev_create(ar); 6397 if (ret) { 6398 ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d", 6399 ret); 6400 goto err_peer_del; 6401 } 6402 } 6403 6404 ret = ath11k_debugfs_add_interface(arvif); 6405 if (ret) 6406 goto err_peer_del; 6407 6408 mutex_unlock(&ar->conf_mutex); 6409 6410 return 0; 6411 6412 err_peer_del: 6413 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 6414 fbret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr); 6415 if (fbret) { 6416 ath11k_warn(ar->ab, "fallback fail to delete peer addr %pM vdev_id %d ret %d\n", 6417 vif->addr, arvif->vdev_id, fbret); 6418 goto err; 6419 } 6420 } 6421 6422 err_vdev_del: 6423 ath11k_wmi_vdev_delete(ar, arvif->vdev_id); 6424 ar->num_created_vdevs--; 6425 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 6426 ab->free_vdev_map |= 1LL << arvif->vdev_id; 6427 spin_lock_bh(&ar->data_lock); 6428 list_del(&arvif->list); 6429 spin_unlock_bh(&ar->data_lock); 6430 6431 err: 6432 ath11k_debugfs_remove_interface(arvif); 6433 mutex_unlock(&ar->conf_mutex); 6434 6435 return ret; 6436 } 6437 6438 static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx) 6439 { 6440 struct ieee80211_vif *vif = (struct ieee80211_vif *)ctx; 6441 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb); 6442 6443 if (skb_cb->vif == vif) 6444 skb_cb->vif = NULL; 6445 6446 return 0; 6447 } 6448 6449 static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw, 6450 struct ieee80211_vif *vif) 6451 { 6452 struct ath11k *ar = hw->priv; 6453 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 6454 struct ath11k_base *ab = ar->ab; 6455 unsigned long time_left; 6456 int ret; 6457 int i; 6458 6459 cancel_delayed_work_sync(&arvif->connection_loss_work); 6460 6461 mutex_lock(&ar->conf_mutex); 6462 6463 ath11k_dbg(ab, ATH11K_DBG_MAC, "mac remove interface (vdev %d)\n", 6464 arvif->vdev_id); 6465 6466 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 6467 ath11k_mac_11d_scan_stop(ar); 6468 6469 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 6470 ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr); 6471 if (ret) 6472 ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n", 6473 arvif->vdev_id, ret); 6474 } 6475 6476 reinit_completion(&ar->vdev_delete_done); 6477 6478 ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id); 6479 if (ret) { 6480 ath11k_warn(ab, "failed to delete WMI vdev %d: %d\n", 6481 arvif->vdev_id, ret); 6482 goto err_vdev_del; 6483 } 6484 6485 time_left = wait_for_completion_timeout(&ar->vdev_delete_done, 6486 ATH11K_VDEV_DELETE_TIMEOUT_HZ); 6487 if (time_left == 0) { 6488 ath11k_warn(ab, "Timeout in receiving vdev delete response\n"); 6489 goto err_vdev_del; 6490 } 6491 6492 ab->free_vdev_map |= 1LL << (arvif->vdev_id); 6493 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 6494 ar->num_created_vdevs--; 6495 6496 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n", 6497 vif->addr, arvif->vdev_id); 6498 6499 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 6500 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 6501 ar->monitor_vdev_id = -1; 6502 } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) && 6503 !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) { 6504 ret = ath11k_mac_monitor_vdev_delete(ar); 6505 if (ret) 6506 /* continue even if there's an error */ 6507 ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d", 6508 ret); 6509 } 6510 6511 err_vdev_del: 6512 spin_lock_bh(&ar->data_lock); 6513 list_del(&arvif->list); 6514 spin_unlock_bh(&ar->data_lock); 6515 6516 ath11k_peer_cleanup(ar, arvif->vdev_id); 6517 6518 idr_for_each(&ar->txmgmt_idr, 6519 ath11k_mac_vif_txmgmt_idr_remove, vif); 6520 6521 for (i = 0; i < ab->hw_params.max_tx_ring; i++) { 6522 spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock); 6523 idr_for_each(&ab->dp.tx_ring[i].txbuf_idr, 6524 ath11k_mac_vif_unref, vif); 6525 spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock); 6526 } 6527 6528 /* Recalc txpower for remaining vdev */ 6529 ath11k_mac_txpower_recalc(ar); 6530 6531 ath11k_debugfs_remove_interface(arvif); 6532 6533 /* TODO: recal traffic pause state based on the available vdevs */ 6534 6535 mutex_unlock(&ar->conf_mutex); 6536 } 6537 6538 /* FIXME: Has to be verified. */ 6539 #define SUPPORTED_FILTERS \ 6540 (FIF_ALLMULTI | \ 6541 FIF_CONTROL | \ 6542 FIF_PSPOLL | \ 6543 FIF_OTHER_BSS | \ 6544 FIF_BCN_PRBRESP_PROMISC | \ 6545 FIF_PROBE_REQ | \ 6546 FIF_FCSFAIL) 6547 6548 static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw, 6549 unsigned int changed_flags, 6550 unsigned int *total_flags, 6551 u64 multicast) 6552 { 6553 struct ath11k *ar = hw->priv; 6554 6555 mutex_lock(&ar->conf_mutex); 6556 6557 *total_flags &= SUPPORTED_FILTERS; 6558 ar->filter_flags = *total_flags; 6559 6560 mutex_unlock(&ar->conf_mutex); 6561 } 6562 6563 static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 6564 { 6565 struct ath11k *ar = hw->priv; 6566 6567 mutex_lock(&ar->conf_mutex); 6568 6569 *tx_ant = ar->cfg_tx_chainmask; 6570 *rx_ant = ar->cfg_rx_chainmask; 6571 6572 mutex_unlock(&ar->conf_mutex); 6573 6574 return 0; 6575 } 6576 6577 static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 6578 { 6579 struct ath11k *ar = hw->priv; 6580 int ret; 6581 6582 mutex_lock(&ar->conf_mutex); 6583 ret = __ath11k_set_antenna(ar, tx_ant, rx_ant); 6584 mutex_unlock(&ar->conf_mutex); 6585 6586 return ret; 6587 } 6588 6589 static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw, 6590 struct ieee80211_vif *vif, 6591 struct ieee80211_ampdu_params *params) 6592 { 6593 struct ath11k *ar = hw->priv; 6594 int ret = -EINVAL; 6595 6596 mutex_lock(&ar->conf_mutex); 6597 6598 switch (params->action) { 6599 case IEEE80211_AMPDU_RX_START: 6600 ret = ath11k_dp_rx_ampdu_start(ar, params); 6601 break; 6602 case IEEE80211_AMPDU_RX_STOP: 6603 ret = ath11k_dp_rx_ampdu_stop(ar, params); 6604 break; 6605 case IEEE80211_AMPDU_TX_START: 6606 case IEEE80211_AMPDU_TX_STOP_CONT: 6607 case IEEE80211_AMPDU_TX_STOP_FLUSH: 6608 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 6609 case IEEE80211_AMPDU_TX_OPERATIONAL: 6610 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211 6611 * Tx aggregation requests. 6612 */ 6613 ret = -EOPNOTSUPP; 6614 break; 6615 } 6616 6617 mutex_unlock(&ar->conf_mutex); 6618 6619 return ret; 6620 } 6621 6622 static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw, 6623 struct ieee80211_chanctx_conf *ctx) 6624 { 6625 struct ath11k *ar = hw->priv; 6626 struct ath11k_base *ab = ar->ab; 6627 6628 ath11k_dbg(ab, ATH11K_DBG_MAC, 6629 "mac chanctx add freq %u width %d ptr %pK\n", 6630 ctx->def.chan->center_freq, ctx->def.width, ctx); 6631 6632 mutex_lock(&ar->conf_mutex); 6633 6634 spin_lock_bh(&ar->data_lock); 6635 /* TODO: In case of multiple channel context, populate rx_channel from 6636 * Rx PPDU desc information. 6637 */ 6638 ar->rx_channel = ctx->def.chan; 6639 spin_unlock_bh(&ar->data_lock); 6640 6641 mutex_unlock(&ar->conf_mutex); 6642 6643 return 0; 6644 } 6645 6646 static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw, 6647 struct ieee80211_chanctx_conf *ctx) 6648 { 6649 struct ath11k *ar = hw->priv; 6650 struct ath11k_base *ab = ar->ab; 6651 6652 ath11k_dbg(ab, ATH11K_DBG_MAC, 6653 "mac chanctx remove freq %u width %d ptr %pK\n", 6654 ctx->def.chan->center_freq, ctx->def.width, ctx); 6655 6656 mutex_lock(&ar->conf_mutex); 6657 6658 spin_lock_bh(&ar->data_lock); 6659 /* TODO: In case of there is one more channel context left, populate 6660 * rx_channel with the channel of that remaining channel context. 6661 */ 6662 ar->rx_channel = NULL; 6663 spin_unlock_bh(&ar->data_lock); 6664 6665 mutex_unlock(&ar->conf_mutex); 6666 } 6667 6668 static int 6669 ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif, 6670 struct ieee80211_chanctx_conf *ctx, 6671 bool restart) 6672 { 6673 struct ath11k *ar = arvif->ar; 6674 struct ath11k_base *ab = ar->ab; 6675 struct wmi_vdev_start_req_arg arg = {}; 6676 const struct cfg80211_chan_def *chandef = &ctx->def; 6677 int he_support = arvif->vif->bss_conf.he_support; 6678 int ret = 0; 6679 6680 lockdep_assert_held(&ar->conf_mutex); 6681 6682 reinit_completion(&ar->vdev_setup_done); 6683 6684 arg.vdev_id = arvif->vdev_id; 6685 arg.dtim_period = arvif->dtim_period; 6686 arg.bcn_intval = arvif->beacon_interval; 6687 6688 arg.channel.freq = chandef->chan->center_freq; 6689 arg.channel.band_center_freq1 = chandef->center_freq1; 6690 arg.channel.band_center_freq2 = chandef->center_freq2; 6691 arg.channel.mode = 6692 ath11k_phymodes[chandef->chan->band][chandef->width]; 6693 6694 arg.channel.min_power = 0; 6695 arg.channel.max_power = chandef->chan->max_power; 6696 arg.channel.max_reg_power = chandef->chan->max_reg_power; 6697 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain; 6698 6699 arg.pref_tx_streams = ar->num_tx_chains; 6700 arg.pref_rx_streams = ar->num_rx_chains; 6701 6702 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 6703 arg.ssid = arvif->u.ap.ssid; 6704 arg.ssid_len = arvif->u.ap.ssid_len; 6705 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 6706 6707 /* For now allow DFS for AP mode */ 6708 arg.channel.chan_radar = 6709 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR); 6710 6711 arg.channel.freq2_radar = ctx->radar_enabled; 6712 6713 arg.channel.passive = arg.channel.chan_radar; 6714 6715 spin_lock_bh(&ab->base_lock); 6716 arg.regdomain = ar->ab->dfs_region; 6717 spin_unlock_bh(&ab->base_lock); 6718 6719 if (he_support) { 6720 ret = ath11k_set_he_mu_sounding_mode(ar, arvif); 6721 if (ret) { 6722 ath11k_warn(ar->ab, "failed to set he mode vdev %i\n", 6723 arg.vdev_id); 6724 return ret; 6725 } 6726 } 6727 } 6728 6729 arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR); 6730 6731 ath11k_dbg(ab, ATH11K_DBG_MAC, 6732 "mac vdev %d start center_freq %d phymode %s\n", 6733 arg.vdev_id, arg.channel.freq, 6734 ath11k_wmi_phymode_str(arg.channel.mode)); 6735 6736 ret = ath11k_wmi_vdev_start(ar, &arg, restart); 6737 if (ret) { 6738 ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n", 6739 restart ? "restart" : "start", arg.vdev_id); 6740 return ret; 6741 } 6742 6743 ret = ath11k_mac_vdev_setup_sync(ar); 6744 if (ret) { 6745 ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n", 6746 arg.vdev_id, restart ? "restart" : "start", ret); 6747 return ret; 6748 } 6749 6750 if (!restart) 6751 ar->num_started_vdevs++; 6752 6753 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM started, vdev_id %d\n", 6754 arvif->vif->addr, arvif->vdev_id); 6755 6756 /* Enable CAC Flag in the driver by checking the channel DFS cac time, 6757 * i.e dfs_cac_ms value which will be valid only for radar channels 6758 * and state as NL80211_DFS_USABLE which indicates CAC needs to be 6759 * done before channel usage. This flags is used to drop rx packets. 6760 * during CAC. 6761 */ 6762 /* TODO Set the flag for other interface types as required */ 6763 if (arvif->vdev_type == WMI_VDEV_TYPE_AP && 6764 chandef->chan->dfs_cac_ms && 6765 chandef->chan->dfs_state == NL80211_DFS_USABLE) { 6766 set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags); 6767 ath11k_dbg(ab, ATH11K_DBG_MAC, 6768 "CAC Started in chan_freq %d for vdev %d\n", 6769 arg.channel.freq, arg.vdev_id); 6770 } 6771 6772 ret = ath11k_mac_set_txbf_conf(arvif); 6773 if (ret) 6774 ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n", 6775 arvif->vdev_id, ret); 6776 6777 return 0; 6778 } 6779 6780 static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif) 6781 { 6782 struct ath11k *ar = arvif->ar; 6783 int ret; 6784 6785 lockdep_assert_held(&ar->conf_mutex); 6786 6787 reinit_completion(&ar->vdev_setup_done); 6788 6789 ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id); 6790 if (ret) { 6791 ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n", 6792 arvif->vdev_id, ret); 6793 goto err; 6794 } 6795 6796 ret = ath11k_mac_vdev_setup_sync(ar); 6797 if (ret) { 6798 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n", 6799 arvif->vdev_id, ret); 6800 goto err; 6801 } 6802 6803 WARN_ON(ar->num_started_vdevs == 0); 6804 6805 ar->num_started_vdevs--; 6806 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n", 6807 arvif->vif->addr, arvif->vdev_id); 6808 6809 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) { 6810 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags); 6811 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n", 6812 arvif->vdev_id); 6813 } 6814 6815 return 0; 6816 err: 6817 return ret; 6818 } 6819 6820 static int ath11k_mac_vdev_start(struct ath11k_vif *arvif, 6821 struct ieee80211_chanctx_conf *ctx) 6822 { 6823 return ath11k_mac_vdev_start_restart(arvif, ctx, false); 6824 } 6825 6826 static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif, 6827 struct ieee80211_chanctx_conf *ctx) 6828 { 6829 return ath11k_mac_vdev_start_restart(arvif, ctx, true); 6830 } 6831 6832 struct ath11k_mac_change_chanctx_arg { 6833 struct ieee80211_chanctx_conf *ctx; 6834 struct ieee80211_vif_chanctx_switch *vifs; 6835 int n_vifs; 6836 int next_vif; 6837 }; 6838 6839 static void 6840 ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac, 6841 struct ieee80211_vif *vif) 6842 { 6843 struct ath11k_mac_change_chanctx_arg *arg = data; 6844 6845 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx) 6846 return; 6847 6848 arg->n_vifs++; 6849 } 6850 6851 static void 6852 ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac, 6853 struct ieee80211_vif *vif) 6854 { 6855 struct ath11k_mac_change_chanctx_arg *arg = data; 6856 struct ieee80211_chanctx_conf *ctx; 6857 6858 ctx = rcu_access_pointer(vif->chanctx_conf); 6859 if (ctx != arg->ctx) 6860 return; 6861 6862 if (WARN_ON(arg->next_vif == arg->n_vifs)) 6863 return; 6864 6865 arg->vifs[arg->next_vif].vif = vif; 6866 arg->vifs[arg->next_vif].old_ctx = ctx; 6867 arg->vifs[arg->next_vif].new_ctx = ctx; 6868 arg->next_vif++; 6869 } 6870 6871 static void 6872 ath11k_mac_update_vif_chan(struct ath11k *ar, 6873 struct ieee80211_vif_chanctx_switch *vifs, 6874 int n_vifs) 6875 { 6876 struct ath11k_base *ab = ar->ab; 6877 struct ath11k_vif *arvif; 6878 int ret; 6879 int i; 6880 bool monitor_vif = false; 6881 6882 lockdep_assert_held(&ar->conf_mutex); 6883 6884 /* Associated channel resources of all relevant vdevs 6885 * should be available for the channel switch now. 6886 */ 6887 6888 /* TODO: Update ar->rx_channel */ 6889 6890 for (i = 0; i < n_vifs; i++) { 6891 arvif = (void *)vifs[i].vif->drv_priv; 6892 6893 if (WARN_ON(!arvif->is_started)) 6894 continue; 6895 6896 /* change_chanctx can be called even before vdev_up from 6897 * ieee80211_start_ap->ieee80211_vif_use_channel-> 6898 * ieee80211_recalc_radar_chanctx. 6899 * 6900 * Firmware expect vdev_restart only if vdev is up. 6901 * If vdev is down then it expect vdev_stop->vdev_start. 6902 */ 6903 if (arvif->is_up) { 6904 ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx); 6905 if (ret) { 6906 ath11k_warn(ab, "failed to restart vdev %d: %d\n", 6907 arvif->vdev_id, ret); 6908 continue; 6909 } 6910 } else { 6911 ret = ath11k_mac_vdev_stop(arvif); 6912 if (ret) { 6913 ath11k_warn(ab, "failed to stop vdev %d: %d\n", 6914 arvif->vdev_id, ret); 6915 continue; 6916 } 6917 6918 ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx); 6919 if (ret) 6920 ath11k_warn(ab, "failed to start vdev %d: %d\n", 6921 arvif->vdev_id, ret); 6922 6923 continue; 6924 } 6925 6926 ret = ath11k_mac_setup_bcn_tmpl(arvif); 6927 if (ret) 6928 ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n", 6929 ret); 6930 6931 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 6932 arvif->bssid); 6933 if (ret) { 6934 ath11k_warn(ab, "failed to bring vdev up %d: %d\n", 6935 arvif->vdev_id, ret); 6936 continue; 6937 } 6938 } 6939 6940 /* Restart the internal monitor vdev on new channel */ 6941 if (!monitor_vif && 6942 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) { 6943 ret = ath11k_mac_monitor_stop(ar); 6944 if (ret) { 6945 ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d", 6946 ret); 6947 return; 6948 } 6949 6950 ret = ath11k_mac_monitor_start(ar); 6951 if (ret) { 6952 ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d", 6953 ret); 6954 return; 6955 } 6956 } 6957 } 6958 6959 static void 6960 ath11k_mac_update_active_vif_chan(struct ath11k *ar, 6961 struct ieee80211_chanctx_conf *ctx) 6962 { 6963 struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx }; 6964 6965 lockdep_assert_held(&ar->conf_mutex); 6966 6967 ieee80211_iterate_active_interfaces_atomic(ar->hw, 6968 IEEE80211_IFACE_ITER_NORMAL, 6969 ath11k_mac_change_chanctx_cnt_iter, 6970 &arg); 6971 if (arg.n_vifs == 0) 6972 return; 6973 6974 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL); 6975 if (!arg.vifs) 6976 return; 6977 6978 ieee80211_iterate_active_interfaces_atomic(ar->hw, 6979 IEEE80211_IFACE_ITER_NORMAL, 6980 ath11k_mac_change_chanctx_fill_iter, 6981 &arg); 6982 6983 ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs); 6984 6985 kfree(arg.vifs); 6986 } 6987 6988 static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw, 6989 struct ieee80211_chanctx_conf *ctx, 6990 u32 changed) 6991 { 6992 struct ath11k *ar = hw->priv; 6993 struct ath11k_base *ab = ar->ab; 6994 6995 mutex_lock(&ar->conf_mutex); 6996 6997 ath11k_dbg(ab, ATH11K_DBG_MAC, 6998 "mac chanctx change freq %u width %d ptr %pK changed %x\n", 6999 ctx->def.chan->center_freq, ctx->def.width, ctx, changed); 7000 7001 /* This shouldn't really happen because channel switching should use 7002 * switch_vif_chanctx(). 7003 */ 7004 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL)) 7005 goto unlock; 7006 7007 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH || 7008 changed & IEEE80211_CHANCTX_CHANGE_RADAR) 7009 ath11k_mac_update_active_vif_chan(ar, ctx); 7010 7011 /* TODO: Recalc radar detection */ 7012 7013 unlock: 7014 mutex_unlock(&ar->conf_mutex); 7015 } 7016 7017 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw, 7018 struct ieee80211_vif *vif) 7019 { 7020 struct ath11k *ar = hw->priv; 7021 struct ath11k_base *ab = ar->ab; 7022 struct ath11k_vif *arvif = (void *)vif->drv_priv; 7023 int ret; 7024 7025 if (WARN_ON(arvif->is_started)) 7026 return -EBUSY; 7027 7028 ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx); 7029 if (ret) { 7030 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 7031 arvif->vdev_id, vif->addr, 7032 arvif->chanctx.def.chan->center_freq, ret); 7033 return ret; 7034 } 7035 7036 /* Reconfigure hardware rate code since it is cleared by firmware. 7037 */ 7038 if (ar->hw_rate_code > 0) { 7039 u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE; 7040 7041 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 7042 ar->hw_rate_code); 7043 if (ret) { 7044 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret); 7045 return ret; 7046 } 7047 } 7048 7049 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7050 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr); 7051 if (ret) { 7052 ath11k_warn(ab, "failed put monitor up: %d\n", ret); 7053 return ret; 7054 } 7055 } 7056 7057 arvif->is_started = true; 7058 7059 /* TODO: Setup ps and cts/rts protection */ 7060 return 0; 7061 } 7062 7063 static int 7064 ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw, 7065 struct ieee80211_vif *vif, 7066 struct ieee80211_chanctx_conf *ctx) 7067 { 7068 struct ath11k *ar = hw->priv; 7069 struct ath11k_base *ab = ar->ab; 7070 struct ath11k_vif *arvif = (void *)vif->drv_priv; 7071 int ret; 7072 struct peer_create_params param; 7073 7074 mutex_lock(&ar->conf_mutex); 7075 7076 ath11k_dbg(ab, ATH11K_DBG_MAC, 7077 "mac chanctx assign ptr %pK vdev_id %i\n", 7078 ctx, arvif->vdev_id); 7079 7080 /* for QCA6390 bss peer must be created before vdev_start */ 7081 if (ab->hw_params.vdev_start_delay && 7082 arvif->vdev_type != WMI_VDEV_TYPE_AP && 7083 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7084 !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) { 7085 memcpy(&arvif->chanctx, ctx, sizeof(*ctx)); 7086 ret = 0; 7087 goto out; 7088 } 7089 7090 if (WARN_ON(arvif->is_started)) { 7091 ret = -EBUSY; 7092 goto out; 7093 } 7094 7095 if (ab->hw_params.vdev_start_delay && 7096 arvif->vdev_type != WMI_VDEV_TYPE_AP && 7097 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) { 7098 param.vdev_id = arvif->vdev_id; 7099 param.peer_type = WMI_PEER_TYPE_DEFAULT; 7100 param.peer_addr = ar->mac_addr; 7101 7102 ret = ath11k_peer_create(ar, arvif, NULL, ¶m); 7103 if (ret) { 7104 ath11k_warn(ab, "failed to create peer after vdev start delay: %d", 7105 ret); 7106 goto out; 7107 } 7108 } 7109 7110 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7111 ret = ath11k_mac_monitor_start(ar); 7112 if (ret) { 7113 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d", 7114 ret); 7115 goto out; 7116 } 7117 7118 arvif->is_started = true; 7119 goto out; 7120 } 7121 7122 ret = ath11k_mac_vdev_start(arvif, ctx); 7123 if (ret) { 7124 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 7125 arvif->vdev_id, vif->addr, 7126 ctx->def.chan->center_freq, ret); 7127 goto out; 7128 } 7129 7130 arvif->is_started = true; 7131 7132 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7133 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) { 7134 ret = ath11k_mac_monitor_start(ar); 7135 if (ret) { 7136 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d", 7137 ret); 7138 goto out; 7139 } 7140 } 7141 7142 /* TODO: Setup ps and cts/rts protection */ 7143 7144 ret = 0; 7145 7146 out: 7147 mutex_unlock(&ar->conf_mutex); 7148 7149 return ret; 7150 } 7151 7152 static void 7153 ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 7154 struct ieee80211_vif *vif, 7155 struct ieee80211_chanctx_conf *ctx) 7156 { 7157 struct ath11k *ar = hw->priv; 7158 struct ath11k_base *ab = ar->ab; 7159 struct ath11k_vif *arvif = (void *)vif->drv_priv; 7160 struct ath11k_peer *peer; 7161 int ret; 7162 7163 mutex_lock(&ar->conf_mutex); 7164 7165 ath11k_dbg(ab, ATH11K_DBG_MAC, 7166 "mac chanctx unassign ptr %pK vdev_id %i\n", 7167 ctx, arvif->vdev_id); 7168 7169 WARN_ON(!arvif->is_started); 7170 7171 if (ab->hw_params.vdev_start_delay && 7172 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7173 spin_lock_bh(&ab->base_lock); 7174 peer = ath11k_peer_find_by_addr(ab, ar->mac_addr); 7175 spin_unlock_bh(&ab->base_lock); 7176 if (peer) 7177 ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr); 7178 } 7179 7180 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7181 ret = ath11k_mac_monitor_stop(ar); 7182 if (ret) { 7183 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d", 7184 ret); 7185 mutex_unlock(&ar->conf_mutex); 7186 return; 7187 } 7188 7189 arvif->is_started = false; 7190 mutex_unlock(&ar->conf_mutex); 7191 return; 7192 } 7193 7194 ret = ath11k_mac_vdev_stop(arvif); 7195 if (ret) 7196 ath11k_warn(ab, "failed to stop vdev %i: %d\n", 7197 arvif->vdev_id, ret); 7198 7199 arvif->is_started = false; 7200 7201 if (ab->hw_params.vdev_start_delay && 7202 arvif->vdev_type == WMI_VDEV_TYPE_STA) { 7203 ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid); 7204 if (ret) 7205 ath11k_warn(ar->ab, 7206 "failed to delete peer %pM for vdev %d: %d\n", 7207 arvif->bssid, arvif->vdev_id, ret); 7208 else 7209 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7210 "mac removed peer %pM vdev %d after vdev stop\n", 7211 arvif->bssid, arvif->vdev_id); 7212 } 7213 7214 if (ab->hw_params.vdev_start_delay && 7215 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 7216 ath11k_wmi_vdev_down(ar, arvif->vdev_id); 7217 7218 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7219 ar->num_started_vdevs == 1 && 7220 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) { 7221 ret = ath11k_mac_monitor_stop(ar); 7222 if (ret) 7223 /* continue even if there's an error */ 7224 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d", 7225 ret); 7226 } 7227 7228 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 7229 ath11k_mac_11d_scan_start(ar, arvif->vdev_id); 7230 7231 mutex_unlock(&ar->conf_mutex); 7232 } 7233 7234 static int 7235 ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw, 7236 struct ieee80211_vif_chanctx_switch *vifs, 7237 int n_vifs, 7238 enum ieee80211_chanctx_switch_mode mode) 7239 { 7240 struct ath11k *ar = hw->priv; 7241 7242 mutex_lock(&ar->conf_mutex); 7243 7244 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7245 "mac chanctx switch n_vifs %d mode %d\n", 7246 n_vifs, mode); 7247 ath11k_mac_update_vif_chan(ar, vifs, n_vifs); 7248 7249 mutex_unlock(&ar->conf_mutex); 7250 7251 return 0; 7252 } 7253 7254 static int 7255 ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value) 7256 { 7257 struct ath11k_vif *arvif; 7258 int ret = 0; 7259 7260 mutex_lock(&ar->conf_mutex); 7261 list_for_each_entry(arvif, &ar->arvifs, list) { 7262 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n", 7263 param, arvif->vdev_id, value); 7264 7265 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7266 param, value); 7267 if (ret) { 7268 ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n", 7269 param, arvif->vdev_id, ret); 7270 break; 7271 } 7272 } 7273 mutex_unlock(&ar->conf_mutex); 7274 return ret; 7275 } 7276 7277 /* mac80211 stores device specific RTS/Fragmentation threshold value, 7278 * this is set interface specific to firmware from ath11k driver 7279 */ 7280 static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 7281 { 7282 struct ath11k *ar = hw->priv; 7283 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 7284 7285 return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value); 7286 } 7287 7288 static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 7289 { 7290 /* Even though there's a WMI vdev param for fragmentation threshold no 7291 * known firmware actually implements it. Moreover it is not possible to 7292 * rely frame fragmentation to mac80211 because firmware clears the 7293 * "more fragments" bit in frame control making it impossible for remote 7294 * devices to reassemble frames. 7295 * 7296 * Hence implement a dummy callback just to say fragmentation isn't 7297 * supported. This effectively prevents mac80211 from doing frame 7298 * fragmentation in software. 7299 */ 7300 return -EOPNOTSUPP; 7301 } 7302 7303 static int ath11k_mac_flush_tx_complete(struct ath11k *ar) 7304 { 7305 long time_left; 7306 int ret = 0; 7307 7308 time_left = wait_event_timeout(ar->dp.tx_empty_waitq, 7309 (atomic_read(&ar->dp.num_tx_pending) == 0), 7310 ATH11K_FLUSH_TIMEOUT); 7311 if (time_left == 0) { 7312 ath11k_warn(ar->ab, "failed to flush transmit queue, data pkts pending %d\n", 7313 atomic_read(&ar->dp.num_tx_pending)); 7314 ret = -ETIMEDOUT; 7315 } 7316 7317 time_left = wait_event_timeout(ar->txmgmt_empty_waitq, 7318 (atomic_read(&ar->num_pending_mgmt_tx) == 0), 7319 ATH11K_FLUSH_TIMEOUT); 7320 if (time_left == 0) { 7321 ath11k_warn(ar->ab, "failed to flush mgmt transmit queue, mgmt pkts pending %d\n", 7322 atomic_read(&ar->num_pending_mgmt_tx)); 7323 ret = -ETIMEDOUT; 7324 } 7325 7326 return ret; 7327 } 7328 7329 int ath11k_mac_wait_tx_complete(struct ath11k *ar) 7330 { 7331 ath11k_mac_drain_tx(ar); 7332 return ath11k_mac_flush_tx_complete(ar); 7333 } 7334 7335 static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 7336 u32 queues, bool drop) 7337 { 7338 struct ath11k *ar = hw->priv; 7339 7340 if (drop) 7341 return; 7342 7343 ath11k_mac_flush_tx_complete(ar); 7344 } 7345 7346 static int 7347 ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar, 7348 enum nl80211_band band, 7349 const struct cfg80211_bitrate_mask *mask) 7350 { 7351 int num_rates = 0; 7352 int i; 7353 7354 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) 7355 num_rates += hweight16(mask->control[band].ht_mcs[i]); 7356 7357 return num_rates; 7358 } 7359 7360 static bool 7361 ath11k_mac_has_single_legacy_rate(struct ath11k *ar, 7362 enum nl80211_band band, 7363 const struct cfg80211_bitrate_mask *mask) 7364 { 7365 int num_rates = 0; 7366 7367 num_rates = hweight32(mask->control[band].legacy); 7368 7369 if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask)) 7370 return false; 7371 7372 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask)) 7373 return false; 7374 7375 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask)) 7376 return false; 7377 7378 return num_rates == 1; 7379 } 7380 7381 static __le16 7382 ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap) 7383 { 7384 if (he_cap->he_cap_elem.phy_cap_info[0] & 7385 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 7386 return he_cap->he_mcs_nss_supp.tx_mcs_80p80; 7387 7388 if (he_cap->he_cap_elem.phy_cap_info[0] & 7389 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) 7390 return he_cap->he_mcs_nss_supp.tx_mcs_160; 7391 7392 return he_cap->he_mcs_nss_supp.tx_mcs_80; 7393 } 7394 7395 static bool 7396 ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar, 7397 enum nl80211_band band, 7398 const struct cfg80211_bitrate_mask *mask, 7399 int *nss) 7400 { 7401 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 7402 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 7403 u16 he_mcs_map = 0; 7404 u8 ht_nss_mask = 0; 7405 u8 vht_nss_mask = 0; 7406 u8 he_nss_mask = 0; 7407 int i; 7408 7409 /* No need to consider legacy here. Basic rates are always present 7410 * in bitrate mask 7411 */ 7412 7413 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 7414 if (mask->control[band].ht_mcs[i] == 0) 7415 continue; 7416 else if (mask->control[band].ht_mcs[i] == 7417 sband->ht_cap.mcs.rx_mask[i]) 7418 ht_nss_mask |= BIT(i); 7419 else 7420 return false; 7421 } 7422 7423 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 7424 if (mask->control[band].vht_mcs[i] == 0) 7425 continue; 7426 else if (mask->control[band].vht_mcs[i] == 7427 ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i)) 7428 vht_nss_mask |= BIT(i); 7429 else 7430 return false; 7431 } 7432 7433 he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(&sband->iftype_data->he_cap)); 7434 7435 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) { 7436 if (mask->control[band].he_mcs[i] == 0) 7437 continue; 7438 7439 if (mask->control[band].he_mcs[i] == 7440 ath11k_mac_get_max_he_mcs_map(he_mcs_map, i)) 7441 he_nss_mask |= BIT(i); 7442 else 7443 return false; 7444 } 7445 7446 if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask) 7447 return false; 7448 7449 if (ht_nss_mask == 0) 7450 return false; 7451 7452 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask) 7453 return false; 7454 7455 *nss = fls(ht_nss_mask); 7456 7457 return true; 7458 } 7459 7460 static int 7461 ath11k_mac_get_single_legacy_rate(struct ath11k *ar, 7462 enum nl80211_band band, 7463 const struct cfg80211_bitrate_mask *mask, 7464 u32 *rate, u8 *nss) 7465 { 7466 int rate_idx; 7467 u16 bitrate; 7468 u8 preamble; 7469 u8 hw_rate; 7470 7471 if (hweight32(mask->control[band].legacy) != 1) 7472 return -EINVAL; 7473 7474 rate_idx = ffs(mask->control[band].legacy) - 1; 7475 7476 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ) 7477 rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX; 7478 7479 hw_rate = ath11k_legacy_rates[rate_idx].hw_value; 7480 bitrate = ath11k_legacy_rates[rate_idx].bitrate; 7481 7482 if (ath11k_mac_bitrate_is_cck(bitrate)) 7483 preamble = WMI_RATE_PREAMBLE_CCK; 7484 else 7485 preamble = WMI_RATE_PREAMBLE_OFDM; 7486 7487 *nss = 1; 7488 *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble); 7489 7490 return 0; 7491 } 7492 7493 static int 7494 ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf) 7495 { 7496 struct ath11k *ar = arvif->ar; 7497 int ret; 7498 7499 /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */ 7500 if (he_gi && he_gi != 0xFF) 7501 he_gi += 1; 7502 7503 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7504 WMI_VDEV_PARAM_SGI, he_gi); 7505 if (ret) { 7506 ath11k_warn(ar->ab, "failed to set he gi %d: %d\n", 7507 he_gi, ret); 7508 return ret; 7509 } 7510 /* start from 1 */ 7511 if (he_ltf != 0xFF) 7512 he_ltf += 1; 7513 7514 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7515 WMI_VDEV_PARAM_HE_LTF, he_ltf); 7516 if (ret) { 7517 ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n", 7518 he_ltf, ret); 7519 return ret; 7520 } 7521 7522 return 0; 7523 } 7524 7525 static int 7526 ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf) 7527 { 7528 struct ath11k *ar = arvif->ar; 7529 int ret; 7530 u32 he_ar_gi_ltf; 7531 7532 if (he_gi != 0xFF) { 7533 switch (he_gi) { 7534 case NL80211_RATE_INFO_HE_GI_0_8: 7535 he_gi = WMI_AUTORATE_800NS_GI; 7536 break; 7537 case NL80211_RATE_INFO_HE_GI_1_6: 7538 he_gi = WMI_AUTORATE_1600NS_GI; 7539 break; 7540 case NL80211_RATE_INFO_HE_GI_3_2: 7541 he_gi = WMI_AUTORATE_3200NS_GI; 7542 break; 7543 default: 7544 ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi); 7545 return -EINVAL; 7546 } 7547 } 7548 7549 if (he_ltf != 0xFF) { 7550 switch (he_ltf) { 7551 case NL80211_RATE_INFO_HE_1XLTF: 7552 he_ltf = WMI_HE_AUTORATE_LTF_1X; 7553 break; 7554 case NL80211_RATE_INFO_HE_2XLTF: 7555 he_ltf = WMI_HE_AUTORATE_LTF_2X; 7556 break; 7557 case NL80211_RATE_INFO_HE_4XLTF: 7558 he_ltf = WMI_HE_AUTORATE_LTF_4X; 7559 break; 7560 default: 7561 ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf); 7562 return -EINVAL; 7563 } 7564 } 7565 7566 he_ar_gi_ltf = he_gi | he_ltf; 7567 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7568 WMI_VDEV_PARAM_AUTORATE_MISC_CFG, 7569 he_ar_gi_ltf); 7570 if (ret) { 7571 ath11k_warn(ar->ab, 7572 "failed to set he autorate gi %u ltf %u: %d\n", 7573 he_gi, he_ltf, ret); 7574 return ret; 7575 } 7576 7577 return 0; 7578 } 7579 7580 static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif, 7581 u32 rate, u8 nss, u8 sgi, u8 ldpc, 7582 u8 he_gi, u8 he_ltf, bool he_fixed_rate) 7583 { 7584 struct ath11k *ar = arvif->ar; 7585 u32 vdev_param; 7586 int ret; 7587 7588 lockdep_assert_held(&ar->conf_mutex); 7589 7590 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7591 "mac set rate params vdev %i rate 0x%02x nss 0x%02x sgi 0x%02x ldpc 0x%02x he_gi 0x%02x he_ltf 0x%02x he_fixed_rate %d\n", 7592 arvif->vdev_id, rate, nss, sgi, ldpc, he_gi, 7593 he_ltf, he_fixed_rate); 7594 7595 if (!arvif->vif->bss_conf.he_support) { 7596 vdev_param = WMI_VDEV_PARAM_FIXED_RATE; 7597 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7598 vdev_param, rate); 7599 if (ret) { 7600 ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n", 7601 rate, ret); 7602 return ret; 7603 } 7604 } 7605 7606 vdev_param = WMI_VDEV_PARAM_NSS; 7607 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7608 vdev_param, nss); 7609 if (ret) { 7610 ath11k_warn(ar->ab, "failed to set nss param %d: %d\n", 7611 nss, ret); 7612 return ret; 7613 } 7614 7615 vdev_param = WMI_VDEV_PARAM_LDPC; 7616 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7617 vdev_param, ldpc); 7618 if (ret) { 7619 ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n", 7620 ldpc, ret); 7621 return ret; 7622 } 7623 7624 if (arvif->vif->bss_conf.he_support) { 7625 if (he_fixed_rate) { 7626 ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi, 7627 he_ltf); 7628 if (ret) { 7629 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n", 7630 ret); 7631 return ret; 7632 } 7633 } else { 7634 ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi, 7635 he_ltf); 7636 if (ret) { 7637 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n", 7638 ret); 7639 return ret; 7640 } 7641 } 7642 } else { 7643 vdev_param = WMI_VDEV_PARAM_SGI; 7644 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7645 vdev_param, sgi); 7646 if (ret) { 7647 ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n", 7648 sgi, ret); 7649 return ret; 7650 } 7651 } 7652 7653 return 0; 7654 } 7655 7656 static bool 7657 ath11k_mac_vht_mcs_range_present(struct ath11k *ar, 7658 enum nl80211_band band, 7659 const struct cfg80211_bitrate_mask *mask) 7660 { 7661 int i; 7662 u16 vht_mcs; 7663 7664 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 7665 vht_mcs = mask->control[band].vht_mcs[i]; 7666 7667 switch (vht_mcs) { 7668 case 0: 7669 case BIT(8) - 1: 7670 case BIT(9) - 1: 7671 case BIT(10) - 1: 7672 break; 7673 default: 7674 return false; 7675 } 7676 } 7677 7678 return true; 7679 } 7680 7681 static bool 7682 ath11k_mac_he_mcs_range_present(struct ath11k *ar, 7683 enum nl80211_band band, 7684 const struct cfg80211_bitrate_mask *mask) 7685 { 7686 int i; 7687 u16 he_mcs; 7688 7689 for (i = 0; i < NL80211_HE_NSS_MAX; i++) { 7690 he_mcs = mask->control[band].he_mcs[i]; 7691 7692 switch (he_mcs) { 7693 case 0: 7694 case BIT(8) - 1: 7695 case BIT(10) - 1: 7696 case BIT(12) - 1: 7697 break; 7698 default: 7699 return false; 7700 } 7701 } 7702 7703 return true; 7704 } 7705 7706 static void ath11k_mac_set_bitrate_mask_iter(void *data, 7707 struct ieee80211_sta *sta) 7708 { 7709 struct ath11k_vif *arvif = data; 7710 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 7711 struct ath11k *ar = arvif->ar; 7712 7713 spin_lock_bh(&ar->data_lock); 7714 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED; 7715 spin_unlock_bh(&ar->data_lock); 7716 7717 ieee80211_queue_work(ar->hw, &arsta->update_wk); 7718 } 7719 7720 static void ath11k_mac_disable_peer_fixed_rate(void *data, 7721 struct ieee80211_sta *sta) 7722 { 7723 struct ath11k_vif *arvif = data; 7724 struct ath11k *ar = arvif->ar; 7725 int ret; 7726 7727 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 7728 arvif->vdev_id, 7729 WMI_PEER_PARAM_FIXED_RATE, 7730 WMI_FIXED_RATE_NONE); 7731 if (ret) 7732 ath11k_warn(ar->ab, 7733 "failed to disable peer fixed rate for STA %pM ret %d\n", 7734 sta->addr, ret); 7735 } 7736 7737 static bool 7738 ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band, 7739 const struct cfg80211_bitrate_mask *mask) 7740 { 7741 bool he_fixed_rate = false, vht_fixed_rate = false; 7742 struct ath11k_peer *peer, *tmp; 7743 const u16 *vht_mcs_mask, *he_mcs_mask; 7744 u8 vht_nss, he_nss; 7745 bool ret = true; 7746 7747 vht_mcs_mask = mask->control[band].vht_mcs; 7748 he_mcs_mask = mask->control[band].he_mcs; 7749 7750 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1) 7751 vht_fixed_rate = true; 7752 7753 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1) 7754 he_fixed_rate = true; 7755 7756 if (!vht_fixed_rate && !he_fixed_rate) 7757 return true; 7758 7759 vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask); 7760 he_nss = ath11k_mac_max_he_nss(he_mcs_mask); 7761 7762 rcu_read_lock(); 7763 spin_lock_bh(&ar->ab->base_lock); 7764 list_for_each_entry_safe(peer, tmp, &ar->ab->peers, list) { 7765 if (peer->sta) { 7766 if (vht_fixed_rate && (!peer->sta->deflink.vht_cap.vht_supported || 7767 peer->sta->deflink.rx_nss < vht_nss)) { 7768 ret = false; 7769 goto out; 7770 } 7771 if (he_fixed_rate && (!peer->sta->deflink.he_cap.has_he || 7772 peer->sta->deflink.rx_nss < he_nss)) { 7773 ret = false; 7774 goto out; 7775 } 7776 } 7777 } 7778 7779 out: 7780 spin_unlock_bh(&ar->ab->base_lock); 7781 rcu_read_unlock(); 7782 return ret; 7783 } 7784 7785 static int 7786 ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw, 7787 struct ieee80211_vif *vif, 7788 const struct cfg80211_bitrate_mask *mask) 7789 { 7790 struct ath11k_vif *arvif = (void *)vif->drv_priv; 7791 struct cfg80211_chan_def def; 7792 struct ath11k *ar = arvif->ar; 7793 enum nl80211_band band; 7794 const u8 *ht_mcs_mask; 7795 const u16 *vht_mcs_mask; 7796 const u16 *he_mcs_mask; 7797 u8 he_ltf = 0; 7798 u8 he_gi = 0; 7799 u32 rate; 7800 u8 nss; 7801 u8 sgi; 7802 u8 ldpc; 7803 int single_nss; 7804 int ret; 7805 int num_rates; 7806 bool he_fixed_rate = false; 7807 7808 if (ath11k_mac_vif_chan(vif, &def)) 7809 return -EPERM; 7810 7811 band = def.chan->band; 7812 ht_mcs_mask = mask->control[band].ht_mcs; 7813 vht_mcs_mask = mask->control[band].vht_mcs; 7814 he_mcs_mask = mask->control[band].he_mcs; 7815 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC); 7816 7817 sgi = mask->control[band].gi; 7818 if (sgi == NL80211_TXRATE_FORCE_LGI) 7819 return -EINVAL; 7820 7821 he_gi = mask->control[band].he_gi; 7822 he_ltf = mask->control[band].he_ltf; 7823 7824 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it 7825 * requires passing atleast one of used basic rates along with them. 7826 * Fixed rate setting across different preambles(legacy, HT, VHT) is 7827 * not supported by the FW. Hence use of FIXED_RATE vdev param is not 7828 * suitable for setting single HT/VHT rates. 7829 * But, there could be a single basic rate passed from userspace which 7830 * can be done through the FIXED_RATE param. 7831 */ 7832 if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) { 7833 ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate, 7834 &nss); 7835 if (ret) { 7836 ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n", 7837 arvif->vdev_id, ret); 7838 return ret; 7839 } 7840 ieee80211_iterate_stations_atomic(ar->hw, 7841 ath11k_mac_disable_peer_fixed_rate, 7842 arvif); 7843 } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, band, mask, 7844 &single_nss)) { 7845 rate = WMI_FIXED_RATE_NONE; 7846 nss = single_nss; 7847 mutex_lock(&ar->conf_mutex); 7848 arvif->bitrate_mask = *mask; 7849 ieee80211_iterate_stations_atomic(ar->hw, 7850 ath11k_mac_set_bitrate_mask_iter, 7851 arvif); 7852 mutex_unlock(&ar->conf_mutex); 7853 } else { 7854 rate = WMI_FIXED_RATE_NONE; 7855 7856 if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask)) 7857 ath11k_warn(ar->ab, 7858 "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n"); 7859 nss = min_t(u32, ar->num_tx_chains, 7860 max(max(ath11k_mac_max_ht_nss(ht_mcs_mask), 7861 ath11k_mac_max_vht_nss(vht_mcs_mask)), 7862 ath11k_mac_max_he_nss(he_mcs_mask))); 7863 7864 /* If multiple rates across different preambles are given 7865 * we can reconfigure this info with all peers using PEER_ASSOC 7866 * command with the below exception cases. 7867 * - Single VHT Rate : peer_assoc command accommodates only MCS 7868 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211 7869 * mandates passing basic rates along with HT/VHT rates, FW 7870 * doesn't allow switching from VHT to Legacy. Hence instead of 7871 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd, 7872 * we could set this VHT rate as peer fixed rate param, which 7873 * will override FIXED rate and FW rate control algorithm. 7874 * If single VHT rate is passed along with HT rates, we select 7875 * the VHT rate as fixed rate for vht peers. 7876 * - Multiple VHT Rates : When Multiple VHT rates are given,this 7877 * can be set using RATEMASK CMD which uses FW rate-ctl alg. 7878 * TODO: Setting multiple VHT MCS and replacing peer_assoc with 7879 * RATEMASK_CMDID can cover all use cases of setting rates 7880 * across multiple preambles and rates within same type. 7881 * But requires more validation of the command at this point. 7882 */ 7883 7884 num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, 7885 mask); 7886 7887 if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) && 7888 num_rates > 1) { 7889 /* TODO: Handle multiple VHT MCS values setting using 7890 * RATEMASK CMD 7891 */ 7892 ath11k_warn(ar->ab, 7893 "setting %d mcs values in bitrate mask not supported\n", 7894 num_rates); 7895 return -EINVAL; 7896 } 7897 7898 num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, 7899 mask); 7900 if (num_rates == 1) 7901 he_fixed_rate = true; 7902 7903 if (!ath11k_mac_he_mcs_range_present(ar, band, mask) && 7904 num_rates > 1) { 7905 ath11k_warn(ar->ab, 7906 "Setting more than one HE MCS Value in bitrate mask not supported\n"); 7907 return -EINVAL; 7908 } 7909 7910 mutex_lock(&ar->conf_mutex); 7911 ieee80211_iterate_stations_atomic(ar->hw, 7912 ath11k_mac_disable_peer_fixed_rate, 7913 arvif); 7914 7915 arvif->bitrate_mask = *mask; 7916 ieee80211_iterate_stations_atomic(ar->hw, 7917 ath11k_mac_set_bitrate_mask_iter, 7918 arvif); 7919 7920 mutex_unlock(&ar->conf_mutex); 7921 } 7922 7923 mutex_lock(&ar->conf_mutex); 7924 7925 ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi, 7926 he_ltf, he_fixed_rate); 7927 if (ret) { 7928 ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n", 7929 arvif->vdev_id, ret); 7930 } 7931 7932 mutex_unlock(&ar->conf_mutex); 7933 7934 return ret; 7935 } 7936 7937 static void 7938 ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw, 7939 enum ieee80211_reconfig_type reconfig_type) 7940 { 7941 struct ath11k *ar = hw->priv; 7942 struct ath11k_base *ab = ar->ab; 7943 int recovery_count; 7944 7945 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) 7946 return; 7947 7948 mutex_lock(&ar->conf_mutex); 7949 7950 if (ar->state == ATH11K_STATE_RESTARTED) { 7951 ath11k_warn(ar->ab, "pdev %d successfully recovered\n", 7952 ar->pdev->pdev_id); 7953 ar->state = ATH11K_STATE_ON; 7954 ieee80211_wake_queues(ar->hw); 7955 7956 if (ar->ab->hw_params.current_cc_support && 7957 ar->alpha2[0] != 0 && ar->alpha2[1] != 0) { 7958 struct wmi_set_current_country_params set_current_param = {}; 7959 7960 memcpy(&set_current_param.alpha2, ar->alpha2, 2); 7961 ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param); 7962 } 7963 7964 if (ab->is_reset) { 7965 recovery_count = atomic_inc_return(&ab->recovery_count); 7966 ath11k_dbg(ab, ATH11K_DBG_BOOT, 7967 "recovery count %d\n", recovery_count); 7968 /* When there are multiple radios in an SOC, 7969 * the recovery has to be done for each radio 7970 */ 7971 if (recovery_count == ab->num_radios) { 7972 atomic_dec(&ab->reset_count); 7973 complete(&ab->reset_complete); 7974 ab->is_reset = false; 7975 atomic_set(&ab->fail_cont_count, 0); 7976 ath11k_dbg(ab, ATH11K_DBG_BOOT, "reset success\n"); 7977 } 7978 } 7979 } 7980 7981 mutex_unlock(&ar->conf_mutex); 7982 } 7983 7984 static void 7985 ath11k_mac_update_bss_chan_survey(struct ath11k *ar, 7986 struct ieee80211_channel *channel) 7987 { 7988 int ret; 7989 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ; 7990 7991 lockdep_assert_held(&ar->conf_mutex); 7992 7993 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) || 7994 ar->rx_channel != channel) 7995 return; 7996 7997 if (ar->scan.state != ATH11K_SCAN_IDLE) { 7998 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7999 "ignoring bss chan info req while scanning..\n"); 8000 return; 8001 } 8002 8003 reinit_completion(&ar->bss_survey_done); 8004 8005 ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type); 8006 if (ret) { 8007 ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n"); 8008 return; 8009 } 8010 8011 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ); 8012 if (ret == 0) 8013 ath11k_warn(ar->ab, "bss channel survey timed out\n"); 8014 } 8015 8016 static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx, 8017 struct survey_info *survey) 8018 { 8019 struct ath11k *ar = hw->priv; 8020 struct ieee80211_supported_band *sband; 8021 struct survey_info *ar_survey; 8022 int ret = 0; 8023 8024 if (idx >= ATH11K_NUM_CHANS) 8025 return -ENOENT; 8026 8027 ar_survey = &ar->survey[idx]; 8028 8029 mutex_lock(&ar->conf_mutex); 8030 8031 sband = hw->wiphy->bands[NL80211_BAND_2GHZ]; 8032 if (sband && idx >= sband->n_channels) { 8033 idx -= sband->n_channels; 8034 sband = NULL; 8035 } 8036 8037 if (!sband) 8038 sband = hw->wiphy->bands[NL80211_BAND_5GHZ]; 8039 if (sband && idx >= sband->n_channels) { 8040 idx -= sband->n_channels; 8041 sband = NULL; 8042 } 8043 8044 if (!sband) 8045 sband = hw->wiphy->bands[NL80211_BAND_6GHZ]; 8046 if (!sband || idx >= sband->n_channels) { 8047 ret = -ENOENT; 8048 goto exit; 8049 } 8050 8051 ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]); 8052 8053 spin_lock_bh(&ar->data_lock); 8054 memcpy(survey, ar_survey, sizeof(*survey)); 8055 spin_unlock_bh(&ar->data_lock); 8056 8057 survey->channel = &sband->channels[idx]; 8058 8059 if (ar->rx_channel == survey->channel) 8060 survey->filled |= SURVEY_INFO_IN_USE; 8061 8062 exit: 8063 mutex_unlock(&ar->conf_mutex); 8064 return ret; 8065 } 8066 8067 static void ath11k_mac_put_chain_rssi(struct station_info *sinfo, 8068 struct ath11k_sta *arsta, 8069 char *pre, 8070 bool clear) 8071 { 8072 struct ath11k *ar = arsta->arvif->ar; 8073 int i; 8074 s8 rssi; 8075 8076 for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) { 8077 sinfo->chains &= ~BIT(i); 8078 rssi = arsta->chain_signal[i]; 8079 if (clear) 8080 arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL; 8081 8082 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 8083 "mac sta statistics %s rssi[%d] %d\n", pre, i, rssi); 8084 8085 if (rssi != ATH11K_DEFAULT_NOISE_FLOOR && 8086 rssi != ATH11K_INVALID_RSSI_FULL && 8087 rssi != ATH11K_INVALID_RSSI_EMPTY && 8088 rssi != 0) { 8089 sinfo->chain_signal[i] = rssi; 8090 sinfo->chains |= BIT(i); 8091 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL); 8092 } 8093 } 8094 } 8095 8096 static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw, 8097 struct ieee80211_vif *vif, 8098 struct ieee80211_sta *sta, 8099 struct station_info *sinfo) 8100 { 8101 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 8102 struct ath11k *ar = arsta->arvif->ar; 8103 s8 signal; 8104 bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT, 8105 ar->ab->wmi_ab.svc_map); 8106 8107 sinfo->rx_duration = arsta->rx_duration; 8108 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION); 8109 8110 sinfo->tx_duration = arsta->tx_duration; 8111 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION); 8112 8113 if (arsta->txrate.legacy || arsta->txrate.nss) { 8114 if (arsta->txrate.legacy) { 8115 sinfo->txrate.legacy = arsta->txrate.legacy; 8116 } else { 8117 sinfo->txrate.mcs = arsta->txrate.mcs; 8118 sinfo->txrate.nss = arsta->txrate.nss; 8119 sinfo->txrate.bw = arsta->txrate.bw; 8120 sinfo->txrate.he_gi = arsta->txrate.he_gi; 8121 sinfo->txrate.he_dcm = arsta->txrate.he_dcm; 8122 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc; 8123 } 8124 sinfo->txrate.flags = arsta->txrate.flags; 8125 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 8126 } 8127 8128 ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false); 8129 8130 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) && 8131 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA && 8132 ar->ab->hw_params.supports_rssi_stats && 8133 !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0, 8134 WMI_REQUEST_RSSI_PER_CHAIN_STAT)) { 8135 ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true); 8136 } 8137 8138 signal = arsta->rssi_comb; 8139 if (!signal && 8140 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA && 8141 ar->ab->hw_params.supports_rssi_stats && 8142 !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0, 8143 WMI_REQUEST_VDEV_STAT))) 8144 signal = arsta->rssi_beacon; 8145 8146 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 8147 "mac sta statistics db2dbm %u rssi comb %d rssi beacon %d\n", 8148 db2dbm, arsta->rssi_comb, arsta->rssi_beacon); 8149 8150 if (signal) { 8151 sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR; 8152 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 8153 } 8154 } 8155 8156 #if IS_ENABLED(CONFIG_IPV6) 8157 static void ath11k_generate_ns_mc_addr(struct ath11k *ar, 8158 struct ath11k_arp_ns_offload *offload) 8159 { 8160 int i; 8161 8162 for (i = 0; i < offload->ipv6_count; i++) { 8163 offload->self_ipv6_addr[i][0] = 0xff; 8164 offload->self_ipv6_addr[i][1] = 0x02; 8165 offload->self_ipv6_addr[i][11] = 0x01; 8166 offload->self_ipv6_addr[i][12] = 0xff; 8167 offload->self_ipv6_addr[i][13] = 8168 offload->ipv6_addr[i][13]; 8169 offload->self_ipv6_addr[i][14] = 8170 offload->ipv6_addr[i][14]; 8171 offload->self_ipv6_addr[i][15] = 8172 offload->ipv6_addr[i][15]; 8173 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "NS solicited addr %pI6\n", 8174 offload->self_ipv6_addr[i]); 8175 } 8176 } 8177 8178 static void ath11k_mac_op_ipv6_changed(struct ieee80211_hw *hw, 8179 struct ieee80211_vif *vif, 8180 struct inet6_dev *idev) 8181 { 8182 struct ath11k *ar = hw->priv; 8183 struct ath11k_arp_ns_offload *offload; 8184 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 8185 struct inet6_ifaddr *ifa6; 8186 struct ifacaddr6 *ifaca6; 8187 struct list_head *p; 8188 u32 count, scope; 8189 8190 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac op ipv6 changed\n"); 8191 8192 offload = &arvif->arp_ns_offload; 8193 count = 0; 8194 8195 read_lock_bh(&idev->lock); 8196 8197 memset(offload->ipv6_addr, 0, sizeof(offload->ipv6_addr)); 8198 memset(offload->self_ipv6_addr, 0, sizeof(offload->self_ipv6_addr)); 8199 memcpy(offload->mac_addr, vif->addr, ETH_ALEN); 8200 8201 /* get unicast address */ 8202 list_for_each(p, &idev->addr_list) { 8203 if (count >= ATH11K_IPV6_MAX_COUNT) 8204 goto generate; 8205 8206 ifa6 = list_entry(p, struct inet6_ifaddr, if_list); 8207 if (ifa6->flags & IFA_F_DADFAILED) 8208 continue; 8209 scope = ipv6_addr_src_scope(&ifa6->addr); 8210 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL || 8211 scope == IPV6_ADDR_SCOPE_GLOBAL) { 8212 memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr, 8213 sizeof(ifa6->addr.s6_addr)); 8214 offload->ipv6_type[count] = ATH11K_IPV6_UC_TYPE; 8215 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 uc %pI6 scope %d\n", 8216 count, offload->ipv6_addr[count], 8217 scope); 8218 count++; 8219 } else { 8220 ath11k_warn(ar->ab, "Unsupported ipv6 scope: %d\n", scope); 8221 } 8222 } 8223 8224 /* get anycast address */ 8225 for (ifaca6 = idev->ac_list; ifaca6; ifaca6 = ifaca6->aca_next) { 8226 if (count >= ATH11K_IPV6_MAX_COUNT) 8227 goto generate; 8228 8229 scope = ipv6_addr_src_scope(&ifaca6->aca_addr); 8230 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL || 8231 scope == IPV6_ADDR_SCOPE_GLOBAL) { 8232 memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr, 8233 sizeof(ifaca6->aca_addr)); 8234 offload->ipv6_type[count] = ATH11K_IPV6_AC_TYPE; 8235 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 ac %pI6 scope %d\n", 8236 count, offload->ipv6_addr[count], 8237 scope); 8238 count++; 8239 } else { 8240 ath11k_warn(ar->ab, "Unsupported ipv scope: %d\n", scope); 8241 } 8242 } 8243 8244 generate: 8245 offload->ipv6_count = count; 8246 read_unlock_bh(&idev->lock); 8247 8248 /* generate ns multicast address */ 8249 ath11k_generate_ns_mc_addr(ar, offload); 8250 } 8251 #endif 8252 8253 static void ath11k_mac_op_set_rekey_data(struct ieee80211_hw *hw, 8254 struct ieee80211_vif *vif, 8255 struct cfg80211_gtk_rekey_data *data) 8256 { 8257 struct ath11k *ar = hw->priv; 8258 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 8259 struct ath11k_rekey_data *rekey_data = &arvif->rekey_data; 8260 8261 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac set rekey data vdev %d\n", 8262 arvif->vdev_id); 8263 8264 mutex_lock(&ar->conf_mutex); 8265 8266 memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN); 8267 memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN); 8268 8269 /* The supplicant works on big-endian, the firmware expects it on 8270 * little endian. 8271 */ 8272 rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr); 8273 8274 arvif->rekey_data.enable_offload = true; 8275 8276 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kck", NULL, 8277 rekey_data->kck, NL80211_KCK_LEN); 8278 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kek", NULL, 8279 rekey_data->kck, NL80211_KEK_LEN); 8280 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "replay ctr", NULL, 8281 &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr)); 8282 8283 mutex_unlock(&ar->conf_mutex); 8284 } 8285 8286 static int ath11k_mac_op_set_bios_sar_specs(struct ieee80211_hw *hw, 8287 const struct cfg80211_sar_specs *sar) 8288 { 8289 struct ath11k *ar = hw->priv; 8290 const struct cfg80211_sar_sub_specs *sspec = sar->sub_specs; 8291 int ret, index; 8292 u8 *sar_tbl; 8293 u32 i; 8294 8295 mutex_lock(&ar->conf_mutex); 8296 8297 if (!test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) || 8298 !ar->ab->hw_params.bios_sar_capa) { 8299 ret = -EOPNOTSUPP; 8300 goto exit; 8301 } 8302 8303 if (!sar || sar->type != NL80211_SAR_TYPE_POWER || 8304 sar->num_sub_specs == 0) { 8305 ret = -EINVAL; 8306 goto exit; 8307 } 8308 8309 ret = ath11k_wmi_pdev_set_bios_geo_table_param(ar); 8310 if (ret) { 8311 ath11k_warn(ar->ab, "failed to set geo table: %d\n", ret); 8312 goto exit; 8313 } 8314 8315 sar_tbl = kzalloc(BIOS_SAR_TABLE_LEN, GFP_KERNEL); 8316 if (!sar_tbl) { 8317 ret = -ENOMEM; 8318 goto exit; 8319 } 8320 8321 for (i = 0; i < sar->num_sub_specs; i++) { 8322 if (sspec->freq_range_index >= (BIOS_SAR_TABLE_LEN >> 1)) { 8323 ath11k_warn(ar->ab, "Ignore bad frequency index %u, max allowed %u\n", 8324 sspec->freq_range_index, BIOS_SAR_TABLE_LEN >> 1); 8325 continue; 8326 } 8327 8328 /* chain0 and chain1 share same power setting */ 8329 sar_tbl[sspec->freq_range_index] = sspec->power; 8330 index = sspec->freq_range_index + (BIOS_SAR_TABLE_LEN >> 1); 8331 sar_tbl[index] = sspec->power; 8332 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "sar tbl[%d] = %d\n", 8333 sspec->freq_range_index, sar_tbl[sspec->freq_range_index]); 8334 sspec++; 8335 } 8336 8337 ret = ath11k_wmi_pdev_set_bios_sar_table_param(ar, sar_tbl); 8338 if (ret) 8339 ath11k_warn(ar->ab, "failed to set sar power: %d", ret); 8340 8341 kfree(sar_tbl); 8342 exit: 8343 mutex_unlock(&ar->conf_mutex); 8344 8345 return ret; 8346 } 8347 8348 static const struct ieee80211_ops ath11k_ops = { 8349 .tx = ath11k_mac_op_tx, 8350 .start = ath11k_mac_op_start, 8351 .stop = ath11k_mac_op_stop, 8352 .reconfig_complete = ath11k_mac_op_reconfig_complete, 8353 .add_interface = ath11k_mac_op_add_interface, 8354 .remove_interface = ath11k_mac_op_remove_interface, 8355 .update_vif_offload = ath11k_mac_op_update_vif_offload, 8356 .config = ath11k_mac_op_config, 8357 .bss_info_changed = ath11k_mac_op_bss_info_changed, 8358 .configure_filter = ath11k_mac_op_configure_filter, 8359 .hw_scan = ath11k_mac_op_hw_scan, 8360 .cancel_hw_scan = ath11k_mac_op_cancel_hw_scan, 8361 .set_key = ath11k_mac_op_set_key, 8362 .set_rekey_data = ath11k_mac_op_set_rekey_data, 8363 .sta_state = ath11k_mac_op_sta_state, 8364 .sta_set_4addr = ath11k_mac_op_sta_set_4addr, 8365 .sta_set_txpwr = ath11k_mac_op_sta_set_txpwr, 8366 .sta_rc_update = ath11k_mac_op_sta_rc_update, 8367 .conf_tx = ath11k_mac_op_conf_tx, 8368 .set_antenna = ath11k_mac_op_set_antenna, 8369 .get_antenna = ath11k_mac_op_get_antenna, 8370 .ampdu_action = ath11k_mac_op_ampdu_action, 8371 .add_chanctx = ath11k_mac_op_add_chanctx, 8372 .remove_chanctx = ath11k_mac_op_remove_chanctx, 8373 .change_chanctx = ath11k_mac_op_change_chanctx, 8374 .assign_vif_chanctx = ath11k_mac_op_assign_vif_chanctx, 8375 .unassign_vif_chanctx = ath11k_mac_op_unassign_vif_chanctx, 8376 .switch_vif_chanctx = ath11k_mac_op_switch_vif_chanctx, 8377 .set_rts_threshold = ath11k_mac_op_set_rts_threshold, 8378 .set_frag_threshold = ath11k_mac_op_set_frag_threshold, 8379 .set_bitrate_mask = ath11k_mac_op_set_bitrate_mask, 8380 .get_survey = ath11k_mac_op_get_survey, 8381 .flush = ath11k_mac_op_flush, 8382 .sta_statistics = ath11k_mac_op_sta_statistics, 8383 CFG80211_TESTMODE_CMD(ath11k_tm_cmd) 8384 8385 #ifdef CONFIG_PM 8386 .suspend = ath11k_wow_op_suspend, 8387 .resume = ath11k_wow_op_resume, 8388 .set_wakeup = ath11k_wow_op_set_wakeup, 8389 #endif 8390 8391 #ifdef CONFIG_ATH11K_DEBUGFS 8392 .sta_add_debugfs = ath11k_debugfs_sta_op_add, 8393 #endif 8394 8395 #if IS_ENABLED(CONFIG_IPV6) 8396 .ipv6_addr_change = ath11k_mac_op_ipv6_changed, 8397 #endif 8398 8399 .set_sar_specs = ath11k_mac_op_set_bios_sar_specs, 8400 }; 8401 8402 static void ath11k_mac_update_ch_list(struct ath11k *ar, 8403 struct ieee80211_supported_band *band, 8404 u32 freq_low, u32 freq_high) 8405 { 8406 int i; 8407 8408 if (!(freq_low && freq_high)) 8409 return; 8410 8411 for (i = 0; i < band->n_channels; i++) { 8412 if (band->channels[i].center_freq < freq_low || 8413 band->channels[i].center_freq > freq_high) 8414 band->channels[i].flags |= IEEE80211_CHAN_DISABLED; 8415 } 8416 } 8417 8418 static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band) 8419 { 8420 struct ath11k_pdev *pdev = ar->pdev; 8421 struct ath11k_pdev_cap *pdev_cap = &pdev->cap; 8422 8423 if (band == WMI_HOST_WLAN_2G_CAP) 8424 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id; 8425 8426 if (band == WMI_HOST_WLAN_5G_CAP) 8427 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id; 8428 8429 ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band); 8430 8431 return 0; 8432 } 8433 8434 static int ath11k_mac_setup_channels_rates(struct ath11k *ar, 8435 u32 supported_bands) 8436 { 8437 struct ieee80211_supported_band *band; 8438 struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap; 8439 void *channels; 8440 u32 phy_id; 8441 8442 BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) + 8443 ARRAY_SIZE(ath11k_5ghz_channels) + 8444 ARRAY_SIZE(ath11k_6ghz_channels)) != 8445 ATH11K_NUM_CHANS); 8446 8447 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx]; 8448 temp_reg_cap = reg_cap; 8449 8450 if (supported_bands & WMI_HOST_WLAN_2G_CAP) { 8451 channels = kmemdup(ath11k_2ghz_channels, 8452 sizeof(ath11k_2ghz_channels), 8453 GFP_KERNEL); 8454 if (!channels) 8455 return -ENOMEM; 8456 8457 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 8458 band->band = NL80211_BAND_2GHZ; 8459 band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels); 8460 band->channels = channels; 8461 band->n_bitrates = ath11k_g_rates_size; 8462 band->bitrates = ath11k_g_rates; 8463 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band; 8464 8465 if (ar->ab->hw_params.single_pdev_only) { 8466 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP); 8467 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id]; 8468 } 8469 ath11k_mac_update_ch_list(ar, band, 8470 temp_reg_cap->low_2ghz_chan, 8471 temp_reg_cap->high_2ghz_chan); 8472 } 8473 8474 if (supported_bands & WMI_HOST_WLAN_5G_CAP) { 8475 if (reg_cap->high_5ghz_chan >= ATH11K_MAX_6G_FREQ) { 8476 channels = kmemdup(ath11k_6ghz_channels, 8477 sizeof(ath11k_6ghz_channels), GFP_KERNEL); 8478 if (!channels) { 8479 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8480 return -ENOMEM; 8481 } 8482 8483 ar->supports_6ghz = true; 8484 band = &ar->mac.sbands[NL80211_BAND_6GHZ]; 8485 band->band = NL80211_BAND_6GHZ; 8486 band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels); 8487 band->channels = channels; 8488 band->n_bitrates = ath11k_a_rates_size; 8489 band->bitrates = ath11k_a_rates; 8490 ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band; 8491 8492 if (ar->ab->hw_params.single_pdev_only) { 8493 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP); 8494 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id]; 8495 } 8496 8497 ath11k_mac_update_ch_list(ar, band, 8498 temp_reg_cap->low_5ghz_chan, 8499 temp_reg_cap->high_5ghz_chan); 8500 } 8501 8502 if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) { 8503 channels = kmemdup(ath11k_5ghz_channels, 8504 sizeof(ath11k_5ghz_channels), 8505 GFP_KERNEL); 8506 if (!channels) { 8507 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8508 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 8509 return -ENOMEM; 8510 } 8511 8512 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 8513 band->band = NL80211_BAND_5GHZ; 8514 band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels); 8515 band->channels = channels; 8516 band->n_bitrates = ath11k_a_rates_size; 8517 band->bitrates = ath11k_a_rates; 8518 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band; 8519 8520 if (ar->ab->hw_params.single_pdev_only) { 8521 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP); 8522 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id]; 8523 } 8524 8525 ath11k_mac_update_ch_list(ar, band, 8526 temp_reg_cap->low_5ghz_chan, 8527 temp_reg_cap->high_5ghz_chan); 8528 } 8529 } 8530 8531 return 0; 8532 } 8533 8534 static int ath11k_mac_setup_iface_combinations(struct ath11k *ar) 8535 { 8536 struct ath11k_base *ab = ar->ab; 8537 struct ieee80211_iface_combination *combinations; 8538 struct ieee80211_iface_limit *limits; 8539 int n_limits; 8540 8541 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL); 8542 if (!combinations) 8543 return -ENOMEM; 8544 8545 n_limits = 2; 8546 8547 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL); 8548 if (!limits) { 8549 kfree(combinations); 8550 return -ENOMEM; 8551 } 8552 8553 limits[0].max = 1; 8554 limits[0].types |= BIT(NL80211_IFTYPE_STATION); 8555 8556 limits[1].max = 16; 8557 limits[1].types |= BIT(NL80211_IFTYPE_AP); 8558 8559 if (IS_ENABLED(CONFIG_MAC80211_MESH) && 8560 ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT)) 8561 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT); 8562 8563 combinations[0].limits = limits; 8564 combinations[0].n_limits = n_limits; 8565 combinations[0].max_interfaces = 16; 8566 combinations[0].num_different_channels = 1; 8567 combinations[0].beacon_int_infra_match = true; 8568 combinations[0].beacon_int_min_gcd = 100; 8569 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 8570 BIT(NL80211_CHAN_WIDTH_20) | 8571 BIT(NL80211_CHAN_WIDTH_40) | 8572 BIT(NL80211_CHAN_WIDTH_80) | 8573 BIT(NL80211_CHAN_WIDTH_80P80) | 8574 BIT(NL80211_CHAN_WIDTH_160); 8575 8576 ar->hw->wiphy->iface_combinations = combinations; 8577 ar->hw->wiphy->n_iface_combinations = 1; 8578 8579 return 0; 8580 } 8581 8582 static const u8 ath11k_if_types_ext_capa[] = { 8583 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 8584 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 8585 }; 8586 8587 static const u8 ath11k_if_types_ext_capa_sta[] = { 8588 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 8589 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 8590 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT, 8591 }; 8592 8593 static const u8 ath11k_if_types_ext_capa_ap[] = { 8594 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 8595 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 8596 [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT, 8597 }; 8598 8599 static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = { 8600 { 8601 .extended_capabilities = ath11k_if_types_ext_capa, 8602 .extended_capabilities_mask = ath11k_if_types_ext_capa, 8603 .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa), 8604 }, { 8605 .iftype = NL80211_IFTYPE_STATION, 8606 .extended_capabilities = ath11k_if_types_ext_capa_sta, 8607 .extended_capabilities_mask = ath11k_if_types_ext_capa_sta, 8608 .extended_capabilities_len = 8609 sizeof(ath11k_if_types_ext_capa_sta), 8610 }, { 8611 .iftype = NL80211_IFTYPE_AP, 8612 .extended_capabilities = ath11k_if_types_ext_capa_ap, 8613 .extended_capabilities_mask = ath11k_if_types_ext_capa_ap, 8614 .extended_capabilities_len = 8615 sizeof(ath11k_if_types_ext_capa_ap), 8616 }, 8617 }; 8618 8619 static void __ath11k_mac_unregister(struct ath11k *ar) 8620 { 8621 cancel_work_sync(&ar->regd_update_work); 8622 8623 ieee80211_unregister_hw(ar->hw); 8624 8625 idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar); 8626 idr_destroy(&ar->txmgmt_idr); 8627 8628 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8629 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 8630 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 8631 8632 kfree(ar->hw->wiphy->iface_combinations[0].limits); 8633 kfree(ar->hw->wiphy->iface_combinations); 8634 8635 SET_IEEE80211_DEV(ar->hw, NULL); 8636 } 8637 8638 void ath11k_mac_unregister(struct ath11k_base *ab) 8639 { 8640 struct ath11k *ar; 8641 struct ath11k_pdev *pdev; 8642 int i; 8643 8644 for (i = 0; i < ab->num_radios; i++) { 8645 pdev = &ab->pdevs[i]; 8646 ar = pdev->ar; 8647 if (!ar) 8648 continue; 8649 8650 __ath11k_mac_unregister(ar); 8651 } 8652 8653 ath11k_peer_rhash_tbl_destroy(ab); 8654 } 8655 8656 static int __ath11k_mac_register(struct ath11k *ar) 8657 { 8658 struct ath11k_base *ab = ar->ab; 8659 struct ath11k_pdev_cap *cap = &ar->pdev->cap; 8660 static const u32 cipher_suites[] = { 8661 WLAN_CIPHER_SUITE_TKIP, 8662 WLAN_CIPHER_SUITE_CCMP, 8663 WLAN_CIPHER_SUITE_AES_CMAC, 8664 WLAN_CIPHER_SUITE_BIP_CMAC_256, 8665 WLAN_CIPHER_SUITE_BIP_GMAC_128, 8666 WLAN_CIPHER_SUITE_BIP_GMAC_256, 8667 WLAN_CIPHER_SUITE_GCMP, 8668 WLAN_CIPHER_SUITE_GCMP_256, 8669 WLAN_CIPHER_SUITE_CCMP_256, 8670 }; 8671 int ret; 8672 u32 ht_cap = 0; 8673 8674 ath11k_pdev_caps_update(ar); 8675 8676 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 8677 8678 SET_IEEE80211_DEV(ar->hw, ab->dev); 8679 8680 ret = ath11k_mac_setup_channels_rates(ar, 8681 cap->supported_bands); 8682 if (ret) 8683 goto err; 8684 8685 ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap); 8686 ath11k_mac_setup_he_cap(ar, cap); 8687 8688 ret = ath11k_mac_setup_iface_combinations(ar); 8689 if (ret) { 8690 ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret); 8691 goto err_free_channels; 8692 } 8693 8694 ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask; 8695 ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask; 8696 8697 ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes; 8698 8699 if (ab->hw_params.single_pdev_only && ar->supports_6ghz) 8700 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS); 8701 8702 ieee80211_hw_set(ar->hw, SIGNAL_DBM); 8703 ieee80211_hw_set(ar->hw, SUPPORTS_PS); 8704 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS); 8705 ieee80211_hw_set(ar->hw, MFP_CAPABLE); 8706 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS); 8707 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL); 8708 ieee80211_hw_set(ar->hw, AP_LINK_PS); 8709 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT); 8710 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR); 8711 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK); 8712 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF); 8713 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA); 8714 ieee80211_hw_set(ar->hw, QUEUE_CONTROL); 8715 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG); 8716 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK); 8717 8718 if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) { 8719 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD); 8720 ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD); 8721 } 8722 8723 if (cap->nss_ratio_enabled) 8724 ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW); 8725 8726 if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) { 8727 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION); 8728 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW); 8729 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER); 8730 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU); 8731 ieee80211_hw_set(ar->hw, USES_RSS); 8732 } 8733 8734 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS; 8735 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 8736 8737 /* TODO: Check if HT capability advertised from firmware is different 8738 * for each band for a dual band capable radio. It will be tricky to 8739 * handle it when the ht capability different for each band. 8740 */ 8741 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS || 8742 (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz)) 8743 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS; 8744 8745 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 8746 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 8747 8748 ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL; 8749 8750 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 8751 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 8752 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 8753 8754 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 8755 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 8756 NL80211_FEATURE_AP_SCAN; 8757 8758 ar->max_num_stations = TARGET_NUM_STATIONS(ab); 8759 ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab); 8760 8761 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations; 8762 8763 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) { 8764 ar->hw->wiphy->features |= 8765 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR; 8766 } 8767 8768 if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) { 8769 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS; 8770 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS; 8771 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH; 8772 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS; 8773 ar->hw->wiphy->max_sched_scan_plan_interval = 8774 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT; 8775 ar->hw->wiphy->max_sched_scan_plan_iterations = 8776 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS; 8777 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR; 8778 } 8779 8780 ret = ath11k_wow_init(ar); 8781 if (ret) { 8782 ath11k_warn(ar->ab, "failed to init wow: %d\n", ret); 8783 goto err_free_if_combs; 8784 } 8785 8786 ar->hw->queues = ATH11K_HW_MAX_QUEUES; 8787 ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN; 8788 ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1; 8789 ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE; 8790 8791 ar->hw->vif_data_size = sizeof(struct ath11k_vif); 8792 ar->hw->sta_data_size = sizeof(struct ath11k_sta); 8793 8794 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 8795 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR); 8796 if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD, 8797 ar->ab->wmi_ab.svc_map)) { 8798 wiphy_ext_feature_set(ar->hw->wiphy, 8799 NL80211_EXT_FEATURE_BSS_COLOR); 8800 ieee80211_hw_set(ar->hw, DETECTS_COLOR_COLLISION); 8801 } 8802 8803 ar->hw->wiphy->cipher_suites = cipher_suites; 8804 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 8805 8806 ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa; 8807 ar->hw->wiphy->num_iftype_ext_capab = 8808 ARRAY_SIZE(ath11k_iftypes_ext_capa); 8809 8810 if (ar->supports_6ghz) { 8811 wiphy_ext_feature_set(ar->hw->wiphy, 8812 NL80211_EXT_FEATURE_FILS_DISCOVERY); 8813 wiphy_ext_feature_set(ar->hw->wiphy, 8814 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP); 8815 } 8816 8817 ath11k_reg_init(ar); 8818 8819 if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) { 8820 ar->hw->netdev_features = NETIF_F_HW_CSUM; 8821 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL); 8822 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT); 8823 } 8824 8825 if (test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) && 8826 ab->hw_params.bios_sar_capa) 8827 ar->hw->wiphy->sar_capa = ab->hw_params.bios_sar_capa; 8828 8829 ret = ieee80211_register_hw(ar->hw); 8830 if (ret) { 8831 ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret); 8832 goto err_free_if_combs; 8833 } 8834 8835 if (!ab->hw_params.supports_monitor) 8836 /* There's a race between calling ieee80211_register_hw() 8837 * and here where the monitor mode is enabled for a little 8838 * while. But that time is so short and in practise it make 8839 * a difference in real life. 8840 */ 8841 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR); 8842 8843 /* Apply the regd received during initialization */ 8844 ret = ath11k_regd_update(ar); 8845 if (ret) { 8846 ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret); 8847 goto err_unregister_hw; 8848 } 8849 8850 if (ab->hw_params.current_cc_support && ab->new_alpha2[0]) { 8851 struct wmi_set_current_country_params set_current_param = {}; 8852 8853 memcpy(&set_current_param.alpha2, ab->new_alpha2, 2); 8854 memcpy(&ar->alpha2, ab->new_alpha2, 2); 8855 ret = ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param); 8856 if (ret) 8857 ath11k_warn(ar->ab, 8858 "failed set cc code for mac register: %d\n", ret); 8859 } 8860 8861 ret = ath11k_debugfs_register(ar); 8862 if (ret) { 8863 ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret); 8864 goto err_unregister_hw; 8865 } 8866 8867 return 0; 8868 8869 err_unregister_hw: 8870 ieee80211_unregister_hw(ar->hw); 8871 8872 err_free_if_combs: 8873 kfree(ar->hw->wiphy->iface_combinations[0].limits); 8874 kfree(ar->hw->wiphy->iface_combinations); 8875 8876 err_free_channels: 8877 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8878 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 8879 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 8880 8881 err: 8882 SET_IEEE80211_DEV(ar->hw, NULL); 8883 return ret; 8884 } 8885 8886 int ath11k_mac_register(struct ath11k_base *ab) 8887 { 8888 struct ath11k *ar; 8889 struct ath11k_pdev *pdev; 8890 int i; 8891 int ret; 8892 8893 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) 8894 return 0; 8895 8896 /* Initialize channel counters frequency value in hertz */ 8897 ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ; 8898 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1; 8899 8900 ret = ath11k_peer_rhash_tbl_init(ab); 8901 if (ret) 8902 return ret; 8903 8904 for (i = 0; i < ab->num_radios; i++) { 8905 pdev = &ab->pdevs[i]; 8906 ar = pdev->ar; 8907 if (ab->pdevs_macaddr_valid) { 8908 ether_addr_copy(ar->mac_addr, pdev->mac_addr); 8909 } else { 8910 ether_addr_copy(ar->mac_addr, ab->mac_addr); 8911 ar->mac_addr[4] += i; 8912 } 8913 8914 idr_init(&ar->txmgmt_idr); 8915 spin_lock_init(&ar->txmgmt_idr_lock); 8916 8917 ret = __ath11k_mac_register(ar); 8918 if (ret) 8919 goto err_cleanup; 8920 8921 init_waitqueue_head(&ar->txmgmt_empty_waitq); 8922 } 8923 8924 return 0; 8925 8926 err_cleanup: 8927 for (i = i - 1; i >= 0; i--) { 8928 pdev = &ab->pdevs[i]; 8929 ar = pdev->ar; 8930 __ath11k_mac_unregister(ar); 8931 } 8932 8933 ath11k_peer_rhash_tbl_destroy(ab); 8934 8935 return ret; 8936 } 8937 8938 int ath11k_mac_allocate(struct ath11k_base *ab) 8939 { 8940 struct ieee80211_hw *hw; 8941 struct ath11k *ar; 8942 struct ath11k_pdev *pdev; 8943 int ret; 8944 int i; 8945 8946 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) 8947 return 0; 8948 8949 for (i = 0; i < ab->num_radios; i++) { 8950 pdev = &ab->pdevs[i]; 8951 hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops); 8952 if (!hw) { 8953 ath11k_warn(ab, "failed to allocate mac80211 hw device\n"); 8954 ret = -ENOMEM; 8955 goto err_free_mac; 8956 } 8957 8958 ar = hw->priv; 8959 ar->hw = hw; 8960 ar->ab = ab; 8961 ar->pdev = pdev; 8962 ar->pdev_idx = i; 8963 ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i); 8964 8965 ar->wmi = &ab->wmi_ab.wmi[i]; 8966 /* FIXME wmi[0] is already initialized during attach, 8967 * Should we do this again? 8968 */ 8969 ath11k_wmi_pdev_attach(ab, i); 8970 8971 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask; 8972 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask; 8973 ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask); 8974 ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask); 8975 8976 pdev->ar = ar; 8977 spin_lock_init(&ar->data_lock); 8978 INIT_LIST_HEAD(&ar->arvifs); 8979 INIT_LIST_HEAD(&ar->ppdu_stats_info); 8980 mutex_init(&ar->conf_mutex); 8981 init_completion(&ar->vdev_setup_done); 8982 init_completion(&ar->vdev_delete_done); 8983 init_completion(&ar->peer_assoc_done); 8984 init_completion(&ar->peer_delete_done); 8985 init_completion(&ar->install_key_done); 8986 init_completion(&ar->bss_survey_done); 8987 init_completion(&ar->scan.started); 8988 init_completion(&ar->scan.completed); 8989 init_completion(&ar->thermal.wmi_sync); 8990 8991 INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work); 8992 INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work); 8993 8994 INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work); 8995 skb_queue_head_init(&ar->wmi_mgmt_tx_queue); 8996 8997 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags); 8998 8999 ar->monitor_vdev_id = -1; 9000 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 9001 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID; 9002 init_completion(&ar->completed_11d_scan); 9003 } 9004 9005 return 0; 9006 9007 err_free_mac: 9008 ath11k_mac_destroy(ab); 9009 9010 return ret; 9011 } 9012 9013 void ath11k_mac_destroy(struct ath11k_base *ab) 9014 { 9015 struct ath11k *ar; 9016 struct ath11k_pdev *pdev; 9017 int i; 9018 9019 for (i = 0; i < ab->num_radios; i++) { 9020 pdev = &ab->pdevs[i]; 9021 ar = pdev->ar; 9022 if (!ar) 9023 continue; 9024 9025 ieee80211_free_hw(ar->hw); 9026 pdev->ar = NULL; 9027 } 9028 } 9029