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