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