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