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