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