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