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); 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->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->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->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->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->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->bandwidth == IEEE80211_STA_RX_BW_80) 1918 arg->bw_80 = true; 1919 1920 if (sta->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->rx_nss) { 1926 user_rate_valid = false; 1927 for (nss_idx = sta->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->rx_nss, sta->addr); 1938 vht_mcs_mask[sta->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->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->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->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->vht_cap.vht_supported) 2161 arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR + 2162 ampdu_factor)) - 1; 2163 else if (sta->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->rx_nss) { 2207 user_rate_valid = false; 2208 for (nss_idx = sta->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->rx_nss, sta->addr); 2219 he_mcs_mask[sta->rx_nss - 1] = he_mcs_mask[he_nss - 1]; 2220 } 2221 2222 switch (sta->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->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->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->he_6ghz_capa.capa) 2320 return; 2321 2322 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2323 arg->bw_40 = true; 2324 2325 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 2326 arg->bw_80 = true; 2327 2328 if (sta->bandwidth == IEEE80211_STA_RX_BW_160) 2329 arg->bw_160 = true; 2330 2331 arg->peer_he_caps_6ghz = le16_to_cpu(sta->he_6ghz_capa.capa); 2332 arg->peer_mpdu_density = 2333 ath11k_parse_mpdudensity(FIELD_GET(IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START, 2334 arg->peer_he_caps_6ghz)); 2335 2336 /* From IEEE Std 802.11ax-2021 - Section 10.12.2: An HE STA shall be capable of 2337 * receiving A-MPDU where the A-MPDU pre-EOF padding length is up to the value 2338 * indicated by the Maximum A-MPDU Length Exponent Extension field in the HE 2339 * Capabilities element and the Maximum A-MPDU Length Exponent field in HE 6 GHz 2340 * Band Capabilities element in the 6 GHz band. 2341 * 2342 * Here, we are extracting the Max A-MPDU Exponent Extension from HE caps and 2343 * factor is the Maximum A-MPDU Length Exponent from HE 6 GHZ Band capability. 2344 */ 2345 ampdu_factor = FIELD_GET(IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK, 2346 he_cap->he_cap_elem.mac_cap_info[3]) + 2347 FIELD_GET(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, 2348 arg->peer_he_caps_6ghz); 2349 2350 arg->peer_max_mpdu = (1u << (IEEE80211_HE_6GHZ_MAX_AMPDU_FACTOR + 2351 ampdu_factor)) - 1; 2352 } 2353 2354 static void ath11k_peer_assoc_h_smps(struct ieee80211_sta *sta, 2355 struct peer_assoc_params *arg) 2356 { 2357 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap; 2358 int smps; 2359 2360 if (!ht_cap->ht_supported && !sta->he_6ghz_capa.capa) 2361 return; 2362 2363 if (ht_cap->ht_supported) { 2364 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 2365 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 2366 } else { 2367 smps = le16_get_bits(sta->he_6ghz_capa.capa, 2368 IEEE80211_HE_6GHZ_CAP_SM_PS); 2369 } 2370 2371 switch (smps) { 2372 case WLAN_HT_CAP_SM_PS_STATIC: 2373 arg->static_mimops_flag = true; 2374 break; 2375 case WLAN_HT_CAP_SM_PS_DYNAMIC: 2376 arg->dynamic_mimops_flag = true; 2377 break; 2378 case WLAN_HT_CAP_SM_PS_DISABLED: 2379 arg->spatial_mux_flag = true; 2380 break; 2381 default: 2382 break; 2383 } 2384 } 2385 2386 static void ath11k_peer_assoc_h_qos(struct ath11k *ar, 2387 struct ieee80211_vif *vif, 2388 struct ieee80211_sta *sta, 2389 struct peer_assoc_params *arg) 2390 { 2391 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2392 2393 switch (arvif->vdev_type) { 2394 case WMI_VDEV_TYPE_AP: 2395 if (sta->wme) { 2396 /* TODO: Check WME vs QoS */ 2397 arg->is_wme_set = true; 2398 arg->qos_flag = true; 2399 } 2400 2401 if (sta->wme && sta->uapsd_queues) { 2402 /* TODO: Check WME vs QoS */ 2403 arg->is_wme_set = true; 2404 arg->apsd_flag = true; 2405 arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG; 2406 } 2407 break; 2408 case WMI_VDEV_TYPE_STA: 2409 if (sta->wme) { 2410 arg->is_wme_set = true; 2411 arg->qos_flag = true; 2412 } 2413 break; 2414 default: 2415 break; 2416 } 2417 2418 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM qos %d\n", 2419 sta->addr, arg->qos_flag); 2420 } 2421 2422 static int ath11k_peer_assoc_qos_ap(struct ath11k *ar, 2423 struct ath11k_vif *arvif, 2424 struct ieee80211_sta *sta) 2425 { 2426 struct ap_ps_params params; 2427 u32 max_sp; 2428 u32 uapsd; 2429 int ret; 2430 2431 lockdep_assert_held(&ar->conf_mutex); 2432 2433 params.vdev_id = arvif->vdev_id; 2434 2435 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n", 2436 sta->uapsd_queues, sta->max_sp); 2437 2438 uapsd = 0; 2439 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) 2440 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN | 2441 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN; 2442 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) 2443 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN | 2444 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN; 2445 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) 2446 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN | 2447 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN; 2448 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) 2449 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN | 2450 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN; 2451 2452 max_sp = 0; 2453 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP) 2454 max_sp = sta->max_sp; 2455 2456 params.param = WMI_AP_PS_PEER_PARAM_UAPSD; 2457 params.value = uapsd; 2458 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms); 2459 if (ret) 2460 goto err; 2461 2462 params.param = WMI_AP_PS_PEER_PARAM_MAX_SP; 2463 params.value = max_sp; 2464 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms); 2465 if (ret) 2466 goto err; 2467 2468 /* TODO revisit during testing */ 2469 params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE; 2470 params.value = DISABLE_SIFS_RESPONSE_TRIGGER; 2471 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms); 2472 if (ret) 2473 goto err; 2474 2475 params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD; 2476 params.value = DISABLE_SIFS_RESPONSE_TRIGGER; 2477 ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, ¶ms); 2478 if (ret) 2479 goto err; 2480 2481 return 0; 2482 2483 err: 2484 ath11k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n", 2485 params.param, arvif->vdev_id, ret); 2486 return ret; 2487 } 2488 2489 static bool ath11k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta) 2490 { 2491 return sta->supp_rates[NL80211_BAND_2GHZ] >> 2492 ATH11K_MAC_FIRST_OFDM_RATE_IDX; 2493 } 2494 2495 static enum wmi_phy_mode ath11k_mac_get_phymode_vht(struct ath11k *ar, 2496 struct ieee80211_sta *sta) 2497 { 2498 if (sta->bandwidth == IEEE80211_STA_RX_BW_160) { 2499 switch (sta->vht_cap.cap & 2500 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) { 2501 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ: 2502 return MODE_11AC_VHT160; 2503 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ: 2504 return MODE_11AC_VHT80_80; 2505 default: 2506 /* not sure if this is a valid case? */ 2507 return MODE_11AC_VHT160; 2508 } 2509 } 2510 2511 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 2512 return MODE_11AC_VHT80; 2513 2514 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2515 return MODE_11AC_VHT40; 2516 2517 if (sta->bandwidth == IEEE80211_STA_RX_BW_20) 2518 return MODE_11AC_VHT20; 2519 2520 return MODE_UNKNOWN; 2521 } 2522 2523 static enum wmi_phy_mode ath11k_mac_get_phymode_he(struct ath11k *ar, 2524 struct ieee80211_sta *sta) 2525 { 2526 if (sta->bandwidth == IEEE80211_STA_RX_BW_160) { 2527 if (sta->he_cap.he_cap_elem.phy_cap_info[0] & 2528 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) 2529 return MODE_11AX_HE160; 2530 else if (sta->he_cap.he_cap_elem.phy_cap_info[0] & 2531 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 2532 return MODE_11AX_HE80_80; 2533 /* not sure if this is a valid case? */ 2534 return MODE_11AX_HE160; 2535 } 2536 2537 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 2538 return MODE_11AX_HE80; 2539 2540 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2541 return MODE_11AX_HE40; 2542 2543 if (sta->bandwidth == IEEE80211_STA_RX_BW_20) 2544 return MODE_11AX_HE20; 2545 2546 return MODE_UNKNOWN; 2547 } 2548 2549 static void ath11k_peer_assoc_h_phymode(struct ath11k *ar, 2550 struct ieee80211_vif *vif, 2551 struct ieee80211_sta *sta, 2552 struct peer_assoc_params *arg) 2553 { 2554 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2555 struct cfg80211_chan_def def; 2556 enum nl80211_band band; 2557 const u8 *ht_mcs_mask; 2558 const u16 *vht_mcs_mask; 2559 const u16 *he_mcs_mask; 2560 enum wmi_phy_mode phymode = MODE_UNKNOWN; 2561 2562 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 2563 return; 2564 2565 band = def.chan->band; 2566 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 2567 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 2568 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs; 2569 2570 switch (band) { 2571 case NL80211_BAND_2GHZ: 2572 if (sta->he_cap.has_he && 2573 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) { 2574 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 2575 phymode = MODE_11AX_HE80_2G; 2576 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2577 phymode = MODE_11AX_HE40_2G; 2578 else 2579 phymode = MODE_11AX_HE20_2G; 2580 } else if (sta->vht_cap.vht_supported && 2581 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2582 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2583 phymode = MODE_11AC_VHT40; 2584 else 2585 phymode = MODE_11AC_VHT20; 2586 } else if (sta->ht_cap.ht_supported && 2587 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2588 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 2589 phymode = MODE_11NG_HT40; 2590 else 2591 phymode = MODE_11NG_HT20; 2592 } else if (ath11k_mac_sta_has_ofdm_only(sta)) { 2593 phymode = MODE_11G; 2594 } else { 2595 phymode = MODE_11B; 2596 } 2597 break; 2598 case NL80211_BAND_5GHZ: 2599 case NL80211_BAND_6GHZ: 2600 /* Check HE first */ 2601 if (sta->he_cap.has_he && 2602 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) { 2603 phymode = ath11k_mac_get_phymode_he(ar, sta); 2604 } else if (sta->vht_cap.vht_supported && 2605 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2606 phymode = ath11k_mac_get_phymode_vht(ar, sta); 2607 } else if (sta->ht_cap.ht_supported && 2608 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2609 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) 2610 phymode = MODE_11NA_HT40; 2611 else 2612 phymode = MODE_11NA_HT20; 2613 } else { 2614 phymode = MODE_11A; 2615 } 2616 break; 2617 default: 2618 break; 2619 } 2620 2621 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM phymode %s\n", 2622 sta->addr, ath11k_wmi_phymode_str(phymode)); 2623 2624 arg->peer_phymode = phymode; 2625 WARN_ON(phymode == MODE_UNKNOWN); 2626 } 2627 2628 static void ath11k_peer_assoc_prepare(struct ath11k *ar, 2629 struct ieee80211_vif *vif, 2630 struct ieee80211_sta *sta, 2631 struct peer_assoc_params *arg, 2632 bool reassoc) 2633 { 2634 struct ath11k_sta *arsta; 2635 2636 lockdep_assert_held(&ar->conf_mutex); 2637 2638 arsta = (struct ath11k_sta *)sta->drv_priv; 2639 2640 memset(arg, 0, sizeof(*arg)); 2641 2642 reinit_completion(&ar->peer_assoc_done); 2643 2644 arg->peer_new_assoc = !reassoc; 2645 ath11k_peer_assoc_h_basic(ar, vif, sta, arg); 2646 ath11k_peer_assoc_h_crypto(ar, vif, sta, arg); 2647 ath11k_peer_assoc_h_rates(ar, vif, sta, arg); 2648 ath11k_peer_assoc_h_phymode(ar, vif, sta, arg); 2649 ath11k_peer_assoc_h_ht(ar, vif, sta, arg); 2650 ath11k_peer_assoc_h_vht(ar, vif, sta, arg); 2651 ath11k_peer_assoc_h_he(ar, vif, sta, arg); 2652 ath11k_peer_assoc_h_he_6ghz(ar, vif, sta, arg); 2653 ath11k_peer_assoc_h_qos(ar, vif, sta, arg); 2654 ath11k_peer_assoc_h_smps(sta, arg); 2655 2656 arsta->peer_nss = arg->peer_nss; 2657 2658 /* TODO: amsdu_disable req? */ 2659 } 2660 2661 static int ath11k_setup_peer_smps(struct ath11k *ar, struct ath11k_vif *arvif, 2662 const u8 *addr, 2663 const struct ieee80211_sta_ht_cap *ht_cap, 2664 u16 he_6ghz_capa) 2665 { 2666 int smps; 2667 2668 if (!ht_cap->ht_supported && !he_6ghz_capa) 2669 return 0; 2670 2671 if (ht_cap->ht_supported) { 2672 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 2673 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 2674 } else { 2675 smps = FIELD_GET(IEEE80211_HE_6GHZ_CAP_SM_PS, he_6ghz_capa); 2676 } 2677 2678 if (smps >= ARRAY_SIZE(ath11k_smps_map)) 2679 return -EINVAL; 2680 2681 return ath11k_wmi_set_peer_param(ar, addr, arvif->vdev_id, 2682 WMI_PEER_MIMO_PS_STATE, 2683 ath11k_smps_map[smps]); 2684 } 2685 2686 static void ath11k_bss_assoc(struct ieee80211_hw *hw, 2687 struct ieee80211_vif *vif, 2688 struct ieee80211_bss_conf *bss_conf) 2689 { 2690 struct ath11k *ar = hw->priv; 2691 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2692 struct peer_assoc_params peer_arg; 2693 struct ieee80211_sta *ap_sta; 2694 struct ath11k_peer *peer; 2695 bool is_auth = false; 2696 int ret; 2697 2698 lockdep_assert_held(&ar->conf_mutex); 2699 2700 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n", 2701 arvif->vdev_id, arvif->bssid, arvif->aid); 2702 2703 rcu_read_lock(); 2704 2705 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid); 2706 if (!ap_sta) { 2707 ath11k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n", 2708 bss_conf->bssid, arvif->vdev_id); 2709 rcu_read_unlock(); 2710 return; 2711 } 2712 2713 ath11k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false); 2714 2715 rcu_read_unlock(); 2716 2717 peer_arg.is_assoc = true; 2718 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 2719 if (ret) { 2720 ath11k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n", 2721 bss_conf->bssid, arvif->vdev_id, ret); 2722 return; 2723 } 2724 2725 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 2726 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 2727 bss_conf->bssid, arvif->vdev_id); 2728 return; 2729 } 2730 2731 ret = ath11k_setup_peer_smps(ar, arvif, bss_conf->bssid, 2732 &ap_sta->ht_cap, 2733 le16_to_cpu(ap_sta->he_6ghz_capa.capa)); 2734 if (ret) { 2735 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n", 2736 arvif->vdev_id, ret); 2737 return; 2738 } 2739 2740 WARN_ON(arvif->is_up); 2741 2742 arvif->aid = bss_conf->aid; 2743 ether_addr_copy(arvif->bssid, bss_conf->bssid); 2744 2745 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid); 2746 if (ret) { 2747 ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n", 2748 arvif->vdev_id, ret); 2749 return; 2750 } 2751 2752 arvif->is_up = true; 2753 2754 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 2755 "mac vdev %d up (associated) bssid %pM aid %d\n", 2756 arvif->vdev_id, bss_conf->bssid, bss_conf->aid); 2757 2758 spin_lock_bh(&ar->ab->base_lock); 2759 2760 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid); 2761 if (peer && peer->is_authorized) 2762 is_auth = true; 2763 2764 spin_unlock_bh(&ar->ab->base_lock); 2765 2766 if (is_auth) { 2767 ret = ath11k_wmi_set_peer_param(ar, arvif->bssid, 2768 arvif->vdev_id, 2769 WMI_PEER_AUTHORIZE, 2770 1); 2771 if (ret) 2772 ath11k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret); 2773 } 2774 2775 ret = ath11k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id, 2776 &bss_conf->he_obss_pd); 2777 if (ret) 2778 ath11k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n", 2779 arvif->vdev_id, ret); 2780 2781 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2782 WMI_VDEV_PARAM_DTIM_POLICY, 2783 WMI_DTIM_POLICY_STICK); 2784 if (ret) 2785 ath11k_warn(ar->ab, "failed to set vdev %d dtim policy: %d\n", 2786 arvif->vdev_id, ret); 2787 2788 ath11k_mac_11d_scan_stop_all(ar->ab); 2789 } 2790 2791 static void ath11k_bss_disassoc(struct ieee80211_hw *hw, 2792 struct ieee80211_vif *vif) 2793 { 2794 struct ath11k *ar = hw->priv; 2795 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2796 int ret; 2797 2798 lockdep_assert_held(&ar->conf_mutex); 2799 2800 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n", 2801 arvif->vdev_id, arvif->bssid); 2802 2803 ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id); 2804 if (ret) 2805 ath11k_warn(ar->ab, "failed to down vdev %i: %d\n", 2806 arvif->vdev_id, ret); 2807 2808 arvif->is_up = false; 2809 2810 cancel_delayed_work_sync(&arvif->connection_loss_work); 2811 } 2812 2813 static u32 ath11k_mac_get_rate_hw_value(int bitrate) 2814 { 2815 u32 preamble; 2816 u16 hw_value; 2817 int rate; 2818 size_t i; 2819 2820 if (ath11k_mac_bitrate_is_cck(bitrate)) 2821 preamble = WMI_RATE_PREAMBLE_CCK; 2822 else 2823 preamble = WMI_RATE_PREAMBLE_OFDM; 2824 2825 for (i = 0; i < ARRAY_SIZE(ath11k_legacy_rates); i++) { 2826 if (ath11k_legacy_rates[i].bitrate != bitrate) 2827 continue; 2828 2829 hw_value = ath11k_legacy_rates[i].hw_value; 2830 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble); 2831 2832 return rate; 2833 } 2834 2835 return -EINVAL; 2836 } 2837 2838 static void ath11k_recalculate_mgmt_rate(struct ath11k *ar, 2839 struct ieee80211_vif *vif, 2840 struct cfg80211_chan_def *def) 2841 { 2842 struct ath11k_vif *arvif = (void *)vif->drv_priv; 2843 const struct ieee80211_supported_band *sband; 2844 u8 basic_rate_idx; 2845 int hw_rate_code; 2846 u32 vdev_param; 2847 u16 bitrate; 2848 int ret; 2849 2850 lockdep_assert_held(&ar->conf_mutex); 2851 2852 sband = ar->hw->wiphy->bands[def->chan->band]; 2853 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1; 2854 bitrate = sband->bitrates[basic_rate_idx].bitrate; 2855 2856 hw_rate_code = ath11k_mac_get_rate_hw_value(bitrate); 2857 if (hw_rate_code < 0) { 2858 ath11k_warn(ar->ab, "bitrate not supported %d\n", bitrate); 2859 return; 2860 } 2861 2862 vdev_param = WMI_VDEV_PARAM_MGMT_RATE; 2863 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 2864 hw_rate_code); 2865 if (ret) 2866 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret); 2867 2868 /* For WCN6855, firmware will clear this param when vdev starts, hence 2869 * cache it here so that we can reconfigure it once vdev starts. 2870 */ 2871 ar->hw_rate_code = hw_rate_code; 2872 2873 vdev_param = WMI_VDEV_PARAM_BEACON_RATE; 2874 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 2875 hw_rate_code); 2876 if (ret) 2877 ath11k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret); 2878 } 2879 2880 static int ath11k_mac_fils_discovery(struct ath11k_vif *arvif, 2881 struct ieee80211_bss_conf *info) 2882 { 2883 struct ath11k *ar = arvif->ar; 2884 struct sk_buff *tmpl; 2885 int ret; 2886 u32 interval; 2887 bool unsol_bcast_probe_resp_enabled = false; 2888 2889 if (info->fils_discovery.max_interval) { 2890 interval = info->fils_discovery.max_interval; 2891 2892 tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif); 2893 if (tmpl) 2894 ret = ath11k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id, 2895 tmpl); 2896 } else if (info->unsol_bcast_probe_resp_interval) { 2897 unsol_bcast_probe_resp_enabled = 1; 2898 interval = info->unsol_bcast_probe_resp_interval; 2899 2900 tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw, 2901 arvif->vif); 2902 if (tmpl) 2903 ret = ath11k_wmi_probe_resp_tmpl(ar, arvif->vdev_id, 2904 tmpl); 2905 } else { /* Disable */ 2906 return ath11k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false); 2907 } 2908 2909 if (!tmpl) { 2910 ath11k_warn(ar->ab, 2911 "mac vdev %i failed to retrieve %s template\n", 2912 arvif->vdev_id, (unsol_bcast_probe_resp_enabled ? 2913 "unsolicited broadcast probe response" : 2914 "FILS discovery")); 2915 return -EPERM; 2916 } 2917 kfree_skb(tmpl); 2918 2919 if (!ret) 2920 ret = ath11k_wmi_fils_discovery(ar, arvif->vdev_id, interval, 2921 unsol_bcast_probe_resp_enabled); 2922 2923 return ret; 2924 } 2925 2926 static int ath11k_mac_config_obss_pd(struct ath11k *ar, 2927 struct ieee80211_he_obss_pd *he_obss_pd) 2928 { 2929 u32 bitmap[2], param_id, param_val, pdev_id; 2930 int ret; 2931 s8 non_srg_th = 0, srg_th = 0; 2932 2933 pdev_id = ar->pdev->pdev_id; 2934 2935 /* Set and enable SRG/non-SRG OBSS PD Threshold */ 2936 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD; 2937 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) { 2938 ret = ath11k_wmi_pdev_set_param(ar, param_id, 0, pdev_id); 2939 if (ret) 2940 ath11k_warn(ar->ab, 2941 "failed to set obss_pd_threshold for pdev: %u\n", 2942 pdev_id); 2943 return ret; 2944 } 2945 2946 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 2947 "mac obss pd sr_ctrl %x non_srg_thres %u srg_max %u\n", 2948 he_obss_pd->sr_ctrl, he_obss_pd->non_srg_max_offset, 2949 he_obss_pd->max_offset); 2950 2951 param_val = 0; 2952 2953 if (he_obss_pd->sr_ctrl & 2954 IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) { 2955 non_srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD; 2956 } else { 2957 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT) 2958 non_srg_th = (ATH11K_OBSS_PD_MAX_THRESHOLD + 2959 he_obss_pd->non_srg_max_offset); 2960 else 2961 non_srg_th = ATH11K_OBSS_PD_NON_SRG_MAX_THRESHOLD; 2962 2963 param_val |= ATH11K_OBSS_PD_NON_SRG_EN; 2964 } 2965 2966 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) { 2967 srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD + he_obss_pd->max_offset; 2968 param_val |= ATH11K_OBSS_PD_SRG_EN; 2969 } 2970 2971 if (test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT, 2972 ar->ab->wmi_ab.svc_map)) { 2973 param_val |= ATH11K_OBSS_PD_THRESHOLD_IN_DBM; 2974 param_val |= FIELD_PREP(GENMASK(15, 8), srg_th); 2975 } else { 2976 non_srg_th -= ATH11K_DEFAULT_NOISE_FLOOR; 2977 /* SRG not supported and threshold in dB */ 2978 param_val &= ~(ATH11K_OBSS_PD_SRG_EN | 2979 ATH11K_OBSS_PD_THRESHOLD_IN_DBM); 2980 } 2981 2982 param_val |= (non_srg_th & GENMASK(7, 0)); 2983 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 2984 if (ret) { 2985 ath11k_warn(ar->ab, 2986 "failed to set obss_pd_threshold for pdev: %u\n", 2987 pdev_id); 2988 return ret; 2989 } 2990 2991 /* Enable OBSS PD for all access category */ 2992 param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC; 2993 param_val = 0xf; 2994 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 2995 if (ret) { 2996 ath11k_warn(ar->ab, 2997 "failed to set obss_pd_per_ac for pdev: %u\n", 2998 pdev_id); 2999 return ret; 3000 } 3001 3002 /* Set SR Prohibit */ 3003 param_id = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT; 3004 param_val = !!(he_obss_pd->sr_ctrl & 3005 IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED); 3006 ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 3007 if (ret) { 3008 ath11k_warn(ar->ab, "failed to set sr_prohibit for pdev: %u\n", 3009 pdev_id); 3010 return ret; 3011 } 3012 3013 if (!test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT, 3014 ar->ab->wmi_ab.svc_map)) 3015 return 0; 3016 3017 /* Set SRG BSS Color Bitmap */ 3018 memcpy(bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap)); 3019 ret = ath11k_wmi_pdev_set_srg_bss_color_bitmap(ar, bitmap); 3020 if (ret) { 3021 ath11k_warn(ar->ab, 3022 "failed to set bss_color_bitmap for pdev: %u\n", 3023 pdev_id); 3024 return ret; 3025 } 3026 3027 /* Set SRG Partial BSSID Bitmap */ 3028 memcpy(bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap)); 3029 ret = ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(ar, bitmap); 3030 if (ret) { 3031 ath11k_warn(ar->ab, 3032 "failed to set partial_bssid_bitmap for pdev: %u\n", 3033 pdev_id); 3034 return ret; 3035 } 3036 3037 memset(bitmap, 0xff, sizeof(bitmap)); 3038 3039 /* Enable all BSS Colors for SRG */ 3040 ret = ath11k_wmi_pdev_srg_obss_color_enable_bitmap(ar, bitmap); 3041 if (ret) { 3042 ath11k_warn(ar->ab, 3043 "failed to set srg_color_en_bitmap pdev: %u\n", 3044 pdev_id); 3045 return ret; 3046 } 3047 3048 /* Enable all patial BSSID mask for SRG */ 3049 ret = ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, bitmap); 3050 if (ret) { 3051 ath11k_warn(ar->ab, 3052 "failed to set srg_bssid_en_bitmap pdev: %u\n", 3053 pdev_id); 3054 return ret; 3055 } 3056 3057 /* Enable all BSS Colors for non-SRG */ 3058 ret = ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, bitmap); 3059 if (ret) { 3060 ath11k_warn(ar->ab, 3061 "failed to set non_srg_color_en_bitmap pdev: %u\n", 3062 pdev_id); 3063 return ret; 3064 } 3065 3066 /* Enable all patial BSSID mask for non-SRG */ 3067 ret = ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, bitmap); 3068 if (ret) { 3069 ath11k_warn(ar->ab, 3070 "failed to set non_srg_bssid_en_bitmap pdev: %u\n", 3071 pdev_id); 3072 return ret; 3073 } 3074 3075 return 0; 3076 } 3077 3078 static void ath11k_mac_op_bss_info_changed(struct ieee80211_hw *hw, 3079 struct ieee80211_vif *vif, 3080 struct ieee80211_bss_conf *info, 3081 u32 changed) 3082 { 3083 struct ath11k *ar = hw->priv; 3084 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3085 struct cfg80211_chan_def def; 3086 u32 param_id, param_value; 3087 enum nl80211_band band; 3088 u32 vdev_param; 3089 int mcast_rate; 3090 u32 preamble; 3091 u16 hw_value; 3092 u16 bitrate; 3093 int ret = 0; 3094 u8 rateidx; 3095 u32 rate; 3096 3097 mutex_lock(&ar->conf_mutex); 3098 3099 if (changed & BSS_CHANGED_BEACON_INT) { 3100 arvif->beacon_interval = info->beacon_int; 3101 3102 param_id = WMI_VDEV_PARAM_BEACON_INTERVAL; 3103 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3104 param_id, 3105 arvif->beacon_interval); 3106 if (ret) 3107 ath11k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n", 3108 arvif->vdev_id); 3109 else 3110 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3111 "Beacon interval: %d set for VDEV: %d\n", 3112 arvif->beacon_interval, arvif->vdev_id); 3113 } 3114 3115 if (changed & BSS_CHANGED_BEACON) { 3116 param_id = WMI_PDEV_PARAM_BEACON_TX_MODE; 3117 param_value = WMI_BEACON_STAGGERED_MODE; 3118 ret = ath11k_wmi_pdev_set_param(ar, param_id, 3119 param_value, ar->pdev->pdev_id); 3120 if (ret) 3121 ath11k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n", 3122 arvif->vdev_id); 3123 else 3124 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3125 "Set staggered beacon mode for VDEV: %d\n", 3126 arvif->vdev_id); 3127 3128 if (!arvif->do_not_send_tmpl || !arvif->bcca_zero_sent) { 3129 ret = ath11k_mac_setup_bcn_tmpl(arvif); 3130 if (ret) 3131 ath11k_warn(ar->ab, "failed to update bcn template: %d\n", 3132 ret); 3133 } 3134 3135 if (arvif->bcca_zero_sent) 3136 arvif->do_not_send_tmpl = true; 3137 else 3138 arvif->do_not_send_tmpl = false; 3139 3140 if (vif->bss_conf.he_support) { 3141 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3142 WMI_VDEV_PARAM_BA_MODE, 3143 WMI_BA_MODE_BUFFER_SIZE_256); 3144 if (ret) 3145 ath11k_warn(ar->ab, 3146 "failed to set BA BUFFER SIZE 256 for vdev: %d\n", 3147 arvif->vdev_id); 3148 else 3149 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3150 "Set BA BUFFER SIZE 256 for VDEV: %d\n", 3151 arvif->vdev_id); 3152 } 3153 } 3154 3155 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) { 3156 arvif->dtim_period = info->dtim_period; 3157 3158 param_id = WMI_VDEV_PARAM_DTIM_PERIOD; 3159 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3160 param_id, 3161 arvif->dtim_period); 3162 3163 if (ret) 3164 ath11k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n", 3165 arvif->vdev_id, ret); 3166 else 3167 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3168 "DTIM period: %d set for VDEV: %d\n", 3169 arvif->dtim_period, arvif->vdev_id); 3170 } 3171 3172 if (changed & BSS_CHANGED_SSID && 3173 vif->type == NL80211_IFTYPE_AP) { 3174 arvif->u.ap.ssid_len = info->ssid_len; 3175 if (info->ssid_len) 3176 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len); 3177 arvif->u.ap.hidden_ssid = info->hidden_ssid; 3178 } 3179 3180 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid)) 3181 ether_addr_copy(arvif->bssid, info->bssid); 3182 3183 if (changed & BSS_CHANGED_BEACON_ENABLED) { 3184 ath11k_control_beaconing(arvif, info); 3185 3186 if (arvif->is_up && vif->bss_conf.he_support && 3187 vif->bss_conf.he_oper.params) { 3188 param_id = WMI_VDEV_PARAM_HEOPS_0_31; 3189 param_value = vif->bss_conf.he_oper.params; 3190 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3191 param_id, param_value); 3192 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3193 "he oper param: %x set for VDEV: %d\n", 3194 param_value, arvif->vdev_id); 3195 3196 if (ret) 3197 ath11k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n", 3198 param_value, arvif->vdev_id, ret); 3199 } 3200 } 3201 3202 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 3203 u32 cts_prot; 3204 3205 cts_prot = !!(info->use_cts_prot); 3206 param_id = WMI_VDEV_PARAM_PROTECTION_MODE; 3207 3208 if (arvif->is_started) { 3209 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3210 param_id, cts_prot); 3211 if (ret) 3212 ath11k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n", 3213 arvif->vdev_id); 3214 else 3215 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n", 3216 cts_prot, arvif->vdev_id); 3217 } else { 3218 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n"); 3219 } 3220 } 3221 3222 if (changed & BSS_CHANGED_ERP_SLOT) { 3223 u32 slottime; 3224 3225 if (info->use_short_slot) 3226 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 3227 3228 else 3229 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 3230 3231 param_id = WMI_VDEV_PARAM_SLOT_TIME; 3232 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3233 param_id, slottime); 3234 if (ret) 3235 ath11k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n", 3236 arvif->vdev_id); 3237 else 3238 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3239 "Set slottime: %d for VDEV: %d\n", 3240 slottime, arvif->vdev_id); 3241 } 3242 3243 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 3244 u32 preamble; 3245 3246 if (info->use_short_preamble) 3247 preamble = WMI_VDEV_PREAMBLE_SHORT; 3248 else 3249 preamble = WMI_VDEV_PREAMBLE_LONG; 3250 3251 param_id = WMI_VDEV_PARAM_PREAMBLE; 3252 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3253 param_id, preamble); 3254 if (ret) 3255 ath11k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n", 3256 arvif->vdev_id); 3257 else 3258 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3259 "Set preamble: %d for VDEV: %d\n", 3260 preamble, arvif->vdev_id); 3261 } 3262 3263 if (changed & BSS_CHANGED_ASSOC) { 3264 if (info->assoc) 3265 ath11k_bss_assoc(hw, vif, info); 3266 else 3267 ath11k_bss_disassoc(hw, vif); 3268 } 3269 3270 if (changed & BSS_CHANGED_TXPOWER) { 3271 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev_id %i txpower %d\n", 3272 arvif->vdev_id, info->txpower); 3273 3274 arvif->txpower = info->txpower; 3275 ath11k_mac_txpower_recalc(ar); 3276 } 3277 3278 if (changed & BSS_CHANGED_PS && 3279 ar->ab->hw_params.supports_sta_ps) { 3280 arvif->ps = vif->bss_conf.ps; 3281 3282 ret = ath11k_mac_config_ps(ar); 3283 if (ret) 3284 ath11k_warn(ar->ab, "failed to setup ps on vdev %i: %d\n", 3285 arvif->vdev_id, ret); 3286 } 3287 3288 if (changed & BSS_CHANGED_MCAST_RATE && 3289 !ath11k_mac_vif_chan(arvif->vif, &def)) { 3290 band = def.chan->band; 3291 mcast_rate = vif->bss_conf.mcast_rate[band]; 3292 3293 if (mcast_rate > 0) 3294 rateidx = mcast_rate - 1; 3295 else 3296 rateidx = ffs(vif->bss_conf.basic_rates) - 1; 3297 3298 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) 3299 rateidx += ATH11K_MAC_FIRST_OFDM_RATE_IDX; 3300 3301 bitrate = ath11k_legacy_rates[rateidx].bitrate; 3302 hw_value = ath11k_legacy_rates[rateidx].hw_value; 3303 3304 if (ath11k_mac_bitrate_is_cck(bitrate)) 3305 preamble = WMI_RATE_PREAMBLE_CCK; 3306 else 3307 preamble = WMI_RATE_PREAMBLE_OFDM; 3308 3309 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble); 3310 3311 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3312 "mac vdev %d mcast_rate %x\n", 3313 arvif->vdev_id, rate); 3314 3315 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE; 3316 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3317 vdev_param, rate); 3318 if (ret) 3319 ath11k_warn(ar->ab, 3320 "failed to set mcast rate on vdev %i: %d\n", 3321 arvif->vdev_id, ret); 3322 3323 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE; 3324 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3325 vdev_param, rate); 3326 if (ret) 3327 ath11k_warn(ar->ab, 3328 "failed to set bcast rate on vdev %i: %d\n", 3329 arvif->vdev_id, ret); 3330 } 3331 3332 if (changed & BSS_CHANGED_BASIC_RATES && 3333 !ath11k_mac_vif_chan(arvif->vif, &def)) 3334 ath11k_recalculate_mgmt_rate(ar, vif, &def); 3335 3336 if (changed & BSS_CHANGED_TWT) { 3337 if (info->twt_requester || info->twt_responder) 3338 ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id); 3339 else 3340 ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id); 3341 } 3342 3343 if (changed & BSS_CHANGED_HE_OBSS_PD) 3344 ath11k_mac_config_obss_pd(ar, &info->he_obss_pd); 3345 3346 if (changed & BSS_CHANGED_HE_BSS_COLOR) { 3347 if (vif->type == NL80211_IFTYPE_AP) { 3348 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd( 3349 ar, arvif->vdev_id, info->he_bss_color.color, 3350 ATH11K_BSS_COLOR_COLLISION_DETECTION_AP_PERIOD_MS, 3351 info->he_bss_color.enabled); 3352 if (ret) 3353 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n", 3354 arvif->vdev_id, ret); 3355 3356 param_id = WMI_VDEV_PARAM_BSS_COLOR; 3357 if (info->he_bss_color.enabled) 3358 param_value = info->he_bss_color.color << 3359 IEEE80211_HE_OPERATION_BSS_COLOR_OFFSET; 3360 else 3361 param_value = IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED; 3362 3363 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 3364 param_id, 3365 param_value); 3366 if (ret) 3367 ath11k_warn(ar->ab, 3368 "failed to set bss color param on vdev %i: %d\n", 3369 arvif->vdev_id, ret); 3370 3371 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3372 "bss color param 0x%x set on vdev %i\n", 3373 param_value, arvif->vdev_id); 3374 } else if (vif->type == NL80211_IFTYPE_STATION) { 3375 ret = ath11k_wmi_send_bss_color_change_enable_cmd(ar, 3376 arvif->vdev_id, 3377 1); 3378 if (ret) 3379 ath11k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n", 3380 arvif->vdev_id, ret); 3381 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd( 3382 ar, arvif->vdev_id, 0, 3383 ATH11K_BSS_COLOR_COLLISION_DETECTION_STA_PERIOD_MS, 1); 3384 if (ret) 3385 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n", 3386 arvif->vdev_id, ret); 3387 } 3388 } 3389 3390 if (changed & BSS_CHANGED_FILS_DISCOVERY || 3391 changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP) 3392 ath11k_mac_fils_discovery(arvif, info); 3393 3394 mutex_unlock(&ar->conf_mutex); 3395 } 3396 3397 void __ath11k_mac_scan_finish(struct ath11k *ar) 3398 { 3399 lockdep_assert_held(&ar->data_lock); 3400 3401 switch (ar->scan.state) { 3402 case ATH11K_SCAN_IDLE: 3403 break; 3404 case ATH11K_SCAN_RUNNING: 3405 case ATH11K_SCAN_ABORTING: 3406 if (ar->scan.is_roc && ar->scan.roc_notify) 3407 ieee80211_remain_on_channel_expired(ar->hw); 3408 fallthrough; 3409 case ATH11K_SCAN_STARTING: 3410 if (!ar->scan.is_roc) { 3411 struct cfg80211_scan_info info = { 3412 .aborted = ((ar->scan.state == 3413 ATH11K_SCAN_ABORTING) || 3414 (ar->scan.state == 3415 ATH11K_SCAN_STARTING)), 3416 }; 3417 3418 ieee80211_scan_completed(ar->hw, &info); 3419 } 3420 3421 ar->scan.state = ATH11K_SCAN_IDLE; 3422 ar->scan_channel = NULL; 3423 ar->scan.roc_freq = 0; 3424 cancel_delayed_work(&ar->scan.timeout); 3425 complete(&ar->scan.completed); 3426 break; 3427 } 3428 } 3429 3430 void ath11k_mac_scan_finish(struct ath11k *ar) 3431 { 3432 spin_lock_bh(&ar->data_lock); 3433 __ath11k_mac_scan_finish(ar); 3434 spin_unlock_bh(&ar->data_lock); 3435 } 3436 3437 static int ath11k_scan_stop(struct ath11k *ar) 3438 { 3439 struct scan_cancel_param arg = { 3440 .req_type = WLAN_SCAN_CANCEL_SINGLE, 3441 .scan_id = ATH11K_SCAN_ID, 3442 }; 3443 int ret; 3444 3445 lockdep_assert_held(&ar->conf_mutex); 3446 3447 /* TODO: Fill other STOP Params */ 3448 arg.pdev_id = ar->pdev->pdev_id; 3449 3450 ret = ath11k_wmi_send_scan_stop_cmd(ar, &arg); 3451 if (ret) { 3452 ath11k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret); 3453 goto out; 3454 } 3455 3456 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ); 3457 if (ret == 0) { 3458 ath11k_warn(ar->ab, 3459 "failed to receive scan abort comple: timed out\n"); 3460 ret = -ETIMEDOUT; 3461 } else if (ret > 0) { 3462 ret = 0; 3463 } 3464 3465 out: 3466 /* Scan state should be updated upon scan completion but in case 3467 * firmware fails to deliver the event (for whatever reason) it is 3468 * desired to clean up scan state anyway. Firmware may have just 3469 * dropped the scan completion event delivery due to transport pipe 3470 * being overflown with data and/or it can recover on its own before 3471 * next scan request is submitted. 3472 */ 3473 spin_lock_bh(&ar->data_lock); 3474 if (ar->scan.state != ATH11K_SCAN_IDLE) 3475 __ath11k_mac_scan_finish(ar); 3476 spin_unlock_bh(&ar->data_lock); 3477 3478 return ret; 3479 } 3480 3481 static void ath11k_scan_abort(struct ath11k *ar) 3482 { 3483 int ret; 3484 3485 lockdep_assert_held(&ar->conf_mutex); 3486 3487 spin_lock_bh(&ar->data_lock); 3488 3489 switch (ar->scan.state) { 3490 case ATH11K_SCAN_IDLE: 3491 /* This can happen if timeout worker kicked in and called 3492 * abortion while scan completion was being processed. 3493 */ 3494 break; 3495 case ATH11K_SCAN_STARTING: 3496 case ATH11K_SCAN_ABORTING: 3497 ath11k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n", 3498 ar->scan.state); 3499 break; 3500 case ATH11K_SCAN_RUNNING: 3501 ar->scan.state = ATH11K_SCAN_ABORTING; 3502 spin_unlock_bh(&ar->data_lock); 3503 3504 ret = ath11k_scan_stop(ar); 3505 if (ret) 3506 ath11k_warn(ar->ab, "failed to abort scan: %d\n", ret); 3507 3508 spin_lock_bh(&ar->data_lock); 3509 break; 3510 } 3511 3512 spin_unlock_bh(&ar->data_lock); 3513 } 3514 3515 static void ath11k_scan_timeout_work(struct work_struct *work) 3516 { 3517 struct ath11k *ar = container_of(work, struct ath11k, 3518 scan.timeout.work); 3519 3520 mutex_lock(&ar->conf_mutex); 3521 ath11k_scan_abort(ar); 3522 mutex_unlock(&ar->conf_mutex); 3523 } 3524 3525 static int ath11k_start_scan(struct ath11k *ar, 3526 struct scan_req_params *arg) 3527 { 3528 int ret; 3529 unsigned long timeout = 1 * HZ; 3530 3531 lockdep_assert_held(&ar->conf_mutex); 3532 3533 if (ath11k_spectral_get_mode(ar) == ATH11K_SPECTRAL_BACKGROUND) 3534 ath11k_spectral_reset_buffer(ar); 3535 3536 ret = ath11k_wmi_send_scan_start_cmd(ar, arg); 3537 if (ret) 3538 return ret; 3539 3540 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) { 3541 timeout = 5 * HZ; 3542 3543 if (ar->supports_6ghz) 3544 timeout += 5 * HZ; 3545 } 3546 3547 ret = wait_for_completion_timeout(&ar->scan.started, timeout); 3548 if (ret == 0) { 3549 ret = ath11k_scan_stop(ar); 3550 if (ret) 3551 ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret); 3552 3553 return -ETIMEDOUT; 3554 } 3555 3556 /* If we failed to start the scan, return error code at 3557 * this point. This is probably due to some issue in the 3558 * firmware, but no need to wedge the driver due to that... 3559 */ 3560 spin_lock_bh(&ar->data_lock); 3561 if (ar->scan.state == ATH11K_SCAN_IDLE) { 3562 spin_unlock_bh(&ar->data_lock); 3563 return -EINVAL; 3564 } 3565 spin_unlock_bh(&ar->data_lock); 3566 3567 return 0; 3568 } 3569 3570 static int ath11k_mac_op_hw_scan(struct ieee80211_hw *hw, 3571 struct ieee80211_vif *vif, 3572 struct ieee80211_scan_request *hw_req) 3573 { 3574 struct ath11k *ar = hw->priv; 3575 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3576 struct cfg80211_scan_request *req = &hw_req->req; 3577 struct scan_req_params arg; 3578 int ret = 0; 3579 int i; 3580 3581 mutex_lock(&ar->conf_mutex); 3582 3583 spin_lock_bh(&ar->data_lock); 3584 switch (ar->scan.state) { 3585 case ATH11K_SCAN_IDLE: 3586 reinit_completion(&ar->scan.started); 3587 reinit_completion(&ar->scan.completed); 3588 ar->scan.state = ATH11K_SCAN_STARTING; 3589 ar->scan.is_roc = false; 3590 ar->scan.vdev_id = arvif->vdev_id; 3591 ret = 0; 3592 break; 3593 case ATH11K_SCAN_STARTING: 3594 case ATH11K_SCAN_RUNNING: 3595 case ATH11K_SCAN_ABORTING: 3596 ret = -EBUSY; 3597 break; 3598 } 3599 spin_unlock_bh(&ar->data_lock); 3600 3601 if (ret) 3602 goto exit; 3603 3604 /* Currently the pending_11d=true only happened 1 time while 3605 * wlan interface up in ath11k_mac_11d_scan_start(), it is called by 3606 * ath11k_mac_op_add_interface(), after wlan interface up, 3607 * pending_11d=false always. 3608 * If remove below wait, it always happened scan fail and lead connect 3609 * fail while wlan interface up, because it has a 11d scan which is running 3610 * in firmware, and lead this scan failed. 3611 */ 3612 if (ar->pending_11d) { 3613 long time_left; 3614 unsigned long timeout = 5 * HZ; 3615 3616 if (ar->supports_6ghz) 3617 timeout += 5 * HZ; 3618 3619 time_left = wait_for_completion_timeout(&ar->finish_11d_ch_list, timeout); 3620 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 3621 "mac wait 11d channel list time left %ld\n", time_left); 3622 } 3623 3624 memset(&arg, 0, sizeof(arg)); 3625 ath11k_wmi_start_scan_init(ar, &arg); 3626 arg.vdev_id = arvif->vdev_id; 3627 arg.scan_id = ATH11K_SCAN_ID; 3628 3629 if (req->ie_len) { 3630 arg.extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL); 3631 if (!arg.extraie.ptr) { 3632 ret = -ENOMEM; 3633 goto exit; 3634 } 3635 arg.extraie.len = req->ie_len; 3636 } 3637 3638 if (req->n_ssids) { 3639 arg.num_ssids = req->n_ssids; 3640 for (i = 0; i < arg.num_ssids; i++) { 3641 arg.ssid[i].length = req->ssids[i].ssid_len; 3642 memcpy(&arg.ssid[i].ssid, req->ssids[i].ssid, 3643 req->ssids[i].ssid_len); 3644 } 3645 } else { 3646 arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE; 3647 } 3648 3649 if (req->n_channels) { 3650 arg.num_chan = req->n_channels; 3651 arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list), 3652 GFP_KERNEL); 3653 3654 if (!arg.chan_list) { 3655 ret = -ENOMEM; 3656 goto exit; 3657 } 3658 3659 for (i = 0; i < arg.num_chan; i++) 3660 arg.chan_list[i] = req->channels[i]->center_freq; 3661 } 3662 3663 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 3664 arg.scan_f_add_spoofed_mac_in_probe = 1; 3665 ether_addr_copy(arg.mac_addr.addr, req->mac_addr); 3666 ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask); 3667 } 3668 3669 ret = ath11k_start_scan(ar, &arg); 3670 if (ret) { 3671 ath11k_warn(ar->ab, "failed to start hw scan: %d\n", ret); 3672 spin_lock_bh(&ar->data_lock); 3673 ar->scan.state = ATH11K_SCAN_IDLE; 3674 spin_unlock_bh(&ar->data_lock); 3675 } 3676 3677 /* Add a 200ms margin to account for event/command processing */ 3678 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout, 3679 msecs_to_jiffies(arg.max_scan_time + 3680 ATH11K_MAC_SCAN_TIMEOUT_MSECS)); 3681 3682 exit: 3683 kfree(arg.chan_list); 3684 3685 if (req->ie_len) 3686 kfree(arg.extraie.ptr); 3687 3688 mutex_unlock(&ar->conf_mutex); 3689 return ret; 3690 } 3691 3692 static void ath11k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw, 3693 struct ieee80211_vif *vif) 3694 { 3695 struct ath11k *ar = hw->priv; 3696 3697 mutex_lock(&ar->conf_mutex); 3698 ath11k_scan_abort(ar); 3699 mutex_unlock(&ar->conf_mutex); 3700 3701 cancel_delayed_work_sync(&ar->scan.timeout); 3702 } 3703 3704 static int ath11k_install_key(struct ath11k_vif *arvif, 3705 struct ieee80211_key_conf *key, 3706 enum set_key_cmd cmd, 3707 const u8 *macaddr, u32 flags) 3708 { 3709 int ret; 3710 struct ath11k *ar = arvif->ar; 3711 struct wmi_vdev_install_key_arg arg = { 3712 .vdev_id = arvif->vdev_id, 3713 .key_idx = key->keyidx, 3714 .key_len = key->keylen, 3715 .key_data = key->key, 3716 .key_flags = flags, 3717 .macaddr = macaddr, 3718 }; 3719 3720 lockdep_assert_held(&arvif->ar->conf_mutex); 3721 3722 reinit_completion(&ar->install_key_done); 3723 3724 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags)) 3725 return 0; 3726 3727 if (cmd == DISABLE_KEY) { 3728 arg.key_cipher = WMI_CIPHER_NONE; 3729 arg.key_data = NULL; 3730 goto install; 3731 } 3732 3733 switch (key->cipher) { 3734 case WLAN_CIPHER_SUITE_CCMP: 3735 arg.key_cipher = WMI_CIPHER_AES_CCM; 3736 /* TODO: Re-check if flag is valid */ 3737 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT; 3738 break; 3739 case WLAN_CIPHER_SUITE_TKIP: 3740 arg.key_cipher = WMI_CIPHER_TKIP; 3741 arg.key_txmic_len = 8; 3742 arg.key_rxmic_len = 8; 3743 break; 3744 case WLAN_CIPHER_SUITE_CCMP_256: 3745 arg.key_cipher = WMI_CIPHER_AES_CCM; 3746 break; 3747 case WLAN_CIPHER_SUITE_GCMP: 3748 case WLAN_CIPHER_SUITE_GCMP_256: 3749 arg.key_cipher = WMI_CIPHER_AES_GCM; 3750 break; 3751 default: 3752 ath11k_warn(ar->ab, "cipher %d is not supported\n", key->cipher); 3753 return -EOPNOTSUPP; 3754 } 3755 3756 if (test_bit(ATH11K_FLAG_RAW_MODE, &ar->ab->dev_flags)) 3757 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV | 3758 IEEE80211_KEY_FLAG_RESERVE_TAILROOM; 3759 3760 install: 3761 ret = ath11k_wmi_vdev_install_key(arvif->ar, &arg); 3762 3763 if (ret) 3764 return ret; 3765 3766 if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ)) 3767 return -ETIMEDOUT; 3768 3769 return ar->install_key_status ? -EINVAL : 0; 3770 } 3771 3772 static int ath11k_clear_peer_keys(struct ath11k_vif *arvif, 3773 const u8 *addr) 3774 { 3775 struct ath11k *ar = arvif->ar; 3776 struct ath11k_base *ab = ar->ab; 3777 struct ath11k_peer *peer; 3778 int first_errno = 0; 3779 int ret; 3780 int i; 3781 u32 flags = 0; 3782 3783 lockdep_assert_held(&ar->conf_mutex); 3784 3785 spin_lock_bh(&ab->base_lock); 3786 peer = ath11k_peer_find(ab, arvif->vdev_id, addr); 3787 spin_unlock_bh(&ab->base_lock); 3788 3789 if (!peer) 3790 return -ENOENT; 3791 3792 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 3793 if (!peer->keys[i]) 3794 continue; 3795 3796 /* key flags are not required to delete the key */ 3797 ret = ath11k_install_key(arvif, peer->keys[i], 3798 DISABLE_KEY, addr, flags); 3799 if (ret < 0 && first_errno == 0) 3800 first_errno = ret; 3801 3802 if (ret < 0) 3803 ath11k_warn(ab, "failed to remove peer key %d: %d\n", 3804 i, ret); 3805 3806 spin_lock_bh(&ab->base_lock); 3807 peer->keys[i] = NULL; 3808 spin_unlock_bh(&ab->base_lock); 3809 } 3810 3811 return first_errno; 3812 } 3813 3814 static int ath11k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 3815 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 3816 struct ieee80211_key_conf *key) 3817 { 3818 struct ath11k *ar = hw->priv; 3819 struct ath11k_base *ab = ar->ab; 3820 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 3821 struct ath11k_peer *peer; 3822 struct ath11k_sta *arsta; 3823 const u8 *peer_addr; 3824 int ret = 0; 3825 u32 flags = 0; 3826 3827 /* BIP needs to be done in software */ 3828 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC || 3829 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 || 3830 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 || 3831 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256) 3832 return 1; 3833 3834 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags)) 3835 return 1; 3836 3837 if (key->keyidx > WMI_MAX_KEY_INDEX) 3838 return -ENOSPC; 3839 3840 mutex_lock(&ar->conf_mutex); 3841 3842 if (sta) 3843 peer_addr = sta->addr; 3844 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 3845 peer_addr = vif->bss_conf.bssid; 3846 else 3847 peer_addr = vif->addr; 3848 3849 key->hw_key_idx = key->keyidx; 3850 3851 /* the peer should not disappear in mid-way (unless FW goes awry) since 3852 * we already hold conf_mutex. we just make sure its there now. 3853 */ 3854 spin_lock_bh(&ab->base_lock); 3855 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr); 3856 3857 /* flush the fragments cache during key (re)install to 3858 * ensure all frags in the new frag list belong to the same key. 3859 */ 3860 if (peer && sta && cmd == SET_KEY) 3861 ath11k_peer_frags_flush(ar, peer); 3862 spin_unlock_bh(&ab->base_lock); 3863 3864 if (!peer) { 3865 if (cmd == SET_KEY) { 3866 ath11k_warn(ab, "cannot install key for non-existent peer %pM\n", 3867 peer_addr); 3868 ret = -EOPNOTSUPP; 3869 goto exit; 3870 } else { 3871 /* if the peer doesn't exist there is no key to disable 3872 * anymore 3873 */ 3874 goto exit; 3875 } 3876 } 3877 3878 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 3879 flags |= WMI_KEY_PAIRWISE; 3880 else 3881 flags |= WMI_KEY_GROUP; 3882 3883 ret = ath11k_install_key(arvif, key, cmd, peer_addr, flags); 3884 if (ret) { 3885 ath11k_warn(ab, "ath11k_install_key failed (%d)\n", ret); 3886 goto exit; 3887 } 3888 3889 ret = ath11k_dp_peer_rx_pn_replay_config(arvif, peer_addr, cmd, key); 3890 if (ret) { 3891 ath11k_warn(ab, "failed to offload PN replay detection %d\n", ret); 3892 goto exit; 3893 } 3894 3895 spin_lock_bh(&ab->base_lock); 3896 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr); 3897 if (peer && cmd == SET_KEY) { 3898 peer->keys[key->keyidx] = key; 3899 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) { 3900 peer->ucast_keyidx = key->keyidx; 3901 peer->sec_type = ath11k_dp_tx_get_encrypt_type(key->cipher); 3902 } else { 3903 peer->mcast_keyidx = key->keyidx; 3904 peer->sec_type_grp = ath11k_dp_tx_get_encrypt_type(key->cipher); 3905 } 3906 } else if (peer && cmd == DISABLE_KEY) { 3907 peer->keys[key->keyidx] = NULL; 3908 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 3909 peer->ucast_keyidx = 0; 3910 else 3911 peer->mcast_keyidx = 0; 3912 } else if (!peer) 3913 /* impossible unless FW goes crazy */ 3914 ath11k_warn(ab, "peer %pM disappeared!\n", peer_addr); 3915 3916 if (sta) { 3917 arsta = (struct ath11k_sta *)sta->drv_priv; 3918 3919 switch (key->cipher) { 3920 case WLAN_CIPHER_SUITE_TKIP: 3921 case WLAN_CIPHER_SUITE_CCMP: 3922 case WLAN_CIPHER_SUITE_CCMP_256: 3923 case WLAN_CIPHER_SUITE_GCMP: 3924 case WLAN_CIPHER_SUITE_GCMP_256: 3925 if (cmd == SET_KEY) 3926 arsta->pn_type = HAL_PN_TYPE_WPA; 3927 else 3928 arsta->pn_type = HAL_PN_TYPE_NONE; 3929 break; 3930 default: 3931 arsta->pn_type = HAL_PN_TYPE_NONE; 3932 break; 3933 } 3934 } 3935 3936 spin_unlock_bh(&ab->base_lock); 3937 3938 exit: 3939 mutex_unlock(&ar->conf_mutex); 3940 return ret; 3941 } 3942 3943 static int 3944 ath11k_mac_bitrate_mask_num_vht_rates(struct ath11k *ar, 3945 enum nl80211_band band, 3946 const struct cfg80211_bitrate_mask *mask) 3947 { 3948 int num_rates = 0; 3949 int i; 3950 3951 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) 3952 num_rates += hweight16(mask->control[band].vht_mcs[i]); 3953 3954 return num_rates; 3955 } 3956 3957 static int 3958 ath11k_mac_bitrate_mask_num_he_rates(struct ath11k *ar, 3959 enum nl80211_band band, 3960 const struct cfg80211_bitrate_mask *mask) 3961 { 3962 int num_rates = 0; 3963 int i; 3964 3965 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) 3966 num_rates += hweight16(mask->control[band].he_mcs[i]); 3967 3968 return num_rates; 3969 } 3970 3971 static int 3972 ath11k_mac_set_peer_vht_fixed_rate(struct ath11k_vif *arvif, 3973 struct ieee80211_sta *sta, 3974 const struct cfg80211_bitrate_mask *mask, 3975 enum nl80211_band band) 3976 { 3977 struct ath11k *ar = arvif->ar; 3978 u8 vht_rate, nss; 3979 u32 rate_code; 3980 int ret, i; 3981 3982 lockdep_assert_held(&ar->conf_mutex); 3983 3984 nss = 0; 3985 3986 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 3987 if (hweight16(mask->control[band].vht_mcs[i]) == 1) { 3988 nss = i + 1; 3989 vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1; 3990 } 3991 } 3992 3993 if (!nss) { 3994 ath11k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM", 3995 sta->addr); 3996 return -EINVAL; 3997 } 3998 3999 /* Avoid updating invalid nss as fixed rate*/ 4000 if (nss > sta->rx_nss) 4001 return -EINVAL; 4002 4003 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4004 "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates", 4005 sta->addr); 4006 4007 rate_code = ATH11K_HW_RATE_CODE(vht_rate, nss - 1, 4008 WMI_RATE_PREAMBLE_VHT); 4009 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4010 arvif->vdev_id, 4011 WMI_PEER_PARAM_FIXED_RATE, 4012 rate_code); 4013 if (ret) 4014 ath11k_warn(ar->ab, 4015 "failed to update STA %pM Fixed Rate %d: %d\n", 4016 sta->addr, rate_code, ret); 4017 4018 return ret; 4019 } 4020 4021 static int 4022 ath11k_mac_set_peer_he_fixed_rate(struct ath11k_vif *arvif, 4023 struct ieee80211_sta *sta, 4024 const struct cfg80211_bitrate_mask *mask, 4025 enum nl80211_band band) 4026 { 4027 struct ath11k *ar = arvif->ar; 4028 u8 he_rate, nss; 4029 u32 rate_code; 4030 int ret, i; 4031 4032 lockdep_assert_held(&ar->conf_mutex); 4033 4034 nss = 0; 4035 4036 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) { 4037 if (hweight16(mask->control[band].he_mcs[i]) == 1) { 4038 nss = i + 1; 4039 he_rate = ffs(mask->control[band].he_mcs[i]) - 1; 4040 } 4041 } 4042 4043 if (!nss) { 4044 ath11k_warn(ar->ab, "No single he fixed rate found to set for %pM", 4045 sta->addr); 4046 return -EINVAL; 4047 } 4048 4049 /* Avoid updating invalid nss as fixed rate */ 4050 if (nss > sta->rx_nss) 4051 return -EINVAL; 4052 4053 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4054 "mac setting fixed he rate for peer %pM, device will not switch to any other selected rates", 4055 sta->addr); 4056 4057 rate_code = ATH11K_HW_RATE_CODE(he_rate, nss - 1, 4058 WMI_RATE_PREAMBLE_HE); 4059 4060 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4061 arvif->vdev_id, 4062 WMI_PEER_PARAM_FIXED_RATE, 4063 rate_code); 4064 if (ret) 4065 ath11k_warn(ar->ab, 4066 "failed to update sta %pM fixed rate %d: %d\n", 4067 sta->addr, rate_code, ret); 4068 4069 return ret; 4070 } 4071 4072 static int ath11k_station_assoc(struct ath11k *ar, 4073 struct ieee80211_vif *vif, 4074 struct ieee80211_sta *sta, 4075 bool reassoc) 4076 { 4077 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4078 struct peer_assoc_params peer_arg; 4079 int ret = 0; 4080 struct cfg80211_chan_def def; 4081 enum nl80211_band band; 4082 struct cfg80211_bitrate_mask *mask; 4083 u8 num_vht_rates, num_he_rates; 4084 4085 lockdep_assert_held(&ar->conf_mutex); 4086 4087 if (WARN_ON(ath11k_mac_vif_chan(vif, &def))) 4088 return -EPERM; 4089 4090 band = def.chan->band; 4091 mask = &arvif->bitrate_mask; 4092 4093 ath11k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc); 4094 4095 peer_arg.is_assoc = true; 4096 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4097 if (ret) { 4098 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 4099 sta->addr, arvif->vdev_id, ret); 4100 return ret; 4101 } 4102 4103 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 4104 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4105 sta->addr, arvif->vdev_id); 4106 return -ETIMEDOUT; 4107 } 4108 4109 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask); 4110 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask); 4111 4112 /* If single VHT/HE rate is configured (by set_bitrate_mask()), 4113 * peer_assoc will disable VHT/HE. This is now enabled by a peer specific 4114 * fixed param. 4115 * Note that all other rates and NSS will be disabled for this peer. 4116 */ 4117 if (sta->vht_cap.vht_supported && num_vht_rates == 1) { 4118 ret = ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 4119 band); 4120 if (ret) 4121 return ret; 4122 } else if (sta->he_cap.has_he && num_he_rates == 1) { 4123 ret = ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask, 4124 band); 4125 if (ret) 4126 return ret; 4127 } 4128 4129 /* Re-assoc is run only to update supported rates for given station. It 4130 * doesn't make much sense to reconfigure the peer completely. 4131 */ 4132 if (reassoc) 4133 return 0; 4134 4135 ret = ath11k_setup_peer_smps(ar, arvif, sta->addr, 4136 &sta->ht_cap, le16_to_cpu(sta->he_6ghz_capa.capa)); 4137 if (ret) { 4138 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n", 4139 arvif->vdev_id, ret); 4140 return ret; 4141 } 4142 4143 if (!sta->wme) { 4144 arvif->num_legacy_stations++; 4145 ret = ath11k_recalc_rtscts_prot(arvif); 4146 if (ret) 4147 return ret; 4148 } 4149 4150 if (sta->wme && sta->uapsd_queues) { 4151 ret = ath11k_peer_assoc_qos_ap(ar, arvif, sta); 4152 if (ret) { 4153 ath11k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n", 4154 sta->addr, arvif->vdev_id, ret); 4155 return ret; 4156 } 4157 } 4158 4159 return 0; 4160 } 4161 4162 static int ath11k_station_disassoc(struct ath11k *ar, 4163 struct ieee80211_vif *vif, 4164 struct ieee80211_sta *sta) 4165 { 4166 struct ath11k_vif *arvif = (void *)vif->drv_priv; 4167 int ret = 0; 4168 4169 lockdep_assert_held(&ar->conf_mutex); 4170 4171 if (!sta->wme) { 4172 arvif->num_legacy_stations--; 4173 ret = ath11k_recalc_rtscts_prot(arvif); 4174 if (ret) 4175 return ret; 4176 } 4177 4178 ret = ath11k_clear_peer_keys(arvif, sta->addr); 4179 if (ret) { 4180 ath11k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n", 4181 arvif->vdev_id, ret); 4182 return ret; 4183 } 4184 return 0; 4185 } 4186 4187 static void ath11k_sta_rc_update_wk(struct work_struct *wk) 4188 { 4189 struct ath11k *ar; 4190 struct ath11k_vif *arvif; 4191 struct ath11k_sta *arsta; 4192 struct ieee80211_sta *sta; 4193 struct cfg80211_chan_def def; 4194 enum nl80211_band band; 4195 const u8 *ht_mcs_mask; 4196 const u16 *vht_mcs_mask; 4197 const u16 *he_mcs_mask; 4198 u32 changed, bw, nss, smps; 4199 int err, num_vht_rates, num_he_rates; 4200 const struct cfg80211_bitrate_mask *mask; 4201 struct peer_assoc_params peer_arg; 4202 4203 arsta = container_of(wk, struct ath11k_sta, update_wk); 4204 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 4205 arvif = arsta->arvif; 4206 ar = arvif->ar; 4207 4208 if (WARN_ON(ath11k_mac_vif_chan(arvif->vif, &def))) 4209 return; 4210 4211 band = def.chan->band; 4212 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 4213 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 4214 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs; 4215 4216 spin_lock_bh(&ar->data_lock); 4217 4218 changed = arsta->changed; 4219 arsta->changed = 0; 4220 4221 bw = arsta->bw; 4222 nss = arsta->nss; 4223 smps = arsta->smps; 4224 4225 spin_unlock_bh(&ar->data_lock); 4226 4227 mutex_lock(&ar->conf_mutex); 4228 4229 nss = max_t(u32, 1, nss); 4230 nss = min(nss, max(max(ath11k_mac_max_ht_nss(ht_mcs_mask), 4231 ath11k_mac_max_vht_nss(vht_mcs_mask)), 4232 ath11k_mac_max_he_nss(he_mcs_mask))); 4233 4234 if (changed & IEEE80211_RC_BW_CHANGED) { 4235 /* Send peer assoc command before set peer bandwidth param to 4236 * avoid the mismatch between the peer phymode and the peer 4237 * bandwidth. 4238 */ 4239 ath11k_peer_assoc_prepare(ar, arvif->vif, sta, &peer_arg, true); 4240 4241 peer_arg.is_assoc = false; 4242 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4243 if (err) { 4244 ath11k_warn(ar->ab, "failed to send peer assoc for STA %pM vdev %i: %d\n", 4245 sta->addr, arvif->vdev_id, err); 4246 } else if (wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 4247 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4248 WMI_PEER_CHWIDTH, bw); 4249 if (err) 4250 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n", 4251 sta->addr, bw, err); 4252 } else { 4253 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4254 sta->addr, arvif->vdev_id); 4255 } 4256 } 4257 4258 if (changed & IEEE80211_RC_NSS_CHANGED) { 4259 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM nss %d\n", 4260 sta->addr, nss); 4261 4262 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4263 WMI_PEER_NSS, nss); 4264 if (err) 4265 ath11k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n", 4266 sta->addr, nss, err); 4267 } 4268 4269 if (changed & IEEE80211_RC_SMPS_CHANGED) { 4270 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM smps %d\n", 4271 sta->addr, smps); 4272 4273 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4274 WMI_PEER_MIMO_PS_STATE, smps); 4275 if (err) 4276 ath11k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n", 4277 sta->addr, smps, err); 4278 } 4279 4280 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) { 4281 mask = &arvif->bitrate_mask; 4282 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, 4283 mask); 4284 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, 4285 mask); 4286 4287 /* Peer_assoc_prepare will reject vht rates in 4288 * bitrate_mask if its not available in range format and 4289 * sets vht tx_rateset as unsupported. So multiple VHT MCS 4290 * setting(eg. MCS 4,5,6) per peer is not supported here. 4291 * But, Single rate in VHT mask can be set as per-peer 4292 * fixed rate. But even if any HT rates are configured in 4293 * the bitrate mask, device will not switch to those rates 4294 * when per-peer Fixed rate is set. 4295 * TODO: Check RATEMASK_CMDID to support auto rates selection 4296 * across HT/VHT and for multiple VHT MCS support. 4297 */ 4298 if (sta->vht_cap.vht_supported && num_vht_rates == 1) { 4299 ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 4300 band); 4301 } else if (sta->he_cap.has_he && num_he_rates == 1) { 4302 ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask, 4303 band); 4304 } else { 4305 /* If the peer is non-VHT/HE or no fixed VHT/HE rate 4306 * is provided in the new bitrate mask we set the 4307 * other rates using peer_assoc command. Also clear 4308 * the peer fixed rate settings as it has higher proprity 4309 * than peer assoc 4310 */ 4311 err = ath11k_wmi_set_peer_param(ar, sta->addr, 4312 arvif->vdev_id, 4313 WMI_PEER_PARAM_FIXED_RATE, 4314 WMI_FIXED_RATE_NONE); 4315 if (err) 4316 ath11k_warn(ar->ab, 4317 "failed to disable peer fixed rate for sta %pM: %d\n", 4318 sta->addr, err); 4319 4320 ath11k_peer_assoc_prepare(ar, arvif->vif, sta, 4321 &peer_arg, true); 4322 4323 peer_arg.is_assoc = false; 4324 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4325 if (err) 4326 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 4327 sta->addr, arvif->vdev_id, err); 4328 4329 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) 4330 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4331 sta->addr, arvif->vdev_id); 4332 } 4333 } 4334 4335 mutex_unlock(&ar->conf_mutex); 4336 } 4337 4338 static void ath11k_sta_set_4addr_wk(struct work_struct *wk) 4339 { 4340 struct ath11k *ar; 4341 struct ath11k_vif *arvif; 4342 struct ath11k_sta *arsta; 4343 struct ieee80211_sta *sta; 4344 int ret = 0; 4345 4346 arsta = container_of(wk, struct ath11k_sta, set_4addr_wk); 4347 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 4348 arvif = arsta->arvif; 4349 ar = arvif->ar; 4350 4351 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4352 "setting USE_4ADDR for peer %pM\n", sta->addr); 4353 4354 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4355 arvif->vdev_id, 4356 WMI_PEER_USE_4ADDR, 1); 4357 4358 if (ret) 4359 ath11k_warn(ar->ab, "failed to set peer %pM 4addr capability: %d\n", 4360 sta->addr, ret); 4361 } 4362 4363 static int ath11k_mac_inc_num_stations(struct ath11k_vif *arvif, 4364 struct ieee80211_sta *sta) 4365 { 4366 struct ath11k *ar = arvif->ar; 4367 4368 lockdep_assert_held(&ar->conf_mutex); 4369 4370 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 4371 return 0; 4372 4373 if (ar->num_stations >= ar->max_num_stations) 4374 return -ENOBUFS; 4375 4376 ar->num_stations++; 4377 4378 return 0; 4379 } 4380 4381 static void ath11k_mac_dec_num_stations(struct ath11k_vif *arvif, 4382 struct ieee80211_sta *sta) 4383 { 4384 struct ath11k *ar = arvif->ar; 4385 4386 lockdep_assert_held(&ar->conf_mutex); 4387 4388 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 4389 return; 4390 4391 ar->num_stations--; 4392 } 4393 4394 static int ath11k_mac_station_add(struct ath11k *ar, 4395 struct ieee80211_vif *vif, 4396 struct ieee80211_sta *sta) 4397 { 4398 struct ath11k_base *ab = ar->ab; 4399 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4400 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 4401 struct peer_create_params peer_param; 4402 int ret; 4403 4404 lockdep_assert_held(&ar->conf_mutex); 4405 4406 ret = ath11k_mac_inc_num_stations(arvif, sta); 4407 if (ret) { 4408 ath11k_warn(ab, "refusing to associate station: too many connected already (%d)\n", 4409 ar->max_num_stations); 4410 goto exit; 4411 } 4412 4413 arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL); 4414 if (!arsta->rx_stats) { 4415 ret = -ENOMEM; 4416 goto dec_num_station; 4417 } 4418 4419 peer_param.vdev_id = arvif->vdev_id; 4420 peer_param.peer_addr = sta->addr; 4421 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 4422 4423 ret = ath11k_peer_create(ar, arvif, sta, &peer_param); 4424 if (ret) { 4425 ath11k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n", 4426 sta->addr, arvif->vdev_id); 4427 goto free_rx_stats; 4428 } 4429 4430 ath11k_dbg(ab, ATH11K_DBG_MAC, "Added peer: %pM for VDEV: %d\n", 4431 sta->addr, arvif->vdev_id); 4432 4433 if (ath11k_debugfs_is_extd_tx_stats_enabled(ar)) { 4434 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), GFP_KERNEL); 4435 if (!arsta->tx_stats) { 4436 ret = -ENOMEM; 4437 goto free_peer; 4438 } 4439 } 4440 4441 if (ieee80211_vif_is_mesh(vif)) { 4442 ath11k_dbg(ab, ATH11K_DBG_MAC, 4443 "setting USE_4ADDR for mesh STA %pM\n", sta->addr); 4444 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4445 arvif->vdev_id, 4446 WMI_PEER_USE_4ADDR, 1); 4447 if (ret) { 4448 ath11k_warn(ab, "failed to set mesh STA %pM 4addr capability: %d\n", 4449 sta->addr, ret); 4450 goto free_tx_stats; 4451 } 4452 } 4453 4454 ret = ath11k_dp_peer_setup(ar, arvif->vdev_id, sta->addr); 4455 if (ret) { 4456 ath11k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n", 4457 sta->addr, arvif->vdev_id, ret); 4458 goto free_tx_stats; 4459 } 4460 4461 if (ab->hw_params.vdev_start_delay && 4462 !arvif->is_started && 4463 arvif->vdev_type != WMI_VDEV_TYPE_AP) { 4464 ret = ath11k_start_vdev_delay(ar->hw, vif); 4465 if (ret) { 4466 ath11k_warn(ab, "failed to delay vdev start: %d\n", ret); 4467 goto free_tx_stats; 4468 } 4469 } 4470 4471 return 0; 4472 4473 free_tx_stats: 4474 kfree(arsta->tx_stats); 4475 arsta->tx_stats = NULL; 4476 free_peer: 4477 ath11k_peer_delete(ar, arvif->vdev_id, sta->addr); 4478 free_rx_stats: 4479 kfree(arsta->rx_stats); 4480 arsta->rx_stats = NULL; 4481 dec_num_station: 4482 ath11k_mac_dec_num_stations(arvif, sta); 4483 exit: 4484 return ret; 4485 } 4486 4487 static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw, 4488 struct ieee80211_vif *vif, 4489 struct ieee80211_sta *sta, 4490 enum ieee80211_sta_state old_state, 4491 enum ieee80211_sta_state new_state) 4492 { 4493 struct ath11k *ar = hw->priv; 4494 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4495 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 4496 struct ath11k_peer *peer; 4497 int ret = 0; 4498 4499 /* cancel must be done outside the mutex to avoid deadlock */ 4500 if ((old_state == IEEE80211_STA_NONE && 4501 new_state == IEEE80211_STA_NOTEXIST)) { 4502 cancel_work_sync(&arsta->update_wk); 4503 cancel_work_sync(&arsta->set_4addr_wk); 4504 } 4505 4506 mutex_lock(&ar->conf_mutex); 4507 4508 if (old_state == IEEE80211_STA_NOTEXIST && 4509 new_state == IEEE80211_STA_NONE) { 4510 memset(arsta, 0, sizeof(*arsta)); 4511 arsta->arvif = arvif; 4512 INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk); 4513 INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk); 4514 4515 ret = ath11k_mac_station_add(ar, vif, sta); 4516 if (ret) 4517 ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n", 4518 sta->addr, arvif->vdev_id); 4519 } else if ((old_state == IEEE80211_STA_NONE && 4520 new_state == IEEE80211_STA_NOTEXIST)) { 4521 bool skip_peer_delete = ar->ab->hw_params.vdev_start_delay && 4522 vif->type == NL80211_IFTYPE_STATION; 4523 4524 ath11k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr); 4525 4526 if (!skip_peer_delete) { 4527 ret = ath11k_peer_delete(ar, arvif->vdev_id, sta->addr); 4528 if (ret) 4529 ath11k_warn(ar->ab, 4530 "Failed to delete peer: %pM for VDEV: %d\n", 4531 sta->addr, arvif->vdev_id); 4532 else 4533 ath11k_dbg(ar->ab, 4534 ATH11K_DBG_MAC, 4535 "Removed peer: %pM for VDEV: %d\n", 4536 sta->addr, arvif->vdev_id); 4537 } 4538 4539 ath11k_mac_dec_num_stations(arvif, sta); 4540 spin_lock_bh(&ar->ab->base_lock); 4541 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4542 if (skip_peer_delete && peer) { 4543 peer->sta = NULL; 4544 } else if (peer && peer->sta == sta) { 4545 ath11k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n", 4546 vif->addr, arvif->vdev_id); 4547 peer->sta = NULL; 4548 list_del(&peer->list); 4549 kfree(peer); 4550 ar->num_peers--; 4551 } 4552 spin_unlock_bh(&ar->ab->base_lock); 4553 4554 kfree(arsta->tx_stats); 4555 arsta->tx_stats = NULL; 4556 4557 kfree(arsta->rx_stats); 4558 arsta->rx_stats = NULL; 4559 } else if (old_state == IEEE80211_STA_AUTH && 4560 new_state == IEEE80211_STA_ASSOC && 4561 (vif->type == NL80211_IFTYPE_AP || 4562 vif->type == NL80211_IFTYPE_MESH_POINT || 4563 vif->type == NL80211_IFTYPE_ADHOC)) { 4564 ret = ath11k_station_assoc(ar, vif, sta, false); 4565 if (ret) 4566 ath11k_warn(ar->ab, "Failed to associate station: %pM\n", 4567 sta->addr); 4568 } else if (old_state == IEEE80211_STA_ASSOC && 4569 new_state == IEEE80211_STA_AUTHORIZED) { 4570 spin_lock_bh(&ar->ab->base_lock); 4571 4572 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4573 if (peer) 4574 peer->is_authorized = true; 4575 4576 spin_unlock_bh(&ar->ab->base_lock); 4577 4578 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) { 4579 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 4580 arvif->vdev_id, 4581 WMI_PEER_AUTHORIZE, 4582 1); 4583 if (ret) 4584 ath11k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n", 4585 sta->addr, arvif->vdev_id, ret); 4586 } 4587 } else if (old_state == IEEE80211_STA_AUTHORIZED && 4588 new_state == IEEE80211_STA_ASSOC) { 4589 spin_lock_bh(&ar->ab->base_lock); 4590 4591 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4592 if (peer) 4593 peer->is_authorized = false; 4594 4595 spin_unlock_bh(&ar->ab->base_lock); 4596 } else if (old_state == IEEE80211_STA_ASSOC && 4597 new_state == IEEE80211_STA_AUTH && 4598 (vif->type == NL80211_IFTYPE_AP || 4599 vif->type == NL80211_IFTYPE_MESH_POINT || 4600 vif->type == NL80211_IFTYPE_ADHOC)) { 4601 ret = ath11k_station_disassoc(ar, vif, sta); 4602 if (ret) 4603 ath11k_warn(ar->ab, "Failed to disassociate station: %pM\n", 4604 sta->addr); 4605 } 4606 4607 mutex_unlock(&ar->conf_mutex); 4608 return ret; 4609 } 4610 4611 static int ath11k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw, 4612 struct ieee80211_vif *vif, 4613 struct ieee80211_sta *sta) 4614 { 4615 struct ath11k *ar = hw->priv; 4616 struct ath11k_vif *arvif = (void *)vif->drv_priv; 4617 int ret = 0; 4618 s16 txpwr; 4619 4620 if (sta->txpwr.type == NL80211_TX_POWER_AUTOMATIC) { 4621 txpwr = 0; 4622 } else { 4623 txpwr = sta->txpwr.power; 4624 if (!txpwr) 4625 return -EINVAL; 4626 } 4627 4628 if (txpwr > ATH11K_TX_POWER_MAX_VAL || txpwr < ATH11K_TX_POWER_MIN_VAL) 4629 return -EINVAL; 4630 4631 mutex_lock(&ar->conf_mutex); 4632 4633 ret = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4634 WMI_PEER_USE_FIXED_PWR, txpwr); 4635 if (ret) { 4636 ath11k_warn(ar->ab, "failed to set tx power for station ret: %d\n", 4637 ret); 4638 goto out; 4639 } 4640 4641 out: 4642 mutex_unlock(&ar->conf_mutex); 4643 return ret; 4644 } 4645 4646 static void ath11k_mac_op_sta_set_4addr(struct ieee80211_hw *hw, 4647 struct ieee80211_vif *vif, 4648 struct ieee80211_sta *sta, bool enabled) 4649 { 4650 struct ath11k *ar = hw->priv; 4651 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 4652 4653 if (enabled && !arsta->use_4addr_set) { 4654 ieee80211_queue_work(ar->hw, &arsta->set_4addr_wk); 4655 arsta->use_4addr_set = true; 4656 } 4657 } 4658 4659 static void ath11k_mac_op_sta_rc_update(struct ieee80211_hw *hw, 4660 struct ieee80211_vif *vif, 4661 struct ieee80211_sta *sta, 4662 u32 changed) 4663 { 4664 struct ath11k *ar = hw->priv; 4665 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 4666 struct ath11k_vif *arvif = (void *)vif->drv_priv; 4667 struct ath11k_peer *peer; 4668 u32 bw, smps; 4669 4670 spin_lock_bh(&ar->ab->base_lock); 4671 4672 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4673 if (!peer) { 4674 spin_unlock_bh(&ar->ab->base_lock); 4675 ath11k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n", 4676 sta->addr, arvif->vdev_id); 4677 return; 4678 } 4679 4680 spin_unlock_bh(&ar->ab->base_lock); 4681 4682 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 4683 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 4684 sta->addr, changed, sta->bandwidth, sta->rx_nss, 4685 sta->smps_mode); 4686 4687 spin_lock_bh(&ar->data_lock); 4688 4689 if (changed & IEEE80211_RC_BW_CHANGED) { 4690 bw = WMI_PEER_CHWIDTH_20MHZ; 4691 4692 switch (sta->bandwidth) { 4693 case IEEE80211_STA_RX_BW_20: 4694 bw = WMI_PEER_CHWIDTH_20MHZ; 4695 break; 4696 case IEEE80211_STA_RX_BW_40: 4697 bw = WMI_PEER_CHWIDTH_40MHZ; 4698 break; 4699 case IEEE80211_STA_RX_BW_80: 4700 bw = WMI_PEER_CHWIDTH_80MHZ; 4701 break; 4702 case IEEE80211_STA_RX_BW_160: 4703 bw = WMI_PEER_CHWIDTH_160MHZ; 4704 break; 4705 default: 4706 ath11k_warn(ar->ab, "Invalid bandwidth %d in rc update for %pM\n", 4707 sta->bandwidth, sta->addr); 4708 bw = WMI_PEER_CHWIDTH_20MHZ; 4709 break; 4710 } 4711 4712 arsta->bw = bw; 4713 } 4714 4715 if (changed & IEEE80211_RC_NSS_CHANGED) 4716 arsta->nss = sta->rx_nss; 4717 4718 if (changed & IEEE80211_RC_SMPS_CHANGED) { 4719 smps = WMI_PEER_SMPS_PS_NONE; 4720 4721 switch (sta->smps_mode) { 4722 case IEEE80211_SMPS_AUTOMATIC: 4723 case IEEE80211_SMPS_OFF: 4724 smps = WMI_PEER_SMPS_PS_NONE; 4725 break; 4726 case IEEE80211_SMPS_STATIC: 4727 smps = WMI_PEER_SMPS_STATIC; 4728 break; 4729 case IEEE80211_SMPS_DYNAMIC: 4730 smps = WMI_PEER_SMPS_DYNAMIC; 4731 break; 4732 default: 4733 ath11k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n", 4734 sta->smps_mode, sta->addr); 4735 smps = WMI_PEER_SMPS_PS_NONE; 4736 break; 4737 } 4738 4739 arsta->smps = smps; 4740 } 4741 4742 arsta->changed |= changed; 4743 4744 spin_unlock_bh(&ar->data_lock); 4745 4746 ieee80211_queue_work(hw, &arsta->update_wk); 4747 } 4748 4749 static int ath11k_conf_tx_uapsd(struct ath11k *ar, struct ieee80211_vif *vif, 4750 u16 ac, bool enable) 4751 { 4752 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 4753 u32 value = 0; 4754 int ret = 0; 4755 4756 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 4757 return 0; 4758 4759 switch (ac) { 4760 case IEEE80211_AC_VO: 4761 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 4762 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 4763 break; 4764 case IEEE80211_AC_VI: 4765 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 4766 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 4767 break; 4768 case IEEE80211_AC_BE: 4769 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 4770 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 4771 break; 4772 case IEEE80211_AC_BK: 4773 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 4774 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 4775 break; 4776 } 4777 4778 if (enable) 4779 arvif->u.sta.uapsd |= value; 4780 else 4781 arvif->u.sta.uapsd &= ~value; 4782 4783 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 4784 WMI_STA_PS_PARAM_UAPSD, 4785 arvif->u.sta.uapsd); 4786 if (ret) { 4787 ath11k_warn(ar->ab, "could not set uapsd params %d\n", ret); 4788 goto exit; 4789 } 4790 4791 if (arvif->u.sta.uapsd) 4792 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 4793 else 4794 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 4795 4796 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 4797 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 4798 value); 4799 if (ret) 4800 ath11k_warn(ar->ab, "could not set rx wake param %d\n", ret); 4801 4802 exit: 4803 return ret; 4804 } 4805 4806 static int ath11k_mac_op_conf_tx(struct ieee80211_hw *hw, 4807 struct ieee80211_vif *vif, u16 ac, 4808 const struct ieee80211_tx_queue_params *params) 4809 { 4810 struct ath11k *ar = hw->priv; 4811 struct ath11k_vif *arvif = (void *)vif->drv_priv; 4812 struct wmi_wmm_params_arg *p = NULL; 4813 int ret; 4814 4815 mutex_lock(&ar->conf_mutex); 4816 4817 switch (ac) { 4818 case IEEE80211_AC_VO: 4819 p = &arvif->wmm_params.ac_vo; 4820 break; 4821 case IEEE80211_AC_VI: 4822 p = &arvif->wmm_params.ac_vi; 4823 break; 4824 case IEEE80211_AC_BE: 4825 p = &arvif->wmm_params.ac_be; 4826 break; 4827 case IEEE80211_AC_BK: 4828 p = &arvif->wmm_params.ac_bk; 4829 break; 4830 } 4831 4832 if (WARN_ON(!p)) { 4833 ret = -EINVAL; 4834 goto exit; 4835 } 4836 4837 p->cwmin = params->cw_min; 4838 p->cwmax = params->cw_max; 4839 p->aifs = params->aifs; 4840 p->txop = params->txop; 4841 4842 ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id, 4843 &arvif->wmm_params); 4844 if (ret) { 4845 ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret); 4846 goto exit; 4847 } 4848 4849 ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 4850 4851 if (ret) 4852 ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret); 4853 4854 exit: 4855 mutex_unlock(&ar->conf_mutex); 4856 return ret; 4857 } 4858 4859 static struct ieee80211_sta_ht_cap 4860 ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask) 4861 { 4862 int i; 4863 struct ieee80211_sta_ht_cap ht_cap = {0}; 4864 u32 ar_vht_cap = ar->pdev->cap.vht_cap; 4865 4866 if (!(ar_ht_cap & WMI_HT_CAP_ENABLED)) 4867 return ht_cap; 4868 4869 ht_cap.ht_supported = 1; 4870 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 4871 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE; 4872 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 4873 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 4874 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT; 4875 4876 if (ar_ht_cap & WMI_HT_CAP_HT20_SGI) 4877 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 4878 4879 if (ar_ht_cap & WMI_HT_CAP_HT40_SGI) 4880 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 4881 4882 if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) { 4883 u32 smps; 4884 4885 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 4886 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 4887 4888 ht_cap.cap |= smps; 4889 } 4890 4891 if (ar_ht_cap & WMI_HT_CAP_TX_STBC) 4892 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 4893 4894 if (ar_ht_cap & WMI_HT_CAP_RX_STBC) { 4895 u32 stbc; 4896 4897 stbc = ar_ht_cap; 4898 stbc &= WMI_HT_CAP_RX_STBC; 4899 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 4900 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 4901 stbc &= IEEE80211_HT_CAP_RX_STBC; 4902 4903 ht_cap.cap |= stbc; 4904 } 4905 4906 if (ar_ht_cap & WMI_HT_CAP_RX_LDPC) 4907 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 4908 4909 if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT) 4910 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 4911 4912 if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 4913 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 4914 4915 for (i = 0; i < ar->num_rx_chains; i++) { 4916 if (rate_cap_rx_chainmask & BIT(i)) 4917 ht_cap.mcs.rx_mask[i] = 0xFF; 4918 } 4919 4920 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 4921 4922 return ht_cap; 4923 } 4924 4925 static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif) 4926 { 4927 u32 value = 0; 4928 struct ath11k *ar = arvif->ar; 4929 int nsts; 4930 int sound_dim; 4931 u32 vht_cap = ar->pdev->cap.vht_cap; 4932 u32 vdev_param = WMI_VDEV_PARAM_TXBF; 4933 4934 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) { 4935 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 4936 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 4937 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET); 4938 } 4939 4940 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) { 4941 sound_dim = vht_cap & 4942 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 4943 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 4944 if (sound_dim > (ar->num_tx_chains - 1)) 4945 sound_dim = ar->num_tx_chains - 1; 4946 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET); 4947 } 4948 4949 if (!value) 4950 return 0; 4951 4952 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) { 4953 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 4954 4955 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) && 4956 arvif->vdev_type == WMI_VDEV_TYPE_AP) 4957 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER; 4958 } 4959 4960 /* TODO: SUBFEE not validated in HK, disable here until validated? */ 4961 4962 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) { 4963 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 4964 4965 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) && 4966 arvif->vdev_type == WMI_VDEV_TYPE_STA) 4967 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE; 4968 } 4969 4970 return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 4971 vdev_param, value); 4972 } 4973 4974 static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap) 4975 { 4976 bool subfer, subfee; 4977 int sound_dim = 0; 4978 4979 subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)); 4980 subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)); 4981 4982 if (ar->num_tx_chains < 2) { 4983 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE); 4984 subfer = false; 4985 } 4986 4987 /* If SU Beaformer is not set, then disable MU Beamformer Capability */ 4988 if (!subfer) 4989 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE); 4990 4991 /* If SU Beaformee is not set, then disable MU Beamformee Capability */ 4992 if (!subfee) 4993 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE); 4994 4995 sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK); 4996 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 4997 *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 4998 4999 /* TODO: Need to check invalid STS and Sound_dim values set by FW? */ 5000 5001 /* Enable Sounding Dimension Field only if SU BF is enabled */ 5002 if (subfer) { 5003 if (sound_dim > (ar->num_tx_chains - 1)) 5004 sound_dim = ar->num_tx_chains - 1; 5005 5006 sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 5007 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 5008 *vht_cap |= sound_dim; 5009 } 5010 5011 /* Use the STS advertised by FW unless SU Beamformee is not supported*/ 5012 if (!subfee) 5013 *vht_cap &= ~(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK); 5014 } 5015 5016 static struct ieee80211_sta_vht_cap 5017 ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask, 5018 u32 rate_cap_rx_chainmask) 5019 { 5020 struct ieee80211_sta_vht_cap vht_cap = {0}; 5021 u16 txmcs_map, rxmcs_map; 5022 int i; 5023 5024 vht_cap.vht_supported = 1; 5025 vht_cap.cap = ar->pdev->cap.vht_cap; 5026 5027 if (ar->pdev->cap.nss_ratio_enabled) 5028 vht_cap.vht_mcs.tx_highest |= 5029 cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE); 5030 5031 ath11k_set_vht_txbf_cap(ar, &vht_cap.cap); 5032 5033 rxmcs_map = 0; 5034 txmcs_map = 0; 5035 for (i = 0; i < 8; i++) { 5036 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i)) 5037 txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 5038 else 5039 txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 5040 5041 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i)) 5042 rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 5043 else 5044 rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 5045 } 5046 5047 if (rate_cap_tx_chainmask <= 1) 5048 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC; 5049 5050 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map); 5051 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map); 5052 5053 return vht_cap; 5054 } 5055 5056 static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar, 5057 struct ath11k_pdev_cap *cap, 5058 u32 *ht_cap_info) 5059 { 5060 struct ieee80211_supported_band *band; 5061 u32 rate_cap_tx_chainmask; 5062 u32 rate_cap_rx_chainmask; 5063 u32 ht_cap; 5064 5065 rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift; 5066 rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift; 5067 5068 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 5069 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 5070 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info; 5071 if (ht_cap_info) 5072 *ht_cap_info = ht_cap; 5073 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap, 5074 rate_cap_rx_chainmask); 5075 } 5076 5077 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 5078 (ar->ab->hw_params.single_pdev_only || 5079 !ar->supports_6ghz)) { 5080 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 5081 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info; 5082 if (ht_cap_info) 5083 *ht_cap_info = ht_cap; 5084 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap, 5085 rate_cap_rx_chainmask); 5086 band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask, 5087 rate_cap_rx_chainmask); 5088 } 5089 } 5090 5091 static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant) 5092 { 5093 /* TODO: Check the request chainmask against the supported 5094 * chainmask table which is advertised in extented_service_ready event 5095 */ 5096 5097 return 0; 5098 } 5099 5100 static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet, 5101 u8 *he_ppet) 5102 { 5103 int nss, ru; 5104 u8 bit = 7; 5105 5106 he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK; 5107 he_ppet[0] |= (fw_ppet->ru_bit_mask << 5108 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) & 5109 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK; 5110 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) { 5111 for (ru = 0; ru < 4; ru++) { 5112 u8 val; 5113 int i; 5114 5115 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0) 5116 continue; 5117 val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) & 5118 0x3f; 5119 val = ((val >> 3) & 0x7) | ((val & 0x7) << 3); 5120 for (i = 5; i >= 0; i--) { 5121 he_ppet[bit / 8] |= 5122 ((val >> i) & 0x1) << ((bit % 8)); 5123 bit++; 5124 } 5125 } 5126 } 5127 } 5128 5129 static void 5130 ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem) 5131 { 5132 u8 m; 5133 5134 m = IEEE80211_HE_MAC_CAP0_TWT_RES | 5135 IEEE80211_HE_MAC_CAP0_TWT_REQ; 5136 he_cap_elem->mac_cap_info[0] &= ~m; 5137 5138 m = IEEE80211_HE_MAC_CAP2_TRS | 5139 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 5140 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 5141 he_cap_elem->mac_cap_info[2] &= ~m; 5142 5143 m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED | 5144 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 5145 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 5146 he_cap_elem->mac_cap_info[3] &= ~m; 5147 5148 m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG | 5149 IEEE80211_HE_MAC_CAP4_BQR; 5150 he_cap_elem->mac_cap_info[4] &= ~m; 5151 5152 m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION | 5153 IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU | 5154 IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING | 5155 IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX; 5156 he_cap_elem->mac_cap_info[5] &= ~m; 5157 5158 m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO | 5159 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO; 5160 he_cap_elem->phy_cap_info[2] &= ~m; 5161 5162 m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU | 5163 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK | 5164 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK; 5165 he_cap_elem->phy_cap_info[3] &= ~m; 5166 5167 m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER; 5168 he_cap_elem->phy_cap_info[4] &= ~m; 5169 5170 m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK; 5171 he_cap_elem->phy_cap_info[5] &= ~m; 5172 5173 m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU | 5174 IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB | 5175 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB | 5176 IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO; 5177 he_cap_elem->phy_cap_info[6] &= ~m; 5178 5179 m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR | 5180 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP | 5181 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ | 5182 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ; 5183 he_cap_elem->phy_cap_info[7] &= ~m; 5184 5185 m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI | 5186 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G | 5187 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU | 5188 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU; 5189 he_cap_elem->phy_cap_info[8] &= ~m; 5190 5191 m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM | 5192 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK | 5193 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU | 5194 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU | 5195 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB | 5196 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB; 5197 he_cap_elem->phy_cap_info[9] &= ~m; 5198 } 5199 5200 static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap, 5201 struct ath11k_band_cap *bcap) 5202 { 5203 u8 val; 5204 5205 bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE; 5206 if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 5207 bcap->he_6ghz_capa |= 5208 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS, 5209 WLAN_HT_CAP_SM_PS_DYNAMIC); 5210 else 5211 bcap->he_6ghz_capa |= 5212 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS, 5213 WLAN_HT_CAP_SM_PS_DISABLED); 5214 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK, 5215 pcap->vht_cap); 5216 bcap->he_6ghz_capa |= 5217 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val); 5218 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap); 5219 bcap->he_6ghz_capa |= 5220 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val); 5221 if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN) 5222 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS; 5223 if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN) 5224 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS; 5225 5226 return cpu_to_le16(bcap->he_6ghz_capa); 5227 } 5228 5229 static int ath11k_mac_copy_he_cap(struct ath11k *ar, 5230 struct ath11k_pdev_cap *cap, 5231 struct ieee80211_sband_iftype_data *data, 5232 int band) 5233 { 5234 int i, idx = 0; 5235 5236 for (i = 0; i < NUM_NL80211_IFTYPES; i++) { 5237 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap; 5238 struct ath11k_band_cap *band_cap = &cap->band[band]; 5239 struct ieee80211_he_cap_elem *he_cap_elem = 5240 &he_cap->he_cap_elem; 5241 5242 switch (i) { 5243 case NL80211_IFTYPE_STATION: 5244 case NL80211_IFTYPE_AP: 5245 case NL80211_IFTYPE_MESH_POINT: 5246 break; 5247 5248 default: 5249 continue; 5250 } 5251 5252 data[idx].types_mask = BIT(i); 5253 he_cap->has_he = true; 5254 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info, 5255 sizeof(he_cap_elem->mac_cap_info)); 5256 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info, 5257 sizeof(he_cap_elem->phy_cap_info)); 5258 5259 he_cap_elem->mac_cap_info[1] &= 5260 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK; 5261 5262 he_cap_elem->phy_cap_info[5] &= 5263 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK; 5264 he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1; 5265 5266 switch (i) { 5267 case NL80211_IFTYPE_AP: 5268 he_cap_elem->phy_cap_info[3] &= 5269 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK; 5270 he_cap_elem->phy_cap_info[9] |= 5271 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU; 5272 break; 5273 case NL80211_IFTYPE_STATION: 5274 he_cap_elem->mac_cap_info[0] &= 5275 ~IEEE80211_HE_MAC_CAP0_TWT_RES; 5276 he_cap_elem->mac_cap_info[0] |= 5277 IEEE80211_HE_MAC_CAP0_TWT_REQ; 5278 he_cap_elem->phy_cap_info[9] |= 5279 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU; 5280 break; 5281 case NL80211_IFTYPE_MESH_POINT: 5282 ath11k_mac_filter_he_cap_mesh(he_cap_elem); 5283 break; 5284 } 5285 5286 he_cap->he_mcs_nss_supp.rx_mcs_80 = 5287 cpu_to_le16(band_cap->he_mcs & 0xffff); 5288 he_cap->he_mcs_nss_supp.tx_mcs_80 = 5289 cpu_to_le16(band_cap->he_mcs & 0xffff); 5290 he_cap->he_mcs_nss_supp.rx_mcs_160 = 5291 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5292 he_cap->he_mcs_nss_supp.tx_mcs_160 = 5293 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5294 he_cap->he_mcs_nss_supp.rx_mcs_80p80 = 5295 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5296 he_cap->he_mcs_nss_supp.tx_mcs_80p80 = 5297 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5298 5299 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres)); 5300 if (he_cap_elem->phy_cap_info[6] & 5301 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) 5302 ath11k_gen_ppe_thresh(&band_cap->he_ppet, 5303 he_cap->ppe_thres); 5304 5305 if (band == NL80211_BAND_6GHZ) { 5306 data[idx].he_6ghz_capa.capa = 5307 ath11k_mac_setup_he_6ghz_cap(cap, band_cap); 5308 } 5309 idx++; 5310 } 5311 5312 return idx; 5313 } 5314 5315 static void ath11k_mac_setup_he_cap(struct ath11k *ar, 5316 struct ath11k_pdev_cap *cap) 5317 { 5318 struct ieee80211_supported_band *band; 5319 int count; 5320 5321 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 5322 count = ath11k_mac_copy_he_cap(ar, cap, 5323 ar->mac.iftype[NL80211_BAND_2GHZ], 5324 NL80211_BAND_2GHZ); 5325 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 5326 band->iftype_data = ar->mac.iftype[NL80211_BAND_2GHZ]; 5327 band->n_iftype_data = count; 5328 } 5329 5330 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) { 5331 count = ath11k_mac_copy_he_cap(ar, cap, 5332 ar->mac.iftype[NL80211_BAND_5GHZ], 5333 NL80211_BAND_5GHZ); 5334 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 5335 band->iftype_data = ar->mac.iftype[NL80211_BAND_5GHZ]; 5336 band->n_iftype_data = count; 5337 } 5338 5339 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 5340 ar->supports_6ghz) { 5341 count = ath11k_mac_copy_he_cap(ar, cap, 5342 ar->mac.iftype[NL80211_BAND_6GHZ], 5343 NL80211_BAND_6GHZ); 5344 band = &ar->mac.sbands[NL80211_BAND_6GHZ]; 5345 band->iftype_data = ar->mac.iftype[NL80211_BAND_6GHZ]; 5346 band->n_iftype_data = count; 5347 } 5348 } 5349 5350 static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant) 5351 { 5352 int ret; 5353 5354 lockdep_assert_held(&ar->conf_mutex); 5355 5356 if (ath11k_check_chain_mask(ar, tx_ant, true)) 5357 return -EINVAL; 5358 5359 if (ath11k_check_chain_mask(ar, rx_ant, false)) 5360 return -EINVAL; 5361 5362 ar->cfg_tx_chainmask = tx_ant; 5363 ar->cfg_rx_chainmask = rx_ant; 5364 5365 if (ar->state != ATH11K_STATE_ON && 5366 ar->state != ATH11K_STATE_RESTARTED) 5367 return 0; 5368 5369 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK, 5370 tx_ant, ar->pdev->pdev_id); 5371 if (ret) { 5372 ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n", 5373 ret, tx_ant); 5374 return ret; 5375 } 5376 5377 ar->num_tx_chains = get_num_chains(tx_ant); 5378 5379 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK, 5380 rx_ant, ar->pdev->pdev_id); 5381 if (ret) { 5382 ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n", 5383 ret, rx_ant); 5384 return ret; 5385 } 5386 5387 ar->num_rx_chains = get_num_chains(rx_ant); 5388 5389 /* Reload HT/VHT/HE capability */ 5390 ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL); 5391 ath11k_mac_setup_he_cap(ar, &ar->pdev->cap); 5392 5393 return 0; 5394 } 5395 5396 static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb) 5397 { 5398 int num_mgmt; 5399 5400 ieee80211_free_txskb(ar->hw, skb); 5401 5402 num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx); 5403 5404 if (num_mgmt < 0) 5405 WARN_ON_ONCE(1); 5406 5407 if (!num_mgmt) 5408 wake_up(&ar->txmgmt_empty_waitq); 5409 } 5410 5411 static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id) 5412 { 5413 struct sk_buff *msdu; 5414 struct ieee80211_tx_info *info; 5415 5416 spin_lock_bh(&ar->txmgmt_idr_lock); 5417 msdu = idr_remove(&ar->txmgmt_idr, buf_id); 5418 spin_unlock_bh(&ar->txmgmt_idr_lock); 5419 5420 if (!msdu) 5421 return; 5422 5423 dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len, 5424 DMA_TO_DEVICE); 5425 5426 info = IEEE80211_SKB_CB(msdu); 5427 memset(&info->status, 0, sizeof(info->status)); 5428 5429 ath11k_mgmt_over_wmi_tx_drop(ar, msdu); 5430 } 5431 5432 int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx) 5433 { 5434 struct ath11k *ar = ctx; 5435 5436 ath11k_mac_tx_mgmt_free(ar, buf_id); 5437 5438 return 0; 5439 } 5440 5441 static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx) 5442 { 5443 struct ieee80211_vif *vif = ctx; 5444 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb); 5445 struct ath11k *ar = skb_cb->ar; 5446 5447 if (skb_cb->vif == vif) 5448 ath11k_mac_tx_mgmt_free(ar, buf_id); 5449 5450 return 0; 5451 } 5452 5453 static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif, 5454 struct sk_buff *skb) 5455 { 5456 struct ath11k_base *ab = ar->ab; 5457 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 5458 struct ieee80211_tx_info *info; 5459 dma_addr_t paddr; 5460 int buf_id; 5461 int ret; 5462 5463 ATH11K_SKB_CB(skb)->ar = ar; 5464 5465 spin_lock_bh(&ar->txmgmt_idr_lock); 5466 buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0, 5467 ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC); 5468 spin_unlock_bh(&ar->txmgmt_idr_lock); 5469 5470 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 5471 "mac tx mgmt frame, buf id %d\n", buf_id); 5472 5473 if (buf_id < 0) 5474 return -ENOSPC; 5475 5476 info = IEEE80211_SKB_CB(skb); 5477 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) { 5478 if ((ieee80211_is_action(hdr->frame_control) || 5479 ieee80211_is_deauth(hdr->frame_control) || 5480 ieee80211_is_disassoc(hdr->frame_control)) && 5481 ieee80211_has_protected(hdr->frame_control)) { 5482 skb_put(skb, IEEE80211_CCMP_MIC_LEN); 5483 } 5484 } 5485 5486 paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE); 5487 if (dma_mapping_error(ab->dev, paddr)) { 5488 ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n"); 5489 ret = -EIO; 5490 goto err_free_idr; 5491 } 5492 5493 ATH11K_SKB_CB(skb)->paddr = paddr; 5494 5495 ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb); 5496 if (ret) { 5497 ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret); 5498 goto err_unmap_buf; 5499 } 5500 5501 return 0; 5502 5503 err_unmap_buf: 5504 dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr, 5505 skb->len, DMA_TO_DEVICE); 5506 err_free_idr: 5507 spin_lock_bh(&ar->txmgmt_idr_lock); 5508 idr_remove(&ar->txmgmt_idr, buf_id); 5509 spin_unlock_bh(&ar->txmgmt_idr_lock); 5510 5511 return ret; 5512 } 5513 5514 static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar) 5515 { 5516 struct sk_buff *skb; 5517 5518 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) 5519 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 5520 } 5521 5522 static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work) 5523 { 5524 struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work); 5525 struct ath11k_skb_cb *skb_cb; 5526 struct ath11k_vif *arvif; 5527 struct sk_buff *skb; 5528 int ret; 5529 5530 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) { 5531 skb_cb = ATH11K_SKB_CB(skb); 5532 if (!skb_cb->vif) { 5533 ath11k_warn(ar->ab, "no vif found for mgmt frame\n"); 5534 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 5535 continue; 5536 } 5537 5538 arvif = ath11k_vif_to_arvif(skb_cb->vif); 5539 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id) && 5540 arvif->is_started) { 5541 ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb); 5542 if (ret) { 5543 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n", 5544 arvif->vdev_id, ret); 5545 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 5546 } else { 5547 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 5548 "mac tx mgmt frame, vdev_id %d\n", 5549 arvif->vdev_id); 5550 } 5551 } else { 5552 ath11k_warn(ar->ab, 5553 "dropping mgmt frame for vdev %d, is_started %d\n", 5554 arvif->vdev_id, 5555 arvif->is_started); 5556 ath11k_mgmt_over_wmi_tx_drop(ar, skb); 5557 } 5558 } 5559 } 5560 5561 static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb, 5562 bool is_prb_rsp) 5563 { 5564 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue; 5565 5566 if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags)) 5567 return -ESHUTDOWN; 5568 5569 /* Drop probe response packets when the pending management tx 5570 * count has reached a certain threshold, so as to prioritize 5571 * other mgmt packets like auth and assoc to be sent on time 5572 * for establishing successful connections. 5573 */ 5574 if (is_prb_rsp && 5575 atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) { 5576 ath11k_warn(ar->ab, 5577 "dropping probe response as pending queue is almost full\n"); 5578 return -ENOSPC; 5579 } 5580 5581 if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) { 5582 ath11k_warn(ar->ab, "mgmt tx queue is full\n"); 5583 return -ENOSPC; 5584 } 5585 5586 skb_queue_tail(q, skb); 5587 atomic_inc(&ar->num_pending_mgmt_tx); 5588 queue_work(ar->ab->workqueue, &ar->wmi_mgmt_tx_work); 5589 5590 return 0; 5591 } 5592 5593 int ath11k_mac_rfkill_config(struct ath11k *ar) 5594 { 5595 struct ath11k_base *ab = ar->ab; 5596 u32 param; 5597 int ret; 5598 5599 if (ab->hw_params.rfkill_pin == 0) 5600 return -EOPNOTSUPP; 5601 5602 ath11k_dbg(ab, ATH11K_DBG_MAC, 5603 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d", 5604 ab->hw_params.rfkill_pin, ab->hw_params.rfkill_cfg, 5605 ab->hw_params.rfkill_on_level); 5606 5607 param = FIELD_PREP(WMI_RFKILL_CFG_RADIO_LEVEL, 5608 ab->hw_params.rfkill_on_level) | 5609 FIELD_PREP(WMI_RFKILL_CFG_GPIO_PIN_NUM, 5610 ab->hw_params.rfkill_pin) | 5611 FIELD_PREP(WMI_RFKILL_CFG_PIN_AS_GPIO, 5612 ab->hw_params.rfkill_cfg); 5613 5614 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_HW_RFKILL_CONFIG, 5615 param, ar->pdev->pdev_id); 5616 if (ret) { 5617 ath11k_warn(ab, 5618 "failed to set rfkill config 0x%x: %d\n", 5619 param, ret); 5620 return ret; 5621 } 5622 5623 return 0; 5624 } 5625 5626 int ath11k_mac_rfkill_enable_radio(struct ath11k *ar, bool enable) 5627 { 5628 enum wmi_rfkill_enable_radio param; 5629 int ret; 5630 5631 if (enable) 5632 param = WMI_RFKILL_ENABLE_RADIO_ON; 5633 else 5634 param = WMI_RFKILL_ENABLE_RADIO_OFF; 5635 5636 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac %d rfkill enable %d", 5637 ar->pdev_idx, param); 5638 5639 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RFKILL_ENABLE, 5640 param, ar->pdev->pdev_id); 5641 if (ret) { 5642 ath11k_warn(ar->ab, "failed to set rfkill enable param %d: %d\n", 5643 param, ret); 5644 return ret; 5645 } 5646 5647 return 0; 5648 } 5649 5650 static void ath11k_mac_op_tx(struct ieee80211_hw *hw, 5651 struct ieee80211_tx_control *control, 5652 struct sk_buff *skb) 5653 { 5654 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb); 5655 struct ath11k *ar = hw->priv; 5656 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 5657 struct ieee80211_vif *vif = info->control.vif; 5658 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 5659 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 5660 struct ieee80211_key_conf *key = info->control.hw_key; 5661 struct ath11k_sta *arsta = NULL; 5662 u32 info_flags = info->flags; 5663 bool is_prb_rsp; 5664 int ret; 5665 5666 memset(skb_cb, 0, sizeof(*skb_cb)); 5667 skb_cb->vif = vif; 5668 5669 if (key) { 5670 skb_cb->cipher = key->cipher; 5671 skb_cb->flags |= ATH11K_SKB_CIPHER_SET; 5672 } 5673 5674 if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) { 5675 skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP; 5676 } else if (ieee80211_is_mgmt(hdr->frame_control)) { 5677 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control); 5678 ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp); 5679 if (ret) { 5680 ath11k_warn(ar->ab, "failed to queue management frame %d\n", 5681 ret); 5682 ieee80211_free_txskb(ar->hw, skb); 5683 } 5684 return; 5685 } 5686 5687 if (control->sta) 5688 arsta = (struct ath11k_sta *)control->sta->drv_priv; 5689 5690 ret = ath11k_dp_tx(ar, arvif, arsta, skb); 5691 if (unlikely(ret)) { 5692 ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret); 5693 ieee80211_free_txskb(ar->hw, skb); 5694 } 5695 } 5696 5697 void ath11k_mac_drain_tx(struct ath11k *ar) 5698 { 5699 /* make sure rcu-protected mac80211 tx path itself is drained */ 5700 synchronize_net(); 5701 5702 cancel_work_sync(&ar->wmi_mgmt_tx_work); 5703 ath11k_mgmt_over_wmi_tx_purge(ar); 5704 } 5705 5706 static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable) 5707 { 5708 struct htt_rx_ring_tlv_filter tlv_filter = {0}; 5709 struct ath11k_base *ab = ar->ab; 5710 int i, ret = 0; 5711 u32 ring_id; 5712 5713 if (enable) { 5714 tlv_filter = ath11k_mac_mon_status_filter_default; 5715 if (ath11k_debugfs_rx_filter(ar)) 5716 tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar); 5717 } 5718 5719 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) { 5720 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id; 5721 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id, 5722 ar->dp.mac_id + i, 5723 HAL_RXDMA_MONITOR_STATUS, 5724 DP_RX_BUFFER_SIZE, 5725 &tlv_filter); 5726 } 5727 5728 if (enable && !ar->ab->hw_params.rxdma1_enable) 5729 mod_timer(&ar->ab->mon_reap_timer, jiffies + 5730 msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL)); 5731 5732 return ret; 5733 } 5734 5735 static int ath11k_mac_op_start(struct ieee80211_hw *hw) 5736 { 5737 struct ath11k *ar = hw->priv; 5738 struct ath11k_base *ab = ar->ab; 5739 struct ath11k_pdev *pdev = ar->pdev; 5740 int ret; 5741 5742 ath11k_mac_drain_tx(ar); 5743 mutex_lock(&ar->conf_mutex); 5744 5745 switch (ar->state) { 5746 case ATH11K_STATE_OFF: 5747 ar->state = ATH11K_STATE_ON; 5748 break; 5749 case ATH11K_STATE_RESTARTING: 5750 ar->state = ATH11K_STATE_RESTARTED; 5751 break; 5752 case ATH11K_STATE_RESTARTED: 5753 case ATH11K_STATE_WEDGED: 5754 case ATH11K_STATE_ON: 5755 WARN_ON(1); 5756 ret = -EINVAL; 5757 goto err; 5758 } 5759 5760 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 5761 1, pdev->pdev_id); 5762 5763 if (ret) { 5764 ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret); 5765 goto err; 5766 } 5767 5768 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1, 5769 pdev->pdev_id); 5770 if (ret) { 5771 ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret); 5772 goto err; 5773 } 5774 5775 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) { 5776 ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr); 5777 if (ret) { 5778 ath11k_err(ab, "failed to set prob req oui: %i\n", ret); 5779 goto err; 5780 } 5781 } 5782 5783 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE, 5784 0, pdev->pdev_id); 5785 if (ret) { 5786 ath11k_err(ab, "failed to set ac override for ARP: %d\n", 5787 ret); 5788 goto err; 5789 } 5790 5791 ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id); 5792 if (ret) { 5793 ath11k_err(ab, "failed to offload radar detection: %d\n", 5794 ret); 5795 goto err; 5796 } 5797 5798 ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar, 5799 HTT_PPDU_STATS_TAG_DEFAULT); 5800 if (ret) { 5801 ath11k_err(ab, "failed to req ppdu stats: %d\n", ret); 5802 goto err; 5803 } 5804 5805 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE, 5806 1, pdev->pdev_id); 5807 5808 if (ret) { 5809 ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret); 5810 goto err; 5811 } 5812 5813 __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask); 5814 5815 /* TODO: Do we need to enable ANI? */ 5816 5817 ath11k_reg_update_chan_list(ar); 5818 5819 ar->num_started_vdevs = 0; 5820 ar->num_created_vdevs = 0; 5821 ar->num_peers = 0; 5822 ar->allocated_vdev_map = 0; 5823 5824 /* Configure monitor status ring with default rx_filter to get rx status 5825 * such as rssi, rx_duration. 5826 */ 5827 ret = ath11k_mac_config_mon_status_default(ar, true); 5828 if (ret) { 5829 ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n", 5830 ret); 5831 goto err; 5832 } 5833 5834 /* Configure the hash seed for hash based reo dest ring selection */ 5835 ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id); 5836 5837 /* allow device to enter IMPS */ 5838 if (ab->hw_params.idle_ps) { 5839 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG, 5840 1, pdev->pdev_id); 5841 if (ret) { 5842 ath11k_err(ab, "failed to enable idle ps: %d\n", ret); 5843 goto err; 5844 } 5845 } 5846 5847 mutex_unlock(&ar->conf_mutex); 5848 5849 rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx], 5850 &ab->pdevs[ar->pdev_idx]); 5851 5852 return 0; 5853 5854 err: 5855 ar->state = ATH11K_STATE_OFF; 5856 mutex_unlock(&ar->conf_mutex); 5857 5858 return ret; 5859 } 5860 5861 static void ath11k_mac_op_stop(struct ieee80211_hw *hw) 5862 { 5863 struct ath11k *ar = hw->priv; 5864 struct htt_ppdu_stats_info *ppdu_stats, *tmp; 5865 int ret; 5866 5867 ath11k_mac_drain_tx(ar); 5868 5869 mutex_lock(&ar->conf_mutex); 5870 ret = ath11k_mac_config_mon_status_default(ar, false); 5871 if (ret) 5872 ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n", 5873 ret); 5874 5875 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags); 5876 ar->state = ATH11K_STATE_OFF; 5877 mutex_unlock(&ar->conf_mutex); 5878 5879 cancel_delayed_work_sync(&ar->scan.timeout); 5880 cancel_work_sync(&ar->regd_update_work); 5881 cancel_work_sync(&ar->ab->update_11d_work); 5882 cancel_work_sync(&ar->ab->rfkill_work); 5883 5884 spin_lock_bh(&ar->data_lock); 5885 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) { 5886 list_del(&ppdu_stats->list); 5887 kfree(ppdu_stats); 5888 } 5889 spin_unlock_bh(&ar->data_lock); 5890 5891 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL); 5892 5893 synchronize_rcu(); 5894 5895 atomic_set(&ar->num_pending_mgmt_tx, 0); 5896 } 5897 5898 static void 5899 ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif, 5900 struct vdev_create_params *params) 5901 { 5902 struct ath11k *ar = arvif->ar; 5903 struct ath11k_pdev *pdev = ar->pdev; 5904 5905 params->if_id = arvif->vdev_id; 5906 params->type = arvif->vdev_type; 5907 params->subtype = arvif->vdev_subtype; 5908 params->pdev_id = pdev->pdev_id; 5909 5910 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) { 5911 params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains; 5912 params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains; 5913 } 5914 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) { 5915 params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains; 5916 params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains; 5917 } 5918 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP && 5919 ar->supports_6ghz) { 5920 params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains; 5921 params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains; 5922 } 5923 } 5924 5925 static u32 5926 ath11k_mac_prepare_he_mode(struct ath11k_pdev *pdev, u32 viftype) 5927 { 5928 struct ath11k_pdev_cap *pdev_cap = &pdev->cap; 5929 struct ath11k_band_cap *cap_band = NULL; 5930 u32 *hecap_phy_ptr = NULL; 5931 u32 hemode = 0; 5932 5933 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) 5934 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ]; 5935 else 5936 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ]; 5937 5938 hecap_phy_ptr = &cap_band->he_cap_phy_info[0]; 5939 5940 hemode = FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE) | 5941 FIELD_PREP(HE_MODE_SU_TX_BFER, HECAP_PHY_SUBFMR_GET(hecap_phy_ptr)) | 5942 FIELD_PREP(HE_MODE_UL_MUMIMO, HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr)); 5943 5944 /* TODO WDS and other modes */ 5945 if (viftype == NL80211_IFTYPE_AP) { 5946 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFER, 5947 HECAP_PHY_MUBFMR_GET(hecap_phy_ptr)) | 5948 FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) | 5949 FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE); 5950 } else { 5951 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFEE, HE_MU_BFEE_ENABLE); 5952 } 5953 5954 return hemode; 5955 } 5956 5957 static int ath11k_set_he_mu_sounding_mode(struct ath11k *ar, 5958 struct ath11k_vif *arvif) 5959 { 5960 u32 param_id, param_value; 5961 struct ath11k_base *ab = ar->ab; 5962 int ret = 0; 5963 5964 param_id = WMI_VDEV_PARAM_SET_HEMU_MODE; 5965 param_value = ath11k_mac_prepare_he_mode(ar->pdev, arvif->vif->type); 5966 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5967 param_id, param_value); 5968 if (ret) { 5969 ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n", 5970 arvif->vdev_id, ret, param_value); 5971 return ret; 5972 } 5973 param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE; 5974 param_value = 5975 FIELD_PREP(HE_VHT_SOUNDING_MODE, HE_VHT_SOUNDING_MODE_ENABLE) | 5976 FIELD_PREP(HE_TRIG_NONTRIG_SOUNDING_MODE, 5977 HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE); 5978 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5979 param_id, param_value); 5980 if (ret) { 5981 ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d\n", 5982 arvif->vdev_id, ret); 5983 return ret; 5984 } 5985 return ret; 5986 } 5987 5988 static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw, 5989 struct ieee80211_vif *vif) 5990 { 5991 struct ath11k *ar = hw->priv; 5992 struct ath11k_base *ab = ar->ab; 5993 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 5994 u32 param_id, param_value; 5995 int ret; 5996 5997 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE; 5998 if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET || 5999 (vif->type != NL80211_IFTYPE_STATION && 6000 vif->type != NL80211_IFTYPE_AP)) 6001 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED | 6002 IEEE80211_OFFLOAD_DECAP_ENABLED); 6003 6004 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED) 6005 param_value = ATH11K_HW_TXRX_ETHERNET; 6006 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) 6007 param_value = ATH11K_HW_TXRX_RAW; 6008 else 6009 param_value = ATH11K_HW_TXRX_NATIVE_WIFI; 6010 6011 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6012 param_id, param_value); 6013 if (ret) { 6014 ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n", 6015 arvif->vdev_id, ret); 6016 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED; 6017 } 6018 6019 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE; 6020 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED) 6021 param_value = ATH11K_HW_TXRX_ETHERNET; 6022 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) 6023 param_value = ATH11K_HW_TXRX_RAW; 6024 else 6025 param_value = ATH11K_HW_TXRX_NATIVE_WIFI; 6026 6027 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6028 param_id, param_value); 6029 if (ret) { 6030 ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n", 6031 arvif->vdev_id, ret); 6032 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED; 6033 } 6034 } 6035 6036 static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab) 6037 { 6038 struct ath11k *ar; 6039 struct ath11k_pdev *pdev; 6040 struct ath11k_vif *arvif; 6041 int i; 6042 6043 for (i = 0; i < ab->num_radios; i++) { 6044 pdev = &ab->pdevs[i]; 6045 ar = pdev->ar; 6046 list_for_each_entry(arvif, &ar->arvifs, list) { 6047 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP) 6048 return true; 6049 } 6050 } 6051 return false; 6052 } 6053 6054 void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id, bool wait) 6055 { 6056 struct wmi_11d_scan_start_params param; 6057 int ret; 6058 6059 mutex_lock(&ar->ab->vdev_id_11d_lock); 6060 6061 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev id for 11d scan %d\n", 6062 ar->vdev_id_11d_scan); 6063 6064 if (ar->regdom_set_by_user) 6065 goto fin; 6066 6067 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) 6068 goto fin; 6069 6070 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) 6071 goto fin; 6072 6073 if (ath11k_mac_vif_ap_active_any(ar->ab)) 6074 goto fin; 6075 6076 param.vdev_id = vdev_id; 6077 param.start_interval_msec = 0; 6078 param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL; 6079 6080 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac start 11d scan\n"); 6081 6082 if (wait) 6083 reinit_completion(&ar->finish_11d_scan); 6084 6085 ret = ath11k_wmi_send_11d_scan_start_cmd(ar, ¶m); 6086 if (ret) { 6087 ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n", 6088 vdev_id, ret); 6089 } else { 6090 ar->vdev_id_11d_scan = vdev_id; 6091 if (wait) { 6092 ar->pending_11d = true; 6093 ret = wait_for_completion_timeout(&ar->finish_11d_scan, 6094 5 * HZ); 6095 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 6096 "mac 11d scan left time %d\n", ret); 6097 6098 if (!ret) 6099 ar->pending_11d = false; 6100 } 6101 } 6102 6103 fin: 6104 mutex_unlock(&ar->ab->vdev_id_11d_lock); 6105 } 6106 6107 void ath11k_mac_11d_scan_stop(struct ath11k *ar) 6108 { 6109 int ret; 6110 u32 vdev_id; 6111 6112 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) 6113 return; 6114 6115 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d scan\n"); 6116 6117 mutex_lock(&ar->ab->vdev_id_11d_lock); 6118 6119 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d vdev id %d\n", 6120 ar->vdev_id_11d_scan); 6121 6122 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) { 6123 vdev_id = ar->vdev_id_11d_scan; 6124 6125 ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id); 6126 if (ret) 6127 ath11k_warn(ar->ab, 6128 "failed to stopt 11d scan vdev %d ret: %d\n", 6129 vdev_id, ret); 6130 else 6131 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID; 6132 } 6133 mutex_unlock(&ar->ab->vdev_id_11d_lock); 6134 } 6135 6136 void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab) 6137 { 6138 struct ath11k *ar; 6139 struct ath11k_pdev *pdev; 6140 int i; 6141 6142 ath11k_dbg(ab, ATH11K_DBG_MAC, "mac stop soc 11d scan\n"); 6143 6144 for (i = 0; i < ab->num_radios; i++) { 6145 pdev = &ab->pdevs[i]; 6146 ar = pdev->ar; 6147 6148 ath11k_mac_11d_scan_stop(ar); 6149 } 6150 } 6151 6152 static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw, 6153 struct ieee80211_vif *vif) 6154 { 6155 struct ath11k *ar = hw->priv; 6156 struct ath11k_base *ab = ar->ab; 6157 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 6158 struct vdev_create_params vdev_param = {0}; 6159 struct peer_create_params peer_param; 6160 u32 param_id, param_value; 6161 u16 nss; 6162 int i; 6163 int ret, fbret; 6164 int bit; 6165 6166 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 6167 6168 mutex_lock(&ar->conf_mutex); 6169 6170 if (vif->type == NL80211_IFTYPE_AP && 6171 ar->num_peers > (ar->max_num_peers - 1)) { 6172 ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n"); 6173 ret = -ENOBUFS; 6174 goto err; 6175 } 6176 6177 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) { 6178 ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n", 6179 ar->num_created_vdevs, TARGET_NUM_VDEVS(ab)); 6180 ret = -EBUSY; 6181 goto err; 6182 } 6183 6184 memset(arvif, 0, sizeof(*arvif)); 6185 6186 arvif->ar = ar; 6187 arvif->vif = vif; 6188 6189 INIT_LIST_HEAD(&arvif->list); 6190 INIT_DELAYED_WORK(&arvif->connection_loss_work, 6191 ath11k_mac_vif_sta_connection_loss_work); 6192 6193 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) { 6194 arvif->bitrate_mask.control[i].legacy = 0xffffffff; 6195 arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI; 6196 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff, 6197 sizeof(arvif->bitrate_mask.control[i].ht_mcs)); 6198 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff, 6199 sizeof(arvif->bitrate_mask.control[i].vht_mcs)); 6200 memset(arvif->bitrate_mask.control[i].he_mcs, 0xff, 6201 sizeof(arvif->bitrate_mask.control[i].he_mcs)); 6202 } 6203 6204 bit = __ffs64(ab->free_vdev_map); 6205 6206 arvif->vdev_id = bit; 6207 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 6208 6209 switch (vif->type) { 6210 case NL80211_IFTYPE_UNSPECIFIED: 6211 case NL80211_IFTYPE_STATION: 6212 arvif->vdev_type = WMI_VDEV_TYPE_STA; 6213 break; 6214 case NL80211_IFTYPE_MESH_POINT: 6215 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S; 6216 fallthrough; 6217 case NL80211_IFTYPE_AP: 6218 arvif->vdev_type = WMI_VDEV_TYPE_AP; 6219 break; 6220 case NL80211_IFTYPE_MONITOR: 6221 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 6222 ar->monitor_vdev_id = bit; 6223 break; 6224 default: 6225 WARN_ON(1); 6226 break; 6227 } 6228 6229 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac add interface id %d type %d subtype %d map %llx\n", 6230 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype, 6231 ab->free_vdev_map); 6232 6233 vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1); 6234 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 6235 vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1); 6236 6237 ath11k_mac_setup_vdev_create_params(arvif, &vdev_param); 6238 6239 ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param); 6240 if (ret) { 6241 ath11k_warn(ab, "failed to create WMI vdev %d: %d\n", 6242 arvif->vdev_id, ret); 6243 goto err; 6244 } 6245 6246 ar->num_created_vdevs++; 6247 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n", 6248 vif->addr, arvif->vdev_id); 6249 ar->allocated_vdev_map |= 1LL << arvif->vdev_id; 6250 ab->free_vdev_map &= ~(1LL << arvif->vdev_id); 6251 6252 spin_lock_bh(&ar->data_lock); 6253 list_add(&arvif->list, &ar->arvifs); 6254 spin_unlock_bh(&ar->data_lock); 6255 6256 ath11k_mac_op_update_vif_offload(hw, vif); 6257 6258 nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1; 6259 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6260 WMI_VDEV_PARAM_NSS, nss); 6261 if (ret) { 6262 ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n", 6263 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret); 6264 goto err_vdev_del; 6265 } 6266 6267 switch (arvif->vdev_type) { 6268 case WMI_VDEV_TYPE_AP: 6269 peer_param.vdev_id = arvif->vdev_id; 6270 peer_param.peer_addr = vif->addr; 6271 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 6272 ret = ath11k_peer_create(ar, arvif, NULL, &peer_param); 6273 if (ret) { 6274 ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n", 6275 arvif->vdev_id, ret); 6276 goto err_vdev_del; 6277 } 6278 6279 ret = ath11k_mac_set_kickout(arvif); 6280 if (ret) { 6281 ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n", 6282 arvif->vdev_id, ret); 6283 goto err_peer_del; 6284 } 6285 6286 ath11k_mac_11d_scan_stop_all(ar->ab); 6287 break; 6288 case WMI_VDEV_TYPE_STA: 6289 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 6290 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 6291 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6292 param_id, param_value); 6293 if (ret) { 6294 ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n", 6295 arvif->vdev_id, ret); 6296 goto err_peer_del; 6297 } 6298 6299 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 6300 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 6301 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6302 param_id, param_value); 6303 if (ret) { 6304 ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n", 6305 arvif->vdev_id, ret); 6306 goto err_peer_del; 6307 } 6308 6309 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT; 6310 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 6311 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6312 param_id, param_value); 6313 if (ret) { 6314 ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n", 6315 arvif->vdev_id, ret); 6316 goto err_peer_del; 6317 } 6318 6319 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, 6320 WMI_STA_PS_MODE_DISABLED); 6321 if (ret) { 6322 ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n", 6323 arvif->vdev_id, ret); 6324 goto err_peer_del; 6325 } 6326 6327 ath11k_mac_11d_scan_start(ar, arvif->vdev_id, true); 6328 6329 break; 6330 case WMI_VDEV_TYPE_MONITOR: 6331 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 6332 break; 6333 default: 6334 break; 6335 } 6336 6337 arvif->txpower = vif->bss_conf.txpower; 6338 ret = ath11k_mac_txpower_recalc(ar); 6339 if (ret) 6340 goto err_peer_del; 6341 6342 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 6343 param_value = ar->hw->wiphy->rts_threshold; 6344 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6345 param_id, param_value); 6346 if (ret) { 6347 ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n", 6348 arvif->vdev_id, ret); 6349 } 6350 6351 ath11k_dp_vdev_tx_attach(ar, arvif); 6352 6353 if (vif->type != NL80211_IFTYPE_MONITOR && 6354 test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) { 6355 ret = ath11k_mac_monitor_vdev_create(ar); 6356 if (ret) { 6357 ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d", 6358 ret); 6359 goto err_peer_del; 6360 } 6361 } 6362 6363 ret = ath11k_debugfs_add_interface(arvif); 6364 if (ret) 6365 goto err_peer_del; 6366 6367 mutex_unlock(&ar->conf_mutex); 6368 6369 return 0; 6370 6371 err_peer_del: 6372 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 6373 reinit_completion(&ar->peer_delete_done); 6374 6375 fbret = ath11k_wmi_send_peer_delete_cmd(ar, vif->addr, 6376 arvif->vdev_id); 6377 if (fbret) { 6378 ath11k_warn(ar->ab, "failed to delete peer vdev_id %d addr %pM\n", 6379 arvif->vdev_id, vif->addr); 6380 goto err; 6381 } 6382 6383 fbret = ath11k_wait_for_peer_delete_done(ar, arvif->vdev_id, 6384 vif->addr); 6385 if (fbret) 6386 goto err; 6387 6388 ar->num_peers--; 6389 } 6390 6391 err_vdev_del: 6392 ath11k_wmi_vdev_delete(ar, arvif->vdev_id); 6393 ar->num_created_vdevs--; 6394 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 6395 ab->free_vdev_map |= 1LL << arvif->vdev_id; 6396 spin_lock_bh(&ar->data_lock); 6397 list_del(&arvif->list); 6398 spin_unlock_bh(&ar->data_lock); 6399 6400 err: 6401 ath11k_debugfs_remove_interface(arvif); 6402 mutex_unlock(&ar->conf_mutex); 6403 6404 return ret; 6405 } 6406 6407 static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx) 6408 { 6409 struct ieee80211_vif *vif = (struct ieee80211_vif *)ctx; 6410 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb); 6411 6412 if (skb_cb->vif == vif) 6413 skb_cb->vif = NULL; 6414 6415 return 0; 6416 } 6417 6418 static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw, 6419 struct ieee80211_vif *vif) 6420 { 6421 struct ath11k *ar = hw->priv; 6422 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif); 6423 struct ath11k_base *ab = ar->ab; 6424 unsigned long time_left; 6425 int ret; 6426 int i; 6427 6428 cancel_delayed_work_sync(&arvif->connection_loss_work); 6429 6430 mutex_lock(&ar->conf_mutex); 6431 6432 ath11k_dbg(ab, ATH11K_DBG_MAC, "mac remove interface (vdev %d)\n", 6433 arvif->vdev_id); 6434 6435 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 6436 ath11k_mac_11d_scan_stop(ar); 6437 6438 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 6439 ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr); 6440 if (ret) 6441 ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n", 6442 arvif->vdev_id, ret); 6443 } 6444 6445 reinit_completion(&ar->vdev_delete_done); 6446 6447 ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id); 6448 if (ret) { 6449 ath11k_warn(ab, "failed to delete WMI vdev %d: %d\n", 6450 arvif->vdev_id, ret); 6451 goto err_vdev_del; 6452 } 6453 6454 time_left = wait_for_completion_timeout(&ar->vdev_delete_done, 6455 ATH11K_VDEV_DELETE_TIMEOUT_HZ); 6456 if (time_left == 0) { 6457 ath11k_warn(ab, "Timeout in receiving vdev delete response\n"); 6458 goto err_vdev_del; 6459 } 6460 6461 ab->free_vdev_map |= 1LL << (arvif->vdev_id); 6462 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 6463 ar->num_created_vdevs--; 6464 6465 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n", 6466 vif->addr, arvif->vdev_id); 6467 6468 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 6469 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 6470 ar->monitor_vdev_id = -1; 6471 } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) && 6472 !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) { 6473 ret = ath11k_mac_monitor_vdev_delete(ar); 6474 if (ret) 6475 /* continue even if there's an error */ 6476 ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d", 6477 ret); 6478 } 6479 6480 err_vdev_del: 6481 spin_lock_bh(&ar->data_lock); 6482 list_del(&arvif->list); 6483 spin_unlock_bh(&ar->data_lock); 6484 6485 ath11k_peer_cleanup(ar, arvif->vdev_id); 6486 6487 idr_for_each(&ar->txmgmt_idr, 6488 ath11k_mac_vif_txmgmt_idr_remove, vif); 6489 6490 for (i = 0; i < ab->hw_params.max_tx_ring; i++) { 6491 spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock); 6492 idr_for_each(&ab->dp.tx_ring[i].txbuf_idr, 6493 ath11k_mac_vif_unref, vif); 6494 spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock); 6495 } 6496 6497 /* Recalc txpower for remaining vdev */ 6498 ath11k_mac_txpower_recalc(ar); 6499 6500 ath11k_debugfs_remove_interface(arvif); 6501 6502 /* TODO: recal traffic pause state based on the available vdevs */ 6503 6504 mutex_unlock(&ar->conf_mutex); 6505 } 6506 6507 /* FIXME: Has to be verified. */ 6508 #define SUPPORTED_FILTERS \ 6509 (FIF_ALLMULTI | \ 6510 FIF_CONTROL | \ 6511 FIF_PSPOLL | \ 6512 FIF_OTHER_BSS | \ 6513 FIF_BCN_PRBRESP_PROMISC | \ 6514 FIF_PROBE_REQ | \ 6515 FIF_FCSFAIL) 6516 6517 static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw, 6518 unsigned int changed_flags, 6519 unsigned int *total_flags, 6520 u64 multicast) 6521 { 6522 struct ath11k *ar = hw->priv; 6523 6524 mutex_lock(&ar->conf_mutex); 6525 6526 *total_flags &= SUPPORTED_FILTERS; 6527 ar->filter_flags = *total_flags; 6528 6529 mutex_unlock(&ar->conf_mutex); 6530 } 6531 6532 static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 6533 { 6534 struct ath11k *ar = hw->priv; 6535 6536 mutex_lock(&ar->conf_mutex); 6537 6538 *tx_ant = ar->cfg_tx_chainmask; 6539 *rx_ant = ar->cfg_rx_chainmask; 6540 6541 mutex_unlock(&ar->conf_mutex); 6542 6543 return 0; 6544 } 6545 6546 static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 6547 { 6548 struct ath11k *ar = hw->priv; 6549 int ret; 6550 6551 mutex_lock(&ar->conf_mutex); 6552 ret = __ath11k_set_antenna(ar, tx_ant, rx_ant); 6553 mutex_unlock(&ar->conf_mutex); 6554 6555 return ret; 6556 } 6557 6558 static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw, 6559 struct ieee80211_vif *vif, 6560 struct ieee80211_ampdu_params *params) 6561 { 6562 struct ath11k *ar = hw->priv; 6563 int ret = -EINVAL; 6564 6565 mutex_lock(&ar->conf_mutex); 6566 6567 switch (params->action) { 6568 case IEEE80211_AMPDU_RX_START: 6569 ret = ath11k_dp_rx_ampdu_start(ar, params); 6570 break; 6571 case IEEE80211_AMPDU_RX_STOP: 6572 ret = ath11k_dp_rx_ampdu_stop(ar, params); 6573 break; 6574 case IEEE80211_AMPDU_TX_START: 6575 case IEEE80211_AMPDU_TX_STOP_CONT: 6576 case IEEE80211_AMPDU_TX_STOP_FLUSH: 6577 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 6578 case IEEE80211_AMPDU_TX_OPERATIONAL: 6579 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211 6580 * Tx aggregation requests. 6581 */ 6582 ret = -EOPNOTSUPP; 6583 break; 6584 } 6585 6586 mutex_unlock(&ar->conf_mutex); 6587 6588 return ret; 6589 } 6590 6591 static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw, 6592 struct ieee80211_chanctx_conf *ctx) 6593 { 6594 struct ath11k *ar = hw->priv; 6595 struct ath11k_base *ab = ar->ab; 6596 6597 ath11k_dbg(ab, ATH11K_DBG_MAC, 6598 "mac chanctx add freq %u width %d ptr %pK\n", 6599 ctx->def.chan->center_freq, ctx->def.width, ctx); 6600 6601 mutex_lock(&ar->conf_mutex); 6602 6603 spin_lock_bh(&ar->data_lock); 6604 /* TODO: In case of multiple channel context, populate rx_channel from 6605 * Rx PPDU desc information. 6606 */ 6607 ar->rx_channel = ctx->def.chan; 6608 spin_unlock_bh(&ar->data_lock); 6609 6610 mutex_unlock(&ar->conf_mutex); 6611 6612 return 0; 6613 } 6614 6615 static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw, 6616 struct ieee80211_chanctx_conf *ctx) 6617 { 6618 struct ath11k *ar = hw->priv; 6619 struct ath11k_base *ab = ar->ab; 6620 6621 ath11k_dbg(ab, ATH11K_DBG_MAC, 6622 "mac chanctx remove freq %u width %d ptr %pK\n", 6623 ctx->def.chan->center_freq, ctx->def.width, ctx); 6624 6625 mutex_lock(&ar->conf_mutex); 6626 6627 spin_lock_bh(&ar->data_lock); 6628 /* TODO: In case of there is one more channel context left, populate 6629 * rx_channel with the channel of that remaining channel context. 6630 */ 6631 ar->rx_channel = NULL; 6632 spin_unlock_bh(&ar->data_lock); 6633 6634 mutex_unlock(&ar->conf_mutex); 6635 } 6636 6637 static int 6638 ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif, 6639 struct ieee80211_chanctx_conf *ctx, 6640 bool restart) 6641 { 6642 struct ath11k *ar = arvif->ar; 6643 struct ath11k_base *ab = ar->ab; 6644 struct wmi_vdev_start_req_arg arg = {}; 6645 const struct cfg80211_chan_def *chandef = &ctx->def; 6646 int he_support = arvif->vif->bss_conf.he_support; 6647 int ret = 0; 6648 6649 lockdep_assert_held(&ar->conf_mutex); 6650 6651 reinit_completion(&ar->vdev_setup_done); 6652 6653 arg.vdev_id = arvif->vdev_id; 6654 arg.dtim_period = arvif->dtim_period; 6655 arg.bcn_intval = arvif->beacon_interval; 6656 6657 arg.channel.freq = chandef->chan->center_freq; 6658 arg.channel.band_center_freq1 = chandef->center_freq1; 6659 arg.channel.band_center_freq2 = chandef->center_freq2; 6660 arg.channel.mode = 6661 ath11k_phymodes[chandef->chan->band][chandef->width]; 6662 6663 arg.channel.min_power = 0; 6664 arg.channel.max_power = chandef->chan->max_power; 6665 arg.channel.max_reg_power = chandef->chan->max_reg_power; 6666 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain; 6667 6668 arg.pref_tx_streams = ar->num_tx_chains; 6669 arg.pref_rx_streams = ar->num_rx_chains; 6670 6671 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 6672 arg.ssid = arvif->u.ap.ssid; 6673 arg.ssid_len = arvif->u.ap.ssid_len; 6674 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 6675 6676 /* For now allow DFS for AP mode */ 6677 arg.channel.chan_radar = 6678 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR); 6679 6680 arg.channel.freq2_radar = ctx->radar_enabled; 6681 6682 arg.channel.passive = arg.channel.chan_radar; 6683 6684 spin_lock_bh(&ab->base_lock); 6685 arg.regdomain = ar->ab->dfs_region; 6686 spin_unlock_bh(&ab->base_lock); 6687 6688 if (he_support) { 6689 ret = ath11k_set_he_mu_sounding_mode(ar, arvif); 6690 if (ret) { 6691 ath11k_warn(ar->ab, "failed to set he mode vdev %i\n", 6692 arg.vdev_id); 6693 return ret; 6694 } 6695 } 6696 } 6697 6698 arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR); 6699 6700 ath11k_dbg(ab, ATH11K_DBG_MAC, 6701 "mac vdev %d start center_freq %d phymode %s\n", 6702 arg.vdev_id, arg.channel.freq, 6703 ath11k_wmi_phymode_str(arg.channel.mode)); 6704 6705 ret = ath11k_wmi_vdev_start(ar, &arg, restart); 6706 if (ret) { 6707 ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n", 6708 restart ? "restart" : "start", arg.vdev_id); 6709 return ret; 6710 } 6711 6712 ret = ath11k_mac_vdev_setup_sync(ar); 6713 if (ret) { 6714 ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n", 6715 arg.vdev_id, restart ? "restart" : "start", ret); 6716 return ret; 6717 } 6718 6719 if (!restart) 6720 ar->num_started_vdevs++; 6721 6722 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM started, vdev_id %d\n", 6723 arvif->vif->addr, arvif->vdev_id); 6724 6725 /* Enable CAC Flag in the driver by checking the channel DFS cac time, 6726 * i.e dfs_cac_ms value which will be valid only for radar channels 6727 * and state as NL80211_DFS_USABLE which indicates CAC needs to be 6728 * done before channel usage. This flags is used to drop rx packets. 6729 * during CAC. 6730 */ 6731 /* TODO Set the flag for other interface types as required */ 6732 if (arvif->vdev_type == WMI_VDEV_TYPE_AP && 6733 chandef->chan->dfs_cac_ms && 6734 chandef->chan->dfs_state == NL80211_DFS_USABLE) { 6735 set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags); 6736 ath11k_dbg(ab, ATH11K_DBG_MAC, 6737 "CAC Started in chan_freq %d for vdev %d\n", 6738 arg.channel.freq, arg.vdev_id); 6739 } 6740 6741 ret = ath11k_mac_set_txbf_conf(arvif); 6742 if (ret) 6743 ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n", 6744 arvif->vdev_id, ret); 6745 6746 return 0; 6747 } 6748 6749 static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif) 6750 { 6751 struct ath11k *ar = arvif->ar; 6752 int ret; 6753 6754 lockdep_assert_held(&ar->conf_mutex); 6755 6756 reinit_completion(&ar->vdev_setup_done); 6757 6758 ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id); 6759 if (ret) { 6760 ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n", 6761 arvif->vdev_id, ret); 6762 goto err; 6763 } 6764 6765 ret = ath11k_mac_vdev_setup_sync(ar); 6766 if (ret) { 6767 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n", 6768 arvif->vdev_id, ret); 6769 goto err; 6770 } 6771 6772 WARN_ON(ar->num_started_vdevs == 0); 6773 6774 ar->num_started_vdevs--; 6775 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n", 6776 arvif->vif->addr, arvif->vdev_id); 6777 6778 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) { 6779 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags); 6780 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n", 6781 arvif->vdev_id); 6782 } 6783 6784 return 0; 6785 err: 6786 return ret; 6787 } 6788 6789 static int ath11k_mac_vdev_start(struct ath11k_vif *arvif, 6790 struct ieee80211_chanctx_conf *ctx) 6791 { 6792 return ath11k_mac_vdev_start_restart(arvif, ctx, false); 6793 } 6794 6795 static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif, 6796 struct ieee80211_chanctx_conf *ctx) 6797 { 6798 return ath11k_mac_vdev_start_restart(arvif, ctx, true); 6799 } 6800 6801 struct ath11k_mac_change_chanctx_arg { 6802 struct ieee80211_chanctx_conf *ctx; 6803 struct ieee80211_vif_chanctx_switch *vifs; 6804 int n_vifs; 6805 int next_vif; 6806 }; 6807 6808 static void 6809 ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac, 6810 struct ieee80211_vif *vif) 6811 { 6812 struct ath11k_mac_change_chanctx_arg *arg = data; 6813 6814 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx) 6815 return; 6816 6817 arg->n_vifs++; 6818 } 6819 6820 static void 6821 ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac, 6822 struct ieee80211_vif *vif) 6823 { 6824 struct ath11k_mac_change_chanctx_arg *arg = data; 6825 struct ieee80211_chanctx_conf *ctx; 6826 6827 ctx = rcu_access_pointer(vif->chanctx_conf); 6828 if (ctx != arg->ctx) 6829 return; 6830 6831 if (WARN_ON(arg->next_vif == arg->n_vifs)) 6832 return; 6833 6834 arg->vifs[arg->next_vif].vif = vif; 6835 arg->vifs[arg->next_vif].old_ctx = ctx; 6836 arg->vifs[arg->next_vif].new_ctx = ctx; 6837 arg->next_vif++; 6838 } 6839 6840 static void 6841 ath11k_mac_update_vif_chan(struct ath11k *ar, 6842 struct ieee80211_vif_chanctx_switch *vifs, 6843 int n_vifs) 6844 { 6845 struct ath11k_base *ab = ar->ab; 6846 struct ath11k_vif *arvif; 6847 int ret; 6848 int i; 6849 bool monitor_vif = false; 6850 6851 lockdep_assert_held(&ar->conf_mutex); 6852 6853 /* Associated channel resources of all relevant vdevs 6854 * should be available for the channel switch now. 6855 */ 6856 6857 /* TODO: Update ar->rx_channel */ 6858 6859 for (i = 0; i < n_vifs; i++) { 6860 arvif = (void *)vifs[i].vif->drv_priv; 6861 6862 if (WARN_ON(!arvif->is_started)) 6863 continue; 6864 6865 /* change_chanctx can be called even before vdev_up from 6866 * ieee80211_start_ap->ieee80211_vif_use_channel-> 6867 * ieee80211_recalc_radar_chanctx. 6868 * 6869 * Firmware expect vdev_restart only if vdev is up. 6870 * If vdev is down then it expect vdev_stop->vdev_start. 6871 */ 6872 if (arvif->is_up) { 6873 ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx); 6874 if (ret) { 6875 ath11k_warn(ab, "failed to restart vdev %d: %d\n", 6876 arvif->vdev_id, ret); 6877 continue; 6878 } 6879 } else { 6880 ret = ath11k_mac_vdev_stop(arvif); 6881 if (ret) { 6882 ath11k_warn(ab, "failed to stop vdev %d: %d\n", 6883 arvif->vdev_id, ret); 6884 continue; 6885 } 6886 6887 ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx); 6888 if (ret) 6889 ath11k_warn(ab, "failed to start vdev %d: %d\n", 6890 arvif->vdev_id, ret); 6891 6892 continue; 6893 } 6894 6895 ret = ath11k_mac_setup_bcn_tmpl(arvif); 6896 if (ret) 6897 ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n", 6898 ret); 6899 6900 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 6901 arvif->bssid); 6902 if (ret) { 6903 ath11k_warn(ab, "failed to bring vdev up %d: %d\n", 6904 arvif->vdev_id, ret); 6905 continue; 6906 } 6907 } 6908 6909 /* Restart the internal monitor vdev on new channel */ 6910 if (!monitor_vif && 6911 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) { 6912 ret = ath11k_mac_monitor_stop(ar); 6913 if (ret) { 6914 ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d", 6915 ret); 6916 return; 6917 } 6918 6919 ret = ath11k_mac_monitor_start(ar); 6920 if (ret) { 6921 ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d", 6922 ret); 6923 return; 6924 } 6925 } 6926 } 6927 6928 static void 6929 ath11k_mac_update_active_vif_chan(struct ath11k *ar, 6930 struct ieee80211_chanctx_conf *ctx) 6931 { 6932 struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx }; 6933 6934 lockdep_assert_held(&ar->conf_mutex); 6935 6936 ieee80211_iterate_active_interfaces_atomic(ar->hw, 6937 IEEE80211_IFACE_ITER_NORMAL, 6938 ath11k_mac_change_chanctx_cnt_iter, 6939 &arg); 6940 if (arg.n_vifs == 0) 6941 return; 6942 6943 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL); 6944 if (!arg.vifs) 6945 return; 6946 6947 ieee80211_iterate_active_interfaces_atomic(ar->hw, 6948 IEEE80211_IFACE_ITER_NORMAL, 6949 ath11k_mac_change_chanctx_fill_iter, 6950 &arg); 6951 6952 ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs); 6953 6954 kfree(arg.vifs); 6955 } 6956 6957 static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw, 6958 struct ieee80211_chanctx_conf *ctx, 6959 u32 changed) 6960 { 6961 struct ath11k *ar = hw->priv; 6962 struct ath11k_base *ab = ar->ab; 6963 6964 mutex_lock(&ar->conf_mutex); 6965 6966 ath11k_dbg(ab, ATH11K_DBG_MAC, 6967 "mac chanctx change freq %u width %d ptr %pK changed %x\n", 6968 ctx->def.chan->center_freq, ctx->def.width, ctx, changed); 6969 6970 /* This shouldn't really happen because channel switching should use 6971 * switch_vif_chanctx(). 6972 */ 6973 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL)) 6974 goto unlock; 6975 6976 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH || 6977 changed & IEEE80211_CHANCTX_CHANGE_RADAR) 6978 ath11k_mac_update_active_vif_chan(ar, ctx); 6979 6980 /* TODO: Recalc radar detection */ 6981 6982 unlock: 6983 mutex_unlock(&ar->conf_mutex); 6984 } 6985 6986 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw, 6987 struct ieee80211_vif *vif) 6988 { 6989 struct ath11k *ar = hw->priv; 6990 struct ath11k_base *ab = ar->ab; 6991 struct ath11k_vif *arvif = (void *)vif->drv_priv; 6992 int ret; 6993 6994 if (WARN_ON(arvif->is_started)) 6995 return -EBUSY; 6996 6997 ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx); 6998 if (ret) { 6999 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 7000 arvif->vdev_id, vif->addr, 7001 arvif->chanctx.def.chan->center_freq, ret); 7002 return ret; 7003 } 7004 7005 /* Reconfigure hardware rate code since it is cleared by firmware. 7006 */ 7007 if (ar->hw_rate_code > 0) { 7008 u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE; 7009 7010 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 7011 ar->hw_rate_code); 7012 if (ret) { 7013 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret); 7014 return ret; 7015 } 7016 } 7017 7018 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7019 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr); 7020 if (ret) { 7021 ath11k_warn(ab, "failed put monitor up: %d\n", ret); 7022 return ret; 7023 } 7024 } 7025 7026 arvif->is_started = true; 7027 7028 /* TODO: Setup ps and cts/rts protection */ 7029 return 0; 7030 } 7031 7032 static int 7033 ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw, 7034 struct ieee80211_vif *vif, 7035 struct ieee80211_chanctx_conf *ctx) 7036 { 7037 struct ath11k *ar = hw->priv; 7038 struct ath11k_base *ab = ar->ab; 7039 struct ath11k_vif *arvif = (void *)vif->drv_priv; 7040 int ret; 7041 struct peer_create_params param; 7042 7043 mutex_lock(&ar->conf_mutex); 7044 7045 ath11k_dbg(ab, ATH11K_DBG_MAC, 7046 "mac chanctx assign ptr %pK vdev_id %i\n", 7047 ctx, arvif->vdev_id); 7048 7049 /* for QCA6390 bss peer must be created before vdev_start */ 7050 if (ab->hw_params.vdev_start_delay && 7051 arvif->vdev_type != WMI_VDEV_TYPE_AP && 7052 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7053 !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) { 7054 memcpy(&arvif->chanctx, ctx, sizeof(*ctx)); 7055 ret = 0; 7056 goto out; 7057 } 7058 7059 if (WARN_ON(arvif->is_started)) { 7060 ret = -EBUSY; 7061 goto out; 7062 } 7063 7064 if (ab->hw_params.vdev_start_delay && 7065 arvif->vdev_type != WMI_VDEV_TYPE_AP && 7066 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) { 7067 param.vdev_id = arvif->vdev_id; 7068 param.peer_type = WMI_PEER_TYPE_DEFAULT; 7069 param.peer_addr = ar->mac_addr; 7070 7071 ret = ath11k_peer_create(ar, arvif, NULL, ¶m); 7072 if (ret) { 7073 ath11k_warn(ab, "failed to create peer after vdev start delay: %d", 7074 ret); 7075 goto out; 7076 } 7077 } 7078 7079 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7080 ret = ath11k_mac_monitor_start(ar); 7081 if (ret) { 7082 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d", 7083 ret); 7084 goto out; 7085 } 7086 7087 arvif->is_started = true; 7088 goto out; 7089 } 7090 7091 ret = ath11k_mac_vdev_start(arvif, ctx); 7092 if (ret) { 7093 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 7094 arvif->vdev_id, vif->addr, 7095 ctx->def.chan->center_freq, ret); 7096 goto out; 7097 } 7098 7099 arvif->is_started = true; 7100 7101 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7102 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) { 7103 ret = ath11k_mac_monitor_start(ar); 7104 if (ret) { 7105 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d", 7106 ret); 7107 goto out; 7108 } 7109 } 7110 7111 /* TODO: Setup ps and cts/rts protection */ 7112 7113 ret = 0; 7114 7115 out: 7116 mutex_unlock(&ar->conf_mutex); 7117 7118 return ret; 7119 } 7120 7121 static void 7122 ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 7123 struct ieee80211_vif *vif, 7124 struct ieee80211_chanctx_conf *ctx) 7125 { 7126 struct ath11k *ar = hw->priv; 7127 struct ath11k_base *ab = ar->ab; 7128 struct ath11k_vif *arvif = (void *)vif->drv_priv; 7129 int ret; 7130 7131 mutex_lock(&ar->conf_mutex); 7132 7133 ath11k_dbg(ab, ATH11K_DBG_MAC, 7134 "mac chanctx unassign ptr %pK vdev_id %i\n", 7135 ctx, arvif->vdev_id); 7136 7137 WARN_ON(!arvif->is_started); 7138 7139 if (ab->hw_params.vdev_start_delay && 7140 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR && 7141 ath11k_peer_find_by_addr(ab, ar->mac_addr)) 7142 ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr); 7143 7144 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7145 ret = ath11k_mac_monitor_stop(ar); 7146 if (ret) { 7147 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d", 7148 ret); 7149 mutex_unlock(&ar->conf_mutex); 7150 return; 7151 } 7152 7153 arvif->is_started = false; 7154 mutex_unlock(&ar->conf_mutex); 7155 return; 7156 } 7157 7158 ret = ath11k_mac_vdev_stop(arvif); 7159 if (ret) 7160 ath11k_warn(ab, "failed to stop vdev %i: %d\n", 7161 arvif->vdev_id, ret); 7162 7163 arvif->is_started = false; 7164 7165 if (ab->hw_params.vdev_start_delay && 7166 arvif->vdev_type == WMI_VDEV_TYPE_STA) { 7167 ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid); 7168 if (ret) 7169 ath11k_warn(ar->ab, 7170 "failed to delete peer %pM for vdev %d: %d\n", 7171 arvif->bssid, arvif->vdev_id, ret); 7172 else 7173 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7174 "mac removed peer %pM vdev %d after vdev stop\n", 7175 arvif->bssid, arvif->vdev_id); 7176 } 7177 7178 if (ab->hw_params.vdev_start_delay && 7179 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 7180 ath11k_wmi_vdev_down(ar, arvif->vdev_id); 7181 7182 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7183 ar->num_started_vdevs == 1 && 7184 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) { 7185 ret = ath11k_mac_monitor_stop(ar); 7186 if (ret) 7187 /* continue even if there's an error */ 7188 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d", 7189 ret); 7190 } 7191 7192 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 7193 ath11k_mac_11d_scan_start(ar, arvif->vdev_id, false); 7194 7195 mutex_unlock(&ar->conf_mutex); 7196 } 7197 7198 static int 7199 ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw, 7200 struct ieee80211_vif_chanctx_switch *vifs, 7201 int n_vifs, 7202 enum ieee80211_chanctx_switch_mode mode) 7203 { 7204 struct ath11k *ar = hw->priv; 7205 7206 mutex_lock(&ar->conf_mutex); 7207 7208 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7209 "mac chanctx switch n_vifs %d mode %d\n", 7210 n_vifs, mode); 7211 ath11k_mac_update_vif_chan(ar, vifs, n_vifs); 7212 7213 mutex_unlock(&ar->conf_mutex); 7214 7215 return 0; 7216 } 7217 7218 static int 7219 ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value) 7220 { 7221 struct ath11k_vif *arvif; 7222 int ret = 0; 7223 7224 mutex_lock(&ar->conf_mutex); 7225 list_for_each_entry(arvif, &ar->arvifs, list) { 7226 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n", 7227 param, arvif->vdev_id, value); 7228 7229 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7230 param, value); 7231 if (ret) { 7232 ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n", 7233 param, arvif->vdev_id, ret); 7234 break; 7235 } 7236 } 7237 mutex_unlock(&ar->conf_mutex); 7238 return ret; 7239 } 7240 7241 /* mac80211 stores device specific RTS/Fragmentation threshold value, 7242 * this is set interface specific to firmware from ath11k driver 7243 */ 7244 static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 7245 { 7246 struct ath11k *ar = hw->priv; 7247 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 7248 7249 return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value); 7250 } 7251 7252 static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 7253 { 7254 /* Even though there's a WMI vdev param for fragmentation threshold no 7255 * known firmware actually implements it. Moreover it is not possible to 7256 * rely frame fragmentation to mac80211 because firmware clears the 7257 * "more fragments" bit in frame control making it impossible for remote 7258 * devices to reassemble frames. 7259 * 7260 * Hence implement a dummy callback just to say fragmentation isn't 7261 * supported. This effectively prevents mac80211 from doing frame 7262 * fragmentation in software. 7263 */ 7264 return -EOPNOTSUPP; 7265 } 7266 7267 static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 7268 u32 queues, bool drop) 7269 { 7270 struct ath11k *ar = hw->priv; 7271 long time_left; 7272 7273 if (drop) 7274 return; 7275 7276 time_left = wait_event_timeout(ar->dp.tx_empty_waitq, 7277 (atomic_read(&ar->dp.num_tx_pending) == 0), 7278 ATH11K_FLUSH_TIMEOUT); 7279 if (time_left == 0) 7280 ath11k_warn(ar->ab, "failed to flush transmit queue %ld\n", time_left); 7281 7282 time_left = wait_event_timeout(ar->txmgmt_empty_waitq, 7283 (atomic_read(&ar->num_pending_mgmt_tx) == 0), 7284 ATH11K_FLUSH_TIMEOUT); 7285 if (time_left == 0) 7286 ath11k_warn(ar->ab, "failed to flush mgmt transmit queue %ld\n", 7287 time_left); 7288 7289 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7290 "mac mgmt tx flush mgmt pending %d\n", 7291 atomic_read(&ar->num_pending_mgmt_tx)); 7292 } 7293 7294 static int 7295 ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar, 7296 enum nl80211_band band, 7297 const struct cfg80211_bitrate_mask *mask) 7298 { 7299 int num_rates = 0; 7300 int i; 7301 7302 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) 7303 num_rates += hweight16(mask->control[band].ht_mcs[i]); 7304 7305 return num_rates; 7306 } 7307 7308 static bool 7309 ath11k_mac_has_single_legacy_rate(struct ath11k *ar, 7310 enum nl80211_band band, 7311 const struct cfg80211_bitrate_mask *mask) 7312 { 7313 int num_rates = 0; 7314 7315 num_rates = hweight32(mask->control[band].legacy); 7316 7317 if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask)) 7318 return false; 7319 7320 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask)) 7321 return false; 7322 7323 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask)) 7324 return false; 7325 7326 return num_rates == 1; 7327 } 7328 7329 static __le16 7330 ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap) 7331 { 7332 if (he_cap->he_cap_elem.phy_cap_info[0] & 7333 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 7334 return he_cap->he_mcs_nss_supp.tx_mcs_80p80; 7335 7336 if (he_cap->he_cap_elem.phy_cap_info[0] & 7337 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) 7338 return he_cap->he_mcs_nss_supp.tx_mcs_160; 7339 7340 return he_cap->he_mcs_nss_supp.tx_mcs_80; 7341 } 7342 7343 static bool 7344 ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar, 7345 enum nl80211_band band, 7346 const struct cfg80211_bitrate_mask *mask, 7347 int *nss) 7348 { 7349 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 7350 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 7351 u16 he_mcs_map = 0; 7352 u8 ht_nss_mask = 0; 7353 u8 vht_nss_mask = 0; 7354 u8 he_nss_mask = 0; 7355 int i; 7356 7357 /* No need to consider legacy here. Basic rates are always present 7358 * in bitrate mask 7359 */ 7360 7361 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 7362 if (mask->control[band].ht_mcs[i] == 0) 7363 continue; 7364 else if (mask->control[band].ht_mcs[i] == 7365 sband->ht_cap.mcs.rx_mask[i]) 7366 ht_nss_mask |= BIT(i); 7367 else 7368 return false; 7369 } 7370 7371 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 7372 if (mask->control[band].vht_mcs[i] == 0) 7373 continue; 7374 else if (mask->control[band].vht_mcs[i] == 7375 ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i)) 7376 vht_nss_mask |= BIT(i); 7377 else 7378 return false; 7379 } 7380 7381 he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(&sband->iftype_data->he_cap)); 7382 7383 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) { 7384 if (mask->control[band].he_mcs[i] == 0) 7385 continue; 7386 7387 if (mask->control[band].he_mcs[i] == 7388 ath11k_mac_get_max_he_mcs_map(he_mcs_map, i)) 7389 he_nss_mask |= BIT(i); 7390 else 7391 return false; 7392 } 7393 7394 if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask) 7395 return false; 7396 7397 if (ht_nss_mask == 0) 7398 return false; 7399 7400 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask) 7401 return false; 7402 7403 *nss = fls(ht_nss_mask); 7404 7405 return true; 7406 } 7407 7408 static int 7409 ath11k_mac_get_single_legacy_rate(struct ath11k *ar, 7410 enum nl80211_band band, 7411 const struct cfg80211_bitrate_mask *mask, 7412 u32 *rate, u8 *nss) 7413 { 7414 int rate_idx; 7415 u16 bitrate; 7416 u8 preamble; 7417 u8 hw_rate; 7418 7419 if (hweight32(mask->control[band].legacy) != 1) 7420 return -EINVAL; 7421 7422 rate_idx = ffs(mask->control[band].legacy) - 1; 7423 7424 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ) 7425 rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX; 7426 7427 hw_rate = ath11k_legacy_rates[rate_idx].hw_value; 7428 bitrate = ath11k_legacy_rates[rate_idx].bitrate; 7429 7430 if (ath11k_mac_bitrate_is_cck(bitrate)) 7431 preamble = WMI_RATE_PREAMBLE_CCK; 7432 else 7433 preamble = WMI_RATE_PREAMBLE_OFDM; 7434 7435 *nss = 1; 7436 *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble); 7437 7438 return 0; 7439 } 7440 7441 static int 7442 ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf) 7443 { 7444 struct ath11k *ar = arvif->ar; 7445 int ret; 7446 7447 /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */ 7448 if (he_gi && he_gi != 0xFF) 7449 he_gi += 1; 7450 7451 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7452 WMI_VDEV_PARAM_SGI, he_gi); 7453 if (ret) { 7454 ath11k_warn(ar->ab, "failed to set he gi %d: %d\n", 7455 he_gi, ret); 7456 return ret; 7457 } 7458 /* start from 1 */ 7459 if (he_ltf != 0xFF) 7460 he_ltf += 1; 7461 7462 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7463 WMI_VDEV_PARAM_HE_LTF, he_ltf); 7464 if (ret) { 7465 ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n", 7466 he_ltf, ret); 7467 return ret; 7468 } 7469 7470 return 0; 7471 } 7472 7473 static int 7474 ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf) 7475 { 7476 struct ath11k *ar = arvif->ar; 7477 int ret; 7478 u32 he_ar_gi_ltf; 7479 7480 if (he_gi != 0xFF) { 7481 switch (he_gi) { 7482 case NL80211_RATE_INFO_HE_GI_0_8: 7483 he_gi = WMI_AUTORATE_800NS_GI; 7484 break; 7485 case NL80211_RATE_INFO_HE_GI_1_6: 7486 he_gi = WMI_AUTORATE_1600NS_GI; 7487 break; 7488 case NL80211_RATE_INFO_HE_GI_3_2: 7489 he_gi = WMI_AUTORATE_3200NS_GI; 7490 break; 7491 default: 7492 ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi); 7493 return -EINVAL; 7494 } 7495 } 7496 7497 if (he_ltf != 0xFF) { 7498 switch (he_ltf) { 7499 case NL80211_RATE_INFO_HE_1XLTF: 7500 he_ltf = WMI_HE_AUTORATE_LTF_1X; 7501 break; 7502 case NL80211_RATE_INFO_HE_2XLTF: 7503 he_ltf = WMI_HE_AUTORATE_LTF_2X; 7504 break; 7505 case NL80211_RATE_INFO_HE_4XLTF: 7506 he_ltf = WMI_HE_AUTORATE_LTF_4X; 7507 break; 7508 default: 7509 ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf); 7510 return -EINVAL; 7511 } 7512 } 7513 7514 he_ar_gi_ltf = he_gi | he_ltf; 7515 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7516 WMI_VDEV_PARAM_AUTORATE_MISC_CFG, 7517 he_ar_gi_ltf); 7518 if (ret) { 7519 ath11k_warn(ar->ab, 7520 "failed to set he autorate gi %u ltf %u: %d\n", 7521 he_gi, he_ltf, ret); 7522 return ret; 7523 } 7524 7525 return 0; 7526 } 7527 7528 static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif, 7529 u32 rate, u8 nss, u8 sgi, u8 ldpc, 7530 u8 he_gi, u8 he_ltf, bool he_fixed_rate) 7531 { 7532 struct ath11k *ar = arvif->ar; 7533 u32 vdev_param; 7534 int ret; 7535 7536 lockdep_assert_held(&ar->conf_mutex); 7537 7538 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7539 "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", 7540 arvif->vdev_id, rate, nss, sgi, ldpc, he_gi, 7541 he_ltf, he_fixed_rate); 7542 7543 if (!arvif->vif->bss_conf.he_support) { 7544 vdev_param = WMI_VDEV_PARAM_FIXED_RATE; 7545 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7546 vdev_param, rate); 7547 if (ret) { 7548 ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n", 7549 rate, ret); 7550 return ret; 7551 } 7552 } 7553 7554 vdev_param = WMI_VDEV_PARAM_NSS; 7555 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7556 vdev_param, nss); 7557 if (ret) { 7558 ath11k_warn(ar->ab, "failed to set nss param %d: %d\n", 7559 nss, ret); 7560 return ret; 7561 } 7562 7563 vdev_param = WMI_VDEV_PARAM_LDPC; 7564 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7565 vdev_param, ldpc); 7566 if (ret) { 7567 ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n", 7568 ldpc, ret); 7569 return ret; 7570 } 7571 7572 if (arvif->vif->bss_conf.he_support) { 7573 if (he_fixed_rate) { 7574 ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi, 7575 he_ltf); 7576 if (ret) { 7577 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n", 7578 ret); 7579 return ret; 7580 } 7581 } else { 7582 ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi, 7583 he_ltf); 7584 if (ret) { 7585 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n", 7586 ret); 7587 return ret; 7588 } 7589 } 7590 } else { 7591 vdev_param = WMI_VDEV_PARAM_SGI; 7592 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7593 vdev_param, sgi); 7594 if (ret) { 7595 ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n", 7596 sgi, ret); 7597 return ret; 7598 } 7599 } 7600 7601 return 0; 7602 } 7603 7604 static bool 7605 ath11k_mac_vht_mcs_range_present(struct ath11k *ar, 7606 enum nl80211_band band, 7607 const struct cfg80211_bitrate_mask *mask) 7608 { 7609 int i; 7610 u16 vht_mcs; 7611 7612 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 7613 vht_mcs = mask->control[band].vht_mcs[i]; 7614 7615 switch (vht_mcs) { 7616 case 0: 7617 case BIT(8) - 1: 7618 case BIT(9) - 1: 7619 case BIT(10) - 1: 7620 break; 7621 default: 7622 return false; 7623 } 7624 } 7625 7626 return true; 7627 } 7628 7629 static bool 7630 ath11k_mac_he_mcs_range_present(struct ath11k *ar, 7631 enum nl80211_band band, 7632 const struct cfg80211_bitrate_mask *mask) 7633 { 7634 int i; 7635 u16 he_mcs; 7636 7637 for (i = 0; i < NL80211_HE_NSS_MAX; i++) { 7638 he_mcs = mask->control[band].he_mcs[i]; 7639 7640 switch (he_mcs) { 7641 case 0: 7642 case BIT(8) - 1: 7643 case BIT(10) - 1: 7644 case BIT(12) - 1: 7645 break; 7646 default: 7647 return false; 7648 } 7649 } 7650 7651 return true; 7652 } 7653 7654 static void ath11k_mac_set_bitrate_mask_iter(void *data, 7655 struct ieee80211_sta *sta) 7656 { 7657 struct ath11k_vif *arvif = data; 7658 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 7659 struct ath11k *ar = arvif->ar; 7660 7661 spin_lock_bh(&ar->data_lock); 7662 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED; 7663 spin_unlock_bh(&ar->data_lock); 7664 7665 ieee80211_queue_work(ar->hw, &arsta->update_wk); 7666 } 7667 7668 static void ath11k_mac_disable_peer_fixed_rate(void *data, 7669 struct ieee80211_sta *sta) 7670 { 7671 struct ath11k_vif *arvif = data; 7672 struct ath11k *ar = arvif->ar; 7673 int ret; 7674 7675 ret = ath11k_wmi_set_peer_param(ar, sta->addr, 7676 arvif->vdev_id, 7677 WMI_PEER_PARAM_FIXED_RATE, 7678 WMI_FIXED_RATE_NONE); 7679 if (ret) 7680 ath11k_warn(ar->ab, 7681 "failed to disable peer fixed rate for STA %pM ret %d\n", 7682 sta->addr, ret); 7683 } 7684 7685 static bool 7686 ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band, 7687 const struct cfg80211_bitrate_mask *mask) 7688 { 7689 bool he_fixed_rate = false, vht_fixed_rate = false; 7690 struct ath11k_peer *peer, *tmp; 7691 const u16 *vht_mcs_mask, *he_mcs_mask; 7692 u8 vht_nss, he_nss; 7693 bool ret = true; 7694 7695 vht_mcs_mask = mask->control[band].vht_mcs; 7696 he_mcs_mask = mask->control[band].he_mcs; 7697 7698 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1) 7699 vht_fixed_rate = true; 7700 7701 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1) 7702 he_fixed_rate = true; 7703 7704 if (!vht_fixed_rate && !he_fixed_rate) 7705 return true; 7706 7707 vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask); 7708 he_nss = ath11k_mac_max_he_nss(he_mcs_mask); 7709 7710 rcu_read_lock(); 7711 spin_lock_bh(&ar->ab->base_lock); 7712 list_for_each_entry_safe(peer, tmp, &ar->ab->peers, list) { 7713 if (peer->sta) { 7714 if (vht_fixed_rate && (!peer->sta->vht_cap.vht_supported || 7715 peer->sta->rx_nss < vht_nss)) { 7716 ret = false; 7717 goto out; 7718 } 7719 if (he_fixed_rate && (!peer->sta->he_cap.has_he || 7720 peer->sta->rx_nss < he_nss)) { 7721 ret = false; 7722 goto out; 7723 } 7724 } 7725 } 7726 7727 out: 7728 spin_unlock_bh(&ar->ab->base_lock); 7729 rcu_read_unlock(); 7730 return ret; 7731 } 7732 7733 static int 7734 ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw, 7735 struct ieee80211_vif *vif, 7736 const struct cfg80211_bitrate_mask *mask) 7737 { 7738 struct ath11k_vif *arvif = (void *)vif->drv_priv; 7739 struct cfg80211_chan_def def; 7740 struct ath11k *ar = arvif->ar; 7741 enum nl80211_band band; 7742 const u8 *ht_mcs_mask; 7743 const u16 *vht_mcs_mask; 7744 const u16 *he_mcs_mask; 7745 u8 he_ltf = 0; 7746 u8 he_gi = 0; 7747 u32 rate; 7748 u8 nss; 7749 u8 sgi; 7750 u8 ldpc; 7751 int single_nss; 7752 int ret; 7753 int num_rates; 7754 bool he_fixed_rate = false; 7755 7756 if (ath11k_mac_vif_chan(vif, &def)) 7757 return -EPERM; 7758 7759 band = def.chan->band; 7760 ht_mcs_mask = mask->control[band].ht_mcs; 7761 vht_mcs_mask = mask->control[band].vht_mcs; 7762 he_mcs_mask = mask->control[band].he_mcs; 7763 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC); 7764 7765 sgi = mask->control[band].gi; 7766 if (sgi == NL80211_TXRATE_FORCE_LGI) 7767 return -EINVAL; 7768 7769 he_gi = mask->control[band].he_gi; 7770 he_ltf = mask->control[band].he_ltf; 7771 7772 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it 7773 * requires passing atleast one of used basic rates along with them. 7774 * Fixed rate setting across different preambles(legacy, HT, VHT) is 7775 * not supported by the FW. Hence use of FIXED_RATE vdev param is not 7776 * suitable for setting single HT/VHT rates. 7777 * But, there could be a single basic rate passed from userspace which 7778 * can be done through the FIXED_RATE param. 7779 */ 7780 if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) { 7781 ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate, 7782 &nss); 7783 if (ret) { 7784 ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n", 7785 arvif->vdev_id, ret); 7786 return ret; 7787 } 7788 ieee80211_iterate_stations_atomic(ar->hw, 7789 ath11k_mac_disable_peer_fixed_rate, 7790 arvif); 7791 } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, band, mask, 7792 &single_nss)) { 7793 rate = WMI_FIXED_RATE_NONE; 7794 nss = single_nss; 7795 mutex_lock(&ar->conf_mutex); 7796 arvif->bitrate_mask = *mask; 7797 ieee80211_iterate_stations_atomic(ar->hw, 7798 ath11k_mac_set_bitrate_mask_iter, 7799 arvif); 7800 mutex_unlock(&ar->conf_mutex); 7801 } else { 7802 rate = WMI_FIXED_RATE_NONE; 7803 7804 if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask)) 7805 ath11k_warn(ar->ab, 7806 "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n"); 7807 nss = min_t(u32, ar->num_tx_chains, 7808 max(max(ath11k_mac_max_ht_nss(ht_mcs_mask), 7809 ath11k_mac_max_vht_nss(vht_mcs_mask)), 7810 ath11k_mac_max_he_nss(he_mcs_mask))); 7811 7812 /* If multiple rates across different preambles are given 7813 * we can reconfigure this info with all peers using PEER_ASSOC 7814 * command with the below exception cases. 7815 * - Single VHT Rate : peer_assoc command accommodates only MCS 7816 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211 7817 * mandates passing basic rates along with HT/VHT rates, FW 7818 * doesn't allow switching from VHT to Legacy. Hence instead of 7819 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd, 7820 * we could set this VHT rate as peer fixed rate param, which 7821 * will override FIXED rate and FW rate control algorithm. 7822 * If single VHT rate is passed along with HT rates, we select 7823 * the VHT rate as fixed rate for vht peers. 7824 * - Multiple VHT Rates : When Multiple VHT rates are given,this 7825 * can be set using RATEMASK CMD which uses FW rate-ctl alg. 7826 * TODO: Setting multiple VHT MCS and replacing peer_assoc with 7827 * RATEMASK_CMDID can cover all use cases of setting rates 7828 * across multiple preambles and rates within same type. 7829 * But requires more validation of the command at this point. 7830 */ 7831 7832 num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, 7833 mask); 7834 7835 if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) && 7836 num_rates > 1) { 7837 /* TODO: Handle multiple VHT MCS values setting using 7838 * RATEMASK CMD 7839 */ 7840 ath11k_warn(ar->ab, 7841 "setting %d mcs values in bitrate mask not supported\n", 7842 num_rates); 7843 return -EINVAL; 7844 } 7845 7846 num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, 7847 mask); 7848 if (num_rates == 1) 7849 he_fixed_rate = true; 7850 7851 if (!ath11k_mac_he_mcs_range_present(ar, band, mask) && 7852 num_rates > 1) { 7853 ath11k_warn(ar->ab, 7854 "Setting more than one HE MCS Value in bitrate mask not supported\n"); 7855 return -EINVAL; 7856 } 7857 7858 mutex_lock(&ar->conf_mutex); 7859 ieee80211_iterate_stations_atomic(ar->hw, 7860 ath11k_mac_disable_peer_fixed_rate, 7861 arvif); 7862 7863 arvif->bitrate_mask = *mask; 7864 ieee80211_iterate_stations_atomic(ar->hw, 7865 ath11k_mac_set_bitrate_mask_iter, 7866 arvif); 7867 7868 mutex_unlock(&ar->conf_mutex); 7869 } 7870 7871 mutex_lock(&ar->conf_mutex); 7872 7873 ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi, 7874 he_ltf, he_fixed_rate); 7875 if (ret) { 7876 ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n", 7877 arvif->vdev_id, ret); 7878 } 7879 7880 mutex_unlock(&ar->conf_mutex); 7881 7882 return ret; 7883 } 7884 7885 static void 7886 ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw, 7887 enum ieee80211_reconfig_type reconfig_type) 7888 { 7889 struct ath11k *ar = hw->priv; 7890 7891 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) 7892 return; 7893 7894 mutex_lock(&ar->conf_mutex); 7895 7896 if (ar->state == ATH11K_STATE_RESTARTED) { 7897 ath11k_warn(ar->ab, "pdev %d successfully recovered\n", 7898 ar->pdev->pdev_id); 7899 ar->state = ATH11K_STATE_ON; 7900 ieee80211_wake_queues(ar->hw); 7901 } 7902 7903 mutex_unlock(&ar->conf_mutex); 7904 } 7905 7906 static void 7907 ath11k_mac_update_bss_chan_survey(struct ath11k *ar, 7908 struct ieee80211_channel *channel) 7909 { 7910 int ret; 7911 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ; 7912 7913 lockdep_assert_held(&ar->conf_mutex); 7914 7915 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) || 7916 ar->rx_channel != channel) 7917 return; 7918 7919 if (ar->scan.state != ATH11K_SCAN_IDLE) { 7920 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 7921 "ignoring bss chan info req while scanning..\n"); 7922 return; 7923 } 7924 7925 reinit_completion(&ar->bss_survey_done); 7926 7927 ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type); 7928 if (ret) { 7929 ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n"); 7930 return; 7931 } 7932 7933 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ); 7934 if (ret == 0) 7935 ath11k_warn(ar->ab, "bss channel survey timed out\n"); 7936 } 7937 7938 static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx, 7939 struct survey_info *survey) 7940 { 7941 struct ath11k *ar = hw->priv; 7942 struct ieee80211_supported_band *sband; 7943 struct survey_info *ar_survey; 7944 int ret = 0; 7945 7946 if (idx >= ATH11K_NUM_CHANS) 7947 return -ENOENT; 7948 7949 ar_survey = &ar->survey[idx]; 7950 7951 mutex_lock(&ar->conf_mutex); 7952 7953 sband = hw->wiphy->bands[NL80211_BAND_2GHZ]; 7954 if (sband && idx >= sband->n_channels) { 7955 idx -= sband->n_channels; 7956 sband = NULL; 7957 } 7958 7959 if (!sband) 7960 sband = hw->wiphy->bands[NL80211_BAND_5GHZ]; 7961 if (sband && idx >= sband->n_channels) { 7962 idx -= sband->n_channels; 7963 sband = NULL; 7964 } 7965 7966 if (!sband) 7967 sband = hw->wiphy->bands[NL80211_BAND_6GHZ]; 7968 if (!sband || idx >= sband->n_channels) { 7969 ret = -ENOENT; 7970 goto exit; 7971 } 7972 7973 ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]); 7974 7975 spin_lock_bh(&ar->data_lock); 7976 memcpy(survey, ar_survey, sizeof(*survey)); 7977 spin_unlock_bh(&ar->data_lock); 7978 7979 survey->channel = &sband->channels[idx]; 7980 7981 if (ar->rx_channel == survey->channel) 7982 survey->filled |= SURVEY_INFO_IN_USE; 7983 7984 exit: 7985 mutex_unlock(&ar->conf_mutex); 7986 return ret; 7987 } 7988 7989 static void ath11k_mac_put_chain_rssi(struct station_info *sinfo, 7990 struct ath11k_sta *arsta, 7991 char *pre, 7992 bool clear) 7993 { 7994 struct ath11k *ar = arsta->arvif->ar; 7995 int i; 7996 s8 rssi; 7997 7998 for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) { 7999 sinfo->chains &= ~BIT(i); 8000 rssi = arsta->chain_signal[i]; 8001 if (clear) 8002 arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL; 8003 8004 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 8005 "mac sta statistics %s rssi[%d] %d\n", pre, i, rssi); 8006 8007 if (rssi != ATH11K_DEFAULT_NOISE_FLOOR && 8008 rssi != ATH11K_INVALID_RSSI_FULL && 8009 rssi != ATH11K_INVALID_RSSI_EMPTY && 8010 rssi != 0) { 8011 sinfo->chain_signal[i] = rssi; 8012 sinfo->chains |= BIT(i); 8013 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL); 8014 } 8015 } 8016 } 8017 8018 static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw, 8019 struct ieee80211_vif *vif, 8020 struct ieee80211_sta *sta, 8021 struct station_info *sinfo) 8022 { 8023 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv; 8024 struct ath11k *ar = arsta->arvif->ar; 8025 s8 signal; 8026 bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT, 8027 ar->ab->wmi_ab.svc_map); 8028 8029 sinfo->rx_duration = arsta->rx_duration; 8030 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION); 8031 8032 sinfo->tx_duration = arsta->tx_duration; 8033 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION); 8034 8035 if (arsta->txrate.legacy || arsta->txrate.nss) { 8036 if (arsta->txrate.legacy) { 8037 sinfo->txrate.legacy = arsta->txrate.legacy; 8038 } else { 8039 sinfo->txrate.mcs = arsta->txrate.mcs; 8040 sinfo->txrate.nss = arsta->txrate.nss; 8041 sinfo->txrate.bw = arsta->txrate.bw; 8042 sinfo->txrate.he_gi = arsta->txrate.he_gi; 8043 sinfo->txrate.he_dcm = arsta->txrate.he_dcm; 8044 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc; 8045 } 8046 sinfo->txrate.flags = arsta->txrate.flags; 8047 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 8048 } 8049 8050 ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false); 8051 8052 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) && 8053 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA && 8054 ar->ab->hw_params.supports_rssi_stats && 8055 !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0, 8056 WMI_REQUEST_RSSI_PER_CHAIN_STAT)) { 8057 ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true); 8058 } 8059 8060 signal = arsta->rssi_comb; 8061 if (!signal && 8062 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA && 8063 ar->ab->hw_params.supports_rssi_stats && 8064 !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0, 8065 WMI_REQUEST_VDEV_STAT))) 8066 signal = arsta->rssi_beacon; 8067 8068 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, 8069 "mac sta statistics db2dbm %u rssi comb %d rssi beacon %d\n", 8070 db2dbm, arsta->rssi_comb, arsta->rssi_beacon); 8071 8072 if (signal) { 8073 sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR; 8074 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 8075 } 8076 } 8077 8078 static const struct ieee80211_ops ath11k_ops = { 8079 .tx = ath11k_mac_op_tx, 8080 .start = ath11k_mac_op_start, 8081 .stop = ath11k_mac_op_stop, 8082 .reconfig_complete = ath11k_mac_op_reconfig_complete, 8083 .add_interface = ath11k_mac_op_add_interface, 8084 .remove_interface = ath11k_mac_op_remove_interface, 8085 .update_vif_offload = ath11k_mac_op_update_vif_offload, 8086 .config = ath11k_mac_op_config, 8087 .bss_info_changed = ath11k_mac_op_bss_info_changed, 8088 .configure_filter = ath11k_mac_op_configure_filter, 8089 .hw_scan = ath11k_mac_op_hw_scan, 8090 .cancel_hw_scan = ath11k_mac_op_cancel_hw_scan, 8091 .set_key = ath11k_mac_op_set_key, 8092 .sta_state = ath11k_mac_op_sta_state, 8093 .sta_set_4addr = ath11k_mac_op_sta_set_4addr, 8094 .sta_set_txpwr = ath11k_mac_op_sta_set_txpwr, 8095 .sta_rc_update = ath11k_mac_op_sta_rc_update, 8096 .conf_tx = ath11k_mac_op_conf_tx, 8097 .set_antenna = ath11k_mac_op_set_antenna, 8098 .get_antenna = ath11k_mac_op_get_antenna, 8099 .ampdu_action = ath11k_mac_op_ampdu_action, 8100 .add_chanctx = ath11k_mac_op_add_chanctx, 8101 .remove_chanctx = ath11k_mac_op_remove_chanctx, 8102 .change_chanctx = ath11k_mac_op_change_chanctx, 8103 .assign_vif_chanctx = ath11k_mac_op_assign_vif_chanctx, 8104 .unassign_vif_chanctx = ath11k_mac_op_unassign_vif_chanctx, 8105 .switch_vif_chanctx = ath11k_mac_op_switch_vif_chanctx, 8106 .set_rts_threshold = ath11k_mac_op_set_rts_threshold, 8107 .set_frag_threshold = ath11k_mac_op_set_frag_threshold, 8108 .set_bitrate_mask = ath11k_mac_op_set_bitrate_mask, 8109 .get_survey = ath11k_mac_op_get_survey, 8110 .flush = ath11k_mac_op_flush, 8111 .sta_statistics = ath11k_mac_op_sta_statistics, 8112 CFG80211_TESTMODE_CMD(ath11k_tm_cmd) 8113 #ifdef CONFIG_ATH11K_DEBUGFS 8114 .sta_add_debugfs = ath11k_debugfs_sta_op_add, 8115 #endif 8116 }; 8117 8118 static void ath11k_mac_update_ch_list(struct ath11k *ar, 8119 struct ieee80211_supported_band *band, 8120 u32 freq_low, u32 freq_high) 8121 { 8122 int i; 8123 8124 if (!(freq_low && freq_high)) 8125 return; 8126 8127 for (i = 0; i < band->n_channels; i++) { 8128 if (band->channels[i].center_freq < freq_low || 8129 band->channels[i].center_freq > freq_high) 8130 band->channels[i].flags |= IEEE80211_CHAN_DISABLED; 8131 } 8132 } 8133 8134 static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band) 8135 { 8136 struct ath11k_pdev *pdev = ar->pdev; 8137 struct ath11k_pdev_cap *pdev_cap = &pdev->cap; 8138 8139 if (band == WMI_HOST_WLAN_2G_CAP) 8140 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id; 8141 8142 if (band == WMI_HOST_WLAN_5G_CAP) 8143 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id; 8144 8145 ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band); 8146 8147 return 0; 8148 } 8149 8150 static int ath11k_mac_setup_channels_rates(struct ath11k *ar, 8151 u32 supported_bands) 8152 { 8153 struct ieee80211_supported_band *band; 8154 struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap; 8155 void *channels; 8156 u32 phy_id; 8157 8158 BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) + 8159 ARRAY_SIZE(ath11k_5ghz_channels) + 8160 ARRAY_SIZE(ath11k_6ghz_channels)) != 8161 ATH11K_NUM_CHANS); 8162 8163 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx]; 8164 temp_reg_cap = reg_cap; 8165 8166 if (supported_bands & WMI_HOST_WLAN_2G_CAP) { 8167 channels = kmemdup(ath11k_2ghz_channels, 8168 sizeof(ath11k_2ghz_channels), 8169 GFP_KERNEL); 8170 if (!channels) 8171 return -ENOMEM; 8172 8173 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 8174 band->band = NL80211_BAND_2GHZ; 8175 band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels); 8176 band->channels = channels; 8177 band->n_bitrates = ath11k_g_rates_size; 8178 band->bitrates = ath11k_g_rates; 8179 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band; 8180 8181 if (ar->ab->hw_params.single_pdev_only) { 8182 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP); 8183 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id]; 8184 } 8185 ath11k_mac_update_ch_list(ar, band, 8186 temp_reg_cap->low_2ghz_chan, 8187 temp_reg_cap->high_2ghz_chan); 8188 } 8189 8190 if (supported_bands & WMI_HOST_WLAN_5G_CAP) { 8191 if (reg_cap->high_5ghz_chan >= ATH11K_MAX_6G_FREQ) { 8192 channels = kmemdup(ath11k_6ghz_channels, 8193 sizeof(ath11k_6ghz_channels), GFP_KERNEL); 8194 if (!channels) { 8195 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8196 return -ENOMEM; 8197 } 8198 8199 ar->supports_6ghz = true; 8200 band = &ar->mac.sbands[NL80211_BAND_6GHZ]; 8201 band->band = NL80211_BAND_6GHZ; 8202 band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels); 8203 band->channels = channels; 8204 band->n_bitrates = ath11k_a_rates_size; 8205 band->bitrates = ath11k_a_rates; 8206 ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band; 8207 8208 if (ar->ab->hw_params.single_pdev_only) { 8209 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP); 8210 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id]; 8211 } 8212 8213 ath11k_mac_update_ch_list(ar, band, 8214 temp_reg_cap->low_5ghz_chan, 8215 temp_reg_cap->high_5ghz_chan); 8216 } 8217 8218 if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) { 8219 channels = kmemdup(ath11k_5ghz_channels, 8220 sizeof(ath11k_5ghz_channels), 8221 GFP_KERNEL); 8222 if (!channels) { 8223 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8224 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 8225 return -ENOMEM; 8226 } 8227 8228 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 8229 band->band = NL80211_BAND_5GHZ; 8230 band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels); 8231 band->channels = channels; 8232 band->n_bitrates = ath11k_a_rates_size; 8233 band->bitrates = ath11k_a_rates; 8234 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band; 8235 8236 if (ar->ab->hw_params.single_pdev_only) { 8237 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP); 8238 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id]; 8239 } 8240 8241 ath11k_mac_update_ch_list(ar, band, 8242 temp_reg_cap->low_5ghz_chan, 8243 temp_reg_cap->high_5ghz_chan); 8244 } 8245 } 8246 8247 return 0; 8248 } 8249 8250 static int ath11k_mac_setup_iface_combinations(struct ath11k *ar) 8251 { 8252 struct ath11k_base *ab = ar->ab; 8253 struct ieee80211_iface_combination *combinations; 8254 struct ieee80211_iface_limit *limits; 8255 int n_limits; 8256 8257 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL); 8258 if (!combinations) 8259 return -ENOMEM; 8260 8261 n_limits = 2; 8262 8263 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL); 8264 if (!limits) { 8265 kfree(combinations); 8266 return -ENOMEM; 8267 } 8268 8269 limits[0].max = 1; 8270 limits[0].types |= BIT(NL80211_IFTYPE_STATION); 8271 8272 limits[1].max = 16; 8273 limits[1].types |= BIT(NL80211_IFTYPE_AP); 8274 8275 if (IS_ENABLED(CONFIG_MAC80211_MESH) && 8276 ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT)) 8277 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT); 8278 8279 combinations[0].limits = limits; 8280 combinations[0].n_limits = n_limits; 8281 combinations[0].max_interfaces = 16; 8282 combinations[0].num_different_channels = 1; 8283 combinations[0].beacon_int_infra_match = true; 8284 combinations[0].beacon_int_min_gcd = 100; 8285 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 8286 BIT(NL80211_CHAN_WIDTH_20) | 8287 BIT(NL80211_CHAN_WIDTH_40) | 8288 BIT(NL80211_CHAN_WIDTH_80) | 8289 BIT(NL80211_CHAN_WIDTH_80P80) | 8290 BIT(NL80211_CHAN_WIDTH_160); 8291 8292 ar->hw->wiphy->iface_combinations = combinations; 8293 ar->hw->wiphy->n_iface_combinations = 1; 8294 8295 return 0; 8296 } 8297 8298 static const u8 ath11k_if_types_ext_capa[] = { 8299 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 8300 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 8301 }; 8302 8303 static const u8 ath11k_if_types_ext_capa_sta[] = { 8304 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 8305 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 8306 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT, 8307 }; 8308 8309 static const u8 ath11k_if_types_ext_capa_ap[] = { 8310 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 8311 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 8312 [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT, 8313 }; 8314 8315 static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = { 8316 { 8317 .extended_capabilities = ath11k_if_types_ext_capa, 8318 .extended_capabilities_mask = ath11k_if_types_ext_capa, 8319 .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa), 8320 }, { 8321 .iftype = NL80211_IFTYPE_STATION, 8322 .extended_capabilities = ath11k_if_types_ext_capa_sta, 8323 .extended_capabilities_mask = ath11k_if_types_ext_capa_sta, 8324 .extended_capabilities_len = 8325 sizeof(ath11k_if_types_ext_capa_sta), 8326 }, { 8327 .iftype = NL80211_IFTYPE_AP, 8328 .extended_capabilities = ath11k_if_types_ext_capa_ap, 8329 .extended_capabilities_mask = ath11k_if_types_ext_capa_ap, 8330 .extended_capabilities_len = 8331 sizeof(ath11k_if_types_ext_capa_ap), 8332 }, 8333 }; 8334 8335 static void __ath11k_mac_unregister(struct ath11k *ar) 8336 { 8337 cancel_work_sync(&ar->regd_update_work); 8338 8339 ieee80211_unregister_hw(ar->hw); 8340 8341 idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar); 8342 idr_destroy(&ar->txmgmt_idr); 8343 8344 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8345 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 8346 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 8347 8348 kfree(ar->hw->wiphy->iface_combinations[0].limits); 8349 kfree(ar->hw->wiphy->iface_combinations); 8350 8351 SET_IEEE80211_DEV(ar->hw, NULL); 8352 } 8353 8354 void ath11k_mac_unregister(struct ath11k_base *ab) 8355 { 8356 struct ath11k *ar; 8357 struct ath11k_pdev *pdev; 8358 int i; 8359 8360 for (i = 0; i < ab->num_radios; i++) { 8361 pdev = &ab->pdevs[i]; 8362 ar = pdev->ar; 8363 if (!ar) 8364 continue; 8365 8366 __ath11k_mac_unregister(ar); 8367 } 8368 } 8369 8370 static int __ath11k_mac_register(struct ath11k *ar) 8371 { 8372 struct ath11k_base *ab = ar->ab; 8373 struct ath11k_pdev_cap *cap = &ar->pdev->cap; 8374 static const u32 cipher_suites[] = { 8375 WLAN_CIPHER_SUITE_TKIP, 8376 WLAN_CIPHER_SUITE_CCMP, 8377 WLAN_CIPHER_SUITE_AES_CMAC, 8378 WLAN_CIPHER_SUITE_BIP_CMAC_256, 8379 WLAN_CIPHER_SUITE_BIP_GMAC_128, 8380 WLAN_CIPHER_SUITE_BIP_GMAC_256, 8381 WLAN_CIPHER_SUITE_GCMP, 8382 WLAN_CIPHER_SUITE_GCMP_256, 8383 WLAN_CIPHER_SUITE_CCMP_256, 8384 }; 8385 int ret; 8386 u32 ht_cap = 0; 8387 8388 ath11k_pdev_caps_update(ar); 8389 8390 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 8391 8392 SET_IEEE80211_DEV(ar->hw, ab->dev); 8393 8394 ret = ath11k_mac_setup_channels_rates(ar, 8395 cap->supported_bands); 8396 if (ret) 8397 goto err; 8398 8399 ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap); 8400 ath11k_mac_setup_he_cap(ar, cap); 8401 8402 ret = ath11k_mac_setup_iface_combinations(ar); 8403 if (ret) { 8404 ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret); 8405 goto err_free_channels; 8406 } 8407 8408 ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask; 8409 ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask; 8410 8411 ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes; 8412 8413 if (ab->hw_params.single_pdev_only && ar->supports_6ghz) 8414 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS); 8415 8416 ieee80211_hw_set(ar->hw, SIGNAL_DBM); 8417 ieee80211_hw_set(ar->hw, SUPPORTS_PS); 8418 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS); 8419 ieee80211_hw_set(ar->hw, MFP_CAPABLE); 8420 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS); 8421 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL); 8422 ieee80211_hw_set(ar->hw, AP_LINK_PS); 8423 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT); 8424 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR); 8425 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK); 8426 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF); 8427 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA); 8428 ieee80211_hw_set(ar->hw, QUEUE_CONTROL); 8429 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG); 8430 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK); 8431 8432 if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) { 8433 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD); 8434 ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD); 8435 } 8436 8437 if (cap->nss_ratio_enabled) 8438 ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW); 8439 8440 if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) { 8441 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION); 8442 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW); 8443 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER); 8444 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU); 8445 ieee80211_hw_set(ar->hw, USES_RSS); 8446 } 8447 8448 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS; 8449 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 8450 8451 /* TODO: Check if HT capability advertised from firmware is different 8452 * for each band for a dual band capable radio. It will be tricky to 8453 * handle it when the ht capability different for each band. 8454 */ 8455 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS || 8456 (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz)) 8457 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS; 8458 8459 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 8460 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 8461 8462 ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL; 8463 8464 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 8465 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 8466 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 8467 8468 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 8469 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 8470 NL80211_FEATURE_AP_SCAN; 8471 8472 ar->max_num_stations = TARGET_NUM_STATIONS(ab); 8473 ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab); 8474 8475 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations; 8476 8477 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) { 8478 ar->hw->wiphy->features |= 8479 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR; 8480 } 8481 8482 ar->hw->queues = ATH11K_HW_MAX_QUEUES; 8483 ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN; 8484 ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1; 8485 ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE; 8486 8487 ar->hw->vif_data_size = sizeof(struct ath11k_vif); 8488 ar->hw->sta_data_size = sizeof(struct ath11k_sta); 8489 8490 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 8491 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR); 8492 if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD, ar->ab->wmi_ab.svc_map)) 8493 wiphy_ext_feature_set(ar->hw->wiphy, 8494 NL80211_EXT_FEATURE_BSS_COLOR); 8495 8496 ar->hw->wiphy->cipher_suites = cipher_suites; 8497 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 8498 8499 ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa; 8500 ar->hw->wiphy->num_iftype_ext_capab = 8501 ARRAY_SIZE(ath11k_iftypes_ext_capa); 8502 8503 if (ar->supports_6ghz) { 8504 wiphy_ext_feature_set(ar->hw->wiphy, 8505 NL80211_EXT_FEATURE_FILS_DISCOVERY); 8506 wiphy_ext_feature_set(ar->hw->wiphy, 8507 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP); 8508 } 8509 8510 ath11k_reg_init(ar); 8511 8512 if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) { 8513 ar->hw->netdev_features = NETIF_F_HW_CSUM; 8514 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL); 8515 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT); 8516 } 8517 8518 ret = ieee80211_register_hw(ar->hw); 8519 if (ret) { 8520 ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret); 8521 goto err_free_if_combs; 8522 } 8523 8524 if (!ab->hw_params.supports_monitor) 8525 /* There's a race between calling ieee80211_register_hw() 8526 * and here where the monitor mode is enabled for a little 8527 * while. But that time is so short and in practise it make 8528 * a difference in real life. 8529 */ 8530 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR); 8531 8532 /* Apply the regd received during initialization */ 8533 ret = ath11k_regd_update(ar); 8534 if (ret) { 8535 ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret); 8536 goto err_unregister_hw; 8537 } 8538 8539 ret = ath11k_debugfs_register(ar); 8540 if (ret) { 8541 ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret); 8542 goto err_unregister_hw; 8543 } 8544 8545 return 0; 8546 8547 err_unregister_hw: 8548 ieee80211_unregister_hw(ar->hw); 8549 8550 err_free_if_combs: 8551 kfree(ar->hw->wiphy->iface_combinations[0].limits); 8552 kfree(ar->hw->wiphy->iface_combinations); 8553 8554 err_free_channels: 8555 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8556 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 8557 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 8558 8559 err: 8560 SET_IEEE80211_DEV(ar->hw, NULL); 8561 return ret; 8562 } 8563 8564 int ath11k_mac_register(struct ath11k_base *ab) 8565 { 8566 struct ath11k *ar; 8567 struct ath11k_pdev *pdev; 8568 int i; 8569 int ret; 8570 8571 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) 8572 return 0; 8573 8574 /* Initialize channel counters frequency value in hertz */ 8575 ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ; 8576 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1; 8577 8578 for (i = 0; i < ab->num_radios; i++) { 8579 pdev = &ab->pdevs[i]; 8580 ar = pdev->ar; 8581 if (ab->pdevs_macaddr_valid) { 8582 ether_addr_copy(ar->mac_addr, pdev->mac_addr); 8583 } else { 8584 ether_addr_copy(ar->mac_addr, ab->mac_addr); 8585 ar->mac_addr[4] += i; 8586 } 8587 8588 idr_init(&ar->txmgmt_idr); 8589 spin_lock_init(&ar->txmgmt_idr_lock); 8590 8591 ret = __ath11k_mac_register(ar); 8592 if (ret) 8593 goto err_cleanup; 8594 8595 init_waitqueue_head(&ar->txmgmt_empty_waitq); 8596 } 8597 8598 return 0; 8599 8600 err_cleanup: 8601 for (i = i - 1; i >= 0; i--) { 8602 pdev = &ab->pdevs[i]; 8603 ar = pdev->ar; 8604 __ath11k_mac_unregister(ar); 8605 } 8606 8607 return ret; 8608 } 8609 8610 int ath11k_mac_allocate(struct ath11k_base *ab) 8611 { 8612 struct ieee80211_hw *hw; 8613 struct ath11k *ar; 8614 struct ath11k_pdev *pdev; 8615 int ret; 8616 int i; 8617 8618 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) 8619 return 0; 8620 8621 for (i = 0; i < ab->num_radios; i++) { 8622 pdev = &ab->pdevs[i]; 8623 hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops); 8624 if (!hw) { 8625 ath11k_warn(ab, "failed to allocate mac80211 hw device\n"); 8626 ret = -ENOMEM; 8627 goto err_free_mac; 8628 } 8629 8630 ar = hw->priv; 8631 ar->hw = hw; 8632 ar->ab = ab; 8633 ar->pdev = pdev; 8634 ar->pdev_idx = i; 8635 ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i); 8636 8637 ar->wmi = &ab->wmi_ab.wmi[i]; 8638 /* FIXME wmi[0] is already initialized during attach, 8639 * Should we do this again? 8640 */ 8641 ath11k_wmi_pdev_attach(ab, i); 8642 8643 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask; 8644 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask; 8645 ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask); 8646 ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask); 8647 8648 pdev->ar = ar; 8649 spin_lock_init(&ar->data_lock); 8650 INIT_LIST_HEAD(&ar->arvifs); 8651 INIT_LIST_HEAD(&ar->ppdu_stats_info); 8652 mutex_init(&ar->conf_mutex); 8653 init_completion(&ar->vdev_setup_done); 8654 init_completion(&ar->vdev_delete_done); 8655 init_completion(&ar->peer_assoc_done); 8656 init_completion(&ar->peer_delete_done); 8657 init_completion(&ar->install_key_done); 8658 init_completion(&ar->bss_survey_done); 8659 init_completion(&ar->scan.started); 8660 init_completion(&ar->scan.completed); 8661 init_completion(&ar->thermal.wmi_sync); 8662 8663 INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work); 8664 INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work); 8665 8666 INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work); 8667 skb_queue_head_init(&ar->wmi_mgmt_tx_queue); 8668 8669 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags); 8670 8671 ar->monitor_vdev_id = -1; 8672 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags); 8673 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID; 8674 init_completion(&ar->finish_11d_scan); 8675 init_completion(&ar->finish_11d_ch_list); 8676 } 8677 8678 return 0; 8679 8680 err_free_mac: 8681 ath11k_mac_destroy(ab); 8682 8683 return ret; 8684 } 8685 8686 void ath11k_mac_destroy(struct ath11k_base *ab) 8687 { 8688 struct ath11k *ar; 8689 struct ath11k_pdev *pdev; 8690 int i; 8691 8692 for (i = 0; i < ab->num_radios; i++) { 8693 pdev = &ab->pdevs[i]; 8694 ar = pdev->ar; 8695 if (!ar) 8696 continue; 8697 8698 ieee80211_free_hw(ar->hw); 8699 pdev->ar = NULL; 8700 } 8701 } 8702