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 peer_arg.is_assoc = true; 3029 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 3030 if (ret) { 3031 ath11k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n", 3032 bss_conf->bssid, arvif->vdev_id, ret); 3033 return; 3034 } 3035 3036 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 3037 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 3038 bss_conf->bssid, arvif->vdev_id); 3039 return; 3040 } 3041 3042 ret = ath11k_setup_peer_smps(ar, arvif, bss_conf->bssid, 3043 &ap_sta->deflink.ht_cap, 3044 le16_to_cpu(ap_sta->deflink.he_6ghz_capa.capa)); 3045 if (ret) { 3046 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n", 3047 arvif->vdev_id, ret); 3048 return; 3049 } 3050 3051 if (!ath11k_mac_vif_recalc_sta_he_txbf(ar, vif, &he_cap)) { 3052 ath11k_warn(ar->ab, "failed to recalc he txbf for vdev %i on bss %pM\n", 3053 arvif->vdev_id, bss_conf->bssid); 3054 return; 3055 } 3056 3057 WARN_ON(arvif->is_up); 3058 3059 arvif->aid = vif->cfg.aid; 3060 ether_addr_copy(arvif->bssid, bss_conf->bssid); 3061 3062 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid, 3063 NULL, 0, 0); 3064 if (ret) { 3065 ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n", 3066 arvif->vdev_id, ret); 3067 return; 3068 } 3069 3070 arvif->is_up = true; 3071 arvif->rekey_data.enable_offload = false; 3072 3073 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3074 "vdev %d up (associated) bssid %pM aid %d\n", 3075 arvif->vdev_id, bss_conf->bssid, vif->cfg.aid); 3076 3077 spin_lock_bh(&ar->ab->base_lock); 3078 3079 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid); 3080 if (peer && peer->is_authorized) 3081 is_auth = true; 3082 3083 spin_unlock_bh(&ar->ab->base_lock); 3084 3085 if (is_auth) { 3086 ret = ath11k_wmi_set_peer_param(ar, arvif->bssid, 3087 arvif->vdev_id, 3088 WMI_PEER_AUTHORIZE, 3089 1); 3090 if (ret) 3091 ath11k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret); 3092 } 3093 3094 ret = ath11k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id, 3095 &bss_conf->he_obss_pd); 3096 if (ret) 3097 ath11k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n", 3098 arvif->vdev_id, ret); 3099 3100 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3101 WMI_VDEV_PARAM_DTIM_POLICY, 3102 WMI_DTIM_POLICY_STICK); 3103 if (ret) 3104 ath11k_warn(ar->ab, "failed to set vdev %d dtim policy: %d\n", 3105 arvif->vdev_id, ret); 3106 3107 ath11k_mac_11d_scan_stop_all(ar->ab); 3108 } 3109 3110 static void ath11k_bss_disassoc(struct ieee80211_hw *hw, 3111 struct ieee80211_vif *vif) 3112 { 3113 struct ath11k *ar = hw->priv; 3114 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3115 int ret; 3116 3117 lockdep_assert_held(&ar->conf_mutex); 3118 3119 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %i disassoc bssid %pM\n", 3120 arvif->vdev_id, arvif->bssid); 3121 3122 ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id); 3123 if (ret) 3124 ath11k_warn(ar->ab, "failed to down vdev %i: %d\n", 3125 arvif->vdev_id, ret); 3126 3127 arvif->is_up = false; 3128 3129 memset(&arvif->rekey_data, 0, sizeof(arvif->rekey_data)); 3130 3131 cancel_delayed_work_sync(&arvif->connection_loss_work); 3132 } 3133 3134 static u32 ath11k_mac_get_rate_hw_value(int bitrate) 3135 { 3136 u32 preamble; 3137 u16 hw_value; 3138 int rate; 3139 size_t i; 3140 3141 if (ath11k_mac_bitrate_is_cck(bitrate)) 3142 preamble = WMI_RATE_PREAMBLE_CCK; 3143 else 3144 preamble = WMI_RATE_PREAMBLE_OFDM; 3145 3146 for (i = 0; i < ARRAY_SIZE(ath11k_legacy_rates); i++) { 3147 if (ath11k_legacy_rates[i].bitrate != bitrate) 3148 continue; 3149 3150 hw_value = ath11k_legacy_rates[i].hw_value; 3151 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble); 3152 3153 return rate; 3154 } 3155 3156 return -EINVAL; 3157 } 3158 3159 static void ath11k_recalculate_mgmt_rate(struct ath11k *ar, 3160 struct ieee80211_vif *vif, 3161 struct cfg80211_chan_def *def) 3162 { 3163 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3164 const struct ieee80211_supported_band *sband; 3165 u8 basic_rate_idx; 3166 int hw_rate_code; 3167 u32 vdev_param; 3168 u16 bitrate; 3169 int ret; 3170 3171 lockdep_assert_held(&ar->conf_mutex); 3172 3173 sband = ar->hw->wiphy->bands[def->chan->band]; 3174 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1; 3175 bitrate = sband->bitrates[basic_rate_idx].bitrate; 3176 3177 hw_rate_code = ath11k_mac_get_rate_hw_value(bitrate); 3178 if (hw_rate_code < 0) { 3179 ath11k_warn(ar->ab, "bitrate not supported %d\n", bitrate); 3180 return; 3181 } 3182 3183 vdev_param = WMI_VDEV_PARAM_MGMT_RATE; 3184 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 3185 hw_rate_code); 3186 if (ret) 3187 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret); 3188 3189 /* For WCN6855, firmware will clear this param when vdev starts, hence 3190 * cache it here so that we can reconfigure it once vdev starts. 3191 */ 3192 ar->hw_rate_code = hw_rate_code; 3193 3194 vdev_param = WMI_VDEV_PARAM_BEACON_RATE; 3195 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 3196 hw_rate_code); 3197 if (ret) 3198 ath11k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret); 3199 } 3200 3201 static int ath11k_mac_fils_discovery(struct ath11k_vif *arvif, 3202 struct ieee80211_bss_conf *info) 3203 { 3204 struct ath11k *ar = arvif->ar; 3205 struct sk_buff *tmpl; 3206 int ret; 3207 u32 interval; 3208 bool unsol_bcast_probe_resp_enabled = false; 3209 3210 if (info->fils_discovery.max_interval) { 3211 interval = info->fils_discovery.max_interval; 3212 3213 tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif); 3214 if (tmpl) 3215 ret = ath11k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id, 3216 tmpl); 3217 } else if (info->unsol_bcast_probe_resp_interval) { 3218 unsol_bcast_probe_resp_enabled = 1; 3219 interval = info->unsol_bcast_probe_resp_interval; 3220 3221 tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw, 3222 arvif->vif); 3223 if (tmpl) 3224 ret = ath11k_wmi_probe_resp_tmpl(ar, arvif->vdev_id, 3225 tmpl); 3226 } else { /* Disable */ 3227 return ath11k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false); 3228 } 3229 3230 if (!tmpl) { 3231 ath11k_warn(ar->ab, 3232 "mac vdev %i failed to retrieve %s template\n", 3233 arvif->vdev_id, (unsol_bcast_probe_resp_enabled ? 3234 "unsolicited broadcast probe response" : 3235 "FILS discovery")); 3236 return -EPERM; 3237 } 3238 kfree_skb(tmpl); 3239 3240 if (!ret) 3241 ret = ath11k_wmi_fils_discovery(ar, arvif->vdev_id, interval, 3242 unsol_bcast_probe_resp_enabled); 3243 3244 return ret; 3245 } 3246 3247 static int ath11k_mac_config_obss_pd(struct ath11k *ar, 3248 struct ieee80211_he_obss_pd *he_obss_pd) 3249 { 3250 u32 bitmap[2], param_id, param_val, pdev_id; 3251 int ret; 3252 s8 non_srg_th = 0, srg_th = 0; 3253 3254 pdev_id = ar->pdev->pdev_id; 3255 3256 /* Set and enable SRG/non-SRG OBSS PD Threshold */ 3257 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD; 3258 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) { 3259 ret = ath11k_wmi_pdev_set_param(ar, param_id, 0, pdev_id); 3260 if (ret) 3261 ath11k_warn(ar->ab, 3262 "failed to set obss_pd_threshold for pdev: %u\n", 3263 pdev_id); 3264 return ret; 3265 } 3266 3267 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3268 "obss pd sr_ctrl %x non_srg_thres %u srg_max %u\n", 3269 he_obss_pd->sr_ctrl, he_obss_pd->non_srg_max_offset, 3270 he_obss_pd->max_offset); 3271 3272 param_val = 0; 3273 3274 if (he_obss_pd->sr_ctrl & 3275 IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) { 3276 non_srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD; 3277 } else { 3278 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT) 3279 non_srg_th = (ATH11K_OBSS_PD_MAX_THRESHOLD + 3280 he_obss_pd->non_srg_max_offset); 3281 else 3282 non_srg_th = ATH11K_OBSS_PD_NON_SRG_MAX_THRESHOLD; 3283 3284 param_val |= ATH11K_OBSS_PD_NON_SRG_EN; 3285 } 3286 3287 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) { 3288 srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD + he_obss_pd->max_offset; 3289 param_val |= ATH11K_OBSS_PD_SRG_EN; 3290 } 3291 3292 if (test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT, 3293 ar->ab->wmi_ab.svc_map)) { 3294 param_val |= ATH11K_OBSS_PD_THRESHOLD_IN_DBM; 3295 param_val |= FIELD_PREP(GENMASK(15, 8), srg_th); 3296 } else { 3297 non_srg_th -= ATH11K_DEFAULT_NOISE_FLOOR; 3298 /* SRG not supported and threshold in dB */ 3299 param_val &= ~(ATH11K_OBSS_PD_SRG_EN | 3300 ATH11K_OBSS_PD_THRESHOLD_IN_DBM); 3301 } 3302 3303 param_val |= (non_srg_th & GENMASK(7, 0)); 3304 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 3305 if (ret) { 3306 ath11k_warn(ar->ab, 3307 "failed to set obss_pd_threshold for pdev: %u\n", 3308 pdev_id); 3309 return ret; 3310 } 3311 3312 /* Enable OBSS PD for all access category */ 3313 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC; 3314 param_val = 0xf; 3315 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 3316 if (ret) { 3317 ath11k_warn(ar->ab, 3318 "failed to set obss_pd_per_ac for pdev: %u\n", 3319 pdev_id); 3320 return ret; 3321 } 3322 3323 /* Set SR Prohibit */ 3324 param_id = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT; 3325 param_val = !!(he_obss_pd->sr_ctrl & 3326 IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED); 3327 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 3328 if (ret) { 3329 ath11k_warn(ar->ab, "failed to set sr_prohibit for pdev: %u\n", 3330 pdev_id); 3331 return ret; 3332 } 3333 3334 if (!test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT, 3335 ar->ab->wmi_ab.svc_map)) 3336 return 0; 3337 3338 /* Set SRG BSS Color Bitmap */ 3339 memcpy(bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap)); 3340 ret = ath11k_wmi_pdev_set_srg_bss_color_bitmap(ar, bitmap); 3341 if (ret) { 3342 ath11k_warn(ar->ab, 3343 "failed to set bss_color_bitmap for pdev: %u\n", 3344 pdev_id); 3345 return ret; 3346 } 3347 3348 /* Set SRG Partial BSSID Bitmap */ 3349 memcpy(bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap)); 3350 ret = ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(ar, bitmap); 3351 if (ret) { 3352 ath11k_warn(ar->ab, 3353 "failed to set partial_bssid_bitmap for pdev: %u\n", 3354 pdev_id); 3355 return ret; 3356 } 3357 3358 memset(bitmap, 0xff, sizeof(bitmap)); 3359 3360 /* Enable all BSS Colors for SRG */ 3361 ret = ath11k_wmi_pdev_srg_obss_color_enable_bitmap(ar, bitmap); 3362 if (ret) { 3363 ath11k_warn(ar->ab, 3364 "failed to set srg_color_en_bitmap pdev: %u\n", 3365 pdev_id); 3366 return ret; 3367 } 3368 3369 /* Enable all partial BSSID mask for SRG */ 3370 ret = ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, bitmap); 3371 if (ret) { 3372 ath11k_warn(ar->ab, 3373 "failed to set srg_bssid_en_bitmap pdev: %u\n", 3374 pdev_id); 3375 return ret; 3376 } 3377 3378 /* Enable all BSS Colors for non-SRG */ 3379 ret = ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, bitmap); 3380 if (ret) { 3381 ath11k_warn(ar->ab, 3382 "failed to set non_srg_color_en_bitmap pdev: %u\n", 3383 pdev_id); 3384 return ret; 3385 } 3386 3387 /* Enable all partial BSSID mask for non-SRG */ 3388 ret = ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, bitmap); 3389 if (ret) { 3390 ath11k_warn(ar->ab, 3391 "failed to set non_srg_bssid_en_bitmap pdev: %u\n", 3392 pdev_id); 3393 return ret; 3394 } 3395 3396 return 0; 3397 } 3398 3399 static void ath11k_mac_op_bss_info_changed(struct ieee80211_hw *hw, 3400 struct ieee80211_vif *vif, 3401 struct ieee80211_bss_conf *info, 3402 u64 changed) 3403 { 3404 struct ath11k *ar = hw->priv; 3405 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3406 struct cfg80211_chan_def def; 3407 u32 param_id, param_value; 3408 enum nl80211_band band; 3409 u32 vdev_param; 3410 int mcast_rate; 3411 u32 preamble; 3412 u16 hw_value; 3413 u16 bitrate; 3414 int ret = 0; 3415 u8 rateidx; 3416 u32 rate, param; 3417 u32 ipv4_cnt; 3418 3419 mutex_lock(&ar->conf_mutex); 3420 3421 if (changed & BSS_CHANGED_BEACON_INT) { 3422 arvif->beacon_interval = info->beacon_int; 3423 3424 param_id = WMI_VDEV_PARAM_BEACON_INTERVAL; 3425 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3426 param_id, 3427 arvif->beacon_interval); 3428 if (ret) 3429 ath11k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n", 3430 arvif->vdev_id); 3431 else 3432 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3433 "Beacon interval: %d set for VDEV: %d\n", 3434 arvif->beacon_interval, arvif->vdev_id); 3435 } 3436 3437 if (changed & BSS_CHANGED_BEACON) { 3438 param_id = WMI_PDEV_PARAM_BEACON_TX_MODE; 3439 param_value = WMI_BEACON_STAGGERED_MODE; 3440 ret = ath11k_wmi_pdev_set_param(ar, param_id, 3441 param_value, ar->pdev->pdev_id); 3442 if (ret) 3443 ath11k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n", 3444 arvif->vdev_id); 3445 else 3446 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3447 "Set staggered beacon mode for VDEV: %d\n", 3448 arvif->vdev_id); 3449 3450 if (!arvif->do_not_send_tmpl || !arvif->bcca_zero_sent) { 3451 ret = ath11k_mac_setup_bcn_tmpl(arvif); 3452 if (ret) 3453 ath11k_warn(ar->ab, "failed to update bcn template: %d\n", 3454 ret); 3455 } 3456 3457 if (arvif->bcca_zero_sent) 3458 arvif->do_not_send_tmpl = true; 3459 else 3460 arvif->do_not_send_tmpl = false; 3461 3462 if (vif->bss_conf.he_support) { 3463 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3464 WMI_VDEV_PARAM_BA_MODE, 3465 WMI_BA_MODE_BUFFER_SIZE_256); 3466 if (ret) 3467 ath11k_warn(ar->ab, 3468 "failed to set BA BUFFER SIZE 256 for vdev: %d\n", 3469 arvif->vdev_id); 3470 else 3471 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3472 "Set BA BUFFER SIZE 256 for VDEV: %d\n", 3473 arvif->vdev_id); 3474 } 3475 } 3476 3477 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) { 3478 arvif->dtim_period = info->dtim_period; 3479 3480 param_id = WMI_VDEV_PARAM_DTIM_PERIOD; 3481 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3482 param_id, 3483 arvif->dtim_period); 3484 3485 if (ret) 3486 ath11k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n", 3487 arvif->vdev_id, ret); 3488 else 3489 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3490 "DTIM period: %d set for VDEV: %d\n", 3491 arvif->dtim_period, arvif->vdev_id); 3492 } 3493 3494 if (changed & BSS_CHANGED_SSID && 3495 vif->type == NL80211_IFTYPE_AP) { 3496 arvif->u.ap.ssid_len = vif->cfg.ssid_len; 3497 if (vif->cfg.ssid_len) 3498 memcpy(arvif->u.ap.ssid, vif->cfg.ssid, 3499 vif->cfg.ssid_len); 3500 arvif->u.ap.hidden_ssid = info->hidden_ssid; 3501 } 3502 3503 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid)) 3504 ether_addr_copy(arvif->bssid, info->bssid); 3505 3506 if (changed & BSS_CHANGED_BEACON_ENABLED) { 3507 if (info->enable_beacon) 3508 ath11k_mac_set_he_txbf_conf(arvif); 3509 ath11k_control_beaconing(arvif, info); 3510 3511 if (arvif->is_up && vif->bss_conf.he_support && 3512 vif->bss_conf.he_oper.params) { 3513 param_id = WMI_VDEV_PARAM_HEOPS_0_31; 3514 param_value = vif->bss_conf.he_oper.params; 3515 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3516 param_id, param_value); 3517 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3518 "he oper param: %x set for VDEV: %d\n", 3519 param_value, arvif->vdev_id); 3520 3521 if (ret) 3522 ath11k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n", 3523 param_value, arvif->vdev_id, ret); 3524 } 3525 } 3526 3527 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 3528 u32 cts_prot; 3529 3530 cts_prot = !!(info->use_cts_prot); 3531 param_id = WMI_VDEV_PARAM_PROTECTION_MODE; 3532 3533 if (arvif->is_started) { 3534 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3535 param_id, cts_prot); 3536 if (ret) 3537 ath11k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n", 3538 arvif->vdev_id); 3539 else 3540 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n", 3541 cts_prot, arvif->vdev_id); 3542 } else { 3543 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n"); 3544 } 3545 } 3546 3547 if (changed & BSS_CHANGED_ERP_SLOT) { 3548 u32 slottime; 3549 3550 if (info->use_short_slot) 3551 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 3552 3553 else 3554 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 3555 3556 param_id = WMI_VDEV_PARAM_SLOT_TIME; 3557 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3558 param_id, slottime); 3559 if (ret) 3560 ath11k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n", 3561 arvif->vdev_id); 3562 else 3563 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3564 "Set slottime: %d for VDEV: %d\n", 3565 slottime, arvif->vdev_id); 3566 } 3567 3568 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 3569 u32 preamble; 3570 3571 if (info->use_short_preamble) 3572 preamble = WMI_VDEV_PREAMBLE_SHORT; 3573 else 3574 preamble = WMI_VDEV_PREAMBLE_LONG; 3575 3576 param_id = WMI_VDEV_PARAM_PREAMBLE; 3577 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3578 param_id, preamble); 3579 if (ret) 3580 ath11k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n", 3581 arvif->vdev_id); 3582 else 3583 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3584 "Set preamble: %d for VDEV: %d\n", 3585 preamble, arvif->vdev_id); 3586 } 3587 3588 if (changed & BSS_CHANGED_ASSOC) { 3589 if (vif->cfg.assoc) 3590 ath11k_bss_assoc(hw, vif, info); 3591 else 3592 ath11k_bss_disassoc(hw, vif); 3593 } 3594 3595 if (changed & BSS_CHANGED_TXPOWER) { 3596 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev_id %i txpower %d\n", 3597 arvif->vdev_id, info->txpower); 3598 3599 arvif->txpower = info->txpower; 3600 ath11k_mac_txpower_recalc(ar); 3601 } 3602 3603 if (changed & BSS_CHANGED_PS && 3604 ar->ab->hw_params.supports_sta_ps) { 3605 arvif->ps = vif->cfg.ps; 3606 3607 ret = ath11k_mac_config_ps(ar); 3608 if (ret) 3609 ath11k_warn(ar->ab, "failed to setup ps on vdev %i: %d\n", 3610 arvif->vdev_id, ret); 3611 } 3612 3613 if (changed & BSS_CHANGED_MCAST_RATE && 3614 !ath11k_mac_vif_chan(arvif->vif, &def)) { 3615 band = def.chan->band; 3616 mcast_rate = vif->bss_conf.mcast_rate[band]; 3617 3618 if (mcast_rate > 0) 3619 rateidx = mcast_rate - 1; 3620 else 3621 rateidx = ffs(vif->bss_conf.basic_rates) - 1; 3622 3623 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) 3624 rateidx += ATH11K_MAC_FIRST_OFDM_RATE_IDX; 3625 3626 bitrate = ath11k_legacy_rates[rateidx].bitrate; 3627 hw_value = ath11k_legacy_rates[rateidx].hw_value; 3628 3629 if (ath11k_mac_bitrate_is_cck(bitrate)) 3630 preamble = WMI_RATE_PREAMBLE_CCK; 3631 else 3632 preamble = WMI_RATE_PREAMBLE_OFDM; 3633 3634 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble); 3635 3636 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3637 "vdev %d mcast_rate %x\n", 3638 arvif->vdev_id, rate); 3639 3640 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE; 3641 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3642 vdev_param, rate); 3643 if (ret) 3644 ath11k_warn(ar->ab, 3645 "failed to set mcast rate on vdev %i: %d\n", 3646 arvif->vdev_id, ret); 3647 3648 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE; 3649 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3650 vdev_param, rate); 3651 if (ret) 3652 ath11k_warn(ar->ab, 3653 "failed to set bcast rate on vdev %i: %d\n", 3654 arvif->vdev_id, ret); 3655 } 3656 3657 if (changed & BSS_CHANGED_BASIC_RATES && 3658 !ath11k_mac_vif_chan(arvif->vif, &def)) 3659 ath11k_recalculate_mgmt_rate(ar, vif, &def); 3660 3661 if (changed & BSS_CHANGED_TWT) { 3662 struct wmi_twt_enable_params twt_params = {0}; 3663 3664 if (info->twt_requester || info->twt_responder) { 3665 ath11k_wmi_fill_default_twt_params(&twt_params); 3666 ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id, 3667 &twt_params); 3668 } else { 3669 ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id); 3670 } 3671 } 3672 3673 if (changed & BSS_CHANGED_HE_OBSS_PD) 3674 ath11k_mac_config_obss_pd(ar, &info->he_obss_pd); 3675 3676 if (changed & BSS_CHANGED_HE_BSS_COLOR) { 3677 if (vif->type == NL80211_IFTYPE_AP) { 3678 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd( 3679 ar, arvif->vdev_id, info->he_bss_color.color, 3680 ATH11K_BSS_COLOR_COLLISION_DETECTION_AP_PERIOD_MS, 3681 info->he_bss_color.enabled); 3682 if (ret) 3683 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n", 3684 arvif->vdev_id, ret); 3685 3686 param_id = WMI_VDEV_PARAM_BSS_COLOR; 3687 if (info->he_bss_color.enabled) 3688 param_value = info->he_bss_color.color << 3689 IEEE80211_HE_OPERATION_BSS_COLOR_OFFSET; 3690 else 3691 param_value = IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED; 3692 3693 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3694 param_id, 3695 param_value); 3696 if (ret) 3697 ath11k_warn(ar->ab, 3698 "failed to set bss color param on vdev %i: %d\n", 3699 arvif->vdev_id, ret); 3700 3701 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3702 "bss color param 0x%x set on vdev %i\n", 3703 param_value, arvif->vdev_id); 3704 } else if (vif->type == NL80211_IFTYPE_STATION) { 3705 ret = ath11k_wmi_send_bss_color_change_enable_cmd(ar, 3706 arvif->vdev_id, 3707 1); 3708 if (ret) 3709 ath11k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n", 3710 arvif->vdev_id, ret); 3711 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd( 3712 ar, arvif->vdev_id, 0, 3713 ATH11K_BSS_COLOR_COLLISION_DETECTION_STA_PERIOD_MS, 1); 3714 if (ret) 3715 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n", 3716 arvif->vdev_id, ret); 3717 } 3718 } 3719 3720 if (changed & BSS_CHANGED_FTM_RESPONDER && 3721 arvif->ftm_responder != info->ftm_responder && 3722 test_bit(WMI_TLV_SERVICE_RTT, ar->ab->wmi_ab.svc_map) && 3723 (vif->type == NL80211_IFTYPE_AP || 3724 vif->type == NL80211_IFTYPE_MESH_POINT)) { 3725 arvif->ftm_responder = info->ftm_responder; 3726 param = WMI_VDEV_PARAM_ENABLE_DISABLE_RTT_RESPONDER_ROLE; 3727 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, 3728 arvif->ftm_responder); 3729 if (ret) 3730 ath11k_warn(ar->ab, "Failed to set ftm responder %i: %d\n", 3731 arvif->vdev_id, ret); 3732 } 3733 3734 if (changed & BSS_CHANGED_FILS_DISCOVERY || 3735 changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP) 3736 ath11k_mac_fils_discovery(arvif, info); 3737 3738 if (changed & BSS_CHANGED_ARP_FILTER) { 3739 ipv4_cnt = min(vif->cfg.arp_addr_cnt, ATH11K_IPV4_MAX_COUNT); 3740 memcpy(arvif->arp_ns_offload.ipv4_addr, 3741 vif->cfg.arp_addr_list, 3742 ipv4_cnt * sizeof(u32)); 3743 memcpy(arvif->arp_ns_offload.mac_addr, vif->addr, ETH_ALEN); 3744 arvif->arp_ns_offload.ipv4_count = ipv4_cnt; 3745 3746 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n", 3747 vif->cfg.arp_addr_cnt, 3748 vif->addr, arvif->arp_ns_offload.ipv4_addr); 3749 } 3750 3751 mutex_unlock(&ar->conf_mutex); 3752 } 3753 3754 void __ath11k_mac_scan_finish(struct ath11k *ar) 3755 { 3756 lockdep_assert_held(&ar->data_lock); 3757 3758 switch (ar->scan.state) { 3759 case ATH11K_SCAN_IDLE: 3760 break; 3761 case ATH11K_SCAN_RUNNING: 3762 case ATH11K_SCAN_ABORTING: 3763 if (ar->scan.is_roc && ar->scan.roc_notify) 3764 ieee80211_remain_on_channel_expired(ar->hw); 3765 fallthrough; 3766 case ATH11K_SCAN_STARTING: 3767 if (!ar->scan.is_roc) { 3768 struct cfg80211_scan_info info = { 3769 .aborted = ((ar->scan.state == 3770 ATH11K_SCAN_ABORTING) || 3771 (ar->scan.state == 3772 ATH11K_SCAN_STARTING)), 3773 }; 3774 3775 ieee80211_scan_completed(ar->hw, &info); 3776 } 3777 3778 ar->scan.state = ATH11K_SCAN_IDLE; 3779 ar->scan_channel = NULL; 3780 ar->scan.roc_freq = 0; 3781 cancel_delayed_work(&ar->scan.timeout); 3782 complete_all(&ar->scan.completed); 3783 break; 3784 } 3785 } 3786 3787 void ath11k_mac_scan_finish(struct ath11k *ar) 3788 { 3789 spin_lock_bh(&ar->data_lock); 3790 __ath11k_mac_scan_finish(ar); 3791 spin_unlock_bh(&ar->data_lock); 3792 } 3793 3794 static int ath11k_scan_stop(struct ath11k *ar) 3795 { 3796 struct scan_cancel_param arg = { 3797 .req_type = WLAN_SCAN_CANCEL_SINGLE, 3798 .scan_id = ATH11K_SCAN_ID, 3799 }; 3800 int ret; 3801 3802 lockdep_assert_held(&ar->conf_mutex); 3803 3804 /* TODO: Fill other STOP Params */ 3805 arg.pdev_id = ar->pdev->pdev_id; 3806 3807 ret = ath11k_wmi_send_scan_stop_cmd(ar, &arg); 3808 if (ret) { 3809 ath11k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret); 3810 goto out; 3811 } 3812 3813 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ); 3814 if (ret == 0) { 3815 ath11k_warn(ar->ab, 3816 "failed to receive scan abort comple: timed out\n"); 3817 ret = -ETIMEDOUT; 3818 } else if (ret > 0) { 3819 ret = 0; 3820 } 3821 3822 out: 3823 /* Scan state should be updated upon scan completion but in case 3824 * firmware fails to deliver the event (for whatever reason) it is 3825 * desired to clean up scan state anyway. Firmware may have just 3826 * dropped the scan completion event delivery due to transport pipe 3827 * being overflown with data and/or it can recover on its own before 3828 * next scan request is submitted. 3829 */ 3830 spin_lock_bh(&ar->data_lock); 3831 if (ar->scan.state != ATH11K_SCAN_IDLE) 3832 __ath11k_mac_scan_finish(ar); 3833 spin_unlock_bh(&ar->data_lock); 3834 3835 return ret; 3836 } 3837 3838 static void ath11k_scan_abort(struct ath11k *ar) 3839 { 3840 int ret; 3841 3842 lockdep_assert_held(&ar->conf_mutex); 3843 3844 spin_lock_bh(&ar->data_lock); 3845 3846 switch (ar->scan.state) { 3847 case ATH11K_SCAN_IDLE: 3848 /* This can happen if timeout worker kicked in and called 3849 * abortion while scan completion was being processed. 3850 */ 3851 break; 3852 case ATH11K_SCAN_STARTING: 3853 case ATH11K_SCAN_ABORTING: 3854 ath11k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n", 3855 ar->scan.state); 3856 break; 3857 case ATH11K_SCAN_RUNNING: 3858 ar->scan.state = ATH11K_SCAN_ABORTING; 3859 spin_unlock_bh(&ar->data_lock); 3860 3861 ret = ath11k_scan_stop(ar); 3862 if (ret) 3863 ath11k_warn(ar->ab, "failed to abort scan: %d\n", ret); 3864 3865 spin_lock_bh(&ar->data_lock); 3866 break; 3867 } 3868 3869 spin_unlock_bh(&ar->data_lock); 3870 } 3871 3872 static void ath11k_scan_timeout_work(struct work_struct *work) 3873 { 3874 struct ath11k *ar = container_of(work, struct ath11k, 3875 scan.timeout.work); 3876 3877 mutex_lock(&ar->conf_mutex); 3878 ath11k_scan_abort(ar); 3879 mutex_unlock(&ar->conf_mutex); 3880 } 3881 3882 static int ath11k_start_scan(struct ath11k *ar, 3883 struct scan_req_params *arg) 3884 { 3885 int ret; 3886 unsigned long timeout = 1 * HZ; 3887 3888 lockdep_assert_held(&ar->conf_mutex); 3889 3890 if (ath11k_spectral_get_mode(ar) == ATH11K_SPECTRAL_BACKGROUND) 3891 ath11k_spectral_reset_buffer(ar); 3892 3893 ret = ath11k_wmi_send_scan_start_cmd(ar, arg); 3894 if (ret) 3895 return ret; 3896 3897 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) { 3898 timeout = 5 * HZ; 3899 3900 if (ar->supports_6ghz) 3901 timeout += 5 * HZ; 3902 } 3903 3904 ret = wait_for_completion_timeout(&ar->scan.started, timeout); 3905 if (ret == 0) { 3906 ret = ath11k_scan_stop(ar); 3907 if (ret) 3908 ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret); 3909 3910 return -ETIMEDOUT; 3911 } 3912 3913 /* If we failed to start the scan, return error code at 3914 * this point. This is probably due to some issue in the 3915 * firmware, but no need to wedge the driver due to that... 3916 */ 3917 spin_lock_bh(&ar->data_lock); 3918 if (ar->scan.state == ATH11K_SCAN_IDLE) { 3919 spin_unlock_bh(&ar->data_lock); 3920 return -EINVAL; 3921 } 3922 spin_unlock_bh(&ar->data_lock); 3923 3924 return 0; 3925 } 3926 3927 static int ath11k_mac_op_hw_scan(struct ieee80211_hw *hw, 3928 struct ieee80211_vif *vif, 3929 struct ieee80211_scan_request *hw_req) 3930 { 3931 struct ath11k *ar = hw->priv; 3932 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3933 struct cfg80211_scan_request *req = &hw_req->req; 3934 struct scan_req_params *arg = NULL; 3935 int ret = 0; 3936 int i; 3937 u32 scan_timeout; 3938 3939 /* Firmwares advertising the support of triggering 11D algorithm 3940 * on the scan results of a regular scan expects driver to send 3941 * WMI_11D_SCAN_START_CMDID before sending WMI_START_SCAN_CMDID. 3942 * With this feature, separate 11D scan can be avoided since 3943 * regdomain can be determined with the scan results of the 3944 * regular scan. 3945 */ 3946 if (ar->state_11d == ATH11K_11D_PREPARING && 3947 test_bit(WMI_TLV_SERVICE_SUPPORT_11D_FOR_HOST_SCAN, 3948 ar->ab->wmi_ab.svc_map)) 3949 ath11k_mac_11d_scan_start(ar, arvif->vdev_id); 3950 3951 mutex_lock(&ar->conf_mutex); 3952 3953 spin_lock_bh(&ar->data_lock); 3954 switch (ar->scan.state) { 3955 case ATH11K_SCAN_IDLE: 3956 reinit_completion(&ar->scan.started); 3957 reinit_completion(&ar->scan.completed); 3958 ar->scan.state = ATH11K_SCAN_STARTING; 3959 ar->scan.is_roc = false; 3960 ar->scan.vdev_id = arvif->vdev_id; 3961 ret = 0; 3962 break; 3963 case ATH11K_SCAN_STARTING: 3964 case ATH11K_SCAN_RUNNING: 3965 case ATH11K_SCAN_ABORTING: 3966 ret = -EBUSY; 3967 break; 3968 } 3969 spin_unlock_bh(&ar->data_lock); 3970 3971 if (ret) 3972 goto exit; 3973 3974 arg = kzalloc(sizeof(*arg), GFP_KERNEL); 3975 3976 if (!arg) { 3977 ret = -ENOMEM; 3978 goto exit; 3979 } 3980 3981 ath11k_wmi_start_scan_init(ar, arg); 3982 arg->vdev_id = arvif->vdev_id; 3983 arg->scan_id = ATH11K_SCAN_ID; 3984 3985 if (req->ie_len) { 3986 arg->extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL); 3987 if (!arg->extraie.ptr) { 3988 ret = -ENOMEM; 3989 goto exit; 3990 } 3991 arg->extraie.len = req->ie_len; 3992 } 3993 3994 if (req->n_ssids) { 3995 arg->num_ssids = req->n_ssids; 3996 for (i = 0; i < arg->num_ssids; i++) { 3997 arg->ssid[i].length = req->ssids[i].ssid_len; 3998 memcpy(&arg->ssid[i].ssid, req->ssids[i].ssid, 3999 req->ssids[i].ssid_len); 4000 } 4001 } else { 4002 arg->scan_flags |= WMI_SCAN_FLAG_PASSIVE; 4003 } 4004 4005 if (req->n_channels) { 4006 arg->num_chan = req->n_channels; 4007 arg->chan_list = kcalloc(arg->num_chan, sizeof(*arg->chan_list), 4008 GFP_KERNEL); 4009 4010 if (!arg->chan_list) { 4011 ret = -ENOMEM; 4012 goto exit; 4013 } 4014 4015 for (i = 0; i < arg->num_chan; i++) { 4016 if (test_bit(WMI_TLV_SERVICE_SCAN_CONFIG_PER_CHANNEL, 4017 ar->ab->wmi_ab.svc_map)) { 4018 arg->chan_list[i] = 4019 u32_encode_bits(req->channels[i]->center_freq, 4020 WMI_SCAN_CONFIG_PER_CHANNEL_MASK); 4021 4022 /* If NL80211_SCAN_FLAG_COLOCATED_6GHZ is set in scan 4023 * flags, then scan all PSC channels in 6 GHz band and 4024 * those non-PSC channels where RNR IE is found during 4025 * the legacy 2.4/5 GHz scan. 4026 * If NL80211_SCAN_FLAG_COLOCATED_6GHZ is not set, 4027 * then all channels in 6 GHz will be scanned. 4028 */ 4029 if (req->channels[i]->band == NL80211_BAND_6GHZ && 4030 req->flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ && 4031 !cfg80211_channel_is_psc(req->channels[i])) 4032 arg->chan_list[i] |= 4033 WMI_SCAN_CH_FLAG_SCAN_ONLY_IF_RNR_FOUND; 4034 } else { 4035 arg->chan_list[i] = req->channels[i]->center_freq; 4036 } 4037 } 4038 } 4039 4040 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 4041 arg->scan_f_add_spoofed_mac_in_probe = 1; 4042 ether_addr_copy(arg->mac_addr.addr, req->mac_addr); 4043 ether_addr_copy(arg->mac_mask.addr, req->mac_addr_mask); 4044 } 4045 4046 /* if duration is set, default dwell times will be overwritten */ 4047 if (req->duration) { 4048 arg->dwell_time_active = req->duration; 4049 arg->dwell_time_active_2g = req->duration; 4050 arg->dwell_time_active_6g = req->duration; 4051 arg->dwell_time_passive = req->duration; 4052 arg->dwell_time_passive_6g = req->duration; 4053 arg->burst_duration = req->duration; 4054 4055 scan_timeout = min_t(u32, arg->max_rest_time * 4056 (arg->num_chan - 1) + (req->duration + 4057 ATH11K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD) * 4058 arg->num_chan, arg->max_scan_time); 4059 } else { 4060 scan_timeout = arg->max_scan_time; 4061 } 4062 4063 /* Add a margin to account for event/command processing */ 4064 scan_timeout += ATH11K_MAC_SCAN_CMD_EVT_OVERHEAD; 4065 4066 ret = ath11k_start_scan(ar, arg); 4067 if (ret) { 4068 ath11k_warn(ar->ab, "failed to start hw scan: %d\n", ret); 4069 spin_lock_bh(&ar->data_lock); 4070 ar->scan.state = ATH11K_SCAN_IDLE; 4071 spin_unlock_bh(&ar->data_lock); 4072 } 4073 4074 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 4075 msecs_to_jiffies(scan_timeout)); 4076 4077 exit: 4078 if (arg) { 4079 kfree(arg->chan_list); 4080 kfree(arg->extraie.ptr); 4081 kfree(arg); 4082 } 4083 4084 mutex_unlock(&ar->conf_mutex); 4085 4086 if (ar->state_11d == ATH11K_11D_PREPARING) 4087 ath11k_mac_11d_scan_start(ar, arvif->vdev_id); 4088 4089 return ret; 4090 } 4091 4092 static void ath11k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw, 4093 struct ieee80211_vif *vif) 4094 { 4095 struct ath11k *ar = hw->priv; 4096 4097 mutex_lock(&ar->conf_mutex); 4098 ath11k_scan_abort(ar); 4099 mutex_unlock(&ar->conf_mutex); 4100 4101 cancel_delayed_work_sync(&ar->scan.timeout); 4102 } 4103 4104 static int ath11k_install_key(struct ath11k_vif *arvif, 4105 struct ieee80211_key_conf *key, 4106 enum set_key_cmd cmd, 4107 const u8 *macaddr, u32 flags) 4108 { 4109 int ret; 4110 struct ath11k *ar = arvif->ar; 4111 struct wmi_vdev_install_key_arg arg = { 4112 .vdev_id = arvif->vdev_id, 4113 .key_idx = key->keyidx, 4114 .key_len = key->keylen, 4115 .key_data = key->key, 4116 .key_flags = flags, 4117 .macaddr = macaddr, 4118 }; 4119 4120 lockdep_assert_held(&arvif->ar->conf_mutex); 4121 4122 reinit_completion(&ar->install_key_done); 4123 4124 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags)) 4125 return 0; 4126 4127 if (cmd == DISABLE_KEY) { 4128 arg.key_cipher = WMI_CIPHER_NONE; 4129 arg.key_data = NULL; 4130 goto install; 4131 } 4132 4133 switch (key->cipher) { 4134 case WLAN_CIPHER_SUITE_CCMP: 4135 arg.key_cipher = WMI_CIPHER_AES_CCM; 4136 /* TODO: Re-check if flag is valid */ 4137 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT; 4138 break; 4139 case WLAN_CIPHER_SUITE_TKIP: 4140 arg.key_cipher = WMI_CIPHER_TKIP; 4141 arg.key_txmic_len = 8; 4142 arg.key_rxmic_len = 8; 4143 break; 4144 case WLAN_CIPHER_SUITE_CCMP_256: 4145 arg.key_cipher = WMI_CIPHER_AES_CCM; 4146 break; 4147 case WLAN_CIPHER_SUITE_GCMP: 4148 case WLAN_CIPHER_SUITE_GCMP_256: 4149 arg.key_cipher = WMI_CIPHER_AES_GCM; 4150 break; 4151 default: 4152 ath11k_warn(ar->ab, "cipher %d is not supported\n", key->cipher); 4153 return -EOPNOTSUPP; 4154 } 4155 4156 if (test_bit(ATH11K_FLAG_RAW_MODE, &ar->ab->dev_flags)) 4157 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV | 4158 IEEE80211_KEY_FLAG_RESERVE_TAILROOM; 4159 4160 install: 4161 ret = ath11k_wmi_vdev_install_key(arvif->ar, &arg); 4162 4163 if (ret) 4164 return ret; 4165 4166 if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ)) 4167 return -ETIMEDOUT; 4168 4169 return ar->install_key_status ? -EINVAL : 0; 4170 } 4171 4172 static int ath11k_clear_peer_keys(struct ath11k_vif *arvif, 4173 const u8 *addr) 4174 { 4175 struct ath11k *ar = arvif->ar; 4176 struct ath11k_base *ab = ar->ab; 4177 struct ath11k_peer *peer; 4178 int first_errno = 0; 4179 int ret; 4180 int i; 4181 u32 flags = 0; 4182 4183 lockdep_assert_held(&ar->conf_mutex); 4184 4185 spin_lock_bh(&ab->base_lock); 4186 peer = ath11k_peer_find(ab, arvif->vdev_id, addr); 4187 spin_unlock_bh(&ab->base_lock); 4188 4189 if (!peer) 4190 return -ENOENT; 4191 4192 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 4193 if (!peer->keys[i]) 4194 continue; 4195 4196 /* key flags are not required to delete the key */ 4197 ret = ath11k_install_key(arvif, peer->keys[i], 4198 DISABLE_KEY, addr, flags); 4199 if (ret < 0 && first_errno == 0) 4200 first_errno = ret; 4201 4202 if (ret < 0) 4203 ath11k_warn(ab, "failed to remove peer key %d: %d\n", 4204 i, ret); 4205 4206 spin_lock_bh(&ab->base_lock); 4207 peer->keys[i] = NULL; 4208 spin_unlock_bh(&ab->base_lock); 4209 } 4210 4211 return first_errno; 4212 } 4213 4214 static int ath11k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 4215 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 4216 struct ieee80211_key_conf *key) 4217 { 4218 struct ath11k *ar = hw->priv; 4219 struct ath11k_base *ab = ar->ab; 4220 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4221 struct ath11k_peer *peer; 4222 struct ath11k_sta *arsta; 4223 const u8 *peer_addr; 4224 int ret = 0; 4225 u32 flags = 0; 4226 4227 /* BIP needs to be done in software */ 4228 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC || 4229 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 || 4230 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 || 4231 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256) 4232 return 1; 4233 4234 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags)) 4235 return 1; 4236 4237 if (key->keyidx > WMI_MAX_KEY_INDEX) 4238 return -ENOSPC; 4239 4240 mutex_lock(&ar->conf_mutex); 4241 4242 if (sta) 4243 peer_addr = sta->addr; 4244 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 4245 peer_addr = vif->bss_conf.bssid; 4246 else 4247 peer_addr = vif->addr; 4248 4249 key->hw_key_idx = key->keyidx; 4250 4251 /* the peer should not disappear in mid-way (unless FW goes awry) since 4252 * we already hold conf_mutex. we just make sure its there now. 4253 */ 4254 spin_lock_bh(&ab->base_lock); 4255 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr); 4256 4257 /* flush the fragments cache during key (re)install to 4258 * ensure all frags in the new frag list belong to the same key. 4259 */ 4260 if (peer && sta && cmd == SET_KEY) 4261 ath11k_peer_frags_flush(ar, peer); 4262 spin_unlock_bh(&ab->base_lock); 4263 4264 if (!peer) { 4265 if (cmd == SET_KEY) { 4266 ath11k_warn(ab, "cannot install key for non-existent peer %pM\n", 4267 peer_addr); 4268 ret = -EOPNOTSUPP; 4269 goto exit; 4270 } else { 4271 /* if the peer doesn't exist there is no key to disable 4272 * anymore 4273 */ 4274 goto exit; 4275 } 4276 } 4277 4278 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 4279 flags |= WMI_KEY_PAIRWISE; 4280 else 4281 flags |= WMI_KEY_GROUP; 4282 4283 ret = ath11k_install_key(arvif, key, cmd, peer_addr, flags); 4284 if (ret) { 4285 ath11k_warn(ab, "ath11k_install_key failed (%d)\n", ret); 4286 goto exit; 4287 } 4288 4289 ret = ath11k_dp_peer_rx_pn_replay_config(arvif, peer_addr, cmd, key); 4290 if (ret) { 4291 ath11k_warn(ab, "failed to offload PN replay detection %d\n", ret); 4292 goto exit; 4293 } 4294 4295 spin_lock_bh(&ab->base_lock); 4296 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr); 4297 if (peer && cmd == SET_KEY) { 4298 peer->keys[key->keyidx] = key; 4299 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) { 4300 peer->ucast_keyidx = key->keyidx; 4301 peer->sec_type = ath11k_dp_tx_get_encrypt_type(key->cipher); 4302 } else { 4303 peer->mcast_keyidx = key->keyidx; 4304 peer->sec_type_grp = ath11k_dp_tx_get_encrypt_type(key->cipher); 4305 } 4306 } else if (peer && cmd == DISABLE_KEY) { 4307 peer->keys[key->keyidx] = NULL; 4308 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 4309 peer->ucast_keyidx = 0; 4310 else 4311 peer->mcast_keyidx = 0; 4312 } else if (!peer) 4313 /* impossible unless FW goes crazy */ 4314 ath11k_warn(ab, "peer %pM disappeared!\n", peer_addr); 4315 4316 if (sta) { 4317 arsta = (struct ath11k_sta *)sta->drv_priv; 4318 4319 switch (key->cipher) { 4320 case WLAN_CIPHER_SUITE_TKIP: 4321 case WLAN_CIPHER_SUITE_CCMP: 4322 case WLAN_CIPHER_SUITE_CCMP_256: 4323 case WLAN_CIPHER_SUITE_GCMP: 4324 case WLAN_CIPHER_SUITE_GCMP_256: 4325 if (cmd == SET_KEY) 4326 arsta->pn_type = HAL_PN_TYPE_WPA; 4327 else 4328 arsta->pn_type = HAL_PN_TYPE_NONE; 4329 break; 4330 default: 4331 arsta->pn_type = HAL_PN_TYPE_NONE; 4332 break; 4333 } 4334 } 4335 4336 spin_unlock_bh(&ab->base_lock); 4337 4338 exit: 4339 mutex_unlock(&ar->conf_mutex); 4340 return ret; 4341 } 4342 4343 static int 4344 ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar, 4345 enum nl80211_band band, 4346 const struct cfg80211_bitrate_mask *mask) 4347 { 4348 int num_rates = 0; 4349 int i; 4350 4351 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) 4352 num_rates += hweight8(mask->control[band].ht_mcs[i]); 4353 4354 return num_rates; 4355 } 4356 4357 static int 4358 ath11k_mac_bitrate_mask_num_vht_rates(struct ath11k *ar, 4359 enum nl80211_band band, 4360 const struct cfg80211_bitrate_mask *mask) 4361 { 4362 int num_rates = 0; 4363 int i; 4364 4365 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) 4366 num_rates += hweight16(mask->control[band].vht_mcs[i]); 4367 4368 return num_rates; 4369 } 4370 4371 static int 4372 ath11k_mac_bitrate_mask_num_he_rates(struct ath11k *ar, 4373 enum nl80211_band band, 4374 const struct cfg80211_bitrate_mask *mask) 4375 { 4376 int num_rates = 0; 4377 int i; 4378 4379 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) 4380 num_rates += hweight16(mask->control[band].he_mcs[i]); 4381 4382 return num_rates; 4383 } 4384 4385 static int 4386 ath11k_mac_set_peer_vht_fixed_rate(struct ath11k_vif *arvif, 4387 struct ieee80211_sta *sta, 4388 const struct cfg80211_bitrate_mask *mask, 4389 enum nl80211_band band) 4390 { 4391 struct ath11k *ar = arvif->ar; 4392 u8 vht_rate, nss; 4393 u32 rate_code; 4394 int ret, i; 4395 4396 lockdep_assert_held(&ar->conf_mutex); 4397 4398 nss = 0; 4399 4400 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 4401 if (hweight16(mask->control[band].vht_mcs[i]) == 1) { 4402 nss = i + 1; 4403 vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1; 4404 } 4405 } 4406 4407 if (!nss) { 4408 ath11k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM", 4409 sta->addr); 4410 return -EINVAL; 4411 } 4412 4413 /* Avoid updating invalid nss as fixed rate*/ 4414 if (nss > sta->deflink.rx_nss) 4415 return -EINVAL; 4416 4417 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4418 "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates", 4419 sta->addr); 4420 4421 rate_code = ATH11K_HW_RATE_CODE(vht_rate, nss - 1, 4422 WMI_RATE_PREAMBLE_VHT); 4423 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4424 arvif->vdev_id, 4425 WMI_PEER_PARAM_FIXED_RATE, 4426 rate_code); 4427 if (ret) 4428 ath11k_warn(ar->ab, 4429 "failed to update STA %pM Fixed Rate %d: %d\n", 4430 sta->addr, rate_code, ret); 4431 4432 return ret; 4433 } 4434 4435 static int 4436 ath11k_mac_set_peer_he_fixed_rate(struct ath11k_vif *arvif, 4437 struct ieee80211_sta *sta, 4438 const struct cfg80211_bitrate_mask *mask, 4439 enum nl80211_band band) 4440 { 4441 struct ath11k *ar = arvif->ar; 4442 u8 he_rate, nss; 4443 u32 rate_code; 4444 int ret, i; 4445 4446 lockdep_assert_held(&ar->conf_mutex); 4447 4448 nss = 0; 4449 4450 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) { 4451 if (hweight16(mask->control[band].he_mcs[i]) == 1) { 4452 nss = i + 1; 4453 he_rate = ffs(mask->control[band].he_mcs[i]) - 1; 4454 } 4455 } 4456 4457 if (!nss) { 4458 ath11k_warn(ar->ab, "No single he fixed rate found to set for %pM", 4459 sta->addr); 4460 return -EINVAL; 4461 } 4462 4463 /* Avoid updating invalid nss as fixed rate */ 4464 if (nss > sta->deflink.rx_nss) 4465 return -EINVAL; 4466 4467 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4468 "setting fixed he rate for peer %pM, device will not switch to any other selected rates", 4469 sta->addr); 4470 4471 rate_code = ATH11K_HW_RATE_CODE(he_rate, nss - 1, 4472 WMI_RATE_PREAMBLE_HE); 4473 4474 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4475 arvif->vdev_id, 4476 WMI_PEER_PARAM_FIXED_RATE, 4477 rate_code); 4478 if (ret) 4479 ath11k_warn(ar->ab, 4480 "failed to update sta %pM fixed rate %d: %d\n", 4481 sta->addr, rate_code, ret); 4482 4483 return ret; 4484 } 4485 4486 static int 4487 ath11k_mac_set_peer_ht_fixed_rate(struct ath11k_vif *arvif, 4488 struct ieee80211_sta *sta, 4489 const struct cfg80211_bitrate_mask *mask, 4490 enum nl80211_band band) 4491 { 4492 struct ath11k *ar = arvif->ar; 4493 u8 ht_rate, nss = 0; 4494 u32 rate_code; 4495 int ret, i; 4496 4497 lockdep_assert_held(&ar->conf_mutex); 4498 4499 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 4500 if (hweight8(mask->control[band].ht_mcs[i]) == 1) { 4501 nss = i + 1; 4502 ht_rate = ffs(mask->control[band].ht_mcs[i]) - 1; 4503 } 4504 } 4505 4506 if (!nss) { 4507 ath11k_warn(ar->ab, "No single HT Fixed rate found to set for %pM", 4508 sta->addr); 4509 return -EINVAL; 4510 } 4511 4512 /* Avoid updating invalid nss as fixed rate*/ 4513 if (nss > sta->deflink.rx_nss) 4514 return -EINVAL; 4515 4516 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4517 "Setting Fixed HT Rate for peer %pM. Device will not switch to any other selected rates", 4518 sta->addr); 4519 4520 rate_code = ATH11K_HW_RATE_CODE(ht_rate, nss - 1, 4521 WMI_RATE_PREAMBLE_HT); 4522 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4523 arvif->vdev_id, 4524 WMI_PEER_PARAM_FIXED_RATE, 4525 rate_code); 4526 if (ret) 4527 ath11k_warn(ar->ab, 4528 "failed to update STA %pM HT Fixed Rate %d: %d\n", 4529 sta->addr, rate_code, ret); 4530 4531 return ret; 4532 } 4533 4534 static int ath11k_station_assoc(struct ath11k *ar, 4535 struct ieee80211_vif *vif, 4536 struct ieee80211_sta *sta, 4537 bool reassoc) 4538 { 4539 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4540 struct peer_assoc_params peer_arg; 4541 int ret = 0; 4542 struct cfg80211_chan_def def; 4543 enum nl80211_band band; 4544 struct cfg80211_bitrate_mask *mask; 4545 u8 num_ht_rates, num_vht_rates, num_he_rates; 4546 4547 lockdep_assert_held(&ar->conf_mutex); 4548 4549 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 4550 return -EPERM; 4551 4552 band = def.chan->band; 4553 mask = &arvif->bitrate_mask; 4554 4555 ath11k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc); 4556 4557 peer_arg.is_assoc = true; 4558 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4559 if (ret) { 4560 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 4561 sta->addr, arvif->vdev_id, ret); 4562 return ret; 4563 } 4564 4565 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 4566 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4567 sta->addr, arvif->vdev_id); 4568 return -ETIMEDOUT; 4569 } 4570 4571 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask); 4572 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask); 4573 num_ht_rates = ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask); 4574 4575 /* If single VHT/HE rate is configured (by set_bitrate_mask()), 4576 * peer_assoc will disable VHT/HE. This is now enabled by a peer specific 4577 * fixed param. 4578 * Note that all other rates and NSS will be disabled for this peer. 4579 */ 4580 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) { 4581 ret = ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 4582 band); 4583 if (ret) 4584 return ret; 4585 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) { 4586 ret = ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask, 4587 band); 4588 if (ret) 4589 return ret; 4590 } else if (sta->deflink.ht_cap.ht_supported && num_ht_rates == 1) { 4591 ret = ath11k_mac_set_peer_ht_fixed_rate(arvif, sta, mask, 4592 band); 4593 if (ret) 4594 return ret; 4595 } 4596 4597 /* Re-assoc is run only to update supported rates for given station. It 4598 * doesn't make much sense to reconfigure the peer completely. 4599 */ 4600 if (reassoc) 4601 return 0; 4602 4603 ret = ath11k_setup_peer_smps(ar, arvif, sta->addr, 4604 &sta->deflink.ht_cap, 4605 le16_to_cpu(sta->deflink.he_6ghz_capa.capa)); 4606 if (ret) { 4607 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n", 4608 arvif->vdev_id, ret); 4609 return ret; 4610 } 4611 4612 if (!sta->wme) { 4613 arvif->num_legacy_stations++; 4614 ret = ath11k_recalc_rtscts_prot(arvif); 4615 if (ret) 4616 return ret; 4617 } 4618 4619 if (sta->wme && sta->uapsd_queues) { 4620 ret = ath11k_peer_assoc_qos_ap(ar, arvif, sta); 4621 if (ret) { 4622 ath11k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n", 4623 sta->addr, arvif->vdev_id, ret); 4624 return ret; 4625 } 4626 } 4627 4628 return 0; 4629 } 4630 4631 static int ath11k_station_disassoc(struct ath11k *ar, 4632 struct ieee80211_vif *vif, 4633 struct ieee80211_sta *sta) 4634 { 4635 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4636 int ret = 0; 4637 4638 lockdep_assert_held(&ar->conf_mutex); 4639 4640 if (!sta->wme) { 4641 arvif->num_legacy_stations--; 4642 ret = ath11k_recalc_rtscts_prot(arvif); 4643 if (ret) 4644 return ret; 4645 } 4646 4647 ret = ath11k_clear_peer_keys(arvif, sta->addr); 4648 if (ret) { 4649 ath11k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n", 4650 arvif->vdev_id, ret); 4651 return ret; 4652 } 4653 return 0; 4654 } 4655 4656 static void ath11k_sta_rc_update_wk(struct work_struct *wk) 4657 { 4658 struct ath11k *ar; 4659 struct ath11k_vif *arvif; 4660 struct ath11k_sta *arsta; 4661 struct ieee80211_sta *sta; 4662 struct cfg80211_chan_def def; 4663 enum nl80211_band band; 4664 const u8 *ht_mcs_mask; 4665 const u16 *vht_mcs_mask; 4666 const u16 *he_mcs_mask; 4667 u32 changed, bw, nss, smps, bw_prev; 4668 int err, num_ht_rates, num_vht_rates, num_he_rates; 4669 const struct cfg80211_bitrate_mask *mask; 4670 struct peer_assoc_params peer_arg; 4671 enum wmi_phy_mode peer_phymode; 4672 4673 arsta = container_of(wk, struct ath11k_sta, update_wk); 4674 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 4675 arvif = arsta->arvif; 4676 ar = arvif->ar; 4677 4678 if (WARN_ON(ath11k_mac_vif_chan(arvif->vif, &def))) 4679 return; 4680 4681 band = def.chan->band; 4682 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 4683 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 4684 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs; 4685 4686 spin_lock_bh(&ar->data_lock); 4687 4688 changed = arsta->changed; 4689 arsta->changed = 0; 4690 4691 bw = arsta->bw; 4692 bw_prev = arsta->bw_prev; 4693 nss = arsta->nss; 4694 smps = arsta->smps; 4695 4696 spin_unlock_bh(&ar->data_lock); 4697 4698 mutex_lock(&ar->conf_mutex); 4699 4700 nss = max_t(u32, 1, nss); 4701 nss = min(nss, max(max(ath11k_mac_max_ht_nss(ht_mcs_mask), 4702 ath11k_mac_max_vht_nss(vht_mcs_mask)), 4703 ath11k_mac_max_he_nss(he_mcs_mask))); 4704 4705 if (changed & IEEE80211_RC_BW_CHANGED) { 4706 /* Get the peer phymode */ 4707 ath11k_peer_assoc_h_phymode(ar, arvif->vif, sta, &peer_arg); 4708 peer_phymode = peer_arg.peer_phymode; 4709 4710 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM peer bw %d phymode %d\n", 4711 sta->addr, bw, peer_phymode); 4712 4713 if (bw > bw_prev) { 4714 /* BW is upgraded. In this case we send WMI_PEER_PHYMODE 4715 * followed by WMI_PEER_CHWIDTH 4716 */ 4717 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "BW upgrade for sta %pM new BW %d, old BW %d\n", 4718 sta->addr, bw, bw_prev); 4719 4720 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4721 WMI_PEER_PHYMODE, peer_phymode); 4722 4723 if (err) { 4724 ath11k_warn(ar->ab, "failed to update STA %pM peer phymode %d: %d\n", 4725 sta->addr, peer_phymode, err); 4726 goto err_rc_bw_changed; 4727 } 4728 4729 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4730 WMI_PEER_CHWIDTH, bw); 4731 4732 if (err) 4733 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n", 4734 sta->addr, bw, err); 4735 } else { 4736 /* BW is downgraded. In this case we send WMI_PEER_CHWIDTH 4737 * followed by WMI_PEER_PHYMODE 4738 */ 4739 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "BW downgrade for sta %pM new BW %d,old BW %d\n", 4740 sta->addr, bw, bw_prev); 4741 4742 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4743 WMI_PEER_CHWIDTH, bw); 4744 4745 if (err) { 4746 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n", 4747 sta->addr, bw, err); 4748 goto err_rc_bw_changed; 4749 } 4750 4751 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4752 WMI_PEER_PHYMODE, peer_phymode); 4753 4754 if (err) 4755 ath11k_warn(ar->ab, "failed to update STA %pM peer phymode %d: %d\n", 4756 sta->addr, peer_phymode, err); 4757 } 4758 } 4759 4760 if (changed & IEEE80211_RC_NSS_CHANGED) { 4761 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM nss %d\n", 4762 sta->addr, nss); 4763 4764 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4765 WMI_PEER_NSS, nss); 4766 if (err) 4767 ath11k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n", 4768 sta->addr, nss, err); 4769 } 4770 4771 if (changed & IEEE80211_RC_SMPS_CHANGED) { 4772 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM smps %d\n", 4773 sta->addr, smps); 4774 4775 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4776 WMI_PEER_MIMO_PS_STATE, smps); 4777 if (err) 4778 ath11k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n", 4779 sta->addr, smps, err); 4780 } 4781 4782 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) { 4783 mask = &arvif->bitrate_mask; 4784 num_ht_rates = ath11k_mac_bitrate_mask_num_ht_rates(ar, band, 4785 mask); 4786 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, 4787 mask); 4788 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, 4789 mask); 4790 4791 /* Peer_assoc_prepare will reject vht rates in 4792 * bitrate_mask if its not available in range format and 4793 * sets vht tx_rateset as unsupported. So multiple VHT MCS 4794 * setting(eg. MCS 4,5,6) per peer is not supported here. 4795 * But, Single rate in VHT mask can be set as per-peer 4796 * fixed rate. But even if any HT rates are configured in 4797 * the bitrate mask, device will not switch to those rates 4798 * when per-peer Fixed rate is set. 4799 * TODO: Check RATEMASK_CMDID to support auto rates selection 4800 * across HT/VHT and for multiple VHT MCS support. 4801 */ 4802 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) { 4803 ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 4804 band); 4805 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) { 4806 ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask, 4807 band); 4808 } else if (sta->deflink.ht_cap.ht_supported && num_ht_rates == 1) { 4809 ath11k_mac_set_peer_ht_fixed_rate(arvif, sta, mask, 4810 band); 4811 } else { 4812 /* If the peer is non-VHT/HE or no fixed VHT/HE rate 4813 * is provided in the new bitrate mask we set the 4814 * other rates using peer_assoc command. Also clear 4815 * the peer fixed rate settings as it has higher proprity 4816 * than peer assoc 4817 */ 4818 err = ath11k_wmi_set_peer_param(ar, sta->addr, 4819 arvif->vdev_id, 4820 WMI_PEER_PARAM_FIXED_RATE, 4821 WMI_FIXED_RATE_NONE); 4822 if (err) 4823 ath11k_warn(ar->ab, 4824 "failed to disable peer fixed rate for sta %pM: %d\n", 4825 sta->addr, err); 4826 4827 ath11k_peer_assoc_prepare(ar, arvif->vif, sta, 4828 &peer_arg, true); 4829 4830 peer_arg.is_assoc = false; 4831 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4832 if (err) 4833 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 4834 sta->addr, arvif->vdev_id, err); 4835 4836 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) 4837 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4838 sta->addr, arvif->vdev_id); 4839 } 4840 } 4841 4842 err_rc_bw_changed: 4843 mutex_unlock(&ar->conf_mutex); 4844 } 4845 4846 static void ath11k_sta_set_4addr_wk(struct work_struct *wk) 4847 { 4848 struct ath11k *ar; 4849 struct ath11k_vif *arvif; 4850 struct ath11k_sta *arsta; 4851 struct ieee80211_sta *sta; 4852 int ret = 0; 4853 4854 arsta = container_of(wk, struct ath11k_sta, set_4addr_wk); 4855 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 4856 arvif = arsta->arvif; 4857 ar = arvif->ar; 4858 4859 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4860 "setting USE_4ADDR for peer %pM\n", sta->addr); 4861 4862 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4863 arvif->vdev_id, 4864 WMI_PEER_USE_4ADDR, 1); 4865 4866 if (ret) 4867 ath11k_warn(ar->ab, "failed to set peer %pM 4addr capability: %d\n", 4868 sta->addr, ret); 4869 } 4870 4871 static int ath11k_mac_inc_num_stations(struct ath11k_vif *arvif, 4872 struct ieee80211_sta *sta) 4873 { 4874 struct ath11k *ar = arvif->ar; 4875 4876 lockdep_assert_held(&ar->conf_mutex); 4877 4878 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 4879 return 0; 4880 4881 if (ar->num_stations >= ar->max_num_stations) 4882 return -ENOBUFS; 4883 4884 ar->num_stations++; 4885 4886 return 0; 4887 } 4888 4889 static void ath11k_mac_dec_num_stations(struct ath11k_vif *arvif, 4890 struct ieee80211_sta *sta) 4891 { 4892 struct ath11k *ar = arvif->ar; 4893 4894 lockdep_assert_held(&ar->conf_mutex); 4895 4896 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 4897 return; 4898 4899 ar->num_stations--; 4900 } 4901 4902 static int ath11k_mac_station_add(struct ath11k *ar, 4903 struct ieee80211_vif *vif, 4904 struct ieee80211_sta *sta) 4905 { 4906 struct ath11k_base *ab = ar->ab; 4907 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4908 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 4909 struct peer_create_params peer_param; 4910 int ret; 4911 4912 lockdep_assert_held(&ar->conf_mutex); 4913 4914 ret = ath11k_mac_inc_num_stations(arvif, sta); 4915 if (ret) { 4916 ath11k_warn(ab, "refusing to associate station: too many connected already (%d)\n", 4917 ar->max_num_stations); 4918 goto exit; 4919 } 4920 4921 arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL); 4922 if (!arsta->rx_stats) { 4923 ret = -ENOMEM; 4924 goto dec_num_station; 4925 } 4926 4927 peer_param.vdev_id = arvif->vdev_id; 4928 peer_param.peer_addr = sta->addr; 4929 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 4930 4931 ret = ath11k_peer_create(ar, arvif, sta, &peer_param); 4932 if (ret) { 4933 ath11k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n", 4934 sta->addr, arvif->vdev_id); 4935 goto free_rx_stats; 4936 } 4937 4938 ath11k_dbg(ab, ATH11K_DBG_MAC, "Added peer: %pM for VDEV: %d\n", 4939 sta->addr, arvif->vdev_id); 4940 4941 if (ath11k_debugfs_is_extd_tx_stats_enabled(ar)) { 4942 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), GFP_KERNEL); 4943 if (!arsta->tx_stats) { 4944 ret = -ENOMEM; 4945 goto free_peer; 4946 } 4947 } 4948 4949 if (ieee80211_vif_is_mesh(vif)) { 4950 ath11k_dbg(ab, ATH11K_DBG_MAC, 4951 "setting USE_4ADDR for mesh STA %pM\n", sta->addr); 4952 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4953 arvif->vdev_id, 4954 WMI_PEER_USE_4ADDR, 1); 4955 if (ret) { 4956 ath11k_warn(ab, "failed to set mesh STA %pM 4addr capability: %d\n", 4957 sta->addr, ret); 4958 goto free_tx_stats; 4959 } 4960 } 4961 4962 ret = ath11k_dp_peer_setup(ar, arvif->vdev_id, sta->addr); 4963 if (ret) { 4964 ath11k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n", 4965 sta->addr, arvif->vdev_id, ret); 4966 goto free_tx_stats; 4967 } 4968 4969 if (ab->hw_params.vdev_start_delay && 4970 !arvif->is_started && 4971 arvif->vdev_type != WMI_VDEV_TYPE_AP) { 4972 ret = ath11k_start_vdev_delay(ar->hw, vif); 4973 if (ret) { 4974 ath11k_warn(ab, "failed to delay vdev start: %d\n", ret); 4975 goto free_tx_stats; 4976 } 4977 } 4978 4979 ewma_avg_rssi_init(&arsta->avg_rssi); 4980 return 0; 4981 4982 free_tx_stats: 4983 kfree(arsta->tx_stats); 4984 arsta->tx_stats = NULL; 4985 free_peer: 4986 ath11k_peer_delete(ar, arvif->vdev_id, sta->addr); 4987 free_rx_stats: 4988 kfree(arsta->rx_stats); 4989 arsta->rx_stats = NULL; 4990 dec_num_station: 4991 ath11k_mac_dec_num_stations(arvif, sta); 4992 exit: 4993 return ret; 4994 } 4995 4996 static u32 ath11k_mac_ieee80211_sta_bw_to_wmi(struct ath11k *ar, 4997 struct ieee80211_sta *sta) 4998 { 4999 u32 bw = WMI_PEER_CHWIDTH_20MHZ; 5000 5001 switch (sta->deflink.bandwidth) { 5002 case IEEE80211_STA_RX_BW_20: 5003 bw = WMI_PEER_CHWIDTH_20MHZ; 5004 break; 5005 case IEEE80211_STA_RX_BW_40: 5006 bw = WMI_PEER_CHWIDTH_40MHZ; 5007 break; 5008 case IEEE80211_STA_RX_BW_80: 5009 bw = WMI_PEER_CHWIDTH_80MHZ; 5010 break; 5011 case IEEE80211_STA_RX_BW_160: 5012 bw = WMI_PEER_CHWIDTH_160MHZ; 5013 break; 5014 default: 5015 ath11k_warn(ar->ab, "Invalid bandwidth %d for %pM\n", 5016 sta->deflink.bandwidth, sta->addr); 5017 bw = WMI_PEER_CHWIDTH_20MHZ; 5018 break; 5019 } 5020 5021 return bw; 5022 } 5023 5024 static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw, 5025 struct ieee80211_vif *vif, 5026 struct ieee80211_sta *sta, 5027 enum ieee80211_sta_state old_state, 5028 enum ieee80211_sta_state new_state) 5029 { 5030 struct ath11k *ar = hw->priv; 5031 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 5032 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 5033 struct ath11k_peer *peer; 5034 int ret = 0; 5035 5036 /* cancel must be done outside the mutex to avoid deadlock */ 5037 if ((old_state == IEEE80211_STA_NONE && 5038 new_state == IEEE80211_STA_NOTEXIST)) { 5039 cancel_work_sync(&arsta->update_wk); 5040 cancel_work_sync(&arsta->set_4addr_wk); 5041 } 5042 5043 mutex_lock(&ar->conf_mutex); 5044 5045 if (old_state == IEEE80211_STA_NOTEXIST && 5046 new_state == IEEE80211_STA_NONE) { 5047 memset(arsta, 0, sizeof(*arsta)); 5048 arsta->arvif = arvif; 5049 arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED; 5050 INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk); 5051 INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk); 5052 5053 ret = ath11k_mac_station_add(ar, vif, sta); 5054 if (ret) 5055 ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n", 5056 sta->addr, arvif->vdev_id); 5057 } else if ((old_state == IEEE80211_STA_NONE && 5058 new_state == IEEE80211_STA_NOTEXIST)) { 5059 bool skip_peer_delete = ar->ab->hw_params.vdev_start_delay && 5060 vif->type == NL80211_IFTYPE_STATION; 5061 5062 ath11k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr); 5063 5064 if (!skip_peer_delete) { 5065 ret = ath11k_peer_delete(ar, arvif->vdev_id, sta->addr); 5066 if (ret) 5067 ath11k_warn(ar->ab, 5068 "Failed to delete peer: %pM for VDEV: %d\n", 5069 sta->addr, arvif->vdev_id); 5070 else 5071 ath11k_dbg(ar->ab, 5072 ATH11K_DBG_MAC, 5073 "Removed peer: %pM for VDEV: %d\n", 5074 sta->addr, arvif->vdev_id); 5075 } 5076 5077 ath11k_mac_dec_num_stations(arvif, sta); 5078 mutex_lock(&ar->ab->tbl_mtx_lock); 5079 spin_lock_bh(&ar->ab->base_lock); 5080 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 5081 if (skip_peer_delete && peer) { 5082 peer->sta = NULL; 5083 } else if (peer && peer->sta == sta) { 5084 ath11k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n", 5085 vif->addr, arvif->vdev_id); 5086 ath11k_peer_rhash_delete(ar->ab, peer); 5087 peer->sta = NULL; 5088 list_del(&peer->list); 5089 kfree(peer); 5090 ar->num_peers--; 5091 } 5092 spin_unlock_bh(&ar->ab->base_lock); 5093 mutex_unlock(&ar->ab->tbl_mtx_lock); 5094 5095 kfree(arsta->tx_stats); 5096 arsta->tx_stats = NULL; 5097 5098 kfree(arsta->rx_stats); 5099 arsta->rx_stats = NULL; 5100 } else if (old_state == IEEE80211_STA_AUTH && 5101 new_state == IEEE80211_STA_ASSOC && 5102 (vif->type == NL80211_IFTYPE_AP || 5103 vif->type == NL80211_IFTYPE_MESH_POINT || 5104 vif->type == NL80211_IFTYPE_ADHOC)) { 5105 ret = ath11k_station_assoc(ar, vif, sta, false); 5106 if (ret) 5107 ath11k_warn(ar->ab, "Failed to associate station: %pM\n", 5108 sta->addr); 5109 5110 spin_lock_bh(&ar->data_lock); 5111 /* Set arsta bw and prev bw */ 5112 arsta->bw = ath11k_mac_ieee80211_sta_bw_to_wmi(ar, sta); 5113 arsta->bw_prev = arsta->bw; 5114 spin_unlock_bh(&ar->data_lock); 5115 } else if (old_state == IEEE80211_STA_ASSOC && 5116 new_state == IEEE80211_STA_AUTHORIZED) { 5117 spin_lock_bh(&ar->ab->base_lock); 5118 5119 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 5120 if (peer) 5121 peer->is_authorized = true; 5122 5123 spin_unlock_bh(&ar->ab->base_lock); 5124 5125 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) { 5126 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 5127 arvif->vdev_id, 5128 WMI_PEER_AUTHORIZE, 5129 1); 5130 if (ret) 5131 ath11k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n", 5132 sta->addr, arvif->vdev_id, ret); 5133 } 5134 } else if (old_state == IEEE80211_STA_AUTHORIZED && 5135 new_state == IEEE80211_STA_ASSOC) { 5136 spin_lock_bh(&ar->ab->base_lock); 5137 5138 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 5139 if (peer) 5140 peer->is_authorized = false; 5141 5142 spin_unlock_bh(&ar->ab->base_lock); 5143 } else if (old_state == IEEE80211_STA_ASSOC && 5144 new_state == IEEE80211_STA_AUTH && 5145 (vif->type == NL80211_IFTYPE_AP || 5146 vif->type == NL80211_IFTYPE_MESH_POINT || 5147 vif->type == NL80211_IFTYPE_ADHOC)) { 5148 ret = ath11k_station_disassoc(ar, vif, sta); 5149 if (ret) 5150 ath11k_warn(ar->ab, "Failed to disassociate station: %pM\n", 5151 sta->addr); 5152 } 5153 5154 mutex_unlock(&ar->conf_mutex); 5155 return ret; 5156 } 5157 5158 static int ath11k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw, 5159 struct ieee80211_vif *vif, 5160 struct ieee80211_sta *sta) 5161 { 5162 struct ath11k *ar = hw->priv; 5163 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 5164 int ret = 0; 5165 s16 txpwr; 5166 5167 if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) { 5168 txpwr = 0; 5169 } else { 5170 txpwr = sta->deflink.txpwr.power; 5171 if (!txpwr) 5172 return -EINVAL; 5173 } 5174 5175 if (txpwr > ATH11K_TX_POWER_MAX_VAL || txpwr < ATH11K_TX_POWER_MIN_VAL) 5176 return -EINVAL; 5177 5178 mutex_lock(&ar->conf_mutex); 5179 5180 ret = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 5181 WMI_PEER_USE_FIXED_PWR, txpwr); 5182 if (ret) { 5183 ath11k_warn(ar->ab, "failed to set tx power for station ret: %d\n", 5184 ret); 5185 goto out; 5186 } 5187 5188 out: 5189 mutex_unlock(&ar->conf_mutex); 5190 return ret; 5191 } 5192 5193 static void ath11k_mac_op_sta_set_4addr(struct ieee80211_hw *hw, 5194 struct ieee80211_vif *vif, 5195 struct ieee80211_sta *sta, bool enabled) 5196 { 5197 struct ath11k *ar = hw->priv; 5198 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 5199 5200 if (enabled && !arsta->use_4addr_set) { 5201 ieee80211_queue_work(ar->hw, &arsta->set_4addr_wk); 5202 arsta->use_4addr_set = true; 5203 } 5204 } 5205 5206 static void ath11k_mac_op_sta_rc_update(struct ieee80211_hw *hw, 5207 struct ieee80211_vif *vif, 5208 struct ieee80211_sta *sta, 5209 u32 changed) 5210 { 5211 struct ath11k *ar = hw->priv; 5212 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 5213 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 5214 struct ath11k_peer *peer; 5215 u32 bw, smps; 5216 5217 spin_lock_bh(&ar->ab->base_lock); 5218 5219 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 5220 if (!peer) { 5221 spin_unlock_bh(&ar->ab->base_lock); 5222 ath11k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n", 5223 sta->addr, arvif->vdev_id); 5224 return; 5225 } 5226 5227 spin_unlock_bh(&ar->ab->base_lock); 5228 5229 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 5230 "sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 5231 sta->addr, changed, sta->deflink.bandwidth, 5232 sta->deflink.rx_nss, 5233 sta->deflink.smps_mode); 5234 5235 spin_lock_bh(&ar->data_lock); 5236 5237 if (changed & IEEE80211_RC_BW_CHANGED) { 5238 bw = ath11k_mac_ieee80211_sta_bw_to_wmi(ar, sta); 5239 arsta->bw_prev = arsta->bw; 5240 arsta->bw = bw; 5241 } 5242 5243 if (changed & IEEE80211_RC_NSS_CHANGED) 5244 arsta->nss = sta->deflink.rx_nss; 5245 5246 if (changed & IEEE80211_RC_SMPS_CHANGED) { 5247 smps = WMI_PEER_SMPS_PS_NONE; 5248 5249 switch (sta->deflink.smps_mode) { 5250 case IEEE80211_SMPS_AUTOMATIC: 5251 case IEEE80211_SMPS_OFF: 5252 smps = WMI_PEER_SMPS_PS_NONE; 5253 break; 5254 case IEEE80211_SMPS_STATIC: 5255 smps = WMI_PEER_SMPS_STATIC; 5256 break; 5257 case IEEE80211_SMPS_DYNAMIC: 5258 smps = WMI_PEER_SMPS_DYNAMIC; 5259 break; 5260 default: 5261 ath11k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n", 5262 sta->deflink.smps_mode, sta->addr); 5263 smps = WMI_PEER_SMPS_PS_NONE; 5264 break; 5265 } 5266 5267 arsta->smps = smps; 5268 } 5269 5270 arsta->changed |= changed; 5271 5272 spin_unlock_bh(&ar->data_lock); 5273 5274 ieee80211_queue_work(hw, &arsta->update_wk); 5275 } 5276 5277 static int ath11k_conf_tx_uapsd(struct ath11k *ar, struct ieee80211_vif *vif, 5278 u16 ac, bool enable) 5279 { 5280 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 5281 u32 value = 0; 5282 int ret = 0; 5283 5284 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 5285 return 0; 5286 5287 switch (ac) { 5288 case IEEE80211_AC_VO: 5289 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 5290 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 5291 break; 5292 case IEEE80211_AC_VI: 5293 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 5294 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 5295 break; 5296 case IEEE80211_AC_BE: 5297 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 5298 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 5299 break; 5300 case IEEE80211_AC_BK: 5301 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 5302 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 5303 break; 5304 } 5305 5306 if (enable) 5307 arvif->u.sta.uapsd |= value; 5308 else 5309 arvif->u.sta.uapsd &= ~value; 5310 5311 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5312 WMI_STA_PS_PARAM_UAPSD, 5313 arvif->u.sta.uapsd); 5314 if (ret) { 5315 ath11k_warn(ar->ab, "could not set uapsd params %d\n", ret); 5316 goto exit; 5317 } 5318 5319 if (arvif->u.sta.uapsd) 5320 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 5321 else 5322 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 5323 5324 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5325 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 5326 value); 5327 if (ret) 5328 ath11k_warn(ar->ab, "could not set rx wake param %d\n", ret); 5329 5330 exit: 5331 return ret; 5332 } 5333 5334 static int ath11k_mac_op_conf_tx(struct ieee80211_hw *hw, 5335 struct ieee80211_vif *vif, 5336 unsigned int link_id, u16 ac, 5337 const struct ieee80211_tx_queue_params *params) 5338 { 5339 struct ath11k *ar = hw->priv; 5340 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 5341 struct wmi_wmm_params_arg *p = NULL; 5342 int ret; 5343 5344 mutex_lock(&ar->conf_mutex); 5345 5346 switch (ac) { 5347 case IEEE80211_AC_VO: 5348 p = &arvif->wmm_params.ac_vo; 5349 break; 5350 case IEEE80211_AC_VI: 5351 p = &arvif->wmm_params.ac_vi; 5352 break; 5353 case IEEE80211_AC_BE: 5354 p = &arvif->wmm_params.ac_be; 5355 break; 5356 case IEEE80211_AC_BK: 5357 p = &arvif->wmm_params.ac_bk; 5358 break; 5359 } 5360 5361 if (WARN_ON(!p)) { 5362 ret = -EINVAL; 5363 goto exit; 5364 } 5365 5366 p->cwmin = params->cw_min; 5367 p->cwmax = params->cw_max; 5368 p->aifs = params->aifs; 5369 p->txop = params->txop; 5370 5371 ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id, 5372 &arvif->wmm_params); 5373 if (ret) { 5374 ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret); 5375 goto exit; 5376 } 5377 5378 ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 5379 5380 if (ret) 5381 ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret); 5382 5383 exit: 5384 mutex_unlock(&ar->conf_mutex); 5385 return ret; 5386 } 5387 5388 static struct ieee80211_sta_ht_cap 5389 ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask) 5390 { 5391 int i; 5392 struct ieee80211_sta_ht_cap ht_cap = {0}; 5393 u32 ar_vht_cap = ar->pdev->cap.vht_cap; 5394 5395 if (!(ar_ht_cap & WMI_HT_CAP_ENABLED)) 5396 return ht_cap; 5397 5398 ht_cap.ht_supported = 1; 5399 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 5400 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE; 5401 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 5402 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 5403 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT; 5404 5405 if (ar_ht_cap & WMI_HT_CAP_HT20_SGI) 5406 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 5407 5408 if (ar_ht_cap & WMI_HT_CAP_HT40_SGI) 5409 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 5410 5411 if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) { 5412 u32 smps; 5413 5414 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 5415 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 5416 5417 ht_cap.cap |= smps; 5418 } 5419 5420 if (ar_ht_cap & WMI_HT_CAP_TX_STBC) 5421 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 5422 5423 if (ar_ht_cap & WMI_HT_CAP_RX_STBC) { 5424 u32 stbc; 5425 5426 stbc = ar_ht_cap; 5427 stbc &= WMI_HT_CAP_RX_STBC; 5428 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 5429 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 5430 stbc &= IEEE80211_HT_CAP_RX_STBC; 5431 5432 ht_cap.cap |= stbc; 5433 } 5434 5435 if (ar_ht_cap & WMI_HT_CAP_RX_LDPC) 5436 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 5437 5438 if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT) 5439 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 5440 5441 if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 5442 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 5443 5444 for (i = 0; i < ar->num_rx_chains; i++) { 5445 if (rate_cap_rx_chainmask & BIT(i)) 5446 ht_cap.mcs.rx_mask[i] = 0xFF; 5447 } 5448 5449 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 5450 5451 return ht_cap; 5452 } 5453 5454 static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif) 5455 { 5456 u32 value = 0; 5457 struct ath11k *ar = arvif->ar; 5458 int nsts; 5459 int sound_dim; 5460 u32 vht_cap = ar->pdev->cap.vht_cap; 5461 u32 vdev_param = WMI_VDEV_PARAM_TXBF; 5462 5463 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) { 5464 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 5465 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 5466 if (nsts > (ar->num_rx_chains - 1)) 5467 nsts = ar->num_rx_chains - 1; 5468 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET); 5469 } 5470 5471 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) { 5472 sound_dim = vht_cap & 5473 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 5474 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 5475 if (sound_dim > (ar->num_tx_chains - 1)) 5476 sound_dim = ar->num_tx_chains - 1; 5477 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET); 5478 } 5479 5480 if (!value) 5481 return 0; 5482 5483 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) { 5484 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 5485 5486 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) && 5487 arvif->vdev_type == WMI_VDEV_TYPE_AP) 5488 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER; 5489 } 5490 5491 /* TODO: SUBFEE not validated in HK, disable here until validated? */ 5492 5493 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) { 5494 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 5495 5496 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) && 5497 arvif->vdev_type == WMI_VDEV_TYPE_STA) 5498 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE; 5499 } 5500 5501 return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5502 vdev_param, value); 5503 } 5504 5505 static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap) 5506 { 5507 bool subfer, subfee; 5508 int sound_dim = 0, nsts = 0; 5509 5510 subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)); 5511 subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)); 5512 5513 if (ar->num_tx_chains < 2) { 5514 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE); 5515 subfer = false; 5516 } 5517 5518 if (ar->num_rx_chains < 2) { 5519 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE); 5520 subfee = false; 5521 } 5522 5523 /* If SU Beaformer is not set, then disable MU Beamformer Capability */ 5524 if (!subfer) 5525 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE); 5526 5527 /* If SU Beaformee is not set, then disable MU Beamformee Capability */ 5528 if (!subfee) 5529 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE); 5530 5531 sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK); 5532 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 5533 *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 5534 5535 nsts = (*vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK); 5536 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 5537 *vht_cap &= ~IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 5538 5539 /* Enable Sounding Dimension Field only if SU BF is enabled */ 5540 if (subfer) { 5541 if (sound_dim > (ar->num_tx_chains - 1)) 5542 sound_dim = ar->num_tx_chains - 1; 5543 5544 sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 5545 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 5546 *vht_cap |= sound_dim; 5547 } 5548 5549 /* Enable Beamformee STS Field only if SU BF is enabled */ 5550 if (subfee) { 5551 if (nsts > (ar->num_rx_chains - 1)) 5552 nsts = ar->num_rx_chains - 1; 5553 5554 nsts <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 5555 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 5556 *vht_cap |= nsts; 5557 } 5558 } 5559 5560 static struct ieee80211_sta_vht_cap 5561 ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask, 5562 u32 rate_cap_rx_chainmask) 5563 { 5564 struct ieee80211_sta_vht_cap vht_cap = {0}; 5565 u16 txmcs_map, rxmcs_map; 5566 int i; 5567 5568 vht_cap.vht_supported = 1; 5569 vht_cap.cap = ar->pdev->cap.vht_cap; 5570 5571 if (ar->pdev->cap.nss_ratio_enabled) 5572 vht_cap.vht_mcs.tx_highest |= 5573 cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE); 5574 5575 ath11k_set_vht_txbf_cap(ar, &vht_cap.cap); 5576 5577 rxmcs_map = 0; 5578 txmcs_map = 0; 5579 for (i = 0; i < 8; i++) { 5580 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i)) 5581 txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 5582 else 5583 txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 5584 5585 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i)) 5586 rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 5587 else 5588 rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 5589 } 5590 5591 if (rate_cap_tx_chainmask <= 1) 5592 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC; 5593 5594 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map); 5595 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map); 5596 5597 return vht_cap; 5598 } 5599 5600 static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar, 5601 struct ath11k_pdev_cap *cap, 5602 u32 *ht_cap_info) 5603 { 5604 struct ieee80211_supported_band *band; 5605 u32 rate_cap_tx_chainmask; 5606 u32 rate_cap_rx_chainmask; 5607 u32 ht_cap; 5608 5609 rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift; 5610 rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift; 5611 5612 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 5613 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 5614 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info; 5615 if (ht_cap_info) 5616 *ht_cap_info = ht_cap; 5617 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap, 5618 rate_cap_rx_chainmask); 5619 } 5620 5621 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 5622 (ar->ab->hw_params.single_pdev_only || 5623 !ar->supports_6ghz)) { 5624 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 5625 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info; 5626 if (ht_cap_info) 5627 *ht_cap_info = ht_cap; 5628 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap, 5629 rate_cap_rx_chainmask); 5630 band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask, 5631 rate_cap_rx_chainmask); 5632 } 5633 } 5634 5635 static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant) 5636 { 5637 /* TODO: Check the request chainmask against the supported 5638 * chainmask table which is advertised in extented_service_ready event 5639 */ 5640 5641 return 0; 5642 } 5643 5644 static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet, 5645 u8 *he_ppet) 5646 { 5647 int nss, ru; 5648 u8 bit = 7; 5649 5650 he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK; 5651 he_ppet[0] |= (fw_ppet->ru_bit_mask << 5652 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) & 5653 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK; 5654 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) { 5655 for (ru = 0; ru < 4; ru++) { 5656 u8 val; 5657 int i; 5658 5659 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0) 5660 continue; 5661 val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) & 5662 0x3f; 5663 val = ((val >> 3) & 0x7) | ((val & 0x7) << 3); 5664 for (i = 5; i >= 0; i--) { 5665 he_ppet[bit / 8] |= 5666 ((val >> i) & 0x1) << ((bit % 8)); 5667 bit++; 5668 } 5669 } 5670 } 5671 } 5672 5673 static void 5674 ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem) 5675 { 5676 u8 m; 5677 5678 m = IEEE80211_HE_MAC_CAP0_TWT_RES | 5679 IEEE80211_HE_MAC_CAP0_TWT_REQ; 5680 he_cap_elem->mac_cap_info[0] &= ~m; 5681 5682 m = IEEE80211_HE_MAC_CAP2_TRS | 5683 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 5684 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 5685 he_cap_elem->mac_cap_info[2] &= ~m; 5686 5687 m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED | 5688 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 5689 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 5690 he_cap_elem->mac_cap_info[3] &= ~m; 5691 5692 m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG | 5693 IEEE80211_HE_MAC_CAP4_BQR; 5694 he_cap_elem->mac_cap_info[4] &= ~m; 5695 5696 m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION | 5697 IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU | 5698 IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING | 5699 IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX; 5700 he_cap_elem->mac_cap_info[5] &= ~m; 5701 5702 m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO | 5703 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO; 5704 he_cap_elem->phy_cap_info[2] &= ~m; 5705 5706 m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU | 5707 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK | 5708 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK; 5709 he_cap_elem->phy_cap_info[3] &= ~m; 5710 5711 m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER; 5712 he_cap_elem->phy_cap_info[4] &= ~m; 5713 5714 m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK; 5715 he_cap_elem->phy_cap_info[5] &= ~m; 5716 5717 m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU | 5718 IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB | 5719 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB | 5720 IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO; 5721 he_cap_elem->phy_cap_info[6] &= ~m; 5722 5723 m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR | 5724 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP | 5725 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ | 5726 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ; 5727 he_cap_elem->phy_cap_info[7] &= ~m; 5728 5729 m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI | 5730 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G | 5731 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU | 5732 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU; 5733 he_cap_elem->phy_cap_info[8] &= ~m; 5734 5735 m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM | 5736 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK | 5737 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU | 5738 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU | 5739 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB | 5740 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB; 5741 he_cap_elem->phy_cap_info[9] &= ~m; 5742 } 5743 5744 static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap, 5745 struct ath11k_band_cap *bcap) 5746 { 5747 u8 val; 5748 5749 bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE; 5750 if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 5751 bcap->he_6ghz_capa |= 5752 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS, 5753 WLAN_HT_CAP_SM_PS_DYNAMIC); 5754 else 5755 bcap->he_6ghz_capa |= 5756 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS, 5757 WLAN_HT_CAP_SM_PS_DISABLED); 5758 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK, 5759 pcap->vht_cap); 5760 bcap->he_6ghz_capa |= 5761 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val); 5762 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap); 5763 bcap->he_6ghz_capa |= 5764 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val); 5765 if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN) 5766 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS; 5767 if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN) 5768 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS; 5769 5770 return cpu_to_le16(bcap->he_6ghz_capa); 5771 } 5772 5773 static void ath11k_mac_set_hemcsmap(struct ath11k *ar, 5774 struct ath11k_pdev_cap *cap, 5775 struct ieee80211_sta_he_cap *he_cap, 5776 int band) 5777 { 5778 u16 txmcs_map, rxmcs_map; 5779 u32 i; 5780 5781 rxmcs_map = 0; 5782 txmcs_map = 0; 5783 for (i = 0; i < 8; i++) { 5784 if (i < ar->num_tx_chains && 5785 (ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift) & BIT(i)) 5786 txmcs_map |= IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2); 5787 else 5788 txmcs_map |= IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2); 5789 5790 if (i < ar->num_rx_chains && 5791 (ar->cfg_rx_chainmask >> cap->tx_chain_mask_shift) & BIT(i)) 5792 rxmcs_map |= IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2); 5793 else 5794 rxmcs_map |= IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2); 5795 } 5796 he_cap->he_mcs_nss_supp.rx_mcs_80 = 5797 cpu_to_le16(rxmcs_map & 0xffff); 5798 he_cap->he_mcs_nss_supp.tx_mcs_80 = 5799 cpu_to_le16(txmcs_map & 0xffff); 5800 he_cap->he_mcs_nss_supp.rx_mcs_160 = 5801 cpu_to_le16(rxmcs_map & 0xffff); 5802 he_cap->he_mcs_nss_supp.tx_mcs_160 = 5803 cpu_to_le16(txmcs_map & 0xffff); 5804 he_cap->he_mcs_nss_supp.rx_mcs_80p80 = 5805 cpu_to_le16(rxmcs_map & 0xffff); 5806 he_cap->he_mcs_nss_supp.tx_mcs_80p80 = 5807 cpu_to_le16(txmcs_map & 0xffff); 5808 } 5809 5810 static int ath11k_mac_copy_he_cap(struct ath11k *ar, 5811 struct ath11k_pdev_cap *cap, 5812 struct ieee80211_sband_iftype_data *data, 5813 int band) 5814 { 5815 int i, idx = 0; 5816 5817 for (i = 0; i < NUM_NL80211_IFTYPES; i++) { 5818 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap; 5819 struct ath11k_band_cap *band_cap = &cap->band[band]; 5820 struct ieee80211_he_cap_elem *he_cap_elem = 5821 &he_cap->he_cap_elem; 5822 5823 switch (i) { 5824 case NL80211_IFTYPE_STATION: 5825 case NL80211_IFTYPE_AP: 5826 case NL80211_IFTYPE_MESH_POINT: 5827 break; 5828 5829 default: 5830 continue; 5831 } 5832 5833 data[idx].types_mask = BIT(i); 5834 he_cap->has_he = true; 5835 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info, 5836 sizeof(he_cap_elem->mac_cap_info)); 5837 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info, 5838 sizeof(he_cap_elem->phy_cap_info)); 5839 5840 he_cap_elem->mac_cap_info[1] &= 5841 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK; 5842 5843 he_cap_elem->phy_cap_info[5] &= 5844 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK; 5845 he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1; 5846 5847 switch (i) { 5848 case NL80211_IFTYPE_AP: 5849 he_cap_elem->phy_cap_info[3] &= 5850 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK; 5851 he_cap_elem->phy_cap_info[9] |= 5852 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU; 5853 break; 5854 case NL80211_IFTYPE_STATION: 5855 he_cap_elem->mac_cap_info[0] &= 5856 ~IEEE80211_HE_MAC_CAP0_TWT_RES; 5857 he_cap_elem->mac_cap_info[0] |= 5858 IEEE80211_HE_MAC_CAP0_TWT_REQ; 5859 he_cap_elem->phy_cap_info[9] |= 5860 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU; 5861 break; 5862 case NL80211_IFTYPE_MESH_POINT: 5863 ath11k_mac_filter_he_cap_mesh(he_cap_elem); 5864 break; 5865 } 5866 5867 ath11k_mac_set_hemcsmap(ar, cap, he_cap, band); 5868 5869 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres)); 5870 if (he_cap_elem->phy_cap_info[6] & 5871 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) 5872 ath11k_gen_ppe_thresh(&band_cap->he_ppet, 5873 he_cap->ppe_thres); 5874 5875 if (band == NL80211_BAND_6GHZ) { 5876 data[idx].he_6ghz_capa.capa = 5877 ath11k_mac_setup_he_6ghz_cap(cap, band_cap); 5878 } 5879 idx++; 5880 } 5881 5882 return idx; 5883 } 5884 5885 static void ath11k_mac_setup_he_cap(struct ath11k *ar, 5886 struct ath11k_pdev_cap *cap) 5887 { 5888 struct ieee80211_supported_band *band; 5889 int count; 5890 5891 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 5892 count = ath11k_mac_copy_he_cap(ar, cap, 5893 ar->mac.iftype[NL80211_BAND_2GHZ], 5894 NL80211_BAND_2GHZ); 5895 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 5896 _ieee80211_set_sband_iftype_data(band, 5897 ar->mac.iftype[NL80211_BAND_2GHZ], 5898 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 _ieee80211_set_sband_iftype_data(band, 5907 ar->mac.iftype[NL80211_BAND_5GHZ], 5908 count); 5909 } 5910 5911 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 5912 ar->supports_6ghz) { 5913 count = ath11k_mac_copy_he_cap(ar, cap, 5914 ar->mac.iftype[NL80211_BAND_6GHZ], 5915 NL80211_BAND_6GHZ); 5916 band = &ar->mac.sbands[NL80211_BAND_6GHZ]; 5917 _ieee80211_set_sband_iftype_data(band, 5918 ar->mac.iftype[NL80211_BAND_6GHZ], 5919 count); 5920 } 5921 } 5922 5923 static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant) 5924 { 5925 int ret; 5926 5927 lockdep_assert_held(&ar->conf_mutex); 5928 5929 if (ath11k_check_chain_mask(ar, tx_ant, true)) 5930 return -EINVAL; 5931 5932 if (ath11k_check_chain_mask(ar, rx_ant, false)) 5933 return -EINVAL; 5934 5935 ar->cfg_tx_chainmask = tx_ant; 5936 ar->cfg_rx_chainmask = rx_ant; 5937 5938 if (ar->state != ATH11K_STATE_ON && 5939 ar->state != ATH11K_STATE_RESTARTED) 5940 return 0; 5941 5942 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK, 5943 tx_ant, ar->pdev->pdev_id); 5944 if (ret) { 5945 ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n", 5946 ret, tx_ant); 5947 return ret; 5948 } 5949 5950 ar->num_tx_chains = get_num_chains(tx_ant); 5951 5952 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK, 5953 rx_ant, ar->pdev->pdev_id); 5954 if (ret) { 5955 ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n", 5956 ret, rx_ant); 5957 return ret; 5958 } 5959 5960 ar->num_rx_chains = get_num_chains(rx_ant); 5961 5962 /* Reload HT/VHT/HE capability */ 5963 ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL); 5964 ath11k_mac_setup_he_cap(ar, &ar->pdev->cap); 5965 5966 return 0; 5967 } 5968 5969 static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb) 5970 { 5971 int num_mgmt; 5972 5973 ieee80211_free_txskb(ar->hw, skb); 5974 5975 num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx); 5976 5977 if (num_mgmt < 0) 5978 WARN_ON_ONCE(1); 5979 5980 if (!num_mgmt) 5981 wake_up(&ar->txmgmt_empty_waitq); 5982 } 5983 5984 static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id) 5985 { 5986 struct sk_buff *msdu; 5987 struct ieee80211_tx_info *info; 5988 5989 spin_lock_bh(&ar->txmgmt_idr_lock); 5990 msdu = idr_remove(&ar->txmgmt_idr, buf_id); 5991 spin_unlock_bh(&ar->txmgmt_idr_lock); 5992 5993 if (!msdu) 5994 return; 5995 5996 dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len, 5997 DMA_TO_DEVICE); 5998 5999 info = IEEE80211_SKB_CB(msdu); 6000 memset(&info->status, 0, sizeof(info->status)); 6001 6002 ath11k_mgmt_over_wmi_tx_drop(ar, msdu); 6003 } 6004 6005 int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx) 6006 { 6007 struct ath11k *ar = ctx; 6008 6009 ath11k_mac_tx_mgmt_free(ar, buf_id); 6010 6011 return 0; 6012 } 6013 6014 static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx) 6015 { 6016 struct ieee80211_vif *vif = ctx; 6017 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb); 6018 struct ath11k *ar = skb_cb->ar; 6019 6020 if (skb_cb->vif == vif) 6021 ath11k_mac_tx_mgmt_free(ar, buf_id); 6022 6023 return 0; 6024 } 6025 6026 static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif, 6027 struct sk_buff *skb) 6028 { 6029 struct ath11k_base *ab = ar->ab; 6030 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 6031 struct ieee80211_tx_info *info; 6032 dma_addr_t paddr; 6033 int buf_id; 6034 int ret; 6035 6036 ATH11K_SKB_CB(skb)->ar = ar; 6037 6038 spin_lock_bh(&ar->txmgmt_idr_lock); 6039 buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0, 6040 ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC); 6041 spin_unlock_bh(&ar->txmgmt_idr_lock); 6042 6043 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 6044 "tx mgmt frame, buf id %d\n", buf_id); 6045 6046 if (buf_id < 0) 6047 return -ENOSPC; 6048 6049 info = IEEE80211_SKB_CB(skb); 6050 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) { 6051 if ((ieee80211_is_action(hdr->frame_control) || 6052 ieee80211_is_deauth(hdr->frame_control) || 6053 ieee80211_is_disassoc(hdr->frame_control)) && 6054 ieee80211_has_protected(hdr->frame_control)) { 6055 skb_put(skb, IEEE80211_CCMP_MIC_LEN); 6056 } 6057 } 6058 6059 paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE); 6060 if (dma_mapping_error(ab->dev, paddr)) { 6061 ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n"); 6062 ret = -EIO; 6063 goto err_free_idr; 6064 } 6065 6066 ATH11K_SKB_CB(skb)->paddr = paddr; 6067 6068 ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb); 6069 if (ret) { 6070 ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret); 6071 goto err_unmap_buf; 6072 } 6073 6074 return 0; 6075 6076 err_unmap_buf: 6077 dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr, 6078 skb->len, DMA_TO_DEVICE); 6079 err_free_idr: 6080 spin_lock_bh(&ar->txmgmt_idr_lock); 6081 idr_remove(&ar->txmgmt_idr, buf_id); 6082 spin_unlock_bh(&ar->txmgmt_idr_lock); 6083 6084 return ret; 6085 } 6086 6087 static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar) 6088 { 6089 struct sk_buff *skb; 6090 6091 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) 6092 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 6093 } 6094 6095 static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work) 6096 { 6097 struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work); 6098 struct ath11k_skb_cb *skb_cb; 6099 struct ath11k_vif *arvif; 6100 struct sk_buff *skb; 6101 int ret; 6102 6103 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) { 6104 skb_cb = ATH11K_SKB_CB(skb); 6105 if (!skb_cb->vif) { 6106 ath11k_warn(ar->ab, "no vif found for mgmt frame\n"); 6107 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 6108 continue; 6109 } 6110 6111 arvif = ath11k_vif_to_arvif(skb_cb->vif); 6112 mutex_lock(&ar->conf_mutex); 6113 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id)) { 6114 ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb); 6115 if (ret) { 6116 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n", 6117 arvif->vdev_id, ret); 6118 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 6119 } else { 6120 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 6121 "tx mgmt frame, vdev_id %d\n", 6122 arvif->vdev_id); 6123 } 6124 } else { 6125 ath11k_warn(ar->ab, 6126 "dropping mgmt frame for vdev %d, is_started %d\n", 6127 arvif->vdev_id, 6128 arvif->is_started); 6129 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 6130 } 6131 mutex_unlock(&ar->conf_mutex); 6132 } 6133 } 6134 6135 static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb, 6136 bool is_prb_rsp) 6137 { 6138 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue; 6139 6140 if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags)) 6141 return -ESHUTDOWN; 6142 6143 /* Drop probe response packets when the pending management tx 6144 * count has reached a certain threshold, so as to prioritize 6145 * other mgmt packets like auth and assoc to be sent on time 6146 * for establishing successful connections. 6147 */ 6148 if (is_prb_rsp && 6149 atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) { 6150 ath11k_warn(ar->ab, 6151 "dropping probe response as pending queue is almost full\n"); 6152 return -ENOSPC; 6153 } 6154 6155 if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) { 6156 ath11k_warn(ar->ab, "mgmt tx queue is full\n"); 6157 return -ENOSPC; 6158 } 6159 6160 skb_queue_tail(q, skb); 6161 atomic_inc(&ar->num_pending_mgmt_tx); 6162 queue_work(ar->ab->workqueue_aux, &ar->wmi_mgmt_tx_work); 6163 6164 return 0; 6165 } 6166 6167 static void ath11k_mac_op_tx(struct ieee80211_hw *hw, 6168 struct ieee80211_tx_control *control, 6169 struct sk_buff *skb) 6170 { 6171 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb); 6172 struct ath11k *ar = hw->priv; 6173 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 6174 struct ieee80211_vif *vif = info->control.vif; 6175 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 6176 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 6177 struct ieee80211_key_conf *key = info->control.hw_key; 6178 struct ath11k_sta *arsta = NULL; 6179 u32 info_flags = info->flags; 6180 bool is_prb_rsp; 6181 int ret; 6182 6183 memset(skb_cb, 0, sizeof(*skb_cb)); 6184 skb_cb->vif = vif; 6185 6186 if (key) { 6187 skb_cb->cipher = key->cipher; 6188 skb_cb->flags |= ATH11K_SKB_CIPHER_SET; 6189 } 6190 6191 if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) { 6192 skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP; 6193 } else if (ieee80211_is_mgmt(hdr->frame_control)) { 6194 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control); 6195 ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp); 6196 if (ret) { 6197 ath11k_warn(ar->ab, "failed to queue management frame %d\n", 6198 ret); 6199 ieee80211_free_txskb(ar->hw, skb); 6200 } 6201 return; 6202 } 6203 6204 if (control->sta) 6205 arsta = (struct ath11k_sta *)control->sta->drv_priv; 6206 6207 ret = ath11k_dp_tx(ar, arvif, arsta, skb); 6208 if (unlikely(ret)) { 6209 ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret); 6210 ieee80211_free_txskb(ar->hw, skb); 6211 } 6212 } 6213 6214 void ath11k_mac_drain_tx(struct ath11k *ar) 6215 { 6216 /* make sure rcu-protected mac80211 tx path itself is drained */ 6217 synchronize_net(); 6218 6219 cancel_work_sync(&ar->wmi_mgmt_tx_work); 6220 ath11k_mgmt_over_wmi_tx_purge(ar); 6221 } 6222 6223 static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable) 6224 { 6225 struct htt_rx_ring_tlv_filter tlv_filter = {0}; 6226 struct ath11k_base *ab = ar->ab; 6227 int i, ret = 0; 6228 u32 ring_id; 6229 6230 if (enable) { 6231 tlv_filter = ath11k_mac_mon_status_filter_default; 6232 if (ath11k_debugfs_rx_filter(ar)) 6233 tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar); 6234 } 6235 6236 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) { 6237 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id; 6238 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id, 6239 ar->dp.mac_id + i, 6240 HAL_RXDMA_MONITOR_STATUS, 6241 DP_RX_BUFFER_SIZE, 6242 &tlv_filter); 6243 } 6244 6245 if (enable && !ar->ab->hw_params.rxdma1_enable) 6246 mod_timer(&ar->ab->mon_reap_timer, jiffies + 6247 msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL)); 6248 6249 return ret; 6250 } 6251 6252 static void ath11k_mac_wait_reconfigure(struct ath11k_base *ab) 6253 { 6254 int recovery_start_count; 6255 6256 if (!ab->is_reset) 6257 return; 6258 6259 recovery_start_count = atomic_inc_return(&ab->recovery_start_count); 6260 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery start count %d\n", recovery_start_count); 6261 6262 if (recovery_start_count == ab->num_radios) { 6263 complete(&ab->recovery_start); 6264 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery started success\n"); 6265 } 6266 6267 ath11k_dbg(ab, ATH11K_DBG_MAC, "waiting reconfigure...\n"); 6268 6269 wait_for_completion_timeout(&ab->reconfigure_complete, 6270 ATH11K_RECONFIGURE_TIMEOUT_HZ); 6271 } 6272 6273 static int ath11k_mac_op_start(struct ieee80211_hw *hw) 6274 { 6275 struct ath11k *ar = hw->priv; 6276 struct ath11k_base *ab = ar->ab; 6277 struct ath11k_pdev *pdev = ar->pdev; 6278 int ret; 6279 6280 if (ath11k_ftm_mode) { 6281 ath11k_warn(ab, "mac operations not supported in factory test mode\n"); 6282 return -EOPNOTSUPP; 6283 } 6284 6285 ath11k_mac_drain_tx(ar); 6286 mutex_lock(&ar->conf_mutex); 6287 6288 switch (ar->state) { 6289 case ATH11K_STATE_OFF: 6290 ar->state = ATH11K_STATE_ON; 6291 break; 6292 case ATH11K_STATE_RESTARTING: 6293 ar->state = ATH11K_STATE_RESTARTED; 6294 ath11k_mac_wait_reconfigure(ab); 6295 break; 6296 case ATH11K_STATE_RESTARTED: 6297 case ATH11K_STATE_WEDGED: 6298 case ATH11K_STATE_ON: 6299 case ATH11K_STATE_FTM: 6300 WARN_ON(1); 6301 ret = -EINVAL; 6302 goto err; 6303 } 6304 6305 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 6306 1, pdev->pdev_id); 6307 6308 if (ret) { 6309 ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret); 6310 goto err; 6311 } 6312 6313 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1, 6314 pdev->pdev_id); 6315 if (ret) { 6316 ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret); 6317 goto err; 6318 } 6319 6320 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) { 6321 ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr); 6322 if (ret) { 6323 ath11k_err(ab, "failed to set prob req oui: %i\n", ret); 6324 goto err; 6325 } 6326 } 6327 6328 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE, 6329 0, pdev->pdev_id); 6330 if (ret) { 6331 ath11k_err(ab, "failed to set ac override for ARP: %d\n", 6332 ret); 6333 goto err; 6334 } 6335 6336 ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id); 6337 if (ret) { 6338 ath11k_err(ab, "failed to offload radar detection: %d\n", 6339 ret); 6340 goto err; 6341 } 6342 6343 ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar, 6344 HTT_PPDU_STATS_TAG_DEFAULT); 6345 if (ret) { 6346 ath11k_err(ab, "failed to req ppdu stats: %d\n", ret); 6347 goto err; 6348 } 6349 6350 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE, 6351 1, pdev->pdev_id); 6352 6353 if (ret) { 6354 ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret); 6355 goto err; 6356 } 6357 6358 __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask); 6359 6360 /* TODO: Do we need to enable ANI? */ 6361 6362 ath11k_reg_update_chan_list(ar, false); 6363 6364 ar->num_started_vdevs = 0; 6365 ar->num_created_vdevs = 0; 6366 ar->num_peers = 0; 6367 ar->allocated_vdev_map = 0; 6368 6369 /* Configure monitor status ring with default rx_filter to get rx status 6370 * such as rssi, rx_duration. 6371 */ 6372 ret = ath11k_mac_config_mon_status_default(ar, true); 6373 if (ret) { 6374 ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n", 6375 ret); 6376 goto err; 6377 } 6378 6379 /* Configure the hash seed for hash based reo dest ring selection */ 6380 ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id); 6381 6382 /* allow device to enter IMPS */ 6383 if (ab->hw_params.idle_ps) { 6384 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG, 6385 1, pdev->pdev_id); 6386 if (ret) { 6387 ath11k_err(ab, "failed to enable idle ps: %d\n", ret); 6388 goto err; 6389 } 6390 } 6391 6392 mutex_unlock(&ar->conf_mutex); 6393 6394 rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx], 6395 &ab->pdevs[ar->pdev_idx]); 6396 6397 return 0; 6398 6399 err: 6400 ar->state = ATH11K_STATE_OFF; 6401 mutex_unlock(&ar->conf_mutex); 6402 6403 return ret; 6404 } 6405 6406 static void ath11k_mac_op_stop(struct ieee80211_hw *hw) 6407 { 6408 struct ath11k *ar = hw->priv; 6409 struct htt_ppdu_stats_info *ppdu_stats, *tmp; 6410 int ret; 6411 6412 ath11k_mac_drain_tx(ar); 6413 6414 mutex_lock(&ar->conf_mutex); 6415 ret = ath11k_mac_config_mon_status_default(ar, false); 6416 if (ret) 6417 ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n", 6418 ret); 6419 6420 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags); 6421 ar->state = ATH11K_STATE_OFF; 6422 mutex_unlock(&ar->conf_mutex); 6423 6424 cancel_delayed_work_sync(&ar->scan.timeout); 6425 cancel_work_sync(&ar->regd_update_work); 6426 cancel_work_sync(&ar->ab->update_11d_work); 6427 6428 if (ar->state_11d == ATH11K_11D_PREPARING) { 6429 ar->state_11d = ATH11K_11D_IDLE; 6430 complete(&ar->completed_11d_scan); 6431 } 6432 6433 spin_lock_bh(&ar->data_lock); 6434 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) { 6435 list_del(&ppdu_stats->list); 6436 kfree(ppdu_stats); 6437 } 6438 spin_unlock_bh(&ar->data_lock); 6439 6440 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL); 6441 6442 synchronize_rcu(); 6443 6444 atomic_set(&ar->num_pending_mgmt_tx, 0); 6445 } 6446 6447 static int ath11k_mac_setup_vdev_params_mbssid(struct ath11k_vif *arvif, 6448 u32 *flags, u32 *tx_vdev_id) 6449 { 6450 struct ath11k *ar = arvif->ar; 6451 struct ath11k_vif *tx_arvif; 6452 struct ieee80211_vif *tx_vif; 6453 6454 *tx_vdev_id = 0; 6455 tx_vif = arvif->vif->mbssid_tx_vif; 6456 if (!tx_vif) { 6457 *flags = WMI_HOST_VDEV_FLAGS_NON_MBSSID_AP; 6458 return 0; 6459 } 6460 6461 tx_arvif = ath11k_vif_to_arvif(tx_vif); 6462 6463 if (arvif->vif->bss_conf.nontransmitted) { 6464 if (ar->hw->wiphy != ieee80211_vif_to_wdev(tx_vif)->wiphy) 6465 return -EINVAL; 6466 6467 *flags = WMI_HOST_VDEV_FLAGS_NON_TRANSMIT_AP; 6468 *tx_vdev_id = ath11k_vif_to_arvif(tx_vif)->vdev_id; 6469 } else if (tx_arvif == arvif) { 6470 *flags = WMI_HOST_VDEV_FLAGS_TRANSMIT_AP; 6471 } else { 6472 return -EINVAL; 6473 } 6474 6475 if (arvif->vif->bss_conf.ema_ap) 6476 *flags |= WMI_HOST_VDEV_FLAGS_EMA_MODE; 6477 6478 return 0; 6479 } 6480 6481 static int ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif, 6482 struct vdev_create_params *params) 6483 { 6484 struct ath11k *ar = arvif->ar; 6485 struct ath11k_pdev *pdev = ar->pdev; 6486 int ret; 6487 6488 params->if_id = arvif->vdev_id; 6489 params->type = arvif->vdev_type; 6490 params->subtype = arvif->vdev_subtype; 6491 params->pdev_id = pdev->pdev_id; 6492 params->mbssid_flags = 0; 6493 params->mbssid_tx_vdev_id = 0; 6494 6495 if (!test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT, 6496 ar->ab->wmi_ab.svc_map)) { 6497 ret = ath11k_mac_setup_vdev_params_mbssid(arvif, 6498 ¶ms->mbssid_flags, 6499 ¶ms->mbssid_tx_vdev_id); 6500 if (ret) 6501 return ret; 6502 } 6503 6504 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) { 6505 params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains; 6506 params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains; 6507 } 6508 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) { 6509 params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains; 6510 params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains; 6511 } 6512 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP && 6513 ar->supports_6ghz) { 6514 params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains; 6515 params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains; 6516 } 6517 return 0; 6518 } 6519 6520 static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw, 6521 struct ieee80211_vif *vif) 6522 { 6523 struct ath11k *ar = hw->priv; 6524 struct ath11k_base *ab = ar->ab; 6525 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 6526 u32 param_id, param_value; 6527 int ret; 6528 6529 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE; 6530 if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET || 6531 (vif->type != NL80211_IFTYPE_STATION && 6532 vif->type != NL80211_IFTYPE_AP)) 6533 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED | 6534 IEEE80211_OFFLOAD_DECAP_ENABLED); 6535 6536 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED) 6537 param_value = ATH11K_HW_TXRX_ETHERNET; 6538 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) 6539 param_value = ATH11K_HW_TXRX_RAW; 6540 else 6541 param_value = ATH11K_HW_TXRX_NATIVE_WIFI; 6542 6543 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6544 param_id, param_value); 6545 if (ret) { 6546 ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n", 6547 arvif->vdev_id, ret); 6548 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED; 6549 } 6550 6551 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE; 6552 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED) 6553 param_value = ATH11K_HW_TXRX_ETHERNET; 6554 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) 6555 param_value = ATH11K_HW_TXRX_RAW; 6556 else 6557 param_value = ATH11K_HW_TXRX_NATIVE_WIFI; 6558 6559 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6560 param_id, param_value); 6561 if (ret) { 6562 ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n", 6563 arvif->vdev_id, ret); 6564 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED; 6565 } 6566 } 6567 6568 static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab) 6569 { 6570 struct ath11k *ar; 6571 struct ath11k_pdev *pdev; 6572 struct ath11k_vif *arvif; 6573 int i; 6574 6575 for (i = 0; i < ab->num_radios; i++) { 6576 pdev = &ab->pdevs[i]; 6577 ar = pdev->ar; 6578 list_for_each_entry(arvif, &ar->arvifs, list) { 6579 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP) 6580 return true; 6581 } 6582 } 6583 return false; 6584 } 6585 6586 void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id) 6587 { 6588 struct wmi_11d_scan_start_params param; 6589 int ret; 6590 6591 mutex_lock(&ar->ab->vdev_id_11d_lock); 6592 6593 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev id for 11d scan %d\n", 6594 ar->vdev_id_11d_scan); 6595 6596 if (ar->regdom_set_by_user) 6597 goto fin; 6598 6599 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) 6600 goto fin; 6601 6602 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) 6603 goto fin; 6604 6605 if (ath11k_mac_vif_ap_active_any(ar->ab)) 6606 goto fin; 6607 6608 param.vdev_id = vdev_id; 6609 param.start_interval_msec = 0; 6610 param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL; 6611 6612 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "start 11d scan\n"); 6613 6614 ret = ath11k_wmi_send_11d_scan_start_cmd(ar, ¶m); 6615 if (ret) { 6616 ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n", 6617 vdev_id, ret); 6618 } else { 6619 ar->vdev_id_11d_scan = vdev_id; 6620 if (ar->state_11d == ATH11K_11D_PREPARING) 6621 ar->state_11d = ATH11K_11D_RUNNING; 6622 } 6623 6624 fin: 6625 if (ar->state_11d == ATH11K_11D_PREPARING) { 6626 ar->state_11d = ATH11K_11D_IDLE; 6627 complete(&ar->completed_11d_scan); 6628 } 6629 6630 mutex_unlock(&ar->ab->vdev_id_11d_lock); 6631 } 6632 6633 void ath11k_mac_11d_scan_stop(struct ath11k *ar) 6634 { 6635 int ret; 6636 u32 vdev_id; 6637 6638 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) 6639 return; 6640 6641 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "stop 11d scan\n"); 6642 6643 mutex_lock(&ar->ab->vdev_id_11d_lock); 6644 6645 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "stop 11d vdev id %d\n", 6646 ar->vdev_id_11d_scan); 6647 6648 if (ar->state_11d == ATH11K_11D_PREPARING) { 6649 ar->state_11d = ATH11K_11D_IDLE; 6650 complete(&ar->completed_11d_scan); 6651 } 6652 6653 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) { 6654 vdev_id = ar->vdev_id_11d_scan; 6655 6656 ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id); 6657 if (ret) { 6658 ath11k_warn(ar->ab, 6659 "failed to stopt 11d scan vdev %d ret: %d\n", 6660 vdev_id, ret); 6661 } else { 6662 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID; 6663 ar->state_11d = ATH11K_11D_IDLE; 6664 complete(&ar->completed_11d_scan); 6665 } 6666 } 6667 mutex_unlock(&ar->ab->vdev_id_11d_lock); 6668 } 6669 6670 void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab) 6671 { 6672 struct ath11k *ar; 6673 struct ath11k_pdev *pdev; 6674 int i; 6675 6676 ath11k_dbg(ab, ATH11K_DBG_MAC, "stop soc 11d scan\n"); 6677 6678 for (i = 0; i < ab->num_radios; i++) { 6679 pdev = &ab->pdevs[i]; 6680 ar = pdev->ar; 6681 6682 ath11k_mac_11d_scan_stop(ar); 6683 } 6684 } 6685 6686 static int ath11k_mac_vdev_delete(struct ath11k *ar, struct ath11k_vif *arvif) 6687 { 6688 unsigned long time_left; 6689 struct ieee80211_vif *vif = arvif->vif; 6690 int ret = 0; 6691 6692 lockdep_assert_held(&ar->conf_mutex); 6693 6694 reinit_completion(&ar->vdev_delete_done); 6695 6696 ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id); 6697 if (ret) { 6698 ath11k_warn(ar->ab, "failed to delete WMI vdev %d: %d\n", 6699 arvif->vdev_id, ret); 6700 return ret; 6701 } 6702 6703 time_left = wait_for_completion_timeout(&ar->vdev_delete_done, 6704 ATH11K_VDEV_DELETE_TIMEOUT_HZ); 6705 if (time_left == 0) { 6706 ath11k_warn(ar->ab, "Timeout in receiving vdev delete response\n"); 6707 return -ETIMEDOUT; 6708 } 6709 6710 ar->ab->free_vdev_map |= 1LL << (arvif->vdev_id); 6711 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 6712 ar->num_created_vdevs--; 6713 6714 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n", 6715 vif->addr, arvif->vdev_id); 6716 6717 return ret; 6718 } 6719 6720 static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw, 6721 struct ieee80211_vif *vif) 6722 { 6723 struct ath11k *ar = hw->priv; 6724 struct ath11k_base *ab = ar->ab; 6725 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 6726 struct vdev_create_params vdev_param = {0}; 6727 struct peer_create_params peer_param; 6728 u32 param_id, param_value; 6729 u16 nss; 6730 int i; 6731 int ret, fbret; 6732 int bit; 6733 6734 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 6735 6736 mutex_lock(&ar->conf_mutex); 6737 6738 if (vif->type == NL80211_IFTYPE_AP && 6739 ar->num_peers > (ar->max_num_peers - 1)) { 6740 ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n"); 6741 ret = -ENOBUFS; 6742 goto err; 6743 } 6744 6745 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) { 6746 ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n", 6747 ar->num_created_vdevs, TARGET_NUM_VDEVS(ab)); 6748 ret = -EBUSY; 6749 goto err; 6750 } 6751 6752 /* In the case of hardware recovery, debugfs files are 6753 * not deleted since ieee80211_ops.remove_interface() is 6754 * not invoked. In such cases, try to delete the files. 6755 * These will be re-created later. 6756 */ 6757 ath11k_debugfs_remove_interface(arvif); 6758 6759 memset(arvif, 0, sizeof(*arvif)); 6760 6761 arvif->ar = ar; 6762 arvif->vif = vif; 6763 6764 INIT_LIST_HEAD(&arvif->list); 6765 INIT_DELAYED_WORK(&arvif->connection_loss_work, 6766 ath11k_mac_vif_sta_connection_loss_work); 6767 6768 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) { 6769 arvif->bitrate_mask.control[i].legacy = 0xffffffff; 6770 arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI; 6771 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff, 6772 sizeof(arvif->bitrate_mask.control[i].ht_mcs)); 6773 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff, 6774 sizeof(arvif->bitrate_mask.control[i].vht_mcs)); 6775 memset(arvif->bitrate_mask.control[i].he_mcs, 0xff, 6776 sizeof(arvif->bitrate_mask.control[i].he_mcs)); 6777 } 6778 6779 bit = __ffs64(ab->free_vdev_map); 6780 6781 arvif->vdev_id = bit; 6782 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 6783 6784 switch (vif->type) { 6785 case NL80211_IFTYPE_UNSPECIFIED: 6786 case NL80211_IFTYPE_STATION: 6787 arvif->vdev_type = WMI_VDEV_TYPE_STA; 6788 break; 6789 case NL80211_IFTYPE_MESH_POINT: 6790 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S; 6791 fallthrough; 6792 case NL80211_IFTYPE_AP: 6793 arvif->vdev_type = WMI_VDEV_TYPE_AP; 6794 break; 6795 case NL80211_IFTYPE_MONITOR: 6796 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 6797 ar->monitor_vdev_id = bit; 6798 break; 6799 default: 6800 WARN_ON(1); 6801 break; 6802 } 6803 6804 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "add interface id %d type %d subtype %d map %llx\n", 6805 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype, 6806 ab->free_vdev_map); 6807 6808 vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1); 6809 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 6810 vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1); 6811 6812 ret = ath11k_mac_setup_vdev_create_params(arvif, &vdev_param); 6813 if (ret) { 6814 ath11k_warn(ab, "failed to create vdev parameters %d: %d\n", 6815 arvif->vdev_id, ret); 6816 goto err; 6817 } 6818 6819 ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param); 6820 if (ret) { 6821 ath11k_warn(ab, "failed to create WMI vdev %d: %d\n", 6822 arvif->vdev_id, ret); 6823 goto err; 6824 } 6825 6826 ar->num_created_vdevs++; 6827 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n", 6828 vif->addr, arvif->vdev_id); 6829 ar->allocated_vdev_map |= 1LL << arvif->vdev_id; 6830 ab->free_vdev_map &= ~(1LL << arvif->vdev_id); 6831 6832 spin_lock_bh(&ar->data_lock); 6833 list_add(&arvif->list, &ar->arvifs); 6834 spin_unlock_bh(&ar->data_lock); 6835 6836 ath11k_mac_op_update_vif_offload(hw, vif); 6837 6838 nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1; 6839 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6840 WMI_VDEV_PARAM_NSS, nss); 6841 if (ret) { 6842 ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n", 6843 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret); 6844 goto err_vdev_del; 6845 } 6846 6847 switch (arvif->vdev_type) { 6848 case WMI_VDEV_TYPE_AP: 6849 peer_param.vdev_id = arvif->vdev_id; 6850 peer_param.peer_addr = vif->addr; 6851 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 6852 ret = ath11k_peer_create(ar, arvif, NULL, &peer_param); 6853 if (ret) { 6854 ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n", 6855 arvif->vdev_id, ret); 6856 goto err_vdev_del; 6857 } 6858 6859 ret = ath11k_mac_set_kickout(arvif); 6860 if (ret) { 6861 ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n", 6862 arvif->vdev_id, ret); 6863 goto err_peer_del; 6864 } 6865 6866 ath11k_mac_11d_scan_stop_all(ar->ab); 6867 break; 6868 case WMI_VDEV_TYPE_STA: 6869 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 6870 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 6871 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6872 param_id, param_value); 6873 if (ret) { 6874 ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n", 6875 arvif->vdev_id, ret); 6876 goto err_peer_del; 6877 } 6878 6879 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 6880 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 6881 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6882 param_id, param_value); 6883 if (ret) { 6884 ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n", 6885 arvif->vdev_id, ret); 6886 goto err_peer_del; 6887 } 6888 6889 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT; 6890 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 6891 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6892 param_id, param_value); 6893 if (ret) { 6894 ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n", 6895 arvif->vdev_id, ret); 6896 goto err_peer_del; 6897 } 6898 6899 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, 6900 WMI_STA_PS_MODE_DISABLED); 6901 if (ret) { 6902 ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n", 6903 arvif->vdev_id, ret); 6904 goto err_peer_del; 6905 } 6906 6907 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map)) { 6908 reinit_completion(&ar->completed_11d_scan); 6909 ar->state_11d = ATH11K_11D_PREPARING; 6910 } 6911 break; 6912 case WMI_VDEV_TYPE_MONITOR: 6913 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 6914 break; 6915 default: 6916 break; 6917 } 6918 6919 arvif->txpower = vif->bss_conf.txpower; 6920 ret = ath11k_mac_txpower_recalc(ar); 6921 if (ret) 6922 goto err_peer_del; 6923 6924 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 6925 param_value = ar->hw->wiphy->rts_threshold; 6926 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6927 param_id, param_value); 6928 if (ret) { 6929 ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n", 6930 arvif->vdev_id, ret); 6931 } 6932 6933 ath11k_dp_vdev_tx_attach(ar, arvif); 6934 6935 ath11k_debugfs_add_interface(arvif); 6936 6937 if (vif->type != NL80211_IFTYPE_MONITOR && 6938 test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) { 6939 ret = ath11k_mac_monitor_vdev_create(ar); 6940 if (ret) 6941 ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d", 6942 ret); 6943 } 6944 6945 mutex_unlock(&ar->conf_mutex); 6946 6947 return 0; 6948 6949 err_peer_del: 6950 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 6951 fbret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr); 6952 if (fbret) { 6953 ath11k_warn(ar->ab, "fallback fail to delete peer addr %pM vdev_id %d ret %d\n", 6954 vif->addr, arvif->vdev_id, fbret); 6955 goto err; 6956 } 6957 } 6958 6959 err_vdev_del: 6960 ath11k_mac_vdev_delete(ar, arvif); 6961 spin_lock_bh(&ar->data_lock); 6962 list_del(&arvif->list); 6963 spin_unlock_bh(&ar->data_lock); 6964 6965 err: 6966 mutex_unlock(&ar->conf_mutex); 6967 6968 return ret; 6969 } 6970 6971 static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx) 6972 { 6973 struct ieee80211_vif *vif = (struct ieee80211_vif *)ctx; 6974 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb); 6975 6976 if (skb_cb->vif == vif) 6977 skb_cb->vif = NULL; 6978 6979 return 0; 6980 } 6981 6982 static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw, 6983 struct ieee80211_vif *vif) 6984 { 6985 struct ath11k *ar = hw->priv; 6986 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 6987 struct ath11k_base *ab = ar->ab; 6988 int ret; 6989 int i; 6990 6991 cancel_delayed_work_sync(&arvif->connection_loss_work); 6992 6993 mutex_lock(&ar->conf_mutex); 6994 6995 ath11k_dbg(ab, ATH11K_DBG_MAC, "remove interface (vdev %d)\n", 6996 arvif->vdev_id); 6997 6998 ret = ath11k_spectral_vif_stop(arvif); 6999 if (ret) 7000 ath11k_warn(ab, "failed to stop spectral for vdev %i: %d\n", 7001 arvif->vdev_id, ret); 7002 7003 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 7004 ath11k_mac_11d_scan_stop(ar); 7005 7006 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 7007 ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr); 7008 if (ret) 7009 ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n", 7010 arvif->vdev_id, ret); 7011 } 7012 7013 ret = ath11k_mac_vdev_delete(ar, arvif); 7014 if (ret) { 7015 ath11k_warn(ab, "failed to delete vdev %d: %d\n", 7016 arvif->vdev_id, ret); 7017 goto err_vdev_del; 7018 } 7019 7020 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7021 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 7022 ar->monitor_vdev_id = -1; 7023 } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) && 7024 !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) { 7025 ret = ath11k_mac_monitor_vdev_delete(ar); 7026 if (ret) 7027 /* continue even if there's an error */ 7028 ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d", 7029 ret); 7030 } 7031 7032 err_vdev_del: 7033 spin_lock_bh(&ar->data_lock); 7034 list_del(&arvif->list); 7035 spin_unlock_bh(&ar->data_lock); 7036 7037 ath11k_peer_cleanup(ar, arvif->vdev_id); 7038 7039 idr_for_each(&ar->txmgmt_idr, 7040 ath11k_mac_vif_txmgmt_idr_remove, vif); 7041 7042 for (i = 0; i < ab->hw_params.max_tx_ring; i++) { 7043 spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock); 7044 idr_for_each(&ab->dp.tx_ring[i].txbuf_idr, 7045 ath11k_mac_vif_unref, vif); 7046 spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock); 7047 } 7048 7049 /* Recalc txpower for remaining vdev */ 7050 ath11k_mac_txpower_recalc(ar); 7051 7052 ath11k_debugfs_remove_interface(arvif); 7053 7054 /* TODO: recal traffic pause state based on the available vdevs */ 7055 7056 mutex_unlock(&ar->conf_mutex); 7057 } 7058 7059 /* FIXME: Has to be verified. */ 7060 #define SUPPORTED_FILTERS \ 7061 (FIF_ALLMULTI | \ 7062 FIF_CONTROL | \ 7063 FIF_PSPOLL | \ 7064 FIF_OTHER_BSS | \ 7065 FIF_BCN_PRBRESP_PROMISC | \ 7066 FIF_PROBE_REQ | \ 7067 FIF_FCSFAIL) 7068 7069 static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw, 7070 unsigned int changed_flags, 7071 unsigned int *total_flags, 7072 u64 multicast) 7073 { 7074 struct ath11k *ar = hw->priv; 7075 7076 mutex_lock(&ar->conf_mutex); 7077 7078 *total_flags &= SUPPORTED_FILTERS; 7079 ar->filter_flags = *total_flags; 7080 7081 mutex_unlock(&ar->conf_mutex); 7082 } 7083 7084 static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 7085 { 7086 struct ath11k *ar = hw->priv; 7087 7088 mutex_lock(&ar->conf_mutex); 7089 7090 *tx_ant = ar->cfg_tx_chainmask; 7091 *rx_ant = ar->cfg_rx_chainmask; 7092 7093 mutex_unlock(&ar->conf_mutex); 7094 7095 return 0; 7096 } 7097 7098 static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 7099 { 7100 struct ath11k *ar = hw->priv; 7101 int ret; 7102 7103 mutex_lock(&ar->conf_mutex); 7104 ret = __ath11k_set_antenna(ar, tx_ant, rx_ant); 7105 mutex_unlock(&ar->conf_mutex); 7106 7107 return ret; 7108 } 7109 7110 static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw, 7111 struct ieee80211_vif *vif, 7112 struct ieee80211_ampdu_params *params) 7113 { 7114 struct ath11k *ar = hw->priv; 7115 int ret = -EINVAL; 7116 7117 mutex_lock(&ar->conf_mutex); 7118 7119 switch (params->action) { 7120 case IEEE80211_AMPDU_RX_START: 7121 ret = ath11k_dp_rx_ampdu_start(ar, params); 7122 break; 7123 case IEEE80211_AMPDU_RX_STOP: 7124 ret = ath11k_dp_rx_ampdu_stop(ar, params); 7125 break; 7126 case IEEE80211_AMPDU_TX_START: 7127 case IEEE80211_AMPDU_TX_STOP_CONT: 7128 case IEEE80211_AMPDU_TX_STOP_FLUSH: 7129 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 7130 case IEEE80211_AMPDU_TX_OPERATIONAL: 7131 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211 7132 * Tx aggregation requests. 7133 */ 7134 ret = -EOPNOTSUPP; 7135 break; 7136 } 7137 7138 mutex_unlock(&ar->conf_mutex); 7139 7140 return ret; 7141 } 7142 7143 static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw, 7144 struct ieee80211_chanctx_conf *ctx) 7145 { 7146 struct ath11k *ar = hw->priv; 7147 struct ath11k_base *ab = ar->ab; 7148 7149 ath11k_dbg(ab, ATH11K_DBG_MAC, 7150 "chanctx add freq %u width %d ptr %p\n", 7151 ctx->def.chan->center_freq, ctx->def.width, ctx); 7152 7153 mutex_lock(&ar->conf_mutex); 7154 7155 spin_lock_bh(&ar->data_lock); 7156 /* TODO: In case of multiple channel context, populate rx_channel from 7157 * Rx PPDU desc information. 7158 */ 7159 ar->rx_channel = ctx->def.chan; 7160 spin_unlock_bh(&ar->data_lock); 7161 7162 mutex_unlock(&ar->conf_mutex); 7163 7164 return 0; 7165 } 7166 7167 static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw, 7168 struct ieee80211_chanctx_conf *ctx) 7169 { 7170 struct ath11k *ar = hw->priv; 7171 struct ath11k_base *ab = ar->ab; 7172 7173 ath11k_dbg(ab, ATH11K_DBG_MAC, 7174 "chanctx remove freq %u width %d ptr %p\n", 7175 ctx->def.chan->center_freq, ctx->def.width, ctx); 7176 7177 mutex_lock(&ar->conf_mutex); 7178 7179 spin_lock_bh(&ar->data_lock); 7180 /* TODO: In case of there is one more channel context left, populate 7181 * rx_channel with the channel of that remaining channel context. 7182 */ 7183 ar->rx_channel = NULL; 7184 spin_unlock_bh(&ar->data_lock); 7185 7186 mutex_unlock(&ar->conf_mutex); 7187 } 7188 7189 static int 7190 ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif, 7191 struct ieee80211_chanctx_conf *ctx, 7192 bool restart) 7193 { 7194 struct ath11k *ar = arvif->ar; 7195 struct ath11k_base *ab = ar->ab; 7196 struct wmi_vdev_start_req_arg arg = {}; 7197 const struct cfg80211_chan_def *chandef = &ctx->def; 7198 int ret = 0; 7199 7200 lockdep_assert_held(&ar->conf_mutex); 7201 7202 reinit_completion(&ar->vdev_setup_done); 7203 7204 arg.vdev_id = arvif->vdev_id; 7205 arg.dtim_period = arvif->dtim_period; 7206 arg.bcn_intval = arvif->beacon_interval; 7207 7208 arg.channel.freq = chandef->chan->center_freq; 7209 arg.channel.band_center_freq1 = chandef->center_freq1; 7210 arg.channel.band_center_freq2 = chandef->center_freq2; 7211 arg.channel.mode = 7212 ath11k_phymodes[chandef->chan->band][chandef->width]; 7213 7214 arg.channel.min_power = 0; 7215 arg.channel.max_power = chandef->chan->max_power; 7216 arg.channel.max_reg_power = chandef->chan->max_reg_power; 7217 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain; 7218 7219 arg.pref_tx_streams = ar->num_tx_chains; 7220 arg.pref_rx_streams = ar->num_rx_chains; 7221 7222 arg.mbssid_flags = 0; 7223 arg.mbssid_tx_vdev_id = 0; 7224 if (test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT, 7225 ar->ab->wmi_ab.svc_map)) { 7226 ret = ath11k_mac_setup_vdev_params_mbssid(arvif, 7227 &arg.mbssid_flags, 7228 &arg.mbssid_tx_vdev_id); 7229 if (ret) 7230 return ret; 7231 } 7232 7233 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 7234 arg.ssid = arvif->u.ap.ssid; 7235 arg.ssid_len = arvif->u.ap.ssid_len; 7236 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 7237 7238 /* For now allow DFS for AP mode */ 7239 arg.channel.chan_radar = 7240 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR); 7241 7242 arg.channel.freq2_radar = ctx->radar_enabled; 7243 7244 arg.channel.passive = arg.channel.chan_radar; 7245 7246 spin_lock_bh(&ab->base_lock); 7247 arg.regdomain = ar->ab->dfs_region; 7248 spin_unlock_bh(&ab->base_lock); 7249 } 7250 7251 arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR); 7252 7253 ath11k_dbg(ab, ATH11K_DBG_MAC, 7254 "vdev %d start center_freq %d phymode %s\n", 7255 arg.vdev_id, arg.channel.freq, 7256 ath11k_wmi_phymode_str(arg.channel.mode)); 7257 7258 ret = ath11k_wmi_vdev_start(ar, &arg, restart); 7259 if (ret) { 7260 ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n", 7261 restart ? "restart" : "start", arg.vdev_id); 7262 return ret; 7263 } 7264 7265 ret = ath11k_mac_vdev_setup_sync(ar); 7266 if (ret) { 7267 ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n", 7268 arg.vdev_id, restart ? "restart" : "start", ret); 7269 return ret; 7270 } 7271 7272 if (!restart) 7273 ar->num_started_vdevs++; 7274 7275 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM started, vdev_id %d\n", 7276 arvif->vif->addr, arvif->vdev_id); 7277 7278 /* Enable CAC Flag in the driver by checking the channel DFS cac time, 7279 * i.e dfs_cac_ms value which will be valid only for radar channels 7280 * and state as NL80211_DFS_USABLE which indicates CAC needs to be 7281 * done before channel usage. This flags is used to drop rx packets. 7282 * during CAC. 7283 */ 7284 /* TODO Set the flag for other interface types as required */ 7285 if (arvif->vdev_type == WMI_VDEV_TYPE_AP && 7286 chandef->chan->dfs_cac_ms && 7287 chandef->chan->dfs_state == NL80211_DFS_USABLE) { 7288 set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags); 7289 ath11k_dbg(ab, ATH11K_DBG_MAC, 7290 "CAC Started in chan_freq %d for vdev %d\n", 7291 arg.channel.freq, arg.vdev_id); 7292 } 7293 7294 ret = ath11k_mac_set_txbf_conf(arvif); 7295 if (ret) 7296 ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n", 7297 arvif->vdev_id, ret); 7298 7299 return 0; 7300 } 7301 7302 static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif) 7303 { 7304 struct ath11k *ar = arvif->ar; 7305 int ret; 7306 7307 lockdep_assert_held(&ar->conf_mutex); 7308 7309 reinit_completion(&ar->vdev_setup_done); 7310 7311 ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id); 7312 if (ret) { 7313 ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n", 7314 arvif->vdev_id, ret); 7315 goto err; 7316 } 7317 7318 ret = ath11k_mac_vdev_setup_sync(ar); 7319 if (ret) { 7320 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n", 7321 arvif->vdev_id, ret); 7322 goto err; 7323 } 7324 7325 WARN_ON(ar->num_started_vdevs == 0); 7326 7327 ar->num_started_vdevs--; 7328 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n", 7329 arvif->vif->addr, arvif->vdev_id); 7330 7331 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) { 7332 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags); 7333 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n", 7334 arvif->vdev_id); 7335 } 7336 7337 return 0; 7338 err: 7339 return ret; 7340 } 7341 7342 static int ath11k_mac_vdev_start(struct ath11k_vif *arvif, 7343 struct ieee80211_chanctx_conf *ctx) 7344 { 7345 return ath11k_mac_vdev_start_restart(arvif, ctx, false); 7346 } 7347 7348 static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif, 7349 struct ieee80211_chanctx_conf *ctx) 7350 { 7351 return ath11k_mac_vdev_start_restart(arvif, ctx, true); 7352 } 7353 7354 struct ath11k_mac_change_chanctx_arg { 7355 struct ieee80211_chanctx_conf *ctx; 7356 struct ieee80211_vif_chanctx_switch *vifs; 7357 int n_vifs; 7358 int next_vif; 7359 }; 7360 7361 static void 7362 ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac, 7363 struct ieee80211_vif *vif) 7364 { 7365 struct ath11k_mac_change_chanctx_arg *arg = data; 7366 7367 if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx) 7368 return; 7369 7370 arg->n_vifs++; 7371 } 7372 7373 static void 7374 ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac, 7375 struct ieee80211_vif *vif) 7376 { 7377 struct ath11k_mac_change_chanctx_arg *arg = data; 7378 struct ieee80211_chanctx_conf *ctx; 7379 7380 ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf); 7381 if (ctx != arg->ctx) 7382 return; 7383 7384 if (WARN_ON(arg->next_vif == arg->n_vifs)) 7385 return; 7386 7387 arg->vifs[arg->next_vif].vif = vif; 7388 arg->vifs[arg->next_vif].old_ctx = ctx; 7389 arg->vifs[arg->next_vif].new_ctx = ctx; 7390 arg->next_vif++; 7391 } 7392 7393 static void 7394 ath11k_mac_update_vif_chan(struct ath11k *ar, 7395 struct ieee80211_vif_chanctx_switch *vifs, 7396 int n_vifs) 7397 { 7398 struct ath11k_base *ab = ar->ab; 7399 struct ath11k_vif *arvif, *tx_arvif = NULL; 7400 struct ieee80211_vif *mbssid_tx_vif; 7401 int ret; 7402 int i; 7403 bool monitor_vif = false; 7404 7405 lockdep_assert_held(&ar->conf_mutex); 7406 7407 /* Associated channel resources of all relevant vdevs 7408 * should be available for the channel switch now. 7409 */ 7410 7411 /* TODO: Update ar->rx_channel */ 7412 7413 for (i = 0; i < n_vifs; i++) { 7414 arvif = ath11k_vif_to_arvif(vifs[i].vif); 7415 7416 if (WARN_ON(!arvif->is_started)) 7417 continue; 7418 7419 /* change_chanctx can be called even before vdev_up from 7420 * ieee80211_start_ap->ieee80211_vif_use_channel-> 7421 * ieee80211_recalc_radar_chanctx. 7422 * 7423 * Firmware expect vdev_restart only if vdev is up. 7424 * If vdev is down then it expect vdev_stop->vdev_start. 7425 */ 7426 if (arvif->is_up) { 7427 ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx); 7428 if (ret) { 7429 ath11k_warn(ab, "failed to restart vdev %d: %d\n", 7430 arvif->vdev_id, ret); 7431 continue; 7432 } 7433 } else { 7434 ret = ath11k_mac_vdev_stop(arvif); 7435 if (ret) { 7436 ath11k_warn(ab, "failed to stop vdev %d: %d\n", 7437 arvif->vdev_id, ret); 7438 continue; 7439 } 7440 7441 ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx); 7442 if (ret) 7443 ath11k_warn(ab, "failed to start vdev %d: %d\n", 7444 arvif->vdev_id, ret); 7445 7446 continue; 7447 } 7448 7449 ret = ath11k_mac_setup_bcn_tmpl(arvif); 7450 if (ret) 7451 ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n", 7452 ret); 7453 7454 mbssid_tx_vif = arvif->vif->mbssid_tx_vif; 7455 if (mbssid_tx_vif) 7456 tx_arvif = ath11k_vif_to_arvif(mbssid_tx_vif); 7457 7458 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 7459 arvif->bssid, 7460 tx_arvif ? tx_arvif->bssid : NULL, 7461 arvif->vif->bss_conf.bssid_index, 7462 1 << arvif->vif->bss_conf.bssid_indicator); 7463 if (ret) { 7464 ath11k_warn(ab, "failed to bring vdev up %d: %d\n", 7465 arvif->vdev_id, ret); 7466 continue; 7467 } 7468 } 7469 7470 /* Restart the internal monitor vdev on new channel */ 7471 if (!monitor_vif && 7472 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) { 7473 ret = ath11k_mac_monitor_stop(ar); 7474 if (ret) { 7475 ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d", 7476 ret); 7477 return; 7478 } 7479 7480 ret = ath11k_mac_monitor_start(ar); 7481 if (ret) { 7482 ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d", 7483 ret); 7484 return; 7485 } 7486 } 7487 } 7488 7489 static void 7490 ath11k_mac_update_active_vif_chan(struct ath11k *ar, 7491 struct ieee80211_chanctx_conf *ctx) 7492 { 7493 struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx }; 7494 7495 lockdep_assert_held(&ar->conf_mutex); 7496 7497 ieee80211_iterate_active_interfaces_atomic(ar->hw, 7498 IEEE80211_IFACE_ITER_NORMAL, 7499 ath11k_mac_change_chanctx_cnt_iter, 7500 &arg); 7501 if (arg.n_vifs == 0) 7502 return; 7503 7504 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL); 7505 if (!arg.vifs) 7506 return; 7507 7508 ieee80211_iterate_active_interfaces_atomic(ar->hw, 7509 IEEE80211_IFACE_ITER_NORMAL, 7510 ath11k_mac_change_chanctx_fill_iter, 7511 &arg); 7512 7513 ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs); 7514 7515 kfree(arg.vifs); 7516 } 7517 7518 static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw, 7519 struct ieee80211_chanctx_conf *ctx, 7520 u32 changed) 7521 { 7522 struct ath11k *ar = hw->priv; 7523 struct ath11k_base *ab = ar->ab; 7524 7525 mutex_lock(&ar->conf_mutex); 7526 7527 ath11k_dbg(ab, ATH11K_DBG_MAC, 7528 "chanctx change freq %u width %d ptr %p changed %x\n", 7529 ctx->def.chan->center_freq, ctx->def.width, ctx, changed); 7530 7531 /* This shouldn't really happen because channel switching should use 7532 * switch_vif_chanctx(). 7533 */ 7534 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL)) 7535 goto unlock; 7536 7537 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH || 7538 changed & IEEE80211_CHANCTX_CHANGE_RADAR) 7539 ath11k_mac_update_active_vif_chan(ar, ctx); 7540 7541 /* TODO: Recalc radar detection */ 7542 7543 unlock: 7544 mutex_unlock(&ar->conf_mutex); 7545 } 7546 7547 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw, 7548 struct ieee80211_vif *vif) 7549 { 7550 struct ath11k *ar = hw->priv; 7551 struct ath11k_base *ab = ar->ab; 7552 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 7553 int ret; 7554 7555 if (WARN_ON(arvif->is_started)) 7556 return -EBUSY; 7557 7558 ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx); 7559 if (ret) { 7560 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 7561 arvif->vdev_id, vif->addr, 7562 arvif->chanctx.def.chan->center_freq, ret); 7563 return ret; 7564 } 7565 7566 /* Reconfigure hardware rate code since it is cleared by firmware. 7567 */ 7568 if (ar->hw_rate_code > 0) { 7569 u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE; 7570 7571 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 7572 ar->hw_rate_code); 7573 if (ret) { 7574 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret); 7575 return ret; 7576 } 7577 } 7578 7579 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7580 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr, 7581 NULL, 0, 0); 7582 if (ret) { 7583 ath11k_warn(ab, "failed put monitor up: %d\n", ret); 7584 return ret; 7585 } 7586 } 7587 7588 arvif->is_started = true; 7589 7590 /* TODO: Setup ps and cts/rts protection */ 7591 return 0; 7592 } 7593 7594 static int 7595 ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw, 7596 struct ieee80211_vif *vif, 7597 struct ieee80211_bss_conf *link_conf, 7598 struct ieee80211_chanctx_conf *ctx) 7599 { 7600 struct ath11k *ar = hw->priv; 7601 struct ath11k_base *ab = ar->ab; 7602 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 7603 int ret; 7604 struct peer_create_params param; 7605 7606 mutex_lock(&ar->conf_mutex); 7607 7608 ath11k_dbg(ab, ATH11K_DBG_MAC, 7609 "chanctx assign ptr %p vdev_id %i\n", 7610 ctx, arvif->vdev_id); 7611 7612 /* for QCA6390 bss peer must be created before vdev_start */ 7613 if (ab->hw_params.vdev_start_delay && 7614 arvif->vdev_type != WMI_VDEV_TYPE_AP && 7615 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7616 !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) { 7617 memcpy(&arvif->chanctx, ctx, sizeof(*ctx)); 7618 ret = 0; 7619 goto out; 7620 } 7621 7622 if (WARN_ON(arvif->is_started)) { 7623 ret = -EBUSY; 7624 goto out; 7625 } 7626 7627 if (ab->hw_params.vdev_start_delay && 7628 arvif->vdev_type != WMI_VDEV_TYPE_AP && 7629 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) { 7630 param.vdev_id = arvif->vdev_id; 7631 param.peer_type = WMI_PEER_TYPE_DEFAULT; 7632 param.peer_addr = ar->mac_addr; 7633 7634 ret = ath11k_peer_create(ar, arvif, NULL, ¶m); 7635 if (ret) { 7636 ath11k_warn(ab, "failed to create peer after vdev start delay: %d", 7637 ret); 7638 goto out; 7639 } 7640 } 7641 7642 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7643 ret = ath11k_mac_monitor_start(ar); 7644 if (ret) { 7645 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d", 7646 ret); 7647 goto out; 7648 } 7649 7650 arvif->is_started = true; 7651 goto out; 7652 } 7653 7654 ret = ath11k_mac_vdev_start(arvif, ctx); 7655 if (ret) { 7656 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 7657 arvif->vdev_id, vif->addr, 7658 ctx->def.chan->center_freq, ret); 7659 goto out; 7660 } 7661 7662 arvif->is_started = true; 7663 7664 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7665 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) { 7666 ret = ath11k_mac_monitor_start(ar); 7667 if (ret) { 7668 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d", 7669 ret); 7670 goto out; 7671 } 7672 } 7673 7674 /* TODO: Setup ps and cts/rts protection */ 7675 7676 ret = 0; 7677 7678 out: 7679 mutex_unlock(&ar->conf_mutex); 7680 7681 return ret; 7682 } 7683 7684 static void 7685 ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 7686 struct ieee80211_vif *vif, 7687 struct ieee80211_bss_conf *link_conf, 7688 struct ieee80211_chanctx_conf *ctx) 7689 { 7690 struct ath11k *ar = hw->priv; 7691 struct ath11k_base *ab = ar->ab; 7692 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 7693 struct ath11k_peer *peer; 7694 int ret; 7695 7696 mutex_lock(&ar->conf_mutex); 7697 7698 ath11k_dbg(ab, ATH11K_DBG_MAC, 7699 "chanctx unassign ptr %p vdev_id %i\n", 7700 ctx, arvif->vdev_id); 7701 7702 WARN_ON(!arvif->is_started); 7703 7704 if (ab->hw_params.vdev_start_delay && 7705 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7706 spin_lock_bh(&ab->base_lock); 7707 peer = ath11k_peer_find_by_addr(ab, ar->mac_addr); 7708 spin_unlock_bh(&ab->base_lock); 7709 if (peer) 7710 ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr); 7711 } 7712 7713 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7714 ret = ath11k_mac_monitor_stop(ar); 7715 if (ret) { 7716 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d", 7717 ret); 7718 mutex_unlock(&ar->conf_mutex); 7719 return; 7720 } 7721 7722 arvif->is_started = false; 7723 mutex_unlock(&ar->conf_mutex); 7724 return; 7725 } 7726 7727 ret = ath11k_mac_vdev_stop(arvif); 7728 if (ret) 7729 ath11k_warn(ab, "failed to stop vdev %i: %d\n", 7730 arvif->vdev_id, ret); 7731 7732 arvif->is_started = false; 7733 7734 if (ab->hw_params.vdev_start_delay && 7735 arvif->vdev_type == WMI_VDEV_TYPE_STA) { 7736 ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid); 7737 if (ret) 7738 ath11k_warn(ar->ab, 7739 "failed to delete peer %pM for vdev %d: %d\n", 7740 arvif->bssid, arvif->vdev_id, ret); 7741 else 7742 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7743 "removed peer %pM vdev %d after vdev stop\n", 7744 arvif->bssid, arvif->vdev_id); 7745 } 7746 7747 if (ab->hw_params.vdev_start_delay && 7748 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 7749 ath11k_wmi_vdev_down(ar, arvif->vdev_id); 7750 7751 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7752 ar->num_started_vdevs == 1 && 7753 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) { 7754 ret = ath11k_mac_monitor_stop(ar); 7755 if (ret) 7756 /* continue even if there's an error */ 7757 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d", 7758 ret); 7759 } 7760 7761 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 7762 ath11k_mac_11d_scan_start(ar, arvif->vdev_id); 7763 7764 mutex_unlock(&ar->conf_mutex); 7765 } 7766 7767 static int 7768 ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw, 7769 struct ieee80211_vif_chanctx_switch *vifs, 7770 int n_vifs, 7771 enum ieee80211_chanctx_switch_mode mode) 7772 { 7773 struct ath11k *ar = hw->priv; 7774 7775 mutex_lock(&ar->conf_mutex); 7776 7777 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7778 "chanctx switch n_vifs %d mode %d\n", 7779 n_vifs, mode); 7780 ath11k_mac_update_vif_chan(ar, vifs, n_vifs); 7781 7782 mutex_unlock(&ar->conf_mutex); 7783 7784 return 0; 7785 } 7786 7787 static int 7788 ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value) 7789 { 7790 struct ath11k_vif *arvif; 7791 int ret = 0; 7792 7793 mutex_lock(&ar->conf_mutex); 7794 list_for_each_entry(arvif, &ar->arvifs, list) { 7795 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n", 7796 param, arvif->vdev_id, value); 7797 7798 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7799 param, value); 7800 if (ret) { 7801 ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n", 7802 param, arvif->vdev_id, ret); 7803 break; 7804 } 7805 } 7806 mutex_unlock(&ar->conf_mutex); 7807 return ret; 7808 } 7809 7810 /* mac80211 stores device specific RTS/Fragmentation threshold value, 7811 * this is set interface specific to firmware from ath11k driver 7812 */ 7813 static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 7814 { 7815 struct ath11k *ar = hw->priv; 7816 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 7817 7818 return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value); 7819 } 7820 7821 static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 7822 { 7823 /* Even though there's a WMI vdev param for fragmentation threshold no 7824 * known firmware actually implements it. Moreover it is not possible to 7825 * rely frame fragmentation to mac80211 because firmware clears the 7826 * "more fragments" bit in frame control making it impossible for remote 7827 * devices to reassemble frames. 7828 * 7829 * Hence implement a dummy callback just to say fragmentation isn't 7830 * supported. This effectively prevents mac80211 from doing frame 7831 * fragmentation in software. 7832 */ 7833 return -EOPNOTSUPP; 7834 } 7835 7836 static int ath11k_mac_flush_tx_complete(struct ath11k *ar) 7837 { 7838 long time_left; 7839 int ret = 0; 7840 7841 time_left = wait_event_timeout(ar->dp.tx_empty_waitq, 7842 (atomic_read(&ar->dp.num_tx_pending) == 0), 7843 ATH11K_FLUSH_TIMEOUT); 7844 if (time_left == 0) { 7845 ath11k_warn(ar->ab, "failed to flush transmit queue, data pkts pending %d\n", 7846 atomic_read(&ar->dp.num_tx_pending)); 7847 ret = -ETIMEDOUT; 7848 } 7849 7850 time_left = wait_event_timeout(ar->txmgmt_empty_waitq, 7851 (atomic_read(&ar->num_pending_mgmt_tx) == 0), 7852 ATH11K_FLUSH_TIMEOUT); 7853 if (time_left == 0) { 7854 ath11k_warn(ar->ab, "failed to flush mgmt transmit queue, mgmt pkts pending %d\n", 7855 atomic_read(&ar->num_pending_mgmt_tx)); 7856 ret = -ETIMEDOUT; 7857 } 7858 7859 return ret; 7860 } 7861 7862 int ath11k_mac_wait_tx_complete(struct ath11k *ar) 7863 { 7864 ath11k_mac_drain_tx(ar); 7865 return ath11k_mac_flush_tx_complete(ar); 7866 } 7867 7868 static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 7869 u32 queues, bool drop) 7870 { 7871 struct ath11k *ar = hw->priv; 7872 7873 if (drop) 7874 return; 7875 7876 ath11k_mac_flush_tx_complete(ar); 7877 } 7878 7879 static bool 7880 ath11k_mac_has_single_legacy_rate(struct ath11k *ar, 7881 enum nl80211_band band, 7882 const struct cfg80211_bitrate_mask *mask) 7883 { 7884 int num_rates = 0; 7885 7886 num_rates = hweight32(mask->control[band].legacy); 7887 7888 if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask)) 7889 return false; 7890 7891 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask)) 7892 return false; 7893 7894 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask)) 7895 return false; 7896 7897 return num_rates == 1; 7898 } 7899 7900 static __le16 7901 ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap) 7902 { 7903 if (he_cap->he_cap_elem.phy_cap_info[0] & 7904 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 7905 return he_cap->he_mcs_nss_supp.tx_mcs_80p80; 7906 7907 if (he_cap->he_cap_elem.phy_cap_info[0] & 7908 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) 7909 return he_cap->he_mcs_nss_supp.tx_mcs_160; 7910 7911 return he_cap->he_mcs_nss_supp.tx_mcs_80; 7912 } 7913 7914 static bool 7915 ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar, 7916 enum nl80211_band band, 7917 const struct cfg80211_bitrate_mask *mask, 7918 int *nss) 7919 { 7920 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 7921 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 7922 u16 he_mcs_map = 0; 7923 u8 ht_nss_mask = 0; 7924 u8 vht_nss_mask = 0; 7925 u8 he_nss_mask = 0; 7926 int i; 7927 7928 /* No need to consider legacy here. Basic rates are always present 7929 * in bitrate mask 7930 */ 7931 7932 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 7933 if (mask->control[band].ht_mcs[i] == 0) 7934 continue; 7935 else if (mask->control[band].ht_mcs[i] == 7936 sband->ht_cap.mcs.rx_mask[i]) 7937 ht_nss_mask |= BIT(i); 7938 else 7939 return false; 7940 } 7941 7942 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 7943 if (mask->control[band].vht_mcs[i] == 0) 7944 continue; 7945 else if (mask->control[band].vht_mcs[i] == 7946 ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i)) 7947 vht_nss_mask |= BIT(i); 7948 else 7949 return false; 7950 } 7951 7952 he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(&sband->iftype_data->he_cap)); 7953 7954 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) { 7955 if (mask->control[band].he_mcs[i] == 0) 7956 continue; 7957 7958 if (mask->control[band].he_mcs[i] == 7959 ath11k_mac_get_max_he_mcs_map(he_mcs_map, i)) 7960 he_nss_mask |= BIT(i); 7961 else 7962 return false; 7963 } 7964 7965 if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask) 7966 return false; 7967 7968 if (ht_nss_mask == 0) 7969 return false; 7970 7971 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask) 7972 return false; 7973 7974 *nss = fls(ht_nss_mask); 7975 7976 return true; 7977 } 7978 7979 static int 7980 ath11k_mac_get_single_legacy_rate(struct ath11k *ar, 7981 enum nl80211_band band, 7982 const struct cfg80211_bitrate_mask *mask, 7983 u32 *rate, u8 *nss) 7984 { 7985 int rate_idx; 7986 u16 bitrate; 7987 u8 preamble; 7988 u8 hw_rate; 7989 7990 if (hweight32(mask->control[band].legacy) != 1) 7991 return -EINVAL; 7992 7993 rate_idx = ffs(mask->control[band].legacy) - 1; 7994 7995 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ) 7996 rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX; 7997 7998 hw_rate = ath11k_legacy_rates[rate_idx].hw_value; 7999 bitrate = ath11k_legacy_rates[rate_idx].bitrate; 8000 8001 if (ath11k_mac_bitrate_is_cck(bitrate)) 8002 preamble = WMI_RATE_PREAMBLE_CCK; 8003 else 8004 preamble = WMI_RATE_PREAMBLE_OFDM; 8005 8006 *nss = 1; 8007 *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble); 8008 8009 return 0; 8010 } 8011 8012 static int 8013 ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf) 8014 { 8015 struct ath11k *ar = arvif->ar; 8016 int ret; 8017 8018 /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */ 8019 if (he_gi && he_gi != 0xFF) 8020 he_gi += 1; 8021 8022 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8023 WMI_VDEV_PARAM_SGI, he_gi); 8024 if (ret) { 8025 ath11k_warn(ar->ab, "failed to set he gi %d: %d\n", 8026 he_gi, ret); 8027 return ret; 8028 } 8029 /* start from 1 */ 8030 if (he_ltf != 0xFF) 8031 he_ltf += 1; 8032 8033 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8034 WMI_VDEV_PARAM_HE_LTF, he_ltf); 8035 if (ret) { 8036 ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n", 8037 he_ltf, ret); 8038 return ret; 8039 } 8040 8041 return 0; 8042 } 8043 8044 static int 8045 ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf) 8046 { 8047 struct ath11k *ar = arvif->ar; 8048 int ret; 8049 u32 he_ar_gi_ltf; 8050 8051 if (he_gi != 0xFF) { 8052 switch (he_gi) { 8053 case NL80211_RATE_INFO_HE_GI_0_8: 8054 he_gi = WMI_AUTORATE_800NS_GI; 8055 break; 8056 case NL80211_RATE_INFO_HE_GI_1_6: 8057 he_gi = WMI_AUTORATE_1600NS_GI; 8058 break; 8059 case NL80211_RATE_INFO_HE_GI_3_2: 8060 he_gi = WMI_AUTORATE_3200NS_GI; 8061 break; 8062 default: 8063 ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi); 8064 return -EINVAL; 8065 } 8066 } 8067 8068 if (he_ltf != 0xFF) { 8069 switch (he_ltf) { 8070 case NL80211_RATE_INFO_HE_1XLTF: 8071 he_ltf = WMI_HE_AUTORATE_LTF_1X; 8072 break; 8073 case NL80211_RATE_INFO_HE_2XLTF: 8074 he_ltf = WMI_HE_AUTORATE_LTF_2X; 8075 break; 8076 case NL80211_RATE_INFO_HE_4XLTF: 8077 he_ltf = WMI_HE_AUTORATE_LTF_4X; 8078 break; 8079 default: 8080 ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf); 8081 return -EINVAL; 8082 } 8083 } 8084 8085 he_ar_gi_ltf = he_gi | he_ltf; 8086 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8087 WMI_VDEV_PARAM_AUTORATE_MISC_CFG, 8088 he_ar_gi_ltf); 8089 if (ret) { 8090 ath11k_warn(ar->ab, 8091 "failed to set he autorate gi %u ltf %u: %d\n", 8092 he_gi, he_ltf, ret); 8093 return ret; 8094 } 8095 8096 return 0; 8097 } 8098 8099 static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif, 8100 u32 rate, u8 nss, u8 sgi, u8 ldpc, 8101 u8 he_gi, u8 he_ltf, bool he_fixed_rate) 8102 { 8103 struct ath11k *ar = arvif->ar; 8104 u32 vdev_param; 8105 int ret; 8106 8107 lockdep_assert_held(&ar->conf_mutex); 8108 8109 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 8110 "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", 8111 arvif->vdev_id, rate, nss, sgi, ldpc, he_gi, 8112 he_ltf, he_fixed_rate); 8113 8114 if (!arvif->vif->bss_conf.he_support) { 8115 vdev_param = WMI_VDEV_PARAM_FIXED_RATE; 8116 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8117 vdev_param, rate); 8118 if (ret) { 8119 ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n", 8120 rate, ret); 8121 return ret; 8122 } 8123 } 8124 8125 vdev_param = WMI_VDEV_PARAM_NSS; 8126 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8127 vdev_param, nss); 8128 if (ret) { 8129 ath11k_warn(ar->ab, "failed to set nss param %d: %d\n", 8130 nss, ret); 8131 return ret; 8132 } 8133 8134 vdev_param = WMI_VDEV_PARAM_LDPC; 8135 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8136 vdev_param, ldpc); 8137 if (ret) { 8138 ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n", 8139 ldpc, ret); 8140 return ret; 8141 } 8142 8143 if (arvif->vif->bss_conf.he_support) { 8144 if (he_fixed_rate) { 8145 ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi, 8146 he_ltf); 8147 if (ret) { 8148 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n", 8149 ret); 8150 return ret; 8151 } 8152 } else { 8153 ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi, 8154 he_ltf); 8155 if (ret) { 8156 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n", 8157 ret); 8158 return ret; 8159 } 8160 } 8161 } else { 8162 vdev_param = WMI_VDEV_PARAM_SGI; 8163 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8164 vdev_param, sgi); 8165 if (ret) { 8166 ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n", 8167 sgi, ret); 8168 return ret; 8169 } 8170 } 8171 8172 return 0; 8173 } 8174 8175 static bool 8176 ath11k_mac_vht_mcs_range_present(struct ath11k *ar, 8177 enum nl80211_band band, 8178 const struct cfg80211_bitrate_mask *mask) 8179 { 8180 int i; 8181 u16 vht_mcs; 8182 8183 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 8184 vht_mcs = mask->control[band].vht_mcs[i]; 8185 8186 switch (vht_mcs) { 8187 case 0: 8188 case BIT(8) - 1: 8189 case BIT(9) - 1: 8190 case BIT(10) - 1: 8191 break; 8192 default: 8193 return false; 8194 } 8195 } 8196 8197 return true; 8198 } 8199 8200 static bool 8201 ath11k_mac_he_mcs_range_present(struct ath11k *ar, 8202 enum nl80211_band band, 8203 const struct cfg80211_bitrate_mask *mask) 8204 { 8205 int i; 8206 u16 he_mcs; 8207 8208 for (i = 0; i < NL80211_HE_NSS_MAX; i++) { 8209 he_mcs = mask->control[band].he_mcs[i]; 8210 8211 switch (he_mcs) { 8212 case 0: 8213 case BIT(8) - 1: 8214 case BIT(10) - 1: 8215 case BIT(12) - 1: 8216 break; 8217 default: 8218 return false; 8219 } 8220 } 8221 8222 return true; 8223 } 8224 8225 static void ath11k_mac_set_bitrate_mask_iter(void *data, 8226 struct ieee80211_sta *sta) 8227 { 8228 struct ath11k_vif *arvif = data; 8229 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 8230 struct ath11k *ar = arvif->ar; 8231 8232 spin_lock_bh(&ar->data_lock); 8233 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED; 8234 spin_unlock_bh(&ar->data_lock); 8235 8236 ieee80211_queue_work(ar->hw, &arsta->update_wk); 8237 } 8238 8239 static void ath11k_mac_disable_peer_fixed_rate(void *data, 8240 struct ieee80211_sta *sta) 8241 { 8242 struct ath11k_vif *arvif = data; 8243 struct ath11k *ar = arvif->ar; 8244 int ret; 8245 8246 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 8247 arvif->vdev_id, 8248 WMI_PEER_PARAM_FIXED_RATE, 8249 WMI_FIXED_RATE_NONE); 8250 if (ret) 8251 ath11k_warn(ar->ab, 8252 "failed to disable peer fixed rate for STA %pM ret %d\n", 8253 sta->addr, ret); 8254 } 8255 8256 static bool 8257 ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band, 8258 const struct cfg80211_bitrate_mask *mask) 8259 { 8260 bool he_fixed_rate = false, vht_fixed_rate = false; 8261 struct ath11k_peer *peer; 8262 const u16 *vht_mcs_mask, *he_mcs_mask; 8263 struct ieee80211_link_sta *deflink; 8264 u8 vht_nss, he_nss; 8265 bool ret = true; 8266 8267 vht_mcs_mask = mask->control[band].vht_mcs; 8268 he_mcs_mask = mask->control[band].he_mcs; 8269 8270 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1) 8271 vht_fixed_rate = true; 8272 8273 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1) 8274 he_fixed_rate = true; 8275 8276 if (!vht_fixed_rate && !he_fixed_rate) 8277 return true; 8278 8279 vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask); 8280 he_nss = ath11k_mac_max_he_nss(he_mcs_mask); 8281 8282 rcu_read_lock(); 8283 spin_lock_bh(&ar->ab->base_lock); 8284 list_for_each_entry(peer, &ar->ab->peers, list) { 8285 if (peer->sta) { 8286 deflink = &peer->sta->deflink; 8287 8288 if (vht_fixed_rate && (!deflink->vht_cap.vht_supported || 8289 deflink->rx_nss < vht_nss)) { 8290 ret = false; 8291 goto out; 8292 } 8293 8294 if (he_fixed_rate && (!deflink->he_cap.has_he || 8295 deflink->rx_nss < he_nss)) { 8296 ret = false; 8297 goto out; 8298 } 8299 } 8300 } 8301 8302 out: 8303 spin_unlock_bh(&ar->ab->base_lock); 8304 rcu_read_unlock(); 8305 return ret; 8306 } 8307 8308 static int 8309 ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw, 8310 struct ieee80211_vif *vif, 8311 const struct cfg80211_bitrate_mask *mask) 8312 { 8313 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 8314 struct cfg80211_chan_def def; 8315 struct ath11k_pdev_cap *cap; 8316 struct ath11k *ar = arvif->ar; 8317 enum nl80211_band band; 8318 const u8 *ht_mcs_mask; 8319 const u16 *vht_mcs_mask; 8320 const u16 *he_mcs_mask; 8321 u8 he_ltf = 0; 8322 u8 he_gi = 0; 8323 u32 rate; 8324 u8 nss; 8325 u8 sgi; 8326 u8 ldpc; 8327 int single_nss; 8328 int ret; 8329 int num_rates; 8330 bool he_fixed_rate = false; 8331 8332 if (ath11k_mac_vif_chan(vif, &def)) 8333 return -EPERM; 8334 8335 band = def.chan->band; 8336 cap = &ar->pdev->cap; 8337 ht_mcs_mask = mask->control[band].ht_mcs; 8338 vht_mcs_mask = mask->control[band].vht_mcs; 8339 he_mcs_mask = mask->control[band].he_mcs; 8340 ldpc = !!(cap->band[band].ht_cap_info & WMI_HT_CAP_TX_LDPC); 8341 8342 sgi = mask->control[band].gi; 8343 if (sgi == NL80211_TXRATE_FORCE_LGI) 8344 return -EINVAL; 8345 8346 he_gi = mask->control[band].he_gi; 8347 he_ltf = mask->control[band].he_ltf; 8348 8349 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it 8350 * requires passing at least one of used basic rates along with them. 8351 * Fixed rate setting across different preambles(legacy, HT, VHT) is 8352 * not supported by the FW. Hence use of FIXED_RATE vdev param is not 8353 * suitable for setting single HT/VHT rates. 8354 * But, there could be a single basic rate passed from userspace which 8355 * can be done through the FIXED_RATE param. 8356 */ 8357 if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) { 8358 ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate, 8359 &nss); 8360 if (ret) { 8361 ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n", 8362 arvif->vdev_id, ret); 8363 return ret; 8364 } 8365 ieee80211_iterate_stations_atomic(ar->hw, 8366 ath11k_mac_disable_peer_fixed_rate, 8367 arvif); 8368 } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, band, mask, 8369 &single_nss)) { 8370 rate = WMI_FIXED_RATE_NONE; 8371 nss = single_nss; 8372 mutex_lock(&ar->conf_mutex); 8373 arvif->bitrate_mask = *mask; 8374 ieee80211_iterate_stations_atomic(ar->hw, 8375 ath11k_mac_set_bitrate_mask_iter, 8376 arvif); 8377 mutex_unlock(&ar->conf_mutex); 8378 } else { 8379 rate = WMI_FIXED_RATE_NONE; 8380 8381 if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask)) 8382 ath11k_warn(ar->ab, 8383 "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n"); 8384 nss = min_t(u32, ar->num_tx_chains, 8385 max(max(ath11k_mac_max_ht_nss(ht_mcs_mask), 8386 ath11k_mac_max_vht_nss(vht_mcs_mask)), 8387 ath11k_mac_max_he_nss(he_mcs_mask))); 8388 8389 /* If multiple rates across different preambles are given 8390 * we can reconfigure this info with all peers using PEER_ASSOC 8391 * command with the below exception cases. 8392 * - Single VHT Rate : peer_assoc command accommodates only MCS 8393 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211 8394 * mandates passing basic rates along with HT/VHT rates, FW 8395 * doesn't allow switching from VHT to Legacy. Hence instead of 8396 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd, 8397 * we could set this VHT rate as peer fixed rate param, which 8398 * will override FIXED rate and FW rate control algorithm. 8399 * If single VHT rate is passed along with HT rates, we select 8400 * the VHT rate as fixed rate for vht peers. 8401 * - Multiple VHT Rates : When Multiple VHT rates are given,this 8402 * can be set using RATEMASK CMD which uses FW rate-ctl alg. 8403 * TODO: Setting multiple VHT MCS and replacing peer_assoc with 8404 * RATEMASK_CMDID can cover all use cases of setting rates 8405 * across multiple preambles and rates within same type. 8406 * But requires more validation of the command at this point. 8407 */ 8408 8409 num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, 8410 mask); 8411 8412 if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) && 8413 num_rates > 1) { 8414 /* TODO: Handle multiple VHT MCS values setting using 8415 * RATEMASK CMD 8416 */ 8417 ath11k_warn(ar->ab, 8418 "setting %d mcs values in bitrate mask not supported\n", 8419 num_rates); 8420 return -EINVAL; 8421 } 8422 8423 num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, 8424 mask); 8425 if (num_rates == 1) 8426 he_fixed_rate = true; 8427 8428 if (!ath11k_mac_he_mcs_range_present(ar, band, mask) && 8429 num_rates > 1) { 8430 ath11k_warn(ar->ab, 8431 "Setting more than one HE MCS Value in bitrate mask not supported\n"); 8432 return -EINVAL; 8433 } 8434 8435 mutex_lock(&ar->conf_mutex); 8436 ieee80211_iterate_stations_atomic(ar->hw, 8437 ath11k_mac_disable_peer_fixed_rate, 8438 arvif); 8439 8440 arvif->bitrate_mask = *mask; 8441 ieee80211_iterate_stations_atomic(ar->hw, 8442 ath11k_mac_set_bitrate_mask_iter, 8443 arvif); 8444 8445 mutex_unlock(&ar->conf_mutex); 8446 } 8447 8448 mutex_lock(&ar->conf_mutex); 8449 8450 ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi, 8451 he_ltf, he_fixed_rate); 8452 if (ret) { 8453 ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n", 8454 arvif->vdev_id, ret); 8455 } 8456 8457 mutex_unlock(&ar->conf_mutex); 8458 8459 return ret; 8460 } 8461 8462 static void 8463 ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw, 8464 enum ieee80211_reconfig_type reconfig_type) 8465 { 8466 struct ath11k *ar = hw->priv; 8467 struct ath11k_base *ab = ar->ab; 8468 int recovery_count; 8469 struct ath11k_vif *arvif; 8470 8471 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) 8472 return; 8473 8474 mutex_lock(&ar->conf_mutex); 8475 8476 if (ar->state == ATH11K_STATE_RESTARTED) { 8477 ath11k_warn(ar->ab, "pdev %d successfully recovered\n", 8478 ar->pdev->pdev_id); 8479 ar->state = ATH11K_STATE_ON; 8480 ieee80211_wake_queues(ar->hw); 8481 8482 if (ar->ab->hw_params.current_cc_support && 8483 ar->alpha2[0] != 0 && ar->alpha2[1] != 0) { 8484 struct wmi_set_current_country_params set_current_param = {}; 8485 8486 memcpy(&set_current_param.alpha2, ar->alpha2, 2); 8487 ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param); 8488 } 8489 8490 if (ab->is_reset) { 8491 recovery_count = atomic_inc_return(&ab->recovery_count); 8492 ath11k_dbg(ab, ATH11K_DBG_BOOT, 8493 "recovery count %d\n", recovery_count); 8494 /* When there are multiple radios in an SOC, 8495 * the recovery has to be done for each radio 8496 */ 8497 if (recovery_count == ab->num_radios) { 8498 atomic_dec(&ab->reset_count); 8499 complete(&ab->reset_complete); 8500 ab->is_reset = false; 8501 atomic_set(&ab->fail_cont_count, 0); 8502 ath11k_dbg(ab, ATH11K_DBG_BOOT, "reset success\n"); 8503 } 8504 } 8505 if (ar->ab->hw_params.support_fw_mac_sequence) { 8506 list_for_each_entry(arvif, &ar->arvifs, list) { 8507 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_STA) 8508 ieee80211_hw_restart_disconnect(arvif->vif); 8509 } 8510 } 8511 } 8512 8513 mutex_unlock(&ar->conf_mutex); 8514 } 8515 8516 static void 8517 ath11k_mac_update_bss_chan_survey(struct ath11k *ar, 8518 struct ieee80211_channel *channel) 8519 { 8520 int ret; 8521 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ; 8522 8523 lockdep_assert_held(&ar->conf_mutex); 8524 8525 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) || 8526 ar->rx_channel != channel) 8527 return; 8528 8529 if (ar->scan.state != ATH11K_SCAN_IDLE) { 8530 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 8531 "ignoring bss chan info req while scanning..\n"); 8532 return; 8533 } 8534 8535 reinit_completion(&ar->bss_survey_done); 8536 8537 ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type); 8538 if (ret) { 8539 ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n"); 8540 return; 8541 } 8542 8543 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ); 8544 if (ret == 0) 8545 ath11k_warn(ar->ab, "bss channel survey timed out\n"); 8546 } 8547 8548 static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx, 8549 struct survey_info *survey) 8550 { 8551 struct ath11k *ar = hw->priv; 8552 struct ieee80211_supported_band *sband; 8553 struct survey_info *ar_survey; 8554 int ret = 0; 8555 8556 if (idx >= ATH11K_NUM_CHANS) 8557 return -ENOENT; 8558 8559 ar_survey = &ar->survey[idx]; 8560 8561 mutex_lock(&ar->conf_mutex); 8562 8563 sband = hw->wiphy->bands[NL80211_BAND_2GHZ]; 8564 if (sband && idx >= sband->n_channels) { 8565 idx -= sband->n_channels; 8566 sband = NULL; 8567 } 8568 8569 if (!sband) 8570 sband = hw->wiphy->bands[NL80211_BAND_5GHZ]; 8571 if (sband && idx >= sband->n_channels) { 8572 idx -= sband->n_channels; 8573 sband = NULL; 8574 } 8575 8576 if (!sband) 8577 sband = hw->wiphy->bands[NL80211_BAND_6GHZ]; 8578 if (!sband || idx >= sband->n_channels) { 8579 ret = -ENOENT; 8580 goto exit; 8581 } 8582 8583 ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]); 8584 8585 spin_lock_bh(&ar->data_lock); 8586 memcpy(survey, ar_survey, sizeof(*survey)); 8587 spin_unlock_bh(&ar->data_lock); 8588 8589 survey->channel = &sband->channels[idx]; 8590 8591 if (ar->rx_channel == survey->channel) 8592 survey->filled |= SURVEY_INFO_IN_USE; 8593 8594 exit: 8595 mutex_unlock(&ar->conf_mutex); 8596 return ret; 8597 } 8598 8599 static void ath11k_mac_put_chain_rssi(struct station_info *sinfo, 8600 struct ath11k_sta *arsta, 8601 char *pre, 8602 bool clear) 8603 { 8604 struct ath11k *ar = arsta->arvif->ar; 8605 int i; 8606 s8 rssi; 8607 8608 for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) { 8609 sinfo->chains &= ~BIT(i); 8610 rssi = arsta->chain_signal[i]; 8611 if (clear) 8612 arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL; 8613 8614 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 8615 "sta statistics %s rssi[%d] %d\n", pre, i, rssi); 8616 8617 if (rssi != ATH11K_DEFAULT_NOISE_FLOOR && 8618 rssi != ATH11K_INVALID_RSSI_FULL && 8619 rssi != ATH11K_INVALID_RSSI_EMPTY && 8620 rssi != 0) { 8621 sinfo->chain_signal[i] = rssi; 8622 sinfo->chains |= BIT(i); 8623 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL); 8624 } 8625 } 8626 } 8627 8628 static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw, 8629 struct ieee80211_vif *vif, 8630 struct ieee80211_sta *sta, 8631 struct station_info *sinfo) 8632 { 8633 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 8634 struct ath11k *ar = arsta->arvif->ar; 8635 s8 signal; 8636 bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT, 8637 ar->ab->wmi_ab.svc_map); 8638 8639 sinfo->rx_duration = arsta->rx_duration; 8640 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION); 8641 8642 sinfo->tx_duration = arsta->tx_duration; 8643 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION); 8644 8645 if (arsta->txrate.legacy || arsta->txrate.nss) { 8646 if (arsta->txrate.legacy) { 8647 sinfo->txrate.legacy = arsta->txrate.legacy; 8648 } else { 8649 sinfo->txrate.mcs = arsta->txrate.mcs; 8650 sinfo->txrate.nss = arsta->txrate.nss; 8651 sinfo->txrate.bw = arsta->txrate.bw; 8652 sinfo->txrate.he_gi = arsta->txrate.he_gi; 8653 sinfo->txrate.he_dcm = arsta->txrate.he_dcm; 8654 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc; 8655 } 8656 sinfo->txrate.flags = arsta->txrate.flags; 8657 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 8658 } 8659 8660 ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false); 8661 8662 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) && 8663 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA && 8664 ar->ab->hw_params.supports_rssi_stats && 8665 !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0, 8666 WMI_REQUEST_RSSI_PER_CHAIN_STAT)) { 8667 ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true); 8668 } 8669 8670 signal = arsta->rssi_comb; 8671 if (!signal && 8672 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA && 8673 ar->ab->hw_params.supports_rssi_stats && 8674 !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0, 8675 WMI_REQUEST_VDEV_STAT))) 8676 signal = arsta->rssi_beacon; 8677 8678 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 8679 "sta statistics db2dbm %u rssi comb %d rssi beacon %d\n", 8680 db2dbm, arsta->rssi_comb, arsta->rssi_beacon); 8681 8682 if (signal) { 8683 sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR; 8684 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 8685 } 8686 8687 sinfo->signal_avg = ewma_avg_rssi_read(&arsta->avg_rssi) + 8688 ATH11K_DEFAULT_NOISE_FLOOR; 8689 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG); 8690 } 8691 8692 #if IS_ENABLED(CONFIG_IPV6) 8693 static void ath11k_generate_ns_mc_addr(struct ath11k *ar, 8694 struct ath11k_arp_ns_offload *offload) 8695 { 8696 int i; 8697 8698 for (i = 0; i < offload->ipv6_count; i++) { 8699 offload->self_ipv6_addr[i][0] = 0xff; 8700 offload->self_ipv6_addr[i][1] = 0x02; 8701 offload->self_ipv6_addr[i][11] = 0x01; 8702 offload->self_ipv6_addr[i][12] = 0xff; 8703 offload->self_ipv6_addr[i][13] = 8704 offload->ipv6_addr[i][13]; 8705 offload->self_ipv6_addr[i][14] = 8706 offload->ipv6_addr[i][14]; 8707 offload->self_ipv6_addr[i][15] = 8708 offload->ipv6_addr[i][15]; 8709 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "NS solicited addr %pI6\n", 8710 offload->self_ipv6_addr[i]); 8711 } 8712 } 8713 8714 static void ath11k_mac_op_ipv6_changed(struct ieee80211_hw *hw, 8715 struct ieee80211_vif *vif, 8716 struct inet6_dev *idev) 8717 { 8718 struct ath11k *ar = hw->priv; 8719 struct ath11k_arp_ns_offload *offload; 8720 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 8721 struct inet6_ifaddr *ifa6; 8722 struct ifacaddr6 *ifaca6; 8723 struct list_head *p; 8724 u32 count, scope; 8725 8726 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "op ipv6 changed\n"); 8727 8728 offload = &arvif->arp_ns_offload; 8729 count = 0; 8730 8731 read_lock_bh(&idev->lock); 8732 8733 memset(offload->ipv6_addr, 0, sizeof(offload->ipv6_addr)); 8734 memset(offload->self_ipv6_addr, 0, sizeof(offload->self_ipv6_addr)); 8735 memcpy(offload->mac_addr, vif->addr, ETH_ALEN); 8736 8737 /* get unicast address */ 8738 list_for_each(p, &idev->addr_list) { 8739 if (count >= ATH11K_IPV6_MAX_COUNT) 8740 goto generate; 8741 8742 ifa6 = list_entry(p, struct inet6_ifaddr, if_list); 8743 if (ifa6->flags & IFA_F_DADFAILED) 8744 continue; 8745 scope = ipv6_addr_src_scope(&ifa6->addr); 8746 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL || 8747 scope == IPV6_ADDR_SCOPE_GLOBAL) { 8748 memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr, 8749 sizeof(ifa6->addr.s6_addr)); 8750 offload->ipv6_type[count] = ATH11K_IPV6_UC_TYPE; 8751 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "count %d ipv6 uc %pI6 scope %d\n", 8752 count, offload->ipv6_addr[count], 8753 scope); 8754 count++; 8755 } else { 8756 ath11k_warn(ar->ab, "Unsupported ipv6 scope: %d\n", scope); 8757 } 8758 } 8759 8760 /* get anycast address */ 8761 for (ifaca6 = idev->ac_list; ifaca6; ifaca6 = ifaca6->aca_next) { 8762 if (count >= ATH11K_IPV6_MAX_COUNT) 8763 goto generate; 8764 8765 scope = ipv6_addr_src_scope(&ifaca6->aca_addr); 8766 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL || 8767 scope == IPV6_ADDR_SCOPE_GLOBAL) { 8768 memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr, 8769 sizeof(ifaca6->aca_addr)); 8770 offload->ipv6_type[count] = ATH11K_IPV6_AC_TYPE; 8771 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "count %d ipv6 ac %pI6 scope %d\n", 8772 count, offload->ipv6_addr[count], 8773 scope); 8774 count++; 8775 } else { 8776 ath11k_warn(ar->ab, "Unsupported ipv scope: %d\n", scope); 8777 } 8778 } 8779 8780 generate: 8781 offload->ipv6_count = count; 8782 read_unlock_bh(&idev->lock); 8783 8784 /* generate ns multicast address */ 8785 ath11k_generate_ns_mc_addr(ar, offload); 8786 } 8787 #endif 8788 8789 static void ath11k_mac_op_set_rekey_data(struct ieee80211_hw *hw, 8790 struct ieee80211_vif *vif, 8791 struct cfg80211_gtk_rekey_data *data) 8792 { 8793 struct ath11k *ar = hw->priv; 8794 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 8795 struct ath11k_rekey_data *rekey_data = &arvif->rekey_data; 8796 8797 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "set rekey data vdev %d\n", 8798 arvif->vdev_id); 8799 8800 mutex_lock(&ar->conf_mutex); 8801 8802 memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN); 8803 memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN); 8804 8805 /* The supplicant works on big-endian, the firmware expects it on 8806 * little endian. 8807 */ 8808 rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr); 8809 8810 arvif->rekey_data.enable_offload = true; 8811 8812 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kck", NULL, 8813 rekey_data->kck, NL80211_KCK_LEN); 8814 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kek", NULL, 8815 rekey_data->kck, NL80211_KEK_LEN); 8816 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "replay ctr", NULL, 8817 &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr)); 8818 8819 mutex_unlock(&ar->conf_mutex); 8820 } 8821 8822 static int ath11k_mac_op_set_bios_sar_specs(struct ieee80211_hw *hw, 8823 const struct cfg80211_sar_specs *sar) 8824 { 8825 struct ath11k *ar = hw->priv; 8826 const struct cfg80211_sar_sub_specs *sspec; 8827 int ret, index; 8828 u8 *sar_tbl; 8829 u32 i; 8830 8831 if (!sar || sar->type != NL80211_SAR_TYPE_POWER || 8832 sar->num_sub_specs == 0) 8833 return -EINVAL; 8834 8835 mutex_lock(&ar->conf_mutex); 8836 8837 if (!test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) || 8838 !ar->ab->hw_params.bios_sar_capa) { 8839 ret = -EOPNOTSUPP; 8840 goto exit; 8841 } 8842 8843 ret = ath11k_wmi_pdev_set_bios_geo_table_param(ar); 8844 if (ret) { 8845 ath11k_warn(ar->ab, "failed to set geo table: %d\n", ret); 8846 goto exit; 8847 } 8848 8849 sar_tbl = kzalloc(BIOS_SAR_TABLE_LEN, GFP_KERNEL); 8850 if (!sar_tbl) { 8851 ret = -ENOMEM; 8852 goto exit; 8853 } 8854 8855 sspec = sar->sub_specs; 8856 for (i = 0; i < sar->num_sub_specs; i++) { 8857 if (sspec->freq_range_index >= (BIOS_SAR_TABLE_LEN >> 1)) { 8858 ath11k_warn(ar->ab, "Ignore bad frequency index %u, max allowed %u\n", 8859 sspec->freq_range_index, BIOS_SAR_TABLE_LEN >> 1); 8860 continue; 8861 } 8862 8863 /* chain0 and chain1 share same power setting */ 8864 sar_tbl[sspec->freq_range_index] = sspec->power; 8865 index = sspec->freq_range_index + (BIOS_SAR_TABLE_LEN >> 1); 8866 sar_tbl[index] = sspec->power; 8867 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "sar tbl[%d] = %d\n", 8868 sspec->freq_range_index, sar_tbl[sspec->freq_range_index]); 8869 sspec++; 8870 } 8871 8872 ret = ath11k_wmi_pdev_set_bios_sar_table_param(ar, sar_tbl); 8873 if (ret) 8874 ath11k_warn(ar->ab, "failed to set sar power: %d", ret); 8875 8876 kfree(sar_tbl); 8877 exit: 8878 mutex_unlock(&ar->conf_mutex); 8879 8880 return ret; 8881 } 8882 8883 static int ath11k_mac_op_cancel_remain_on_channel(struct ieee80211_hw *hw, 8884 struct ieee80211_vif *vif) 8885 { 8886 struct ath11k *ar = hw->priv; 8887 8888 mutex_lock(&ar->conf_mutex); 8889 8890 spin_lock_bh(&ar->data_lock); 8891 ar->scan.roc_notify = false; 8892 spin_unlock_bh(&ar->data_lock); 8893 8894 ath11k_scan_abort(ar); 8895 8896 mutex_unlock(&ar->conf_mutex); 8897 8898 cancel_delayed_work_sync(&ar->scan.timeout); 8899 8900 return 0; 8901 } 8902 8903 static int ath11k_mac_op_remain_on_channel(struct ieee80211_hw *hw, 8904 struct ieee80211_vif *vif, 8905 struct ieee80211_channel *chan, 8906 int duration, 8907 enum ieee80211_roc_type type) 8908 { 8909 struct ath11k *ar = hw->priv; 8910 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 8911 struct scan_req_params arg; 8912 int ret; 8913 u32 scan_time_msec; 8914 8915 mutex_lock(&ar->conf_mutex); 8916 8917 spin_lock_bh(&ar->data_lock); 8918 switch (ar->scan.state) { 8919 case ATH11K_SCAN_IDLE: 8920 reinit_completion(&ar->scan.started); 8921 reinit_completion(&ar->scan.completed); 8922 reinit_completion(&ar->scan.on_channel); 8923 ar->scan.state = ATH11K_SCAN_STARTING; 8924 ar->scan.is_roc = true; 8925 ar->scan.vdev_id = arvif->vdev_id; 8926 ar->scan.roc_freq = chan->center_freq; 8927 ar->scan.roc_notify = true; 8928 ret = 0; 8929 break; 8930 case ATH11K_SCAN_STARTING: 8931 case ATH11K_SCAN_RUNNING: 8932 case ATH11K_SCAN_ABORTING: 8933 ret = -EBUSY; 8934 break; 8935 } 8936 spin_unlock_bh(&ar->data_lock); 8937 8938 if (ret) 8939 goto exit; 8940 8941 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2; 8942 8943 memset(&arg, 0, sizeof(arg)); 8944 ath11k_wmi_start_scan_init(ar, &arg); 8945 arg.num_chan = 1; 8946 arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list), 8947 GFP_KERNEL); 8948 if (!arg.chan_list) { 8949 ret = -ENOMEM; 8950 goto exit; 8951 } 8952 8953 arg.vdev_id = arvif->vdev_id; 8954 arg.scan_id = ATH11K_SCAN_ID; 8955 arg.chan_list[0] = chan->center_freq; 8956 arg.dwell_time_active = scan_time_msec; 8957 arg.dwell_time_passive = scan_time_msec; 8958 arg.max_scan_time = scan_time_msec; 8959 arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE; 8960 arg.scan_flags |= WMI_SCAN_FILTER_PROBE_REQ; 8961 arg.burst_duration = duration; 8962 8963 ret = ath11k_start_scan(ar, &arg); 8964 if (ret) { 8965 ath11k_warn(ar->ab, "failed to start roc scan: %d\n", ret); 8966 8967 spin_lock_bh(&ar->data_lock); 8968 ar->scan.state = ATH11K_SCAN_IDLE; 8969 spin_unlock_bh(&ar->data_lock); 8970 goto free_chan_list; 8971 } 8972 8973 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ); 8974 if (ret == 0) { 8975 ath11k_warn(ar->ab, "failed to switch to channel for roc scan\n"); 8976 ret = ath11k_scan_stop(ar); 8977 if (ret) 8978 ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret); 8979 ret = -ETIMEDOUT; 8980 goto free_chan_list; 8981 } 8982 8983 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 8984 msecs_to_jiffies(duration)); 8985 8986 ret = 0; 8987 8988 free_chan_list: 8989 kfree(arg.chan_list); 8990 exit: 8991 mutex_unlock(&ar->conf_mutex); 8992 return ret; 8993 } 8994 8995 static int ath11k_fw_stats_request(struct ath11k *ar, 8996 struct stats_request_params *req_param) 8997 { 8998 struct ath11k_base *ab = ar->ab; 8999 unsigned long time_left; 9000 int ret; 9001 9002 lockdep_assert_held(&ar->conf_mutex); 9003 9004 spin_lock_bh(&ar->data_lock); 9005 ar->fw_stats_done = false; 9006 ath11k_fw_stats_pdevs_free(&ar->fw_stats.pdevs); 9007 spin_unlock_bh(&ar->data_lock); 9008 9009 reinit_completion(&ar->fw_stats_complete); 9010 9011 ret = ath11k_wmi_send_stats_request_cmd(ar, req_param); 9012 if (ret) { 9013 ath11k_warn(ab, "could not request fw stats (%d)\n", 9014 ret); 9015 return ret; 9016 } 9017 9018 time_left = wait_for_completion_timeout(&ar->fw_stats_complete, 9019 1 * HZ); 9020 9021 if (!time_left) 9022 return -ETIMEDOUT; 9023 9024 return 0; 9025 } 9026 9027 static int ath11k_mac_op_get_txpower(struct ieee80211_hw *hw, 9028 struct ieee80211_vif *vif, 9029 int *dbm) 9030 { 9031 struct ath11k *ar = hw->priv; 9032 struct ath11k_base *ab = ar->ab; 9033 struct stats_request_params req_param = {0}; 9034 struct ath11k_fw_stats_pdev *pdev; 9035 int ret; 9036 9037 /* Final Tx power is minimum of Target Power, CTL power, Regulatory 9038 * Power, PSD EIRP Power. We just know the Regulatory power from the 9039 * regulatory rules obtained. FW knows all these power and sets the min 9040 * of these. Hence, we request the FW pdev stats in which FW reports 9041 * the minimum of all vdev's channel Tx power. 9042 */ 9043 mutex_lock(&ar->conf_mutex); 9044 9045 if (ar->state != ATH11K_STATE_ON) 9046 goto err_fallback; 9047 9048 req_param.pdev_id = ar->pdev->pdev_id; 9049 req_param.stats_id = WMI_REQUEST_PDEV_STAT; 9050 9051 ret = ath11k_fw_stats_request(ar, &req_param); 9052 if (ret) { 9053 ath11k_warn(ab, "failed to request fw pdev stats: %d\n", ret); 9054 goto err_fallback; 9055 } 9056 9057 spin_lock_bh(&ar->data_lock); 9058 pdev = list_first_entry_or_null(&ar->fw_stats.pdevs, 9059 struct ath11k_fw_stats_pdev, list); 9060 if (!pdev) { 9061 spin_unlock_bh(&ar->data_lock); 9062 goto err_fallback; 9063 } 9064 9065 /* tx power is set as 2 units per dBm in FW. */ 9066 *dbm = pdev->chan_tx_power / 2; 9067 9068 spin_unlock_bh(&ar->data_lock); 9069 mutex_unlock(&ar->conf_mutex); 9070 9071 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower from firmware %d, reported %d dBm\n", 9072 pdev->chan_tx_power, *dbm); 9073 return 0; 9074 9075 err_fallback: 9076 mutex_unlock(&ar->conf_mutex); 9077 /* We didn't get txpower from FW. Hence, relying on vif->bss_conf.txpower */ 9078 *dbm = vif->bss_conf.txpower; 9079 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower from firmware NaN, reported %d dBm\n", 9080 *dbm); 9081 return 0; 9082 } 9083 9084 static const struct ieee80211_ops ath11k_ops = { 9085 .tx = ath11k_mac_op_tx, 9086 .wake_tx_queue = ieee80211_handle_wake_tx_queue, 9087 .start = ath11k_mac_op_start, 9088 .stop = ath11k_mac_op_stop, 9089 .reconfig_complete = ath11k_mac_op_reconfig_complete, 9090 .add_interface = ath11k_mac_op_add_interface, 9091 .remove_interface = ath11k_mac_op_remove_interface, 9092 .update_vif_offload = ath11k_mac_op_update_vif_offload, 9093 .config = ath11k_mac_op_config, 9094 .bss_info_changed = ath11k_mac_op_bss_info_changed, 9095 .configure_filter = ath11k_mac_op_configure_filter, 9096 .hw_scan = ath11k_mac_op_hw_scan, 9097 .cancel_hw_scan = ath11k_mac_op_cancel_hw_scan, 9098 .set_key = ath11k_mac_op_set_key, 9099 .set_rekey_data = ath11k_mac_op_set_rekey_data, 9100 .sta_state = ath11k_mac_op_sta_state, 9101 .sta_set_4addr = ath11k_mac_op_sta_set_4addr, 9102 .sta_set_txpwr = ath11k_mac_op_sta_set_txpwr, 9103 .sta_rc_update = ath11k_mac_op_sta_rc_update, 9104 .conf_tx = ath11k_mac_op_conf_tx, 9105 .set_antenna = ath11k_mac_op_set_antenna, 9106 .get_antenna = ath11k_mac_op_get_antenna, 9107 .ampdu_action = ath11k_mac_op_ampdu_action, 9108 .add_chanctx = ath11k_mac_op_add_chanctx, 9109 .remove_chanctx = ath11k_mac_op_remove_chanctx, 9110 .change_chanctx = ath11k_mac_op_change_chanctx, 9111 .assign_vif_chanctx = ath11k_mac_op_assign_vif_chanctx, 9112 .unassign_vif_chanctx = ath11k_mac_op_unassign_vif_chanctx, 9113 .switch_vif_chanctx = ath11k_mac_op_switch_vif_chanctx, 9114 .set_rts_threshold = ath11k_mac_op_set_rts_threshold, 9115 .set_frag_threshold = ath11k_mac_op_set_frag_threshold, 9116 .set_bitrate_mask = ath11k_mac_op_set_bitrate_mask, 9117 .get_survey = ath11k_mac_op_get_survey, 9118 .flush = ath11k_mac_op_flush, 9119 .sta_statistics = ath11k_mac_op_sta_statistics, 9120 CFG80211_TESTMODE_CMD(ath11k_tm_cmd) 9121 9122 #ifdef CONFIG_PM 9123 .suspend = ath11k_wow_op_suspend, 9124 .resume = ath11k_wow_op_resume, 9125 .set_wakeup = ath11k_wow_op_set_wakeup, 9126 #endif 9127 9128 #ifdef CONFIG_ATH11K_DEBUGFS 9129 .sta_add_debugfs = ath11k_debugfs_sta_op_add, 9130 #endif 9131 9132 #if IS_ENABLED(CONFIG_IPV6) 9133 .ipv6_addr_change = ath11k_mac_op_ipv6_changed, 9134 #endif 9135 .get_txpower = ath11k_mac_op_get_txpower, 9136 9137 .set_sar_specs = ath11k_mac_op_set_bios_sar_specs, 9138 .remain_on_channel = ath11k_mac_op_remain_on_channel, 9139 .cancel_remain_on_channel = ath11k_mac_op_cancel_remain_on_channel, 9140 }; 9141 9142 static void ath11k_mac_update_ch_list(struct ath11k *ar, 9143 struct ieee80211_supported_band *band, 9144 u32 freq_low, u32 freq_high) 9145 { 9146 int i; 9147 9148 if (!(freq_low && freq_high)) 9149 return; 9150 9151 for (i = 0; i < band->n_channels; i++) { 9152 if (band->channels[i].center_freq < freq_low || 9153 band->channels[i].center_freq > freq_high) 9154 band->channels[i].flags |= IEEE80211_CHAN_DISABLED; 9155 } 9156 } 9157 9158 static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band) 9159 { 9160 struct ath11k_pdev *pdev = ar->pdev; 9161 struct ath11k_pdev_cap *pdev_cap = &pdev->cap; 9162 9163 if (band == WMI_HOST_WLAN_2G_CAP) 9164 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id; 9165 9166 if (band == WMI_HOST_WLAN_5G_CAP) 9167 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id; 9168 9169 ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band); 9170 9171 return 0; 9172 } 9173 9174 static int ath11k_mac_setup_channels_rates(struct ath11k *ar, 9175 u32 supported_bands) 9176 { 9177 struct ieee80211_supported_band *band; 9178 struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap; 9179 void *channels; 9180 u32 phy_id; 9181 9182 BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) + 9183 ARRAY_SIZE(ath11k_5ghz_channels) + 9184 ARRAY_SIZE(ath11k_6ghz_channels)) != 9185 ATH11K_NUM_CHANS); 9186 9187 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx]; 9188 temp_reg_cap = reg_cap; 9189 9190 if (supported_bands & WMI_HOST_WLAN_2G_CAP) { 9191 channels = kmemdup(ath11k_2ghz_channels, 9192 sizeof(ath11k_2ghz_channels), 9193 GFP_KERNEL); 9194 if (!channels) 9195 return -ENOMEM; 9196 9197 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 9198 band->band = NL80211_BAND_2GHZ; 9199 band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels); 9200 band->channels = channels; 9201 band->n_bitrates = ath11k_g_rates_size; 9202 band->bitrates = ath11k_g_rates; 9203 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band; 9204 9205 if (ar->ab->hw_params.single_pdev_only) { 9206 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP); 9207 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id]; 9208 } 9209 ath11k_mac_update_ch_list(ar, band, 9210 temp_reg_cap->low_2ghz_chan, 9211 temp_reg_cap->high_2ghz_chan); 9212 } 9213 9214 if (supported_bands & WMI_HOST_WLAN_5G_CAP) { 9215 if (reg_cap->high_5ghz_chan >= ATH11K_MIN_6G_FREQ) { 9216 channels = kmemdup(ath11k_6ghz_channels, 9217 sizeof(ath11k_6ghz_channels), GFP_KERNEL); 9218 if (!channels) { 9219 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 9220 return -ENOMEM; 9221 } 9222 9223 ar->supports_6ghz = true; 9224 band = &ar->mac.sbands[NL80211_BAND_6GHZ]; 9225 band->band = NL80211_BAND_6GHZ; 9226 band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels); 9227 band->channels = channels; 9228 band->n_bitrates = ath11k_a_rates_size; 9229 band->bitrates = ath11k_a_rates; 9230 ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band; 9231 9232 if (ar->ab->hw_params.single_pdev_only) { 9233 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP); 9234 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id]; 9235 } 9236 9237 ath11k_mac_update_ch_list(ar, band, 9238 temp_reg_cap->low_5ghz_chan, 9239 temp_reg_cap->high_5ghz_chan); 9240 } 9241 9242 if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) { 9243 channels = kmemdup(ath11k_5ghz_channels, 9244 sizeof(ath11k_5ghz_channels), 9245 GFP_KERNEL); 9246 if (!channels) { 9247 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 9248 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 9249 return -ENOMEM; 9250 } 9251 9252 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 9253 band->band = NL80211_BAND_5GHZ; 9254 band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels); 9255 band->channels = channels; 9256 band->n_bitrates = ath11k_a_rates_size; 9257 band->bitrates = ath11k_a_rates; 9258 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band; 9259 9260 if (ar->ab->hw_params.single_pdev_only) { 9261 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP); 9262 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id]; 9263 } 9264 9265 ath11k_mac_update_ch_list(ar, band, 9266 temp_reg_cap->low_5ghz_chan, 9267 temp_reg_cap->high_5ghz_chan); 9268 } 9269 } 9270 9271 return 0; 9272 } 9273 9274 static int ath11k_mac_setup_iface_combinations(struct ath11k *ar) 9275 { 9276 struct ath11k_base *ab = ar->ab; 9277 struct ieee80211_iface_combination *combinations; 9278 struct ieee80211_iface_limit *limits; 9279 int n_limits; 9280 9281 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL); 9282 if (!combinations) 9283 return -ENOMEM; 9284 9285 n_limits = 2; 9286 9287 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL); 9288 if (!limits) { 9289 kfree(combinations); 9290 return -ENOMEM; 9291 } 9292 9293 limits[0].max = 1; 9294 limits[0].types |= BIT(NL80211_IFTYPE_STATION); 9295 9296 limits[1].max = 16; 9297 limits[1].types |= BIT(NL80211_IFTYPE_AP); 9298 9299 if (IS_ENABLED(CONFIG_MAC80211_MESH) && 9300 ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT)) 9301 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT); 9302 9303 combinations[0].limits = limits; 9304 combinations[0].n_limits = n_limits; 9305 combinations[0].max_interfaces = 16; 9306 combinations[0].num_different_channels = 1; 9307 combinations[0].beacon_int_infra_match = true; 9308 combinations[0].beacon_int_min_gcd = 100; 9309 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 9310 BIT(NL80211_CHAN_WIDTH_20) | 9311 BIT(NL80211_CHAN_WIDTH_40) | 9312 BIT(NL80211_CHAN_WIDTH_80) | 9313 BIT(NL80211_CHAN_WIDTH_80P80) | 9314 BIT(NL80211_CHAN_WIDTH_160); 9315 9316 ar->hw->wiphy->iface_combinations = combinations; 9317 ar->hw->wiphy->n_iface_combinations = 1; 9318 9319 return 0; 9320 } 9321 9322 static const u8 ath11k_if_types_ext_capa[] = { 9323 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 9324 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT, 9325 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 9326 }; 9327 9328 static const u8 ath11k_if_types_ext_capa_sta[] = { 9329 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 9330 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT, 9331 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 9332 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT, 9333 }; 9334 9335 static const u8 ath11k_if_types_ext_capa_ap[] = { 9336 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 9337 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT, 9338 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 9339 [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT, 9340 [10] = WLAN_EXT_CAPA11_EMA_SUPPORT, 9341 }; 9342 9343 static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = { 9344 { 9345 .extended_capabilities = ath11k_if_types_ext_capa, 9346 .extended_capabilities_mask = ath11k_if_types_ext_capa, 9347 .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa), 9348 }, { 9349 .iftype = NL80211_IFTYPE_STATION, 9350 .extended_capabilities = ath11k_if_types_ext_capa_sta, 9351 .extended_capabilities_mask = ath11k_if_types_ext_capa_sta, 9352 .extended_capabilities_len = 9353 sizeof(ath11k_if_types_ext_capa_sta), 9354 }, { 9355 .iftype = NL80211_IFTYPE_AP, 9356 .extended_capabilities = ath11k_if_types_ext_capa_ap, 9357 .extended_capabilities_mask = ath11k_if_types_ext_capa_ap, 9358 .extended_capabilities_len = 9359 sizeof(ath11k_if_types_ext_capa_ap), 9360 }, 9361 }; 9362 9363 static void __ath11k_mac_unregister(struct ath11k *ar) 9364 { 9365 cancel_work_sync(&ar->regd_update_work); 9366 9367 ieee80211_unregister_hw(ar->hw); 9368 9369 idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar); 9370 idr_destroy(&ar->txmgmt_idr); 9371 9372 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 9373 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 9374 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 9375 9376 kfree(ar->hw->wiphy->iface_combinations[0].limits); 9377 kfree(ar->hw->wiphy->iface_combinations); 9378 9379 SET_IEEE80211_DEV(ar->hw, NULL); 9380 } 9381 9382 void ath11k_mac_unregister(struct ath11k_base *ab) 9383 { 9384 struct ath11k *ar; 9385 struct ath11k_pdev *pdev; 9386 int i; 9387 9388 for (i = 0; i < ab->num_radios; i++) { 9389 pdev = &ab->pdevs[i]; 9390 ar = pdev->ar; 9391 if (!ar) 9392 continue; 9393 9394 __ath11k_mac_unregister(ar); 9395 } 9396 9397 ath11k_peer_rhash_tbl_destroy(ab); 9398 } 9399 9400 static int __ath11k_mac_register(struct ath11k *ar) 9401 { 9402 struct ath11k_base *ab = ar->ab; 9403 struct ath11k_pdev_cap *cap = &ar->pdev->cap; 9404 static const u32 cipher_suites[] = { 9405 WLAN_CIPHER_SUITE_TKIP, 9406 WLAN_CIPHER_SUITE_CCMP, 9407 WLAN_CIPHER_SUITE_AES_CMAC, 9408 WLAN_CIPHER_SUITE_BIP_CMAC_256, 9409 WLAN_CIPHER_SUITE_BIP_GMAC_128, 9410 WLAN_CIPHER_SUITE_BIP_GMAC_256, 9411 WLAN_CIPHER_SUITE_GCMP, 9412 WLAN_CIPHER_SUITE_GCMP_256, 9413 WLAN_CIPHER_SUITE_CCMP_256, 9414 }; 9415 int ret; 9416 u32 ht_cap = 0; 9417 9418 ath11k_pdev_caps_update(ar); 9419 9420 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 9421 9422 SET_IEEE80211_DEV(ar->hw, ab->dev); 9423 9424 ret = ath11k_mac_setup_channels_rates(ar, 9425 cap->supported_bands); 9426 if (ret) 9427 goto err; 9428 9429 ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap); 9430 ath11k_mac_setup_he_cap(ar, cap); 9431 9432 ret = ath11k_mac_setup_iface_combinations(ar); 9433 if (ret) { 9434 ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret); 9435 goto err_free_channels; 9436 } 9437 9438 ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask; 9439 ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask; 9440 9441 ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes; 9442 9443 if (ab->hw_params.single_pdev_only && ar->supports_6ghz) 9444 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS); 9445 9446 if (ab->hw_params.supports_multi_bssid) { 9447 ieee80211_hw_set(ar->hw, SUPPORTS_MULTI_BSSID); 9448 ieee80211_hw_set(ar->hw, SUPPORTS_ONLY_HE_MULTI_BSSID); 9449 } 9450 9451 ieee80211_hw_set(ar->hw, SIGNAL_DBM); 9452 ieee80211_hw_set(ar->hw, SUPPORTS_PS); 9453 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS); 9454 ieee80211_hw_set(ar->hw, MFP_CAPABLE); 9455 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS); 9456 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL); 9457 ieee80211_hw_set(ar->hw, AP_LINK_PS); 9458 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT); 9459 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR); 9460 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK); 9461 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF); 9462 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA); 9463 ieee80211_hw_set(ar->hw, QUEUE_CONTROL); 9464 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG); 9465 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK); 9466 9467 if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) { 9468 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD); 9469 ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD); 9470 } 9471 9472 if (cap->nss_ratio_enabled) 9473 ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW); 9474 9475 if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) { 9476 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION); 9477 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW); 9478 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER); 9479 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU); 9480 ieee80211_hw_set(ar->hw, USES_RSS); 9481 } 9482 9483 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS; 9484 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 9485 9486 /* TODO: Check if HT capability advertised from firmware is different 9487 * for each band for a dual band capable radio. It will be tricky to 9488 * handle it when the ht capability different for each band. 9489 */ 9490 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS || 9491 (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz)) 9492 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS; 9493 9494 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 9495 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 9496 9497 ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL; 9498 9499 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 9500 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 9501 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 9502 9503 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 9504 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 9505 NL80211_FEATURE_AP_SCAN; 9506 9507 ar->max_num_stations = TARGET_NUM_STATIONS(ab); 9508 ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab); 9509 9510 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations; 9511 9512 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) { 9513 ar->hw->wiphy->features |= 9514 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR; 9515 } 9516 9517 if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) { 9518 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS; 9519 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS; 9520 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH; 9521 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS; 9522 ar->hw->wiphy->max_sched_scan_plan_interval = 9523 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT; 9524 ar->hw->wiphy->max_sched_scan_plan_iterations = 9525 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS; 9526 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR; 9527 } 9528 9529 ret = ath11k_wow_init(ar); 9530 if (ret) { 9531 ath11k_warn(ar->ab, "failed to init wow: %d\n", ret); 9532 goto err_free_if_combs; 9533 } 9534 9535 if (test_bit(WMI_TLV_SERVICE_TX_DATA_MGMT_ACK_RSSI, 9536 ar->ab->wmi_ab.svc_map)) 9537 wiphy_ext_feature_set(ar->hw->wiphy, 9538 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT); 9539 9540 ar->hw->queues = ATH11K_HW_MAX_QUEUES; 9541 ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN; 9542 ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1; 9543 ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE; 9544 9545 ar->hw->vif_data_size = sizeof(struct ath11k_vif); 9546 ar->hw->sta_data_size = sizeof(struct ath11k_sta); 9547 9548 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 9549 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR); 9550 if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD, 9551 ar->ab->wmi_ab.svc_map)) { 9552 wiphy_ext_feature_set(ar->hw->wiphy, 9553 NL80211_EXT_FEATURE_BSS_COLOR); 9554 ieee80211_hw_set(ar->hw, DETECTS_COLOR_COLLISION); 9555 } 9556 9557 ar->hw->wiphy->cipher_suites = cipher_suites; 9558 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 9559 9560 ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa; 9561 ar->hw->wiphy->num_iftype_ext_capab = 9562 ARRAY_SIZE(ath11k_iftypes_ext_capa); 9563 9564 if (ar->supports_6ghz) { 9565 wiphy_ext_feature_set(ar->hw->wiphy, 9566 NL80211_EXT_FEATURE_FILS_DISCOVERY); 9567 wiphy_ext_feature_set(ar->hw->wiphy, 9568 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP); 9569 } 9570 9571 wiphy_ext_feature_set(ar->hw->wiphy, 9572 NL80211_EXT_FEATURE_SET_SCAN_DWELL); 9573 9574 if (test_bit(WMI_TLV_SERVICE_RTT, ar->ab->wmi_ab.svc_map)) 9575 wiphy_ext_feature_set(ar->hw->wiphy, 9576 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER); 9577 9578 ar->hw->wiphy->mbssid_max_interfaces = TARGET_NUM_VDEVS(ab); 9579 ar->hw->wiphy->ema_max_profile_periodicity = TARGET_EMA_MAX_PROFILE_PERIOD; 9580 9581 ath11k_reg_init(ar); 9582 9583 if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) { 9584 ar->hw->netdev_features = NETIF_F_HW_CSUM; 9585 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL); 9586 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT); 9587 } 9588 9589 if (test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) && 9590 ab->hw_params.bios_sar_capa) 9591 ar->hw->wiphy->sar_capa = ab->hw_params.bios_sar_capa; 9592 9593 ret = ieee80211_register_hw(ar->hw); 9594 if (ret) { 9595 ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret); 9596 goto err_free_if_combs; 9597 } 9598 9599 if (!ab->hw_params.supports_monitor) 9600 /* There's a race between calling ieee80211_register_hw() 9601 * and here where the monitor mode is enabled for a little 9602 * while. But that time is so short and in practise it make 9603 * a difference in real life. 9604 */ 9605 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR); 9606 9607 /* Apply the regd received during initialization */ 9608 ret = ath11k_regd_update(ar); 9609 if (ret) { 9610 ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret); 9611 goto err_unregister_hw; 9612 } 9613 9614 if (ab->hw_params.current_cc_support && ab->new_alpha2[0]) { 9615 struct wmi_set_current_country_params set_current_param = {}; 9616 9617 memcpy(&set_current_param.alpha2, ab->new_alpha2, 2); 9618 memcpy(&ar->alpha2, ab->new_alpha2, 2); 9619 ret = ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param); 9620 if (ret) 9621 ath11k_warn(ar->ab, 9622 "failed set cc code for mac register: %d\n", ret); 9623 } 9624 9625 ret = ath11k_debugfs_register(ar); 9626 if (ret) { 9627 ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret); 9628 goto err_unregister_hw; 9629 } 9630 9631 return 0; 9632 9633 err_unregister_hw: 9634 ieee80211_unregister_hw(ar->hw); 9635 9636 err_free_if_combs: 9637 kfree(ar->hw->wiphy->iface_combinations[0].limits); 9638 kfree(ar->hw->wiphy->iface_combinations); 9639 9640 err_free_channels: 9641 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 9642 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 9643 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 9644 9645 err: 9646 SET_IEEE80211_DEV(ar->hw, NULL); 9647 return ret; 9648 } 9649 9650 int ath11k_mac_register(struct ath11k_base *ab) 9651 { 9652 struct ath11k *ar; 9653 struct ath11k_pdev *pdev; 9654 int i; 9655 int ret; 9656 u8 mac_addr[ETH_ALEN] = {0}; 9657 9658 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) 9659 return 0; 9660 9661 /* Initialize channel counters frequency value in hertz */ 9662 ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ; 9663 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1; 9664 9665 ret = ath11k_peer_rhash_tbl_init(ab); 9666 if (ret) 9667 return ret; 9668 9669 device_get_mac_address(ab->dev, mac_addr); 9670 9671 for (i = 0; i < ab->num_radios; i++) { 9672 pdev = &ab->pdevs[i]; 9673 ar = pdev->ar; 9674 if (ab->pdevs_macaddr_valid) { 9675 ether_addr_copy(ar->mac_addr, pdev->mac_addr); 9676 } else { 9677 if (is_zero_ether_addr(mac_addr)) 9678 ether_addr_copy(ar->mac_addr, ab->mac_addr); 9679 else 9680 ether_addr_copy(ar->mac_addr, mac_addr); 9681 ar->mac_addr[4] += i; 9682 } 9683 9684 idr_init(&ar->txmgmt_idr); 9685 spin_lock_init(&ar->txmgmt_idr_lock); 9686 9687 ret = __ath11k_mac_register(ar); 9688 if (ret) 9689 goto err_cleanup; 9690 9691 init_waitqueue_head(&ar->txmgmt_empty_waitq); 9692 } 9693 9694 return 0; 9695 9696 err_cleanup: 9697 for (i = i - 1; i >= 0; i--) { 9698 pdev = &ab->pdevs[i]; 9699 ar = pdev->ar; 9700 __ath11k_mac_unregister(ar); 9701 } 9702 9703 ath11k_peer_rhash_tbl_destroy(ab); 9704 9705 return ret; 9706 } 9707 9708 int ath11k_mac_allocate(struct ath11k_base *ab) 9709 { 9710 struct ieee80211_hw *hw; 9711 struct ath11k *ar; 9712 struct ath11k_pdev *pdev; 9713 int ret; 9714 int i; 9715 9716 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) 9717 return 0; 9718 9719 for (i = 0; i < ab->num_radios; i++) { 9720 pdev = &ab->pdevs[i]; 9721 hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops); 9722 if (!hw) { 9723 ath11k_warn(ab, "failed to allocate mac80211 hw device\n"); 9724 ret = -ENOMEM; 9725 goto err_free_mac; 9726 } 9727 9728 ar = hw->priv; 9729 ar->hw = hw; 9730 ar->ab = ab; 9731 ar->pdev = pdev; 9732 ar->pdev_idx = i; 9733 ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i); 9734 9735 ar->wmi = &ab->wmi_ab.wmi[i]; 9736 /* FIXME wmi[0] is already initialized during attach, 9737 * Should we do this again? 9738 */ 9739 ath11k_wmi_pdev_attach(ab, i); 9740 9741 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask; 9742 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask; 9743 ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask); 9744 ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask); 9745 9746 pdev->ar = ar; 9747 spin_lock_init(&ar->data_lock); 9748 INIT_LIST_HEAD(&ar->arvifs); 9749 INIT_LIST_HEAD(&ar->ppdu_stats_info); 9750 mutex_init(&ar->conf_mutex); 9751 init_completion(&ar->vdev_setup_done); 9752 init_completion(&ar->vdev_delete_done); 9753 init_completion(&ar->peer_assoc_done); 9754 init_completion(&ar->peer_delete_done); 9755 init_completion(&ar->install_key_done); 9756 init_completion(&ar->bss_survey_done); 9757 init_completion(&ar->scan.started); 9758 init_completion(&ar->scan.completed); 9759 init_completion(&ar->scan.on_channel); 9760 init_completion(&ar->thermal.wmi_sync); 9761 9762 INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work); 9763 INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work); 9764 9765 INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work); 9766 skb_queue_head_init(&ar->wmi_mgmt_tx_queue); 9767 9768 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags); 9769 9770 ar->monitor_vdev_id = -1; 9771 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 9772 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID; 9773 init_completion(&ar->completed_11d_scan); 9774 9775 ath11k_fw_stats_init(ar); 9776 } 9777 9778 return 0; 9779 9780 err_free_mac: 9781 ath11k_mac_destroy(ab); 9782 9783 return ret; 9784 } 9785 9786 void ath11k_mac_destroy(struct ath11k_base *ab) 9787 { 9788 struct ath11k *ar; 9789 struct ath11k_pdev *pdev; 9790 int i; 9791 9792 for (i = 0; i < ab->num_radios; i++) { 9793 pdev = &ab->pdevs[i]; 9794 ar = pdev->ar; 9795 if (!ar) 9796 continue; 9797 9798 ath11k_fw_stats_free(&ar->fw_stats); 9799 ieee80211_free_hw(ar->hw); 9800 pdev->ar = NULL; 9801 } 9802 } 9803 9804 int ath11k_mac_vif_set_keepalive(struct ath11k_vif *arvif, 9805 enum wmi_sta_keepalive_method method, 9806 u32 interval) 9807 { 9808 struct ath11k *ar = arvif->ar; 9809 struct wmi_sta_keepalive_arg arg = {}; 9810 int ret; 9811 9812 lockdep_assert_held(&ar->conf_mutex); 9813 9814 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 9815 return 0; 9816 9817 if (!test_bit(WMI_TLV_SERVICE_STA_KEEP_ALIVE, ar->ab->wmi_ab.svc_map)) 9818 return 0; 9819 9820 arg.vdev_id = arvif->vdev_id; 9821 arg.enabled = 1; 9822 arg.method = method; 9823 arg.interval = interval; 9824 9825 ret = ath11k_wmi_sta_keepalive(ar, &arg); 9826 if (ret) { 9827 ath11k_warn(ar->ab, "failed to set keepalive on vdev %i: %d\n", 9828 arvif->vdev_id, ret); 9829 return ret; 9830 } 9831 9832 return 0; 9833 } 9834