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