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