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