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