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