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