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