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 = {}; 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 ath12k_wmi_start_scan_init(ar, &arg); 3749 arg.vdev_id = arvif->vdev_id; 3750 arg.scan_id = ATH12K_SCAN_ID; 3751 3752 if (req->ie_len) { 3753 arg.extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL); 3754 if (!arg.extraie.ptr) { 3755 ret = -ENOMEM; 3756 goto exit; 3757 } 3758 arg.extraie.len = req->ie_len; 3759 } 3760 3761 if (req->n_ssids) { 3762 arg.num_ssids = req->n_ssids; 3763 for (i = 0; i < arg.num_ssids; i++) 3764 arg.ssid[i] = req->ssids[i]; 3765 } else { 3766 arg.scan_f_passive = 1; 3767 } 3768 3769 if (req->n_channels) { 3770 arg.num_chan = req->n_channels; 3771 arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list), 3772 GFP_KERNEL); 3773 3774 if (!arg.chan_list) { 3775 ret = -ENOMEM; 3776 goto exit; 3777 } 3778 3779 for (i = 0; i < arg.num_chan; i++) 3780 arg.chan_list[i] = req->channels[i]->center_freq; 3781 } 3782 3783 ret = ath12k_start_scan(ar, &arg); 3784 if (ret) { 3785 ath12k_warn(ar->ab, "failed to start hw scan: %d\n", ret); 3786 spin_lock_bh(&ar->data_lock); 3787 ar->scan.state = ATH12K_SCAN_IDLE; 3788 spin_unlock_bh(&ar->data_lock); 3789 } 3790 3791 /* Add a margin to account for event/command processing */ 3792 ieee80211_queue_delayed_work(ath12k_ar_to_hw(ar), &ar->scan.timeout, 3793 msecs_to_jiffies(arg.max_scan_time + 3794 ATH12K_MAC_SCAN_TIMEOUT_MSECS)); 3795 3796 exit: 3797 kfree(arg.chan_list); 3798 3799 if (req->ie_len) 3800 kfree(arg.extraie.ptr); 3801 3802 mutex_unlock(&ar->conf_mutex); 3803 3804 return ret; 3805 } 3806 3807 static void ath12k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw, 3808 struct ieee80211_vif *vif) 3809 { 3810 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 3811 struct ath12k *ar; 3812 3813 if (!arvif->is_created) 3814 return; 3815 3816 ar = arvif->ar; 3817 3818 mutex_lock(&ar->conf_mutex); 3819 ath12k_scan_abort(ar); 3820 mutex_unlock(&ar->conf_mutex); 3821 3822 cancel_delayed_work_sync(&ar->scan.timeout); 3823 } 3824 3825 static int ath12k_install_key(struct ath12k_vif *arvif, 3826 struct ieee80211_key_conf *key, 3827 enum set_key_cmd cmd, 3828 const u8 *macaddr, u32 flags) 3829 { 3830 int ret; 3831 struct ath12k *ar = arvif->ar; 3832 struct wmi_vdev_install_key_arg arg = { 3833 .vdev_id = arvif->vdev_id, 3834 .key_idx = key->keyidx, 3835 .key_len = key->keylen, 3836 .key_data = key->key, 3837 .key_flags = flags, 3838 .macaddr = macaddr, 3839 }; 3840 3841 lockdep_assert_held(&arvif->ar->conf_mutex); 3842 3843 reinit_completion(&ar->install_key_done); 3844 3845 if (test_bit(ATH12K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags)) 3846 return 0; 3847 3848 if (cmd == DISABLE_KEY) { 3849 /* TODO: Check if FW expects value other than NONE for del */ 3850 /* arg.key_cipher = WMI_CIPHER_NONE; */ 3851 arg.key_len = 0; 3852 arg.key_data = NULL; 3853 goto install; 3854 } 3855 3856 switch (key->cipher) { 3857 case WLAN_CIPHER_SUITE_CCMP: 3858 arg.key_cipher = WMI_CIPHER_AES_CCM; 3859 /* TODO: Re-check if flag is valid */ 3860 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT; 3861 break; 3862 case WLAN_CIPHER_SUITE_TKIP: 3863 arg.key_cipher = WMI_CIPHER_TKIP; 3864 arg.key_txmic_len = 8; 3865 arg.key_rxmic_len = 8; 3866 break; 3867 case WLAN_CIPHER_SUITE_CCMP_256: 3868 arg.key_cipher = WMI_CIPHER_AES_CCM; 3869 break; 3870 case WLAN_CIPHER_SUITE_GCMP: 3871 case WLAN_CIPHER_SUITE_GCMP_256: 3872 arg.key_cipher = WMI_CIPHER_AES_GCM; 3873 break; 3874 default: 3875 ath12k_warn(ar->ab, "cipher %d is not supported\n", key->cipher); 3876 return -EOPNOTSUPP; 3877 } 3878 3879 if (test_bit(ATH12K_FLAG_RAW_MODE, &ar->ab->dev_flags)) 3880 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV | 3881 IEEE80211_KEY_FLAG_RESERVE_TAILROOM; 3882 3883 install: 3884 ret = ath12k_wmi_vdev_install_key(arvif->ar, &arg); 3885 3886 if (ret) 3887 return ret; 3888 3889 if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ)) 3890 return -ETIMEDOUT; 3891 3892 if (ether_addr_equal(macaddr, arvif->vif->addr)) 3893 arvif->key_cipher = key->cipher; 3894 3895 return ar->install_key_status ? -EINVAL : 0; 3896 } 3897 3898 static int ath12k_clear_peer_keys(struct ath12k_vif *arvif, 3899 const u8 *addr) 3900 { 3901 struct ath12k *ar = arvif->ar; 3902 struct ath12k_base *ab = ar->ab; 3903 struct ath12k_peer *peer; 3904 int first_errno = 0; 3905 int ret; 3906 int i; 3907 u32 flags = 0; 3908 3909 lockdep_assert_held(&ar->conf_mutex); 3910 3911 spin_lock_bh(&ab->base_lock); 3912 peer = ath12k_peer_find(ab, arvif->vdev_id, addr); 3913 spin_unlock_bh(&ab->base_lock); 3914 3915 if (!peer) 3916 return -ENOENT; 3917 3918 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 3919 if (!peer->keys[i]) 3920 continue; 3921 3922 /* key flags are not required to delete the key */ 3923 ret = ath12k_install_key(arvif, peer->keys[i], 3924 DISABLE_KEY, addr, flags); 3925 if (ret < 0 && first_errno == 0) 3926 first_errno = ret; 3927 3928 if (ret < 0) 3929 ath12k_warn(ab, "failed to remove peer key %d: %d\n", 3930 i, ret); 3931 3932 spin_lock_bh(&ab->base_lock); 3933 peer->keys[i] = NULL; 3934 spin_unlock_bh(&ab->base_lock); 3935 } 3936 3937 return first_errno; 3938 } 3939 3940 static int ath12k_mac_set_key(struct ath12k *ar, enum set_key_cmd cmd, 3941 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 3942 struct ieee80211_key_conf *key) 3943 { 3944 struct ath12k_base *ab = ar->ab; 3945 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 3946 struct ath12k_peer *peer; 3947 struct ath12k_sta *arsta; 3948 const u8 *peer_addr; 3949 int ret = 0; 3950 u32 flags = 0; 3951 3952 lockdep_assert_held(&ar->conf_mutex); 3953 3954 if (test_bit(ATH12K_FLAG_HW_CRYPTO_DISABLED, &ab->dev_flags)) 3955 return 1; 3956 3957 if (sta) 3958 peer_addr = sta->addr; 3959 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 3960 peer_addr = vif->bss_conf.bssid; 3961 else 3962 peer_addr = vif->addr; 3963 3964 key->hw_key_idx = key->keyidx; 3965 3966 /* the peer should not disappear in mid-way (unless FW goes awry) since 3967 * we already hold conf_mutex. we just make sure its there now. 3968 */ 3969 spin_lock_bh(&ab->base_lock); 3970 peer = ath12k_peer_find(ab, arvif->vdev_id, peer_addr); 3971 spin_unlock_bh(&ab->base_lock); 3972 3973 if (!peer) { 3974 if (cmd == SET_KEY) { 3975 ath12k_warn(ab, "cannot install key for non-existent peer %pM\n", 3976 peer_addr); 3977 ret = -EOPNOTSUPP; 3978 goto exit; 3979 } else { 3980 /* if the peer doesn't exist there is no key to disable 3981 * anymore 3982 */ 3983 goto exit; 3984 } 3985 } 3986 3987 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 3988 flags |= WMI_KEY_PAIRWISE; 3989 else 3990 flags |= WMI_KEY_GROUP; 3991 3992 ret = ath12k_install_key(arvif, key, cmd, peer_addr, flags); 3993 if (ret) { 3994 ath12k_warn(ab, "ath12k_install_key failed (%d)\n", ret); 3995 goto exit; 3996 } 3997 3998 ret = ath12k_dp_rx_peer_pn_replay_config(arvif, peer_addr, cmd, key); 3999 if (ret) { 4000 ath12k_warn(ab, "failed to offload PN replay detection %d\n", ret); 4001 goto exit; 4002 } 4003 4004 spin_lock_bh(&ab->base_lock); 4005 peer = ath12k_peer_find(ab, arvif->vdev_id, peer_addr); 4006 if (peer && cmd == SET_KEY) { 4007 peer->keys[key->keyidx] = key; 4008 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) { 4009 peer->ucast_keyidx = key->keyidx; 4010 peer->sec_type = ath12k_dp_tx_get_encrypt_type(key->cipher); 4011 } else { 4012 peer->mcast_keyidx = key->keyidx; 4013 peer->sec_type_grp = ath12k_dp_tx_get_encrypt_type(key->cipher); 4014 } 4015 } else if (peer && cmd == DISABLE_KEY) { 4016 peer->keys[key->keyidx] = NULL; 4017 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 4018 peer->ucast_keyidx = 0; 4019 else 4020 peer->mcast_keyidx = 0; 4021 } else if (!peer) 4022 /* impossible unless FW goes crazy */ 4023 ath12k_warn(ab, "peer %pM disappeared!\n", peer_addr); 4024 4025 if (sta) { 4026 arsta = ath12k_sta_to_arsta(sta); 4027 4028 switch (key->cipher) { 4029 case WLAN_CIPHER_SUITE_TKIP: 4030 case WLAN_CIPHER_SUITE_CCMP: 4031 case WLAN_CIPHER_SUITE_CCMP_256: 4032 case WLAN_CIPHER_SUITE_GCMP: 4033 case WLAN_CIPHER_SUITE_GCMP_256: 4034 if (cmd == SET_KEY) 4035 arsta->pn_type = HAL_PN_TYPE_WPA; 4036 else 4037 arsta->pn_type = HAL_PN_TYPE_NONE; 4038 break; 4039 default: 4040 arsta->pn_type = HAL_PN_TYPE_NONE; 4041 break; 4042 } 4043 } 4044 4045 spin_unlock_bh(&ab->base_lock); 4046 4047 exit: 4048 return ret; 4049 } 4050 4051 static int ath12k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 4052 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 4053 struct ieee80211_key_conf *key) 4054 { 4055 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 4056 struct ath12k_vif_cache *cache; 4057 struct ath12k *ar; 4058 int ret; 4059 4060 /* BIP needs to be done in software */ 4061 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC || 4062 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 || 4063 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 || 4064 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256) 4065 return 1; 4066 4067 if (key->keyidx > WMI_MAX_KEY_INDEX) 4068 return -ENOSPC; 4069 4070 ar = ath12k_get_ar_by_vif(hw, vif); 4071 if (!ar) { 4072 /* ar is expected to be valid when sta ptr is available */ 4073 if (sta) { 4074 WARN_ON_ONCE(1); 4075 return -EINVAL; 4076 } 4077 4078 cache = ath12k_arvif_get_cache(arvif); 4079 if (!cache) 4080 return -ENOSPC; 4081 cache->key_conf.cmd = cmd; 4082 cache->key_conf.key = key; 4083 cache->key_conf.changed = true; 4084 return 0; 4085 } 4086 4087 mutex_lock(&ar->conf_mutex); 4088 ret = ath12k_mac_set_key(ar, cmd, vif, sta, key); 4089 mutex_unlock(&ar->conf_mutex); 4090 return ret; 4091 } 4092 4093 static int 4094 ath12k_mac_bitrate_mask_num_vht_rates(struct ath12k *ar, 4095 enum nl80211_band band, 4096 const struct cfg80211_bitrate_mask *mask) 4097 { 4098 int num_rates = 0; 4099 int i; 4100 4101 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) 4102 num_rates += hweight16(mask->control[band].vht_mcs[i]); 4103 4104 return num_rates; 4105 } 4106 4107 static int 4108 ath12k_mac_set_peer_vht_fixed_rate(struct ath12k_vif *arvif, 4109 struct ieee80211_sta *sta, 4110 const struct cfg80211_bitrate_mask *mask, 4111 enum nl80211_band band) 4112 { 4113 struct ath12k *ar = arvif->ar; 4114 u8 vht_rate, nss; 4115 u32 rate_code; 4116 int ret, i; 4117 4118 lockdep_assert_held(&ar->conf_mutex); 4119 4120 nss = 0; 4121 4122 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 4123 if (hweight16(mask->control[band].vht_mcs[i]) == 1) { 4124 nss = i + 1; 4125 vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1; 4126 } 4127 } 4128 4129 if (!nss) { 4130 ath12k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM", 4131 sta->addr); 4132 return -EINVAL; 4133 } 4134 4135 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 4136 "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates", 4137 sta->addr); 4138 4139 rate_code = ATH12K_HW_RATE_CODE(vht_rate, nss - 1, 4140 WMI_RATE_PREAMBLE_VHT); 4141 ret = ath12k_wmi_set_peer_param(ar, sta->addr, 4142 arvif->vdev_id, 4143 WMI_PEER_PARAM_FIXED_RATE, 4144 rate_code); 4145 if (ret) 4146 ath12k_warn(ar->ab, 4147 "failed to update STA %pM Fixed Rate %d: %d\n", 4148 sta->addr, rate_code, ret); 4149 4150 return ret; 4151 } 4152 4153 static int ath12k_station_assoc(struct ath12k *ar, 4154 struct ieee80211_vif *vif, 4155 struct ieee80211_sta *sta, 4156 bool reassoc) 4157 { 4158 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 4159 struct ath12k_wmi_peer_assoc_arg peer_arg; 4160 int ret; 4161 struct cfg80211_chan_def def; 4162 enum nl80211_band band; 4163 struct cfg80211_bitrate_mask *mask; 4164 u8 num_vht_rates; 4165 4166 lockdep_assert_held(&ar->conf_mutex); 4167 4168 if (WARN_ON(ath12k_mac_vif_chan(vif, &def))) 4169 return -EPERM; 4170 4171 band = def.chan->band; 4172 mask = &arvif->bitrate_mask; 4173 4174 ath12k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc); 4175 4176 if (peer_arg.peer_nss < 1) { 4177 ath12k_warn(ar->ab, 4178 "invalid peer NSS %d\n", peer_arg.peer_nss); 4179 return -EINVAL; 4180 } 4181 ret = ath12k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4182 if (ret) { 4183 ath12k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 4184 sta->addr, arvif->vdev_id, ret); 4185 return ret; 4186 } 4187 4188 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 4189 ath12k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4190 sta->addr, arvif->vdev_id); 4191 return -ETIMEDOUT; 4192 } 4193 4194 num_vht_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band, mask); 4195 4196 /* If single VHT rate is configured (by set_bitrate_mask()), 4197 * peer_assoc will disable VHT. This is now enabled by a peer specific 4198 * fixed param. 4199 * Note that all other rates and NSS will be disabled for this peer. 4200 */ 4201 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) { 4202 ret = ath12k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 4203 band); 4204 if (ret) 4205 return ret; 4206 } 4207 4208 /* Re-assoc is run only to update supported rates for given station. It 4209 * doesn't make much sense to reconfigure the peer completely. 4210 */ 4211 if (reassoc) 4212 return 0; 4213 4214 ret = ath12k_setup_peer_smps(ar, arvif, sta->addr, 4215 &sta->deflink.ht_cap, 4216 &sta->deflink.he_6ghz_capa); 4217 if (ret) { 4218 ath12k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n", 4219 arvif->vdev_id, ret); 4220 return ret; 4221 } 4222 4223 if (!sta->wme) { 4224 arvif->num_legacy_stations++; 4225 ret = ath12k_recalc_rtscts_prot(arvif); 4226 if (ret) 4227 return ret; 4228 } 4229 4230 if (sta->wme && sta->uapsd_queues) { 4231 ret = ath12k_peer_assoc_qos_ap(ar, arvif, sta); 4232 if (ret) { 4233 ath12k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n", 4234 sta->addr, arvif->vdev_id, ret); 4235 return ret; 4236 } 4237 } 4238 4239 return 0; 4240 } 4241 4242 static int ath12k_station_disassoc(struct ath12k *ar, 4243 struct ieee80211_vif *vif, 4244 struct ieee80211_sta *sta) 4245 { 4246 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 4247 int ret; 4248 4249 lockdep_assert_held(&ar->conf_mutex); 4250 4251 if (!sta->wme) { 4252 arvif->num_legacy_stations--; 4253 ret = ath12k_recalc_rtscts_prot(arvif); 4254 if (ret) 4255 return ret; 4256 } 4257 4258 ret = ath12k_clear_peer_keys(arvif, sta->addr); 4259 if (ret) { 4260 ath12k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n", 4261 arvif->vdev_id, ret); 4262 return ret; 4263 } 4264 return 0; 4265 } 4266 4267 static void ath12k_sta_rc_update_wk(struct work_struct *wk) 4268 { 4269 struct ath12k *ar; 4270 struct ath12k_vif *arvif; 4271 struct ath12k_sta *arsta; 4272 struct ieee80211_sta *sta; 4273 struct cfg80211_chan_def def; 4274 enum nl80211_band band; 4275 const u8 *ht_mcs_mask; 4276 const u16 *vht_mcs_mask; 4277 u32 changed, bw, nss, smps, bw_prev; 4278 int err, num_vht_rates; 4279 const struct cfg80211_bitrate_mask *mask; 4280 struct ath12k_wmi_peer_assoc_arg peer_arg; 4281 enum wmi_phy_mode peer_phymode; 4282 4283 arsta = container_of(wk, struct ath12k_sta, update_wk); 4284 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 4285 arvif = arsta->arvif; 4286 ar = arvif->ar; 4287 4288 if (WARN_ON(ath12k_mac_vif_chan(arvif->vif, &def))) 4289 return; 4290 4291 band = def.chan->band; 4292 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 4293 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 4294 4295 spin_lock_bh(&ar->data_lock); 4296 4297 changed = arsta->changed; 4298 arsta->changed = 0; 4299 4300 bw = arsta->bw; 4301 bw_prev = arsta->bw_prev; 4302 nss = arsta->nss; 4303 smps = arsta->smps; 4304 4305 spin_unlock_bh(&ar->data_lock); 4306 4307 mutex_lock(&ar->conf_mutex); 4308 4309 nss = max_t(u32, 1, nss); 4310 nss = min(nss, max(ath12k_mac_max_ht_nss(ht_mcs_mask), 4311 ath12k_mac_max_vht_nss(vht_mcs_mask))); 4312 4313 if (changed & IEEE80211_RC_BW_CHANGED) { 4314 ath12k_peer_assoc_h_phymode(ar, arvif->vif, sta, &peer_arg); 4315 peer_phymode = peer_arg.peer_phymode; 4316 4317 if (bw > bw_prev) { 4318 /* Phymode shows maximum supported channel width, if we 4319 * upgrade bandwidth then due to sanity check of firmware, 4320 * we have to send WMI_PEER_PHYMODE followed by 4321 * WMI_PEER_CHWIDTH 4322 */ 4323 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac bandwidth upgrade for sta %pM new %d old %d\n", 4324 sta->addr, bw, bw_prev); 4325 err = ath12k_wmi_set_peer_param(ar, sta->addr, 4326 arvif->vdev_id, WMI_PEER_PHYMODE, 4327 peer_phymode); 4328 if (err) { 4329 ath12k_warn(ar->ab, "failed to update STA %pM to peer phymode %d: %d\n", 4330 sta->addr, peer_phymode, err); 4331 goto err_rc_bw_changed; 4332 } 4333 err = ath12k_wmi_set_peer_param(ar, sta->addr, 4334 arvif->vdev_id, WMI_PEER_CHWIDTH, 4335 bw); 4336 if (err) 4337 ath12k_warn(ar->ab, "failed to update STA %pM to peer bandwidth %d: %d\n", 4338 sta->addr, bw, err); 4339 } else { 4340 /* When we downgrade bandwidth this will conflict with phymode 4341 * and cause to trigger firmware crash. In this case we send 4342 * WMI_PEER_CHWIDTH followed by WMI_PEER_PHYMODE 4343 */ 4344 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac bandwidth downgrade for sta %pM new %d old %d\n", 4345 sta->addr, bw, bw_prev); 4346 err = ath12k_wmi_set_peer_param(ar, sta->addr, 4347 arvif->vdev_id, WMI_PEER_CHWIDTH, 4348 bw); 4349 if (err) { 4350 ath12k_warn(ar->ab, "failed to update STA %pM peer to bandwidth %d: %d\n", 4351 sta->addr, bw, err); 4352 goto err_rc_bw_changed; 4353 } 4354 err = ath12k_wmi_set_peer_param(ar, sta->addr, 4355 arvif->vdev_id, WMI_PEER_PHYMODE, 4356 peer_phymode); 4357 if (err) 4358 ath12k_warn(ar->ab, "failed to update STA %pM to peer phymode %d: %d\n", 4359 sta->addr, peer_phymode, err); 4360 } 4361 } 4362 4363 if (changed & IEEE80211_RC_NSS_CHANGED) { 4364 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac update sta %pM nss %d\n", 4365 sta->addr, nss); 4366 4367 err = ath12k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4368 WMI_PEER_NSS, nss); 4369 if (err) 4370 ath12k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n", 4371 sta->addr, nss, err); 4372 } 4373 4374 if (changed & IEEE80211_RC_SMPS_CHANGED) { 4375 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac update sta %pM smps %d\n", 4376 sta->addr, smps); 4377 4378 err = ath12k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4379 WMI_PEER_MIMO_PS_STATE, smps); 4380 if (err) 4381 ath12k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n", 4382 sta->addr, smps, err); 4383 } 4384 4385 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) { 4386 mask = &arvif->bitrate_mask; 4387 num_vht_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band, 4388 mask); 4389 4390 /* Peer_assoc_prepare will reject vht rates in 4391 * bitrate_mask if its not available in range format and 4392 * sets vht tx_rateset as unsupported. So multiple VHT MCS 4393 * setting(eg. MCS 4,5,6) per peer is not supported here. 4394 * But, Single rate in VHT mask can be set as per-peer 4395 * fixed rate. But even if any HT rates are configured in 4396 * the bitrate mask, device will not switch to those rates 4397 * when per-peer Fixed rate is set. 4398 * TODO: Check RATEMASK_CMDID to support auto rates selection 4399 * across HT/VHT and for multiple VHT MCS support. 4400 */ 4401 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) { 4402 ath12k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 4403 band); 4404 } else { 4405 /* If the peer is non-VHT or no fixed VHT rate 4406 * is provided in the new bitrate mask we set the 4407 * other rates using peer_assoc command. 4408 */ 4409 ath12k_peer_assoc_prepare(ar, arvif->vif, sta, 4410 &peer_arg, true); 4411 4412 err = ath12k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 4413 if (err) 4414 ath12k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 4415 sta->addr, arvif->vdev_id, err); 4416 4417 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) 4418 ath12k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 4419 sta->addr, arvif->vdev_id); 4420 } 4421 } 4422 err_rc_bw_changed: 4423 mutex_unlock(&ar->conf_mutex); 4424 } 4425 4426 static int ath12k_mac_inc_num_stations(struct ath12k_vif *arvif, 4427 struct ieee80211_sta *sta) 4428 { 4429 struct ath12k *ar = arvif->ar; 4430 4431 lockdep_assert_held(&ar->conf_mutex); 4432 4433 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 4434 return 0; 4435 4436 if (ar->num_stations >= ar->max_num_stations) 4437 return -ENOBUFS; 4438 4439 ar->num_stations++; 4440 4441 return 0; 4442 } 4443 4444 static void ath12k_mac_dec_num_stations(struct ath12k_vif *arvif, 4445 struct ieee80211_sta *sta) 4446 { 4447 struct ath12k *ar = arvif->ar; 4448 4449 lockdep_assert_held(&ar->conf_mutex); 4450 4451 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 4452 return; 4453 4454 ar->num_stations--; 4455 } 4456 4457 static int ath12k_mac_station_add(struct ath12k *ar, 4458 struct ieee80211_vif *vif, 4459 struct ieee80211_sta *sta) 4460 { 4461 struct ath12k_base *ab = ar->ab; 4462 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 4463 struct ath12k_sta *arsta = ath12k_sta_to_arsta(sta); 4464 struct ath12k_wmi_peer_create_arg peer_param; 4465 int ret; 4466 4467 lockdep_assert_held(&ar->conf_mutex); 4468 4469 ret = ath12k_mac_inc_num_stations(arvif, sta); 4470 if (ret) { 4471 ath12k_warn(ab, "refusing to associate station: too many connected already (%d)\n", 4472 ar->max_num_stations); 4473 goto exit; 4474 } 4475 4476 arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL); 4477 if (!arsta->rx_stats) { 4478 ret = -ENOMEM; 4479 goto dec_num_station; 4480 } 4481 4482 peer_param.vdev_id = arvif->vdev_id; 4483 peer_param.peer_addr = sta->addr; 4484 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 4485 4486 ret = ath12k_peer_create(ar, arvif, sta, &peer_param); 4487 if (ret) { 4488 ath12k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n", 4489 sta->addr, arvif->vdev_id); 4490 goto free_peer; 4491 } 4492 4493 ath12k_dbg(ab, ATH12K_DBG_MAC, "Added peer: %pM for VDEV: %d\n", 4494 sta->addr, arvif->vdev_id); 4495 4496 if (ieee80211_vif_is_mesh(vif)) { 4497 ret = ath12k_wmi_set_peer_param(ar, sta->addr, 4498 arvif->vdev_id, 4499 WMI_PEER_USE_4ADDR, 1); 4500 if (ret) { 4501 ath12k_warn(ab, "failed to STA %pM 4addr capability: %d\n", 4502 sta->addr, ret); 4503 goto free_peer; 4504 } 4505 } 4506 4507 ret = ath12k_dp_peer_setup(ar, arvif->vdev_id, sta->addr); 4508 if (ret) { 4509 ath12k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n", 4510 sta->addr, arvif->vdev_id, ret); 4511 goto free_peer; 4512 } 4513 4514 if (ab->hw_params->vdev_start_delay && 4515 !arvif->is_started && 4516 arvif->vdev_type != WMI_VDEV_TYPE_AP) { 4517 ret = ath12k_start_vdev_delay(ar, arvif); 4518 if (ret) { 4519 ath12k_warn(ab, "failed to delay vdev start: %d\n", ret); 4520 goto free_peer; 4521 } 4522 } 4523 4524 return 0; 4525 4526 free_peer: 4527 ath12k_peer_delete(ar, arvif->vdev_id, sta->addr); 4528 dec_num_station: 4529 ath12k_mac_dec_num_stations(arvif, sta); 4530 exit: 4531 return ret; 4532 } 4533 4534 static u32 ath12k_mac_ieee80211_sta_bw_to_wmi(struct ath12k *ar, 4535 struct ieee80211_sta *sta) 4536 { 4537 u32 bw = WMI_PEER_CHWIDTH_20MHZ; 4538 4539 switch (sta->deflink.bandwidth) { 4540 case IEEE80211_STA_RX_BW_20: 4541 bw = WMI_PEER_CHWIDTH_20MHZ; 4542 break; 4543 case IEEE80211_STA_RX_BW_40: 4544 bw = WMI_PEER_CHWIDTH_40MHZ; 4545 break; 4546 case IEEE80211_STA_RX_BW_80: 4547 bw = WMI_PEER_CHWIDTH_80MHZ; 4548 break; 4549 case IEEE80211_STA_RX_BW_160: 4550 bw = WMI_PEER_CHWIDTH_160MHZ; 4551 break; 4552 case IEEE80211_STA_RX_BW_320: 4553 bw = WMI_PEER_CHWIDTH_320MHZ; 4554 break; 4555 default: 4556 ath12k_warn(ar->ab, "Invalid bandwidth %d in rc update for %pM\n", 4557 sta->deflink.bandwidth, sta->addr); 4558 bw = WMI_PEER_CHWIDTH_20MHZ; 4559 break; 4560 } 4561 4562 return bw; 4563 } 4564 4565 static int ath12k_mac_op_sta_state(struct ieee80211_hw *hw, 4566 struct ieee80211_vif *vif, 4567 struct ieee80211_sta *sta, 4568 enum ieee80211_sta_state old_state, 4569 enum ieee80211_sta_state new_state) 4570 { 4571 struct ath12k *ar; 4572 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 4573 struct ath12k_sta *arsta = ath12k_sta_to_arsta(sta); 4574 struct ath12k_peer *peer; 4575 int ret = 0; 4576 4577 /* cancel must be done outside the mutex to avoid deadlock */ 4578 if ((old_state == IEEE80211_STA_NONE && 4579 new_state == IEEE80211_STA_NOTEXIST)) 4580 cancel_work_sync(&arsta->update_wk); 4581 4582 ar = ath12k_get_ar_by_vif(hw, vif); 4583 if (!ar) { 4584 WARN_ON_ONCE(1); 4585 return -EINVAL; 4586 } 4587 4588 mutex_lock(&ar->conf_mutex); 4589 4590 if (old_state == IEEE80211_STA_NOTEXIST && 4591 new_state == IEEE80211_STA_NONE) { 4592 memset(arsta, 0, sizeof(*arsta)); 4593 arsta->arvif = arvif; 4594 INIT_WORK(&arsta->update_wk, ath12k_sta_rc_update_wk); 4595 4596 ret = ath12k_mac_station_add(ar, vif, sta); 4597 if (ret) 4598 ath12k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n", 4599 sta->addr, arvif->vdev_id); 4600 } else if ((old_state == IEEE80211_STA_NONE && 4601 new_state == IEEE80211_STA_NOTEXIST)) { 4602 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) { 4603 ath12k_bss_disassoc(ar, arvif); 4604 ret = ath12k_mac_vdev_stop(arvif); 4605 if (ret) 4606 ath12k_warn(ar->ab, "failed to stop vdev %i: %d\n", 4607 arvif->vdev_id, ret); 4608 } 4609 ath12k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr); 4610 4611 ret = ath12k_peer_delete(ar, arvif->vdev_id, sta->addr); 4612 if (ret) 4613 ath12k_warn(ar->ab, "Failed to delete peer: %pM for VDEV: %d\n", 4614 sta->addr, arvif->vdev_id); 4615 else 4616 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "Removed peer: %pM for VDEV: %d\n", 4617 sta->addr, arvif->vdev_id); 4618 4619 ath12k_mac_dec_num_stations(arvif, sta); 4620 spin_lock_bh(&ar->ab->base_lock); 4621 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4622 if (peer && peer->sta == sta) { 4623 ath12k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n", 4624 vif->addr, arvif->vdev_id); 4625 peer->sta = NULL; 4626 list_del(&peer->list); 4627 kfree(peer); 4628 ar->num_peers--; 4629 } 4630 spin_unlock_bh(&ar->ab->base_lock); 4631 4632 kfree(arsta->rx_stats); 4633 arsta->rx_stats = NULL; 4634 } else if (old_state == IEEE80211_STA_AUTH && 4635 new_state == IEEE80211_STA_ASSOC && 4636 (vif->type == NL80211_IFTYPE_AP || 4637 vif->type == NL80211_IFTYPE_MESH_POINT || 4638 vif->type == NL80211_IFTYPE_ADHOC)) { 4639 ret = ath12k_station_assoc(ar, vif, sta, false); 4640 if (ret) 4641 ath12k_warn(ar->ab, "Failed to associate station: %pM\n", 4642 sta->addr); 4643 4644 spin_lock_bh(&ar->data_lock); 4645 4646 arsta->bw = ath12k_mac_ieee80211_sta_bw_to_wmi(ar, sta); 4647 arsta->bw_prev = sta->deflink.bandwidth; 4648 4649 spin_unlock_bh(&ar->data_lock); 4650 } else if (old_state == IEEE80211_STA_ASSOC && 4651 new_state == IEEE80211_STA_AUTHORIZED) { 4652 spin_lock_bh(&ar->ab->base_lock); 4653 4654 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4655 if (peer) 4656 peer->is_authorized = true; 4657 4658 spin_unlock_bh(&ar->ab->base_lock); 4659 4660 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) { 4661 ret = ath12k_wmi_set_peer_param(ar, sta->addr, 4662 arvif->vdev_id, 4663 WMI_PEER_AUTHORIZE, 4664 1); 4665 if (ret) 4666 ath12k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n", 4667 sta->addr, arvif->vdev_id, ret); 4668 } 4669 } else if (old_state == IEEE80211_STA_AUTHORIZED && 4670 new_state == IEEE80211_STA_ASSOC) { 4671 spin_lock_bh(&ar->ab->base_lock); 4672 4673 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4674 if (peer) 4675 peer->is_authorized = false; 4676 4677 spin_unlock_bh(&ar->ab->base_lock); 4678 } else if (old_state == IEEE80211_STA_ASSOC && 4679 new_state == IEEE80211_STA_AUTH && 4680 (vif->type == NL80211_IFTYPE_AP || 4681 vif->type == NL80211_IFTYPE_MESH_POINT || 4682 vif->type == NL80211_IFTYPE_ADHOC)) { 4683 ret = ath12k_station_disassoc(ar, vif, sta); 4684 if (ret) 4685 ath12k_warn(ar->ab, "Failed to disassociate station: %pM\n", 4686 sta->addr); 4687 } 4688 4689 mutex_unlock(&ar->conf_mutex); 4690 4691 return ret; 4692 } 4693 4694 static int ath12k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw, 4695 struct ieee80211_vif *vif, 4696 struct ieee80211_sta *sta) 4697 { 4698 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 4699 struct ath12k *ar; 4700 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 4701 int ret; 4702 s16 txpwr; 4703 4704 if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) { 4705 txpwr = 0; 4706 } else { 4707 txpwr = sta->deflink.txpwr.power; 4708 if (!txpwr) 4709 return -EINVAL; 4710 } 4711 4712 if (txpwr > ATH12K_TX_POWER_MAX_VAL || txpwr < ATH12K_TX_POWER_MIN_VAL) 4713 return -EINVAL; 4714 4715 ar = ath12k_ah_to_ar(ah, 0); 4716 4717 mutex_lock(&ar->conf_mutex); 4718 4719 ret = ath12k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 4720 WMI_PEER_USE_FIXED_PWR, txpwr); 4721 if (ret) { 4722 ath12k_warn(ar->ab, "failed to set tx power for station ret: %d\n", 4723 ret); 4724 goto out; 4725 } 4726 4727 out: 4728 mutex_unlock(&ar->conf_mutex); 4729 return ret; 4730 } 4731 4732 static void ath12k_mac_op_sta_rc_update(struct ieee80211_hw *hw, 4733 struct ieee80211_vif *vif, 4734 struct ieee80211_sta *sta, 4735 u32 changed) 4736 { 4737 struct ath12k *ar; 4738 struct ath12k_sta *arsta = ath12k_sta_to_arsta(sta); 4739 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 4740 struct ath12k_peer *peer; 4741 u32 bw, smps; 4742 4743 ar = ath12k_get_ar_by_vif(hw, vif); 4744 if (!ar) { 4745 WARN_ON_ONCE(1); 4746 return; 4747 } 4748 4749 spin_lock_bh(&ar->ab->base_lock); 4750 4751 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 4752 if (!peer) { 4753 spin_unlock_bh(&ar->ab->base_lock); 4754 ath12k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n", 4755 sta->addr, arvif->vdev_id); 4756 return; 4757 } 4758 4759 spin_unlock_bh(&ar->ab->base_lock); 4760 4761 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 4762 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 4763 sta->addr, changed, sta->deflink.bandwidth, sta->deflink.rx_nss, 4764 sta->deflink.smps_mode); 4765 4766 spin_lock_bh(&ar->data_lock); 4767 4768 if (changed & IEEE80211_RC_BW_CHANGED) { 4769 bw = ath12k_mac_ieee80211_sta_bw_to_wmi(ar, sta); 4770 arsta->bw_prev = arsta->bw; 4771 arsta->bw = bw; 4772 } 4773 4774 if (changed & IEEE80211_RC_NSS_CHANGED) 4775 arsta->nss = sta->deflink.rx_nss; 4776 4777 if (changed & IEEE80211_RC_SMPS_CHANGED) { 4778 smps = WMI_PEER_SMPS_PS_NONE; 4779 4780 switch (sta->deflink.smps_mode) { 4781 case IEEE80211_SMPS_AUTOMATIC: 4782 case IEEE80211_SMPS_OFF: 4783 smps = WMI_PEER_SMPS_PS_NONE; 4784 break; 4785 case IEEE80211_SMPS_STATIC: 4786 smps = WMI_PEER_SMPS_STATIC; 4787 break; 4788 case IEEE80211_SMPS_DYNAMIC: 4789 smps = WMI_PEER_SMPS_DYNAMIC; 4790 break; 4791 default: 4792 ath12k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n", 4793 sta->deflink.smps_mode, sta->addr); 4794 smps = WMI_PEER_SMPS_PS_NONE; 4795 break; 4796 } 4797 4798 arsta->smps = smps; 4799 } 4800 4801 arsta->changed |= changed; 4802 4803 spin_unlock_bh(&ar->data_lock); 4804 4805 ieee80211_queue_work(hw, &arsta->update_wk); 4806 } 4807 4808 static int ath12k_conf_tx_uapsd(struct ath12k_vif *arvif, 4809 u16 ac, bool enable) 4810 { 4811 struct ath12k *ar = arvif->ar; 4812 u32 value; 4813 int ret; 4814 4815 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 4816 return 0; 4817 4818 switch (ac) { 4819 case IEEE80211_AC_VO: 4820 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 4821 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 4822 break; 4823 case IEEE80211_AC_VI: 4824 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 4825 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 4826 break; 4827 case IEEE80211_AC_BE: 4828 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 4829 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 4830 break; 4831 case IEEE80211_AC_BK: 4832 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 4833 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 4834 break; 4835 } 4836 4837 if (enable) 4838 arvif->u.sta.uapsd |= value; 4839 else 4840 arvif->u.sta.uapsd &= ~value; 4841 4842 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 4843 WMI_STA_PS_PARAM_UAPSD, 4844 arvif->u.sta.uapsd); 4845 if (ret) { 4846 ath12k_warn(ar->ab, "could not set uapsd params %d\n", ret); 4847 goto exit; 4848 } 4849 4850 if (arvif->u.sta.uapsd) 4851 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 4852 else 4853 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 4854 4855 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 4856 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 4857 value); 4858 if (ret) 4859 ath12k_warn(ar->ab, "could not set rx wake param %d\n", ret); 4860 4861 exit: 4862 return ret; 4863 } 4864 4865 static int ath12k_mac_conf_tx(struct ath12k_vif *arvif, 4866 unsigned int link_id, u16 ac, 4867 const struct ieee80211_tx_queue_params *params) 4868 { 4869 struct wmi_wmm_params_arg *p = NULL; 4870 struct ath12k *ar = arvif->ar; 4871 struct ath12k_base *ab = ar->ab; 4872 int ret; 4873 4874 lockdep_assert_held(&ar->conf_mutex); 4875 4876 switch (ac) { 4877 case IEEE80211_AC_VO: 4878 p = &arvif->wmm_params.ac_vo; 4879 break; 4880 case IEEE80211_AC_VI: 4881 p = &arvif->wmm_params.ac_vi; 4882 break; 4883 case IEEE80211_AC_BE: 4884 p = &arvif->wmm_params.ac_be; 4885 break; 4886 case IEEE80211_AC_BK: 4887 p = &arvif->wmm_params.ac_bk; 4888 break; 4889 } 4890 4891 if (WARN_ON(!p)) { 4892 ret = -EINVAL; 4893 goto exit; 4894 } 4895 4896 p->cwmin = params->cw_min; 4897 p->cwmax = params->cw_max; 4898 p->aifs = params->aifs; 4899 p->txop = params->txop; 4900 4901 ret = ath12k_wmi_send_wmm_update_cmd(ar, arvif->vdev_id, 4902 &arvif->wmm_params); 4903 if (ret) { 4904 ath12k_warn(ab, "pdev idx %d failed to set wmm params: %d\n", 4905 ar->pdev_idx, ret); 4906 goto exit; 4907 } 4908 4909 ret = ath12k_conf_tx_uapsd(arvif, ac, params->uapsd); 4910 if (ret) 4911 ath12k_warn(ab, "pdev idx %d failed to set sta uapsd: %d\n", 4912 ar->pdev_idx, ret); 4913 4914 exit: 4915 return ret; 4916 } 4917 4918 static int ath12k_mac_op_conf_tx(struct ieee80211_hw *hw, 4919 struct ieee80211_vif *vif, 4920 unsigned int link_id, u16 ac, 4921 const struct ieee80211_tx_queue_params *params) 4922 { 4923 struct ath12k *ar; 4924 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 4925 struct ath12k_vif_cache *cache = arvif->cache; 4926 int ret; 4927 4928 ar = ath12k_get_ar_by_vif(hw, vif); 4929 if (!ar) { 4930 /* cache the info and apply after vdev is created */ 4931 cache = ath12k_arvif_get_cache(arvif); 4932 if (!cache) 4933 return -ENOSPC; 4934 cache->tx_conf.changed = true; 4935 cache->tx_conf.ac = ac; 4936 cache->tx_conf.tx_queue_params = *params; 4937 return 0; 4938 } 4939 4940 mutex_lock(&ar->conf_mutex); 4941 ret = ath12k_mac_conf_tx(arvif, link_id, ac, params); 4942 mutex_unlock(&ar->conf_mutex); 4943 4944 return ret; 4945 } 4946 4947 static struct ieee80211_sta_ht_cap 4948 ath12k_create_ht_cap(struct ath12k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask) 4949 { 4950 int i; 4951 struct ieee80211_sta_ht_cap ht_cap = {0}; 4952 u32 ar_vht_cap = ar->pdev->cap.vht_cap; 4953 4954 if (!(ar_ht_cap & WMI_HT_CAP_ENABLED)) 4955 return ht_cap; 4956 4957 ht_cap.ht_supported = 1; 4958 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 4959 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE; 4960 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 4961 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 4962 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT; 4963 4964 if (ar_ht_cap & WMI_HT_CAP_HT20_SGI) 4965 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 4966 4967 if (ar_ht_cap & WMI_HT_CAP_HT40_SGI) 4968 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 4969 4970 if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) { 4971 u32 smps; 4972 4973 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 4974 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 4975 4976 ht_cap.cap |= smps; 4977 } 4978 4979 if (ar_ht_cap & WMI_HT_CAP_TX_STBC) 4980 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 4981 4982 if (ar_ht_cap & WMI_HT_CAP_RX_STBC) { 4983 u32 stbc; 4984 4985 stbc = ar_ht_cap; 4986 stbc &= WMI_HT_CAP_RX_STBC; 4987 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 4988 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 4989 stbc &= IEEE80211_HT_CAP_RX_STBC; 4990 4991 ht_cap.cap |= stbc; 4992 } 4993 4994 if (ar_ht_cap & WMI_HT_CAP_RX_LDPC) 4995 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 4996 4997 if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT) 4998 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 4999 5000 if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 5001 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 5002 5003 for (i = 0; i < ar->num_rx_chains; i++) { 5004 if (rate_cap_rx_chainmask & BIT(i)) 5005 ht_cap.mcs.rx_mask[i] = 0xFF; 5006 } 5007 5008 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 5009 5010 return ht_cap; 5011 } 5012 5013 static int ath12k_mac_set_txbf_conf(struct ath12k_vif *arvif) 5014 { 5015 u32 value = 0; 5016 struct ath12k *ar = arvif->ar; 5017 int nsts; 5018 int sound_dim; 5019 u32 vht_cap = ar->pdev->cap.vht_cap; 5020 u32 vdev_param = WMI_VDEV_PARAM_TXBF; 5021 5022 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) { 5023 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 5024 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 5025 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET); 5026 } 5027 5028 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) { 5029 sound_dim = vht_cap & 5030 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 5031 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 5032 if (sound_dim > (ar->num_tx_chains - 1)) 5033 sound_dim = ar->num_tx_chains - 1; 5034 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET); 5035 } 5036 5037 if (!value) 5038 return 0; 5039 5040 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) { 5041 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 5042 5043 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) && 5044 arvif->vdev_type == WMI_VDEV_TYPE_AP) 5045 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER; 5046 } 5047 5048 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) { 5049 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 5050 5051 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) && 5052 arvif->vdev_type == WMI_VDEV_TYPE_STA) 5053 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE; 5054 } 5055 5056 return ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5057 vdev_param, value); 5058 } 5059 5060 static void ath12k_set_vht_txbf_cap(struct ath12k *ar, u32 *vht_cap) 5061 { 5062 bool subfer, subfee; 5063 int sound_dim = 0; 5064 5065 subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)); 5066 subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)); 5067 5068 if (ar->num_tx_chains < 2) { 5069 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE); 5070 subfer = false; 5071 } 5072 5073 /* If SU Beaformer is not set, then disable MU Beamformer Capability */ 5074 if (!subfer) 5075 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE); 5076 5077 /* If SU Beaformee is not set, then disable MU Beamformee Capability */ 5078 if (!subfee) 5079 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE); 5080 5081 sound_dim = u32_get_bits(*vht_cap, 5082 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK); 5083 *vht_cap = u32_replace_bits(*vht_cap, 0, 5084 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK); 5085 5086 /* TODO: Need to check invalid STS and Sound_dim values set by FW? */ 5087 5088 /* Enable Sounding Dimension Field only if SU BF is enabled */ 5089 if (subfer) { 5090 if (sound_dim > (ar->num_tx_chains - 1)) 5091 sound_dim = ar->num_tx_chains - 1; 5092 5093 *vht_cap = u32_replace_bits(*vht_cap, sound_dim, 5094 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK); 5095 } 5096 5097 /* Use the STS advertised by FW unless SU Beamformee is not supported*/ 5098 if (!subfee) 5099 *vht_cap &= ~(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK); 5100 } 5101 5102 static struct ieee80211_sta_vht_cap 5103 ath12k_create_vht_cap(struct ath12k *ar, u32 rate_cap_tx_chainmask, 5104 u32 rate_cap_rx_chainmask) 5105 { 5106 struct ieee80211_sta_vht_cap vht_cap = {0}; 5107 u16 txmcs_map, rxmcs_map; 5108 int i; 5109 5110 vht_cap.vht_supported = 1; 5111 vht_cap.cap = ar->pdev->cap.vht_cap; 5112 5113 ath12k_set_vht_txbf_cap(ar, &vht_cap.cap); 5114 5115 /* TODO: Enable back VHT160 mode once association issues are fixed */ 5116 /* Disabling VHT160 and VHT80+80 modes */ 5117 vht_cap.cap &= ~IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK; 5118 vht_cap.cap &= ~IEEE80211_VHT_CAP_SHORT_GI_160; 5119 5120 rxmcs_map = 0; 5121 txmcs_map = 0; 5122 for (i = 0; i < 8; i++) { 5123 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i)) 5124 txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 5125 else 5126 txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 5127 5128 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i)) 5129 rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 5130 else 5131 rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 5132 } 5133 5134 if (rate_cap_tx_chainmask <= 1) 5135 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC; 5136 5137 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map); 5138 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map); 5139 5140 return vht_cap; 5141 } 5142 5143 static void ath12k_mac_setup_ht_vht_cap(struct ath12k *ar, 5144 struct ath12k_pdev_cap *cap, 5145 u32 *ht_cap_info) 5146 { 5147 struct ieee80211_supported_band *band; 5148 u32 rate_cap_tx_chainmask; 5149 u32 rate_cap_rx_chainmask; 5150 u32 ht_cap; 5151 5152 rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift; 5153 rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift; 5154 5155 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 5156 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 5157 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info; 5158 if (ht_cap_info) 5159 *ht_cap_info = ht_cap; 5160 band->ht_cap = ath12k_create_ht_cap(ar, ht_cap, 5161 rate_cap_rx_chainmask); 5162 } 5163 5164 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 5165 (ar->ab->hw_params->single_pdev_only || 5166 !ar->supports_6ghz)) { 5167 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 5168 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info; 5169 if (ht_cap_info) 5170 *ht_cap_info = ht_cap; 5171 band->ht_cap = ath12k_create_ht_cap(ar, ht_cap, 5172 rate_cap_rx_chainmask); 5173 band->vht_cap = ath12k_create_vht_cap(ar, rate_cap_tx_chainmask, 5174 rate_cap_rx_chainmask); 5175 } 5176 } 5177 5178 static int ath12k_check_chain_mask(struct ath12k *ar, u32 ant, bool is_tx_ant) 5179 { 5180 /* TODO: Check the request chainmask against the supported 5181 * chainmask table which is advertised in extented_service_ready event 5182 */ 5183 5184 return 0; 5185 } 5186 5187 static void ath12k_gen_ppe_thresh(struct ath12k_wmi_ppe_threshold_arg *fw_ppet, 5188 u8 *he_ppet) 5189 { 5190 int nss, ru; 5191 u8 bit = 7; 5192 5193 he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK; 5194 he_ppet[0] |= (fw_ppet->ru_bit_mask << 5195 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) & 5196 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK; 5197 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) { 5198 for (ru = 0; ru < 4; ru++) { 5199 u8 val; 5200 int i; 5201 5202 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0) 5203 continue; 5204 val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) & 5205 0x3f; 5206 val = ((val >> 3) & 0x7) | ((val & 0x7) << 3); 5207 for (i = 5; i >= 0; i--) { 5208 he_ppet[bit / 8] |= 5209 ((val >> i) & 0x1) << ((bit % 8)); 5210 bit++; 5211 } 5212 } 5213 } 5214 } 5215 5216 static void 5217 ath12k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem) 5218 { 5219 u8 m; 5220 5221 m = IEEE80211_HE_MAC_CAP0_TWT_RES | 5222 IEEE80211_HE_MAC_CAP0_TWT_REQ; 5223 he_cap_elem->mac_cap_info[0] &= ~m; 5224 5225 m = IEEE80211_HE_MAC_CAP2_TRS | 5226 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 5227 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 5228 he_cap_elem->mac_cap_info[2] &= ~m; 5229 5230 m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED | 5231 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 5232 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 5233 he_cap_elem->mac_cap_info[3] &= ~m; 5234 5235 m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG | 5236 IEEE80211_HE_MAC_CAP4_BQR; 5237 he_cap_elem->mac_cap_info[4] &= ~m; 5238 5239 m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION | 5240 IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU | 5241 IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING | 5242 IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX; 5243 he_cap_elem->mac_cap_info[5] &= ~m; 5244 5245 m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO | 5246 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO; 5247 he_cap_elem->phy_cap_info[2] &= ~m; 5248 5249 m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU | 5250 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK | 5251 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK; 5252 he_cap_elem->phy_cap_info[3] &= ~m; 5253 5254 m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER; 5255 he_cap_elem->phy_cap_info[4] &= ~m; 5256 5257 m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK; 5258 he_cap_elem->phy_cap_info[5] &= ~m; 5259 5260 m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU | 5261 IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB | 5262 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB | 5263 IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO; 5264 he_cap_elem->phy_cap_info[6] &= ~m; 5265 5266 m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR | 5267 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP | 5268 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ | 5269 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ; 5270 he_cap_elem->phy_cap_info[7] &= ~m; 5271 5272 m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI | 5273 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G | 5274 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU | 5275 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU; 5276 he_cap_elem->phy_cap_info[8] &= ~m; 5277 5278 m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM | 5279 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK | 5280 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU | 5281 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU | 5282 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB | 5283 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB; 5284 he_cap_elem->phy_cap_info[9] &= ~m; 5285 } 5286 5287 static __le16 ath12k_mac_setup_he_6ghz_cap(struct ath12k_pdev_cap *pcap, 5288 struct ath12k_band_cap *bcap) 5289 { 5290 u8 val; 5291 5292 bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE; 5293 if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 5294 bcap->he_6ghz_capa |= 5295 u32_encode_bits(WLAN_HT_CAP_SM_PS_DYNAMIC, 5296 IEEE80211_HE_6GHZ_CAP_SM_PS); 5297 else 5298 bcap->he_6ghz_capa |= 5299 u32_encode_bits(WLAN_HT_CAP_SM_PS_DISABLED, 5300 IEEE80211_HE_6GHZ_CAP_SM_PS); 5301 val = u32_get_bits(pcap->vht_cap, 5302 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK); 5303 bcap->he_6ghz_capa |= 5304 u32_encode_bits(val, IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP); 5305 val = u32_get_bits(pcap->vht_cap, 5306 IEEE80211_VHT_CAP_MAX_MPDU_MASK); 5307 bcap->he_6ghz_capa |= 5308 u32_encode_bits(val, IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN); 5309 if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN) 5310 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS; 5311 if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN) 5312 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS; 5313 5314 return cpu_to_le16(bcap->he_6ghz_capa); 5315 } 5316 5317 static void ath12k_mac_copy_he_cap(struct ath12k_band_cap *band_cap, 5318 int iftype, u8 num_tx_chains, 5319 struct ieee80211_sta_he_cap *he_cap) 5320 { 5321 struct ieee80211_he_cap_elem *he_cap_elem = &he_cap->he_cap_elem; 5322 struct ieee80211_he_mcs_nss_supp *mcs_nss = &he_cap->he_mcs_nss_supp; 5323 5324 he_cap->has_he = true; 5325 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info, 5326 sizeof(he_cap_elem->mac_cap_info)); 5327 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info, 5328 sizeof(he_cap_elem->phy_cap_info)); 5329 5330 he_cap_elem->mac_cap_info[1] &= 5331 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK; 5332 5333 he_cap_elem->phy_cap_info[5] &= 5334 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK; 5335 he_cap_elem->phy_cap_info[5] &= 5336 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_MASK; 5337 he_cap_elem->phy_cap_info[5] |= num_tx_chains - 1; 5338 5339 switch (iftype) { 5340 case NL80211_IFTYPE_AP: 5341 he_cap_elem->phy_cap_info[3] &= 5342 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK; 5343 he_cap_elem->phy_cap_info[9] |= 5344 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU; 5345 break; 5346 case NL80211_IFTYPE_STATION: 5347 he_cap_elem->mac_cap_info[0] &= ~IEEE80211_HE_MAC_CAP0_TWT_RES; 5348 he_cap_elem->mac_cap_info[0] |= IEEE80211_HE_MAC_CAP0_TWT_REQ; 5349 he_cap_elem->phy_cap_info[9] |= 5350 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU; 5351 break; 5352 case NL80211_IFTYPE_MESH_POINT: 5353 ath12k_mac_filter_he_cap_mesh(he_cap_elem); 5354 break; 5355 } 5356 5357 mcs_nss->rx_mcs_80 = cpu_to_le16(band_cap->he_mcs & 0xffff); 5358 mcs_nss->tx_mcs_80 = cpu_to_le16(band_cap->he_mcs & 0xffff); 5359 mcs_nss->rx_mcs_160 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5360 mcs_nss->tx_mcs_160 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5361 mcs_nss->rx_mcs_80p80 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5362 mcs_nss->tx_mcs_80p80 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 5363 5364 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres)); 5365 if (he_cap_elem->phy_cap_info[6] & 5366 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) 5367 ath12k_gen_ppe_thresh(&band_cap->he_ppet, he_cap->ppe_thres); 5368 } 5369 5370 static void 5371 ath12k_mac_copy_eht_mcs_nss(struct ath12k_band_cap *band_cap, 5372 struct ieee80211_eht_mcs_nss_supp *mcs_nss, 5373 const struct ieee80211_he_cap_elem *he_cap, 5374 const struct ieee80211_eht_cap_elem_fixed *eht_cap) 5375 { 5376 if ((he_cap->phy_cap_info[0] & 5377 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G | 5378 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G | 5379 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G | 5380 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)) == 0) 5381 memcpy(&mcs_nss->only_20mhz, &band_cap->eht_mcs_20_only, 5382 sizeof(struct ieee80211_eht_mcs_nss_supp_20mhz_only)); 5383 5384 if (he_cap->phy_cap_info[0] & 5385 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G | 5386 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G)) 5387 memcpy(&mcs_nss->bw._80, &band_cap->eht_mcs_80, 5388 sizeof(struct ieee80211_eht_mcs_nss_supp_bw)); 5389 5390 if (he_cap->phy_cap_info[0] & 5391 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) 5392 memcpy(&mcs_nss->bw._160, &band_cap->eht_mcs_160, 5393 sizeof(struct ieee80211_eht_mcs_nss_supp_bw)); 5394 5395 if (eht_cap->phy_cap_info[0] & IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ) 5396 memcpy(&mcs_nss->bw._320, &band_cap->eht_mcs_320, 5397 sizeof(struct ieee80211_eht_mcs_nss_supp_bw)); 5398 } 5399 5400 static void ath12k_mac_copy_eht_ppe_thresh(struct ath12k_wmi_ppe_threshold_arg *fw_ppet, 5401 struct ieee80211_sta_eht_cap *cap) 5402 { 5403 u16 bit = IEEE80211_EHT_PPE_THRES_INFO_HEADER_SIZE; 5404 u8 i, nss, ru, ppet_bit_len_per_ru = IEEE80211_EHT_PPE_THRES_INFO_PPET_SIZE * 2; 5405 5406 u8p_replace_bits(&cap->eht_ppe_thres[0], fw_ppet->numss_m1, 5407 IEEE80211_EHT_PPE_THRES_NSS_MASK); 5408 5409 u16p_replace_bits((u16 *)&cap->eht_ppe_thres[0], fw_ppet->ru_bit_mask, 5410 IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK); 5411 5412 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) { 5413 for (ru = 0; 5414 ru < hweight16(IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK); 5415 ru++) { 5416 u32 val = 0; 5417 5418 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0) 5419 continue; 5420 5421 u32p_replace_bits(&val, fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> 5422 (ru * ppet_bit_len_per_ru), 5423 GENMASK(ppet_bit_len_per_ru - 1, 0)); 5424 5425 for (i = 0; i < ppet_bit_len_per_ru; i++) { 5426 cap->eht_ppe_thres[bit / 8] |= 5427 (((val >> i) & 0x1) << ((bit % 8))); 5428 bit++; 5429 } 5430 } 5431 } 5432 } 5433 5434 static void 5435 ath12k_mac_filter_eht_cap_mesh(struct ieee80211_eht_cap_elem_fixed 5436 *eht_cap_elem) 5437 { 5438 u8 m; 5439 5440 m = IEEE80211_EHT_MAC_CAP0_EPCS_PRIO_ACCESS; 5441 eht_cap_elem->mac_cap_info[0] &= ~m; 5442 5443 m = IEEE80211_EHT_PHY_CAP0_PARTIAL_BW_UL_MU_MIMO; 5444 eht_cap_elem->phy_cap_info[0] &= ~m; 5445 5446 m = IEEE80211_EHT_PHY_CAP3_NG_16_MU_FEEDBACK | 5447 IEEE80211_EHT_PHY_CAP3_CODEBOOK_7_5_MU_FDBK | 5448 IEEE80211_EHT_PHY_CAP3_TRIG_MU_BF_PART_BW_FDBK | 5449 IEEE80211_EHT_PHY_CAP3_TRIG_CQI_FDBK; 5450 eht_cap_elem->phy_cap_info[3] &= ~m; 5451 5452 m = IEEE80211_EHT_PHY_CAP4_PART_BW_DL_MU_MIMO | 5453 IEEE80211_EHT_PHY_CAP4_PSR_SR_SUPP | 5454 IEEE80211_EHT_PHY_CAP4_POWER_BOOST_FACT_SUPP | 5455 IEEE80211_EHT_PHY_CAP4_EHT_MU_PPDU_4_EHT_LTF_08_GI; 5456 eht_cap_elem->phy_cap_info[4] &= ~m; 5457 5458 m = IEEE80211_EHT_PHY_CAP5_NON_TRIG_CQI_FEEDBACK | 5459 IEEE80211_EHT_PHY_CAP5_TX_LESS_242_TONE_RU_SUPP | 5460 IEEE80211_EHT_PHY_CAP5_RX_LESS_242_TONE_RU_SUPP | 5461 IEEE80211_EHT_PHY_CAP5_MAX_NUM_SUPP_EHT_LTF_MASK; 5462 eht_cap_elem->phy_cap_info[5] &= ~m; 5463 5464 m = IEEE80211_EHT_PHY_CAP6_MAX_NUM_SUPP_EHT_LTF_MASK; 5465 eht_cap_elem->phy_cap_info[6] &= ~m; 5466 5467 m = IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_80MHZ | 5468 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_160MHZ | 5469 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_320MHZ | 5470 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_80MHZ | 5471 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_160MHZ | 5472 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_320MHZ; 5473 eht_cap_elem->phy_cap_info[7] &= ~m; 5474 } 5475 5476 static void ath12k_mac_copy_eht_cap(struct ath12k *ar, 5477 struct ath12k_band_cap *band_cap, 5478 struct ieee80211_he_cap_elem *he_cap_elem, 5479 int iftype, 5480 struct ieee80211_sta_eht_cap *eht_cap) 5481 { 5482 struct ieee80211_eht_cap_elem_fixed *eht_cap_elem = &eht_cap->eht_cap_elem; 5483 5484 memset(eht_cap, 0, sizeof(struct ieee80211_sta_eht_cap)); 5485 5486 if (!(test_bit(WMI_TLV_SERVICE_11BE, ar->ab->wmi_ab.svc_map))) 5487 return; 5488 5489 eht_cap->has_eht = true; 5490 memcpy(eht_cap_elem->mac_cap_info, band_cap->eht_cap_mac_info, 5491 sizeof(eht_cap_elem->mac_cap_info)); 5492 memcpy(eht_cap_elem->phy_cap_info, band_cap->eht_cap_phy_info, 5493 sizeof(eht_cap_elem->phy_cap_info)); 5494 5495 switch (iftype) { 5496 case NL80211_IFTYPE_AP: 5497 eht_cap_elem->phy_cap_info[0] &= 5498 ~IEEE80211_EHT_PHY_CAP0_242_TONE_RU_GT20MHZ; 5499 eht_cap_elem->phy_cap_info[4] &= 5500 ~IEEE80211_EHT_PHY_CAP4_PART_BW_DL_MU_MIMO; 5501 eht_cap_elem->phy_cap_info[5] &= 5502 ~IEEE80211_EHT_PHY_CAP5_TX_LESS_242_TONE_RU_SUPP; 5503 break; 5504 case NL80211_IFTYPE_STATION: 5505 eht_cap_elem->phy_cap_info[7] &= 5506 ~(IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_80MHZ | 5507 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_160MHZ | 5508 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_320MHZ); 5509 eht_cap_elem->phy_cap_info[7] &= 5510 ~(IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_80MHZ | 5511 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_160MHZ | 5512 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_320MHZ); 5513 break; 5514 case NL80211_IFTYPE_MESH_POINT: 5515 ath12k_mac_filter_eht_cap_mesh(eht_cap_elem); 5516 break; 5517 default: 5518 break; 5519 } 5520 5521 ath12k_mac_copy_eht_mcs_nss(band_cap, &eht_cap->eht_mcs_nss_supp, 5522 he_cap_elem, eht_cap_elem); 5523 5524 if (eht_cap_elem->phy_cap_info[5] & 5525 IEEE80211_EHT_PHY_CAP5_PPE_THRESHOLD_PRESENT) 5526 ath12k_mac_copy_eht_ppe_thresh(&band_cap->eht_ppet, eht_cap); 5527 } 5528 5529 static int ath12k_mac_copy_sband_iftype_data(struct ath12k *ar, 5530 struct ath12k_pdev_cap *cap, 5531 struct ieee80211_sband_iftype_data *data, 5532 int band) 5533 { 5534 struct ath12k_band_cap *band_cap = &cap->band[band]; 5535 int i, idx = 0; 5536 5537 for (i = 0; i < NUM_NL80211_IFTYPES; i++) { 5538 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap; 5539 5540 switch (i) { 5541 case NL80211_IFTYPE_STATION: 5542 case NL80211_IFTYPE_AP: 5543 case NL80211_IFTYPE_MESH_POINT: 5544 break; 5545 5546 default: 5547 continue; 5548 } 5549 5550 data[idx].types_mask = BIT(i); 5551 5552 ath12k_mac_copy_he_cap(band_cap, i, ar->num_tx_chains, he_cap); 5553 if (band == NL80211_BAND_6GHZ) { 5554 data[idx].he_6ghz_capa.capa = 5555 ath12k_mac_setup_he_6ghz_cap(cap, band_cap); 5556 } 5557 ath12k_mac_copy_eht_cap(ar, band_cap, &he_cap->he_cap_elem, i, 5558 &data[idx].eht_cap); 5559 idx++; 5560 } 5561 5562 return idx; 5563 } 5564 5565 static void ath12k_mac_setup_sband_iftype_data(struct ath12k *ar, 5566 struct ath12k_pdev_cap *cap) 5567 { 5568 struct ieee80211_supported_band *sband; 5569 enum nl80211_band band; 5570 int count; 5571 5572 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 5573 band = NL80211_BAND_2GHZ; 5574 count = ath12k_mac_copy_sband_iftype_data(ar, cap, 5575 ar->mac.iftype[band], 5576 band); 5577 sband = &ar->mac.sbands[band]; 5578 _ieee80211_set_sband_iftype_data(sband, ar->mac.iftype[band], 5579 count); 5580 } 5581 5582 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) { 5583 band = NL80211_BAND_5GHZ; 5584 count = ath12k_mac_copy_sband_iftype_data(ar, cap, 5585 ar->mac.iftype[band], 5586 band); 5587 sband = &ar->mac.sbands[band]; 5588 _ieee80211_set_sband_iftype_data(sband, ar->mac.iftype[band], 5589 count); 5590 } 5591 5592 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 5593 ar->supports_6ghz) { 5594 band = NL80211_BAND_6GHZ; 5595 count = ath12k_mac_copy_sband_iftype_data(ar, cap, 5596 ar->mac.iftype[band], 5597 band); 5598 sband = &ar->mac.sbands[band]; 5599 _ieee80211_set_sband_iftype_data(sband, ar->mac.iftype[band], 5600 count); 5601 } 5602 } 5603 5604 static int __ath12k_set_antenna(struct ath12k *ar, u32 tx_ant, u32 rx_ant) 5605 { 5606 struct ath12k_hw *ah = ath12k_ar_to_ah(ar); 5607 int ret; 5608 5609 lockdep_assert_held(&ar->conf_mutex); 5610 5611 if (ath12k_check_chain_mask(ar, tx_ant, true)) 5612 return -EINVAL; 5613 5614 if (ath12k_check_chain_mask(ar, rx_ant, false)) 5615 return -EINVAL; 5616 5617 /* Since we advertised the max cap of all radios combined during wiphy 5618 * registration, ensure we don't set the antenna config higher than the 5619 * limits 5620 */ 5621 tx_ant = min_t(u32, tx_ant, ar->pdev->cap.tx_chain_mask); 5622 rx_ant = min_t(u32, rx_ant, ar->pdev->cap.rx_chain_mask); 5623 5624 ar->cfg_tx_chainmask = tx_ant; 5625 ar->cfg_rx_chainmask = rx_ant; 5626 5627 if (ah->state != ATH12K_HW_STATE_ON && 5628 ah->state != ATH12K_HW_STATE_RESTARTED) 5629 return 0; 5630 5631 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK, 5632 tx_ant, ar->pdev->pdev_id); 5633 if (ret) { 5634 ath12k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n", 5635 ret, tx_ant); 5636 return ret; 5637 } 5638 5639 ar->num_tx_chains = hweight32(tx_ant); 5640 5641 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK, 5642 rx_ant, ar->pdev->pdev_id); 5643 if (ret) { 5644 ath12k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n", 5645 ret, rx_ant); 5646 return ret; 5647 } 5648 5649 ar->num_rx_chains = hweight32(rx_ant); 5650 5651 /* Reload HT/VHT/HE capability */ 5652 ath12k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL); 5653 ath12k_mac_setup_sband_iftype_data(ar, &ar->pdev->cap); 5654 5655 return 0; 5656 } 5657 5658 static void ath12k_mgmt_over_wmi_tx_drop(struct ath12k *ar, struct sk_buff *skb) 5659 { 5660 int num_mgmt; 5661 5662 ieee80211_free_txskb(ath12k_ar_to_hw(ar), skb); 5663 5664 num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx); 5665 5666 if (num_mgmt < 0) 5667 WARN_ON_ONCE(1); 5668 5669 if (!num_mgmt) 5670 wake_up(&ar->txmgmt_empty_waitq); 5671 } 5672 5673 int ath12k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx) 5674 { 5675 struct sk_buff *msdu = skb; 5676 struct ieee80211_tx_info *info; 5677 struct ath12k *ar = ctx; 5678 struct ath12k_base *ab = ar->ab; 5679 5680 spin_lock_bh(&ar->txmgmt_idr_lock); 5681 idr_remove(&ar->txmgmt_idr, buf_id); 5682 spin_unlock_bh(&ar->txmgmt_idr_lock); 5683 dma_unmap_single(ab->dev, ATH12K_SKB_CB(msdu)->paddr, msdu->len, 5684 DMA_TO_DEVICE); 5685 5686 info = IEEE80211_SKB_CB(msdu); 5687 memset(&info->status, 0, sizeof(info->status)); 5688 5689 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 5690 5691 return 0; 5692 } 5693 5694 static int ath12k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx) 5695 { 5696 struct ieee80211_vif *vif = ctx; 5697 struct ath12k_skb_cb *skb_cb = ATH12K_SKB_CB(skb); 5698 struct sk_buff *msdu = skb; 5699 struct ath12k *ar = skb_cb->ar; 5700 struct ath12k_base *ab = ar->ab; 5701 5702 if (skb_cb->vif == vif) { 5703 spin_lock_bh(&ar->txmgmt_idr_lock); 5704 idr_remove(&ar->txmgmt_idr, buf_id); 5705 spin_unlock_bh(&ar->txmgmt_idr_lock); 5706 dma_unmap_single(ab->dev, skb_cb->paddr, msdu->len, 5707 DMA_TO_DEVICE); 5708 } 5709 5710 return 0; 5711 } 5712 5713 static int ath12k_mac_mgmt_tx_wmi(struct ath12k *ar, struct ath12k_vif *arvif, 5714 struct sk_buff *skb) 5715 { 5716 struct ath12k_base *ab = ar->ab; 5717 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 5718 struct ieee80211_tx_info *info; 5719 dma_addr_t paddr; 5720 int buf_id; 5721 int ret; 5722 5723 ATH12K_SKB_CB(skb)->ar = ar; 5724 spin_lock_bh(&ar->txmgmt_idr_lock); 5725 buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0, 5726 ATH12K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC); 5727 spin_unlock_bh(&ar->txmgmt_idr_lock); 5728 if (buf_id < 0) 5729 return -ENOSPC; 5730 5731 info = IEEE80211_SKB_CB(skb); 5732 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) { 5733 if ((ieee80211_is_action(hdr->frame_control) || 5734 ieee80211_is_deauth(hdr->frame_control) || 5735 ieee80211_is_disassoc(hdr->frame_control)) && 5736 ieee80211_has_protected(hdr->frame_control)) { 5737 skb_put(skb, IEEE80211_CCMP_MIC_LEN); 5738 } 5739 } 5740 5741 paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE); 5742 if (dma_mapping_error(ab->dev, paddr)) { 5743 ath12k_warn(ab, "failed to DMA map mgmt Tx buffer\n"); 5744 ret = -EIO; 5745 goto err_free_idr; 5746 } 5747 5748 ATH12K_SKB_CB(skb)->paddr = paddr; 5749 5750 ret = ath12k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb); 5751 if (ret) { 5752 ath12k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret); 5753 goto err_unmap_buf; 5754 } 5755 5756 return 0; 5757 5758 err_unmap_buf: 5759 dma_unmap_single(ab->dev, ATH12K_SKB_CB(skb)->paddr, 5760 skb->len, DMA_TO_DEVICE); 5761 err_free_idr: 5762 spin_lock_bh(&ar->txmgmt_idr_lock); 5763 idr_remove(&ar->txmgmt_idr, buf_id); 5764 spin_unlock_bh(&ar->txmgmt_idr_lock); 5765 5766 return ret; 5767 } 5768 5769 static void ath12k_mgmt_over_wmi_tx_purge(struct ath12k *ar) 5770 { 5771 struct sk_buff *skb; 5772 5773 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) 5774 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 5775 } 5776 5777 static void ath12k_mgmt_over_wmi_tx_work(struct work_struct *work) 5778 { 5779 struct ath12k *ar = container_of(work, struct ath12k, wmi_mgmt_tx_work); 5780 struct ath12k_skb_cb *skb_cb; 5781 struct ath12k_vif *arvif; 5782 struct sk_buff *skb; 5783 int ret; 5784 5785 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) { 5786 skb_cb = ATH12K_SKB_CB(skb); 5787 if (!skb_cb->vif) { 5788 ath12k_warn(ar->ab, "no vif found for mgmt frame\n"); 5789 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 5790 continue; 5791 } 5792 5793 arvif = ath12k_vif_to_arvif(skb_cb->vif); 5794 5795 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id)) { 5796 ret = ath12k_mac_mgmt_tx_wmi(ar, arvif, skb); 5797 if (ret) { 5798 ath12k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n", 5799 arvif->vdev_id, ret); 5800 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 5801 } 5802 } else { 5803 ath12k_warn(ar->ab, 5804 "dropping mgmt frame for vdev %d, is_started %d\n", 5805 arvif->vdev_id, 5806 arvif->is_started); 5807 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 5808 } 5809 } 5810 } 5811 5812 static int ath12k_mac_mgmt_tx(struct ath12k *ar, struct sk_buff *skb, 5813 bool is_prb_rsp) 5814 { 5815 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue; 5816 5817 if (test_bit(ATH12K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags)) 5818 return -ESHUTDOWN; 5819 5820 /* Drop probe response packets when the pending management tx 5821 * count has reached a certain threshold, so as to prioritize 5822 * other mgmt packets like auth and assoc to be sent on time 5823 * for establishing successful connections. 5824 */ 5825 if (is_prb_rsp && 5826 atomic_read(&ar->num_pending_mgmt_tx) > ATH12K_PRB_RSP_DROP_THRESHOLD) { 5827 ath12k_warn(ar->ab, 5828 "dropping probe response as pending queue is almost full\n"); 5829 return -ENOSPC; 5830 } 5831 5832 if (skb_queue_len_lockless(q) >= ATH12K_TX_MGMT_NUM_PENDING_MAX) { 5833 ath12k_warn(ar->ab, "mgmt tx queue is full\n"); 5834 return -ENOSPC; 5835 } 5836 5837 skb_queue_tail(q, skb); 5838 atomic_inc(&ar->num_pending_mgmt_tx); 5839 ieee80211_queue_work(ath12k_ar_to_hw(ar), &ar->wmi_mgmt_tx_work); 5840 5841 return 0; 5842 } 5843 5844 static void ath12k_mac_add_p2p_noa_ie(struct ath12k *ar, 5845 struct ieee80211_vif *vif, 5846 struct sk_buff *skb, 5847 bool is_prb_rsp) 5848 { 5849 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 5850 5851 if (likely(!is_prb_rsp)) 5852 return; 5853 5854 spin_lock_bh(&ar->data_lock); 5855 5856 if (arvif->u.ap.noa_data && 5857 !pskb_expand_head(skb, 0, arvif->u.ap.noa_len, 5858 GFP_ATOMIC)) 5859 skb_put_data(skb, arvif->u.ap.noa_data, 5860 arvif->u.ap.noa_len); 5861 5862 spin_unlock_bh(&ar->data_lock); 5863 } 5864 5865 static void ath12k_mac_op_tx(struct ieee80211_hw *hw, 5866 struct ieee80211_tx_control *control, 5867 struct sk_buff *skb) 5868 { 5869 struct ath12k_skb_cb *skb_cb = ATH12K_SKB_CB(skb); 5870 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 5871 struct ieee80211_vif *vif = info->control.vif; 5872 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 5873 struct ath12k *ar = arvif->ar; 5874 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 5875 struct ieee80211_key_conf *key = info->control.hw_key; 5876 u32 info_flags = info->flags; 5877 bool is_prb_rsp; 5878 int ret; 5879 5880 memset(skb_cb, 0, sizeof(*skb_cb)); 5881 skb_cb->vif = vif; 5882 5883 if (key) { 5884 skb_cb->cipher = key->cipher; 5885 skb_cb->flags |= ATH12K_SKB_CIPHER_SET; 5886 } 5887 5888 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control); 5889 5890 if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) { 5891 skb_cb->flags |= ATH12K_SKB_HW_80211_ENCAP; 5892 } else if (ieee80211_is_mgmt(hdr->frame_control)) { 5893 ret = ath12k_mac_mgmt_tx(ar, skb, is_prb_rsp); 5894 if (ret) { 5895 ath12k_warn(ar->ab, "failed to queue management frame %d\n", 5896 ret); 5897 ieee80211_free_txskb(hw, skb); 5898 } 5899 return; 5900 } 5901 5902 /* This is case only for P2P_GO */ 5903 if (vif->type == NL80211_IFTYPE_AP && vif->p2p) 5904 ath12k_mac_add_p2p_noa_ie(ar, vif, skb, is_prb_rsp); 5905 5906 ret = ath12k_dp_tx(ar, arvif, skb); 5907 if (ret) { 5908 ath12k_warn(ar->ab, "failed to transmit frame %d\n", ret); 5909 ieee80211_free_txskb(hw, skb); 5910 } 5911 } 5912 5913 void ath12k_mac_drain_tx(struct ath12k *ar) 5914 { 5915 /* make sure rcu-protected mac80211 tx path itself is drained */ 5916 synchronize_net(); 5917 5918 cancel_work_sync(&ar->wmi_mgmt_tx_work); 5919 ath12k_mgmt_over_wmi_tx_purge(ar); 5920 } 5921 5922 static int ath12k_mac_config_mon_status_default(struct ath12k *ar, bool enable) 5923 { 5924 return -EOPNOTSUPP; 5925 /* TODO: Need to support new monitor mode */ 5926 } 5927 5928 static int ath12k_mac_start(struct ath12k *ar) 5929 { 5930 struct ath12k_hw *ah = ar->ah; 5931 struct ath12k_base *ab = ar->ab; 5932 struct ath12k_pdev *pdev = ar->pdev; 5933 int ret; 5934 5935 lockdep_assert_held(&ah->hw_mutex); 5936 5937 mutex_lock(&ar->conf_mutex); 5938 5939 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 5940 1, pdev->pdev_id); 5941 5942 if (ret) { 5943 ath12k_err(ab, "failed to enable PMF QOS: (%d\n", ret); 5944 goto err; 5945 } 5946 5947 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1, 5948 pdev->pdev_id); 5949 if (ret) { 5950 ath12k_err(ab, "failed to enable dynamic bw: %d\n", ret); 5951 goto err; 5952 } 5953 5954 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE, 5955 0, pdev->pdev_id); 5956 if (ret) { 5957 ath12k_err(ab, "failed to set ac override for ARP: %d\n", 5958 ret); 5959 goto err; 5960 } 5961 5962 ret = ath12k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id); 5963 if (ret) { 5964 ath12k_err(ab, "failed to offload radar detection: %d\n", 5965 ret); 5966 goto err; 5967 } 5968 5969 ret = ath12k_dp_tx_htt_h2t_ppdu_stats_req(ar, 5970 HTT_PPDU_STATS_TAG_DEFAULT); 5971 if (ret) { 5972 ath12k_err(ab, "failed to req ppdu stats: %d\n", ret); 5973 goto err; 5974 } 5975 5976 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE, 5977 1, pdev->pdev_id); 5978 5979 if (ret) { 5980 ath12k_err(ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret); 5981 goto err; 5982 } 5983 5984 __ath12k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask); 5985 5986 /* TODO: Do we need to enable ANI? */ 5987 5988 ath12k_reg_update_chan_list(ar); 5989 5990 ar->num_started_vdevs = 0; 5991 ar->num_created_vdevs = 0; 5992 ar->num_peers = 0; 5993 ar->allocated_vdev_map = 0; 5994 5995 /* Configure monitor status ring with default rx_filter to get rx status 5996 * such as rssi, rx_duration. 5997 */ 5998 ret = ath12k_mac_config_mon_status_default(ar, true); 5999 if (ret && (ret != -EOPNOTSUPP)) { 6000 ath12k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n", 6001 ret); 6002 goto err; 6003 } 6004 6005 if (ret == -EOPNOTSUPP) 6006 ath12k_dbg(ab, ATH12K_DBG_MAC, 6007 "monitor status config is not yet supported"); 6008 6009 /* Configure the hash seed for hash based reo dest ring selection */ 6010 ath12k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id); 6011 6012 /* allow device to enter IMPS */ 6013 if (ab->hw_params->idle_ps) { 6014 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG, 6015 1, pdev->pdev_id); 6016 if (ret) { 6017 ath12k_err(ab, "failed to enable idle ps: %d\n", ret); 6018 goto err; 6019 } 6020 } 6021 6022 mutex_unlock(&ar->conf_mutex); 6023 6024 rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx], 6025 &ab->pdevs[ar->pdev_idx]); 6026 6027 return 0; 6028 err: 6029 mutex_unlock(&ar->conf_mutex); 6030 6031 return ret; 6032 } 6033 6034 static void ath12k_drain_tx(struct ath12k_hw *ah) 6035 { 6036 struct ath12k *ar; 6037 int i; 6038 6039 for_each_ar(ah, ar, i) 6040 ath12k_mac_drain_tx(ar); 6041 } 6042 6043 static int ath12k_mac_op_start(struct ieee80211_hw *hw) 6044 { 6045 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 6046 struct ath12k *ar; 6047 int ret, i; 6048 6049 ath12k_drain_tx(ah); 6050 6051 guard(mutex)(&ah->hw_mutex); 6052 6053 switch (ah->state) { 6054 case ATH12K_HW_STATE_OFF: 6055 ah->state = ATH12K_HW_STATE_ON; 6056 break; 6057 case ATH12K_HW_STATE_RESTARTING: 6058 ah->state = ATH12K_HW_STATE_RESTARTED; 6059 break; 6060 case ATH12K_HW_STATE_RESTARTED: 6061 case ATH12K_HW_STATE_WEDGED: 6062 case ATH12K_HW_STATE_ON: 6063 ah->state = ATH12K_HW_STATE_OFF; 6064 6065 WARN_ON(1); 6066 return -EINVAL; 6067 } 6068 6069 for_each_ar(ah, ar, i) { 6070 ret = ath12k_mac_start(ar); 6071 if (ret) { 6072 ah->state = ATH12K_HW_STATE_OFF; 6073 6074 ath12k_err(ar->ab, "fail to start mac operations in pdev idx %d ret %d\n", 6075 ar->pdev_idx, ret); 6076 goto fail_start; 6077 } 6078 } 6079 6080 return 0; 6081 6082 fail_start: 6083 for (; i > 0; i--) { 6084 ar = ath12k_ah_to_ar(ah, i - 1); 6085 ath12k_mac_stop(ar); 6086 } 6087 6088 return ret; 6089 } 6090 6091 int ath12k_mac_rfkill_config(struct ath12k *ar) 6092 { 6093 struct ath12k_base *ab = ar->ab; 6094 u32 param; 6095 int ret; 6096 6097 if (ab->hw_params->rfkill_pin == 0) 6098 return -EOPNOTSUPP; 6099 6100 ath12k_dbg(ab, ATH12K_DBG_MAC, 6101 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d", 6102 ab->hw_params->rfkill_pin, ab->hw_params->rfkill_cfg, 6103 ab->hw_params->rfkill_on_level); 6104 6105 param = u32_encode_bits(ab->hw_params->rfkill_on_level, 6106 WMI_RFKILL_CFG_RADIO_LEVEL) | 6107 u32_encode_bits(ab->hw_params->rfkill_pin, 6108 WMI_RFKILL_CFG_GPIO_PIN_NUM) | 6109 u32_encode_bits(ab->hw_params->rfkill_cfg, 6110 WMI_RFKILL_CFG_PIN_AS_GPIO); 6111 6112 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_HW_RFKILL_CONFIG, 6113 param, ar->pdev->pdev_id); 6114 if (ret) { 6115 ath12k_warn(ab, 6116 "failed to set rfkill config 0x%x: %d\n", 6117 param, ret); 6118 return ret; 6119 } 6120 6121 return 0; 6122 } 6123 6124 int ath12k_mac_rfkill_enable_radio(struct ath12k *ar, bool enable) 6125 { 6126 enum wmi_rfkill_enable_radio param; 6127 int ret; 6128 6129 if (enable) 6130 param = WMI_RFKILL_ENABLE_RADIO_ON; 6131 else 6132 param = WMI_RFKILL_ENABLE_RADIO_OFF; 6133 6134 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac %d rfkill enable %d", 6135 ar->pdev_idx, param); 6136 6137 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RFKILL_ENABLE, 6138 param, ar->pdev->pdev_id); 6139 if (ret) { 6140 ath12k_warn(ar->ab, "failed to set rfkill enable param %d: %d\n", 6141 param, ret); 6142 return ret; 6143 } 6144 6145 return 0; 6146 } 6147 6148 static void ath12k_mac_stop(struct ath12k *ar) 6149 { 6150 struct ath12k_hw *ah = ar->ah; 6151 struct htt_ppdu_stats_info *ppdu_stats, *tmp; 6152 int ret; 6153 6154 lockdep_assert_held(&ah->hw_mutex); 6155 6156 mutex_lock(&ar->conf_mutex); 6157 ret = ath12k_mac_config_mon_status_default(ar, false); 6158 if (ret && (ret != -EOPNOTSUPP)) 6159 ath12k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n", 6160 ret); 6161 6162 clear_bit(ATH12K_CAC_RUNNING, &ar->dev_flags); 6163 mutex_unlock(&ar->conf_mutex); 6164 6165 cancel_delayed_work_sync(&ar->scan.timeout); 6166 cancel_work_sync(&ar->regd_update_work); 6167 cancel_work_sync(&ar->ab->rfkill_work); 6168 6169 spin_lock_bh(&ar->data_lock); 6170 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) { 6171 list_del(&ppdu_stats->list); 6172 kfree(ppdu_stats); 6173 } 6174 spin_unlock_bh(&ar->data_lock); 6175 6176 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL); 6177 6178 synchronize_rcu(); 6179 6180 atomic_set(&ar->num_pending_mgmt_tx, 0); 6181 } 6182 6183 static void ath12k_mac_op_stop(struct ieee80211_hw *hw, bool suspend) 6184 { 6185 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 6186 struct ath12k *ar; 6187 int i; 6188 6189 ath12k_drain_tx(ah); 6190 6191 mutex_lock(&ah->hw_mutex); 6192 6193 ah->state = ATH12K_HW_STATE_OFF; 6194 6195 for_each_ar(ah, ar, i) 6196 ath12k_mac_stop(ar); 6197 6198 mutex_unlock(&ah->hw_mutex); 6199 } 6200 6201 static u8 6202 ath12k_mac_get_vdev_stats_id(struct ath12k_vif *arvif) 6203 { 6204 struct ath12k_base *ab = arvif->ar->ab; 6205 u8 vdev_stats_id = 0; 6206 6207 do { 6208 if (ab->free_vdev_stats_id_map & (1LL << vdev_stats_id)) { 6209 vdev_stats_id++; 6210 if (vdev_stats_id >= ATH12K_MAX_VDEV_STATS_ID) { 6211 vdev_stats_id = ATH12K_INVAL_VDEV_STATS_ID; 6212 break; 6213 } 6214 } else { 6215 ab->free_vdev_stats_id_map |= (1LL << vdev_stats_id); 6216 break; 6217 } 6218 } while (vdev_stats_id); 6219 6220 arvif->vdev_stats_id = vdev_stats_id; 6221 return vdev_stats_id; 6222 } 6223 6224 static int ath12k_mac_setup_vdev_params_mbssid(struct ath12k_vif *arvif, 6225 u32 *flags, u32 *tx_vdev_id) 6226 { 6227 struct ieee80211_vif *tx_vif = arvif->vif->mbssid_tx_vif; 6228 struct ath12k *ar = arvif->ar; 6229 struct ath12k_vif *tx_arvif; 6230 6231 if (!tx_vif) 6232 return 0; 6233 6234 tx_arvif = ath12k_vif_to_arvif(tx_vif); 6235 6236 if (arvif->vif->bss_conf.nontransmitted) { 6237 if (ar->ah->hw->wiphy != ieee80211_vif_to_wdev(tx_vif)->wiphy) 6238 return -EINVAL; 6239 6240 *flags = WMI_VDEV_MBSSID_FLAGS_NON_TRANSMIT_AP; 6241 *tx_vdev_id = tx_arvif->vdev_id; 6242 } else if (tx_arvif == arvif) { 6243 *flags = WMI_VDEV_MBSSID_FLAGS_TRANSMIT_AP; 6244 } else { 6245 return -EINVAL; 6246 } 6247 6248 if (arvif->vif->bss_conf.ema_ap) 6249 *flags |= WMI_VDEV_MBSSID_FLAGS_EMA_MODE; 6250 6251 return 0; 6252 } 6253 6254 static int ath12k_mac_setup_vdev_create_arg(struct ath12k_vif *arvif, 6255 struct ath12k_wmi_vdev_create_arg *arg) 6256 { 6257 struct ath12k *ar = arvif->ar; 6258 struct ath12k_pdev *pdev = ar->pdev; 6259 int ret; 6260 6261 arg->if_id = arvif->vdev_id; 6262 arg->type = arvif->vdev_type; 6263 arg->subtype = arvif->vdev_subtype; 6264 arg->pdev_id = pdev->pdev_id; 6265 6266 arg->mbssid_flags = WMI_VDEV_MBSSID_FLAGS_NON_MBSSID_AP; 6267 arg->mbssid_tx_vdev_id = 0; 6268 if (!test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT, 6269 ar->ab->wmi_ab.svc_map)) { 6270 ret = ath12k_mac_setup_vdev_params_mbssid(arvif, 6271 &arg->mbssid_flags, 6272 &arg->mbssid_tx_vdev_id); 6273 if (ret) 6274 return ret; 6275 } 6276 6277 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) { 6278 arg->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains; 6279 arg->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains; 6280 } 6281 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) { 6282 arg->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains; 6283 arg->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains; 6284 } 6285 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP && 6286 ar->supports_6ghz) { 6287 arg->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains; 6288 arg->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains; 6289 } 6290 6291 arg->if_stats_id = ath12k_mac_get_vdev_stats_id(arvif); 6292 return 0; 6293 } 6294 6295 static u32 6296 ath12k_mac_prepare_he_mode(struct ath12k_pdev *pdev, u32 viftype) 6297 { 6298 struct ath12k_pdev_cap *pdev_cap = &pdev->cap; 6299 struct ath12k_band_cap *cap_band = NULL; 6300 u32 *hecap_phy_ptr = NULL; 6301 u32 hemode; 6302 6303 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) 6304 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ]; 6305 else 6306 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ]; 6307 6308 hecap_phy_ptr = &cap_band->he_cap_phy_info[0]; 6309 6310 hemode = u32_encode_bits(HE_SU_BFEE_ENABLE, HE_MODE_SU_TX_BFEE) | 6311 u32_encode_bits(HECAP_PHY_SUBFMR_GET(hecap_phy_ptr), 6312 HE_MODE_SU_TX_BFER) | 6313 u32_encode_bits(HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr), 6314 HE_MODE_UL_MUMIMO); 6315 6316 /* TODO: WDS and other modes */ 6317 if (viftype == NL80211_IFTYPE_AP) { 6318 hemode |= u32_encode_bits(HECAP_PHY_MUBFMR_GET(hecap_phy_ptr), 6319 HE_MODE_MU_TX_BFER) | 6320 u32_encode_bits(HE_DL_MUOFDMA_ENABLE, HE_MODE_DL_OFDMA) | 6321 u32_encode_bits(HE_UL_MUOFDMA_ENABLE, HE_MODE_UL_OFDMA); 6322 } else { 6323 hemode |= u32_encode_bits(HE_MU_BFEE_ENABLE, HE_MODE_MU_TX_BFEE); 6324 } 6325 6326 return hemode; 6327 } 6328 6329 static int ath12k_set_he_mu_sounding_mode(struct ath12k *ar, 6330 struct ath12k_vif *arvif) 6331 { 6332 u32 param_id, param_value; 6333 struct ath12k_base *ab = ar->ab; 6334 int ret; 6335 6336 param_id = WMI_VDEV_PARAM_SET_HEMU_MODE; 6337 param_value = ath12k_mac_prepare_he_mode(ar->pdev, arvif->vif->type); 6338 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6339 param_id, param_value); 6340 if (ret) { 6341 ath12k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n", 6342 arvif->vdev_id, ret, param_value); 6343 return ret; 6344 } 6345 param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE; 6346 param_value = 6347 u32_encode_bits(HE_VHT_SOUNDING_MODE_ENABLE, HE_VHT_SOUNDING_MODE) | 6348 u32_encode_bits(HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE, 6349 HE_TRIG_NONTRIG_SOUNDING_MODE); 6350 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6351 param_id, param_value); 6352 if (ret) { 6353 ath12k_warn(ab, "failed to set vdev %d HE MU mode: %d\n", 6354 arvif->vdev_id, ret); 6355 return ret; 6356 } 6357 return ret; 6358 } 6359 6360 static void ath12k_mac_update_vif_offload(struct ath12k_vif *arvif) 6361 { 6362 struct ieee80211_vif *vif = arvif->vif; 6363 struct ath12k *ar = arvif->ar; 6364 struct ath12k_base *ab = ar->ab; 6365 u32 param_id, param_value; 6366 int ret; 6367 6368 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE; 6369 if (vif->type != NL80211_IFTYPE_STATION && 6370 vif->type != NL80211_IFTYPE_AP) 6371 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED | 6372 IEEE80211_OFFLOAD_DECAP_ENABLED); 6373 6374 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED) 6375 arvif->tx_encap_type = ATH12K_HW_TXRX_ETHERNET; 6376 else if (test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) 6377 arvif->tx_encap_type = ATH12K_HW_TXRX_RAW; 6378 else 6379 arvif->tx_encap_type = ATH12K_HW_TXRX_NATIVE_WIFI; 6380 6381 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6382 param_id, arvif->tx_encap_type); 6383 if (ret) { 6384 ath12k_warn(ab, "failed to set vdev %d tx encap mode: %d\n", 6385 arvif->vdev_id, ret); 6386 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED; 6387 } 6388 6389 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE; 6390 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED) 6391 param_value = ATH12K_HW_TXRX_ETHERNET; 6392 else if (test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) 6393 param_value = ATH12K_HW_TXRX_RAW; 6394 else 6395 param_value = ATH12K_HW_TXRX_NATIVE_WIFI; 6396 6397 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6398 param_id, param_value); 6399 if (ret) { 6400 ath12k_warn(ab, "failed to set vdev %d rx decap mode: %d\n", 6401 arvif->vdev_id, ret); 6402 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED; 6403 } 6404 } 6405 6406 static void ath12k_mac_op_update_vif_offload(struct ieee80211_hw *hw, 6407 struct ieee80211_vif *vif) 6408 { 6409 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6410 6411 ath12k_mac_update_vif_offload(arvif); 6412 } 6413 6414 static int ath12k_mac_vdev_create(struct ath12k *ar, struct ieee80211_vif *vif) 6415 { 6416 struct ath12k_hw *ah = ar->ah; 6417 struct ath12k_base *ab = ar->ab; 6418 struct ieee80211_hw *hw = ah->hw; 6419 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6420 struct ath12k_wmi_vdev_create_arg vdev_arg = {0}; 6421 struct ath12k_wmi_peer_create_arg peer_param; 6422 u32 param_id, param_value; 6423 u16 nss; 6424 int i; 6425 int ret, vdev_id; 6426 6427 lockdep_assert_held(&ar->conf_mutex); 6428 6429 arvif->ar = ar; 6430 vdev_id = __ffs64(ab->free_vdev_map); 6431 arvif->vdev_id = vdev_id; 6432 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 6433 6434 switch (vif->type) { 6435 case NL80211_IFTYPE_UNSPECIFIED: 6436 case NL80211_IFTYPE_STATION: 6437 arvif->vdev_type = WMI_VDEV_TYPE_STA; 6438 6439 if (vif->p2p) 6440 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT; 6441 6442 break; 6443 case NL80211_IFTYPE_MESH_POINT: 6444 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S; 6445 fallthrough; 6446 case NL80211_IFTYPE_AP: 6447 arvif->vdev_type = WMI_VDEV_TYPE_AP; 6448 6449 if (vif->p2p) 6450 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO; 6451 6452 break; 6453 case NL80211_IFTYPE_MONITOR: 6454 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 6455 ar->monitor_vdev_id = vdev_id; 6456 break; 6457 case NL80211_IFTYPE_P2P_DEVICE: 6458 arvif->vdev_type = WMI_VDEV_TYPE_STA; 6459 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE; 6460 break; 6461 default: 6462 WARN_ON(1); 6463 break; 6464 } 6465 6466 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vdev create id %d type %d subtype %d map %llx\n", 6467 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype, 6468 ab->free_vdev_map); 6469 6470 vif->cab_queue = arvif->vdev_id % (ATH12K_HW_MAX_QUEUES - 1); 6471 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 6472 vif->hw_queue[i] = i % (ATH12K_HW_MAX_QUEUES - 1); 6473 6474 ret = ath12k_mac_setup_vdev_create_arg(arvif, &vdev_arg); 6475 if (ret) { 6476 ath12k_warn(ab, "failed to create vdev parameters %d: %d\n", 6477 arvif->vdev_id, ret); 6478 goto err; 6479 } 6480 6481 ret = ath12k_wmi_vdev_create(ar, vif->addr, &vdev_arg); 6482 if (ret) { 6483 ath12k_warn(ab, "failed to create WMI vdev %d: %d\n", 6484 arvif->vdev_id, ret); 6485 goto err; 6486 } 6487 6488 ar->num_created_vdevs++; 6489 arvif->is_created = true; 6490 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM created, vdev_id %d\n", 6491 vif->addr, arvif->vdev_id); 6492 ar->allocated_vdev_map |= 1LL << arvif->vdev_id; 6493 ab->free_vdev_map &= ~(1LL << arvif->vdev_id); 6494 6495 spin_lock_bh(&ar->data_lock); 6496 list_add(&arvif->list, &ar->arvifs); 6497 spin_unlock_bh(&ar->data_lock); 6498 6499 ath12k_mac_update_vif_offload(arvif); 6500 6501 nss = hweight32(ar->cfg_tx_chainmask) ? : 1; 6502 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6503 WMI_VDEV_PARAM_NSS, nss); 6504 if (ret) { 6505 ath12k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n", 6506 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret); 6507 goto err_vdev_del; 6508 } 6509 6510 switch (arvif->vdev_type) { 6511 case WMI_VDEV_TYPE_AP: 6512 peer_param.vdev_id = arvif->vdev_id; 6513 peer_param.peer_addr = vif->addr; 6514 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 6515 ret = ath12k_peer_create(ar, arvif, NULL, &peer_param); 6516 if (ret) { 6517 ath12k_warn(ab, "failed to vdev %d create peer for AP: %d\n", 6518 arvif->vdev_id, ret); 6519 goto err_vdev_del; 6520 } 6521 6522 ret = ath12k_mac_set_kickout(arvif); 6523 if (ret) { 6524 ath12k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n", 6525 arvif->vdev_id, ret); 6526 goto err_peer_del; 6527 } 6528 break; 6529 case WMI_VDEV_TYPE_STA: 6530 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 6531 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 6532 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6533 param_id, param_value); 6534 if (ret) { 6535 ath12k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n", 6536 arvif->vdev_id, ret); 6537 goto err_peer_del; 6538 } 6539 6540 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 6541 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 6542 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6543 param_id, param_value); 6544 if (ret) { 6545 ath12k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n", 6546 arvif->vdev_id, ret); 6547 goto err_peer_del; 6548 } 6549 6550 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT; 6551 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 6552 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 6553 param_id, param_value); 6554 if (ret) { 6555 ath12k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n", 6556 arvif->vdev_id, ret); 6557 goto err_peer_del; 6558 } 6559 6560 ret = ath12k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, false); 6561 if (ret) { 6562 ath12k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n", 6563 arvif->vdev_id, ret); 6564 goto err_peer_del; 6565 } 6566 break; 6567 default: 6568 break; 6569 } 6570 6571 arvif->txpower = vif->bss_conf.txpower; 6572 ret = ath12k_mac_txpower_recalc(ar); 6573 if (ret) 6574 goto err_peer_del; 6575 6576 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 6577 param_value = hw->wiphy->rts_threshold; 6578 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6579 param_id, param_value); 6580 if (ret) { 6581 ath12k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n", 6582 arvif->vdev_id, ret); 6583 } 6584 6585 ath12k_dp_vdev_tx_attach(ar, arvif); 6586 6587 if (vif->type != NL80211_IFTYPE_MONITOR && ar->monitor_conf_enabled) 6588 ath12k_mac_monitor_vdev_create(ar); 6589 6590 arvif->ar = ar; 6591 return ret; 6592 6593 err_peer_del: 6594 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 6595 reinit_completion(&ar->peer_delete_done); 6596 6597 ret = ath12k_wmi_send_peer_delete_cmd(ar, vif->addr, 6598 arvif->vdev_id); 6599 if (ret) { 6600 ath12k_warn(ar->ab, "failed to delete peer vdev_id %d addr %pM\n", 6601 arvif->vdev_id, vif->addr); 6602 goto err; 6603 } 6604 6605 ret = ath12k_wait_for_peer_delete_done(ar, arvif->vdev_id, 6606 vif->addr); 6607 if (ret) 6608 goto err; 6609 6610 ar->num_peers--; 6611 } 6612 6613 err_vdev_del: 6614 ath12k_wmi_vdev_delete(ar, arvif->vdev_id); 6615 ar->num_created_vdevs--; 6616 arvif->is_created = false; 6617 arvif->ar = NULL; 6618 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 6619 ab->free_vdev_map |= 1LL << arvif->vdev_id; 6620 ab->free_vdev_stats_id_map &= ~(1LL << arvif->vdev_stats_id); 6621 spin_lock_bh(&ar->data_lock); 6622 list_del(&arvif->list); 6623 spin_unlock_bh(&ar->data_lock); 6624 6625 err: 6626 arvif->ar = NULL; 6627 return ret; 6628 } 6629 6630 static void ath12k_mac_vif_cache_flush(struct ath12k *ar, struct ieee80211_vif *vif) 6631 { 6632 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6633 struct ath12k_vif_cache *cache = arvif->cache; 6634 struct ath12k_base *ab = ar->ab; 6635 6636 int ret; 6637 6638 lockdep_assert_held(&ar->conf_mutex); 6639 6640 if (!cache) 6641 return; 6642 6643 if (cache->tx_conf.changed) { 6644 ret = ath12k_mac_conf_tx(arvif, 0, cache->tx_conf.ac, 6645 &cache->tx_conf.tx_queue_params); 6646 if (ret) 6647 ath12k_warn(ab, 6648 "unable to apply tx config parameters to vdev %d\n", 6649 ret); 6650 } 6651 6652 if (cache->bss_conf_changed) { 6653 ath12k_mac_bss_info_changed(ar, arvif, &vif->bss_conf, 6654 cache->bss_conf_changed); 6655 } 6656 6657 if (cache->key_conf.changed) { 6658 ret = ath12k_mac_set_key(ar, cache->key_conf.cmd, vif, NULL, 6659 cache->key_conf.key); 6660 if (ret) 6661 ath12k_warn(ab, "unable to apply set key param to vdev %d ret %d\n", 6662 arvif->vdev_id, ret); 6663 } 6664 ath12k_arvif_put_cache(arvif); 6665 } 6666 6667 static struct ath12k *ath12k_mac_assign_vif_to_vdev(struct ieee80211_hw *hw, 6668 struct ieee80211_vif *vif, 6669 struct ieee80211_chanctx_conf *ctx) 6670 { 6671 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6672 struct ath12k_hw *ah = hw->priv; 6673 struct ath12k *ar, *prev_ar; 6674 struct ath12k_base *ab; 6675 int ret; 6676 6677 if (ah->num_radio == 1) 6678 ar = ah->radio; 6679 else if (ctx) 6680 ar = ath12k_get_ar_by_ctx(hw, ctx); 6681 else 6682 return NULL; 6683 6684 if (!ar) 6685 return NULL; 6686 6687 if (arvif->ar) { 6688 /* This is not expected really */ 6689 if (WARN_ON(!arvif->is_created)) { 6690 arvif->ar = NULL; 6691 return NULL; 6692 } 6693 6694 if (ah->num_radio == 1) 6695 return arvif->ar; 6696 6697 /* This can happen as scan vdev gets created during multiple scans 6698 * across different radios before a vdev is brought up in 6699 * a certain radio. 6700 */ 6701 if (ar != arvif->ar) { 6702 if (WARN_ON(arvif->is_started)) 6703 return NULL; 6704 6705 /* backup the previously used ar ptr since arvif->ar would 6706 * be set to NULL after vdev delete is done 6707 */ 6708 prev_ar = arvif->ar; 6709 mutex_lock(&prev_ar->conf_mutex); 6710 ret = ath12k_mac_vdev_delete(prev_ar, vif); 6711 6712 if (ret) 6713 ath12k_warn(prev_ar->ab, "unable to delete vdev %d\n", 6714 ret); 6715 mutex_unlock(&prev_ar->conf_mutex); 6716 } 6717 } 6718 6719 ab = ar->ab; 6720 6721 mutex_lock(&ar->conf_mutex); 6722 6723 if (arvif->is_created) 6724 goto flush; 6725 6726 if (vif->type == NL80211_IFTYPE_AP && 6727 ar->num_peers > (ar->max_num_peers - 1)) { 6728 ath12k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n"); 6729 goto unlock; 6730 } 6731 6732 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS - 1)) { 6733 ath12k_warn(ab, "failed to create vdev, reached max vdev limit %d\n", 6734 TARGET_NUM_VDEVS); 6735 goto unlock; 6736 } 6737 6738 ret = ath12k_mac_vdev_create(ar, vif); 6739 if (ret) { 6740 ath12k_warn(ab, "failed to create vdev %pM ret %d", vif->addr, ret); 6741 goto unlock; 6742 } 6743 6744 flush: 6745 /* If the vdev is created during channel assign and not during 6746 * add_interface(), Apply any parameters for the vdev which were received 6747 * after add_interface, corresponding to this vif. 6748 */ 6749 ath12k_mac_vif_cache_flush(ar, vif); 6750 unlock: 6751 mutex_unlock(&ar->conf_mutex); 6752 return arvif->ar; 6753 } 6754 6755 static int ath12k_mac_op_add_interface(struct ieee80211_hw *hw, 6756 struct ieee80211_vif *vif) 6757 { 6758 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6759 int i; 6760 6761 memset(arvif, 0, sizeof(*arvif)); 6762 6763 arvif->vif = vif; 6764 6765 INIT_LIST_HEAD(&arvif->list); 6766 INIT_DELAYED_WORK(&arvif->connection_loss_work, 6767 ath12k_mac_vif_sta_connection_loss_work); 6768 6769 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) { 6770 arvif->bitrate_mask.control[i].legacy = 0xffffffff; 6771 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff, 6772 sizeof(arvif->bitrate_mask.control[i].ht_mcs)); 6773 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff, 6774 sizeof(arvif->bitrate_mask.control[i].vht_mcs)); 6775 } 6776 6777 /* Allocate Default Queue now and reassign during actual vdev create */ 6778 vif->cab_queue = ATH12K_HW_DEFAULT_QUEUE; 6779 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 6780 vif->hw_queue[i] = ATH12K_HW_DEFAULT_QUEUE; 6781 6782 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 6783 6784 /* For single radio wiphy(i.e ah->num_radio is 1), create the vdev 6785 * during add_interface itself, for multi radio wiphy, defer the vdev 6786 * creation until channel_assign to determine the radio on which the 6787 * vdev needs to be created 6788 */ 6789 ath12k_mac_assign_vif_to_vdev(hw, vif, NULL); 6790 return 0; 6791 } 6792 6793 static void ath12k_mac_vif_unref(struct ath12k_dp *dp, struct ieee80211_vif *vif) 6794 { 6795 struct ath12k_tx_desc_info *tx_desc_info; 6796 struct ath12k_skb_cb *skb_cb; 6797 struct sk_buff *skb; 6798 int i; 6799 6800 for (i = 0; i < ATH12K_HW_MAX_QUEUES; i++) { 6801 spin_lock_bh(&dp->tx_desc_lock[i]); 6802 6803 list_for_each_entry(tx_desc_info, &dp->tx_desc_used_list[i], 6804 list) { 6805 skb = tx_desc_info->skb; 6806 if (!skb) 6807 continue; 6808 6809 skb_cb = ATH12K_SKB_CB(skb); 6810 if (skb_cb->vif == vif) 6811 skb_cb->vif = NULL; 6812 } 6813 6814 spin_unlock_bh(&dp->tx_desc_lock[i]); 6815 } 6816 } 6817 6818 static int ath12k_mac_vdev_delete(struct ath12k *ar, struct ieee80211_vif *vif) 6819 { 6820 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6821 struct ath12k_base *ab = ar->ab; 6822 unsigned long time_left; 6823 int ret; 6824 6825 lockdep_assert_held(&ar->conf_mutex); 6826 reinit_completion(&ar->vdev_delete_done); 6827 6828 ret = ath12k_wmi_vdev_delete(ar, arvif->vdev_id); 6829 if (ret) { 6830 ath12k_warn(ab, "failed to delete WMI vdev %d: %d\n", 6831 arvif->vdev_id, ret); 6832 goto err_vdev_del; 6833 } 6834 6835 time_left = wait_for_completion_timeout(&ar->vdev_delete_done, 6836 ATH12K_VDEV_DELETE_TIMEOUT_HZ); 6837 if (time_left == 0) { 6838 ath12k_warn(ab, "Timeout in receiving vdev delete response\n"); 6839 goto err_vdev_del; 6840 } 6841 6842 ab->free_vdev_map |= 1LL << arvif->vdev_id; 6843 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 6844 ar->num_created_vdevs--; 6845 6846 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 6847 ar->monitor_vdev_id = -1; 6848 ar->monitor_vdev_created = false; 6849 } else if (ar->monitor_vdev_created && !ar->monitor_started) { 6850 ret = ath12k_mac_monitor_vdev_delete(ar); 6851 } 6852 6853 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n", 6854 vif->addr, arvif->vdev_id); 6855 6856 err_vdev_del: 6857 spin_lock_bh(&ar->data_lock); 6858 list_del(&arvif->list); 6859 spin_unlock_bh(&ar->data_lock); 6860 6861 ath12k_peer_cleanup(ar, arvif->vdev_id); 6862 ath12k_arvif_put_cache(arvif); 6863 6864 idr_for_each(&ar->txmgmt_idr, 6865 ath12k_mac_vif_txmgmt_idr_remove, vif); 6866 6867 ath12k_mac_vif_unref(&ab->dp, vif); 6868 ath12k_dp_tx_put_bank_profile(&ab->dp, arvif->bank_id); 6869 6870 /* Recalc txpower for remaining vdev */ 6871 ath12k_mac_txpower_recalc(ar); 6872 6873 /* TODO: recal traffic pause state based on the available vdevs */ 6874 arvif->is_created = false; 6875 arvif->ar = NULL; 6876 6877 return ret; 6878 } 6879 6880 static void ath12k_mac_op_remove_interface(struct ieee80211_hw *hw, 6881 struct ieee80211_vif *vif) 6882 { 6883 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6884 struct ath12k_base *ab; 6885 struct ath12k *ar; 6886 int ret; 6887 6888 if (!arvif->is_created) { 6889 /* if we cached some config but never received assign chanctx, 6890 * free the allocated cache. 6891 */ 6892 ath12k_arvif_put_cache(arvif); 6893 return; 6894 } 6895 6896 ar = arvif->ar; 6897 ab = ar->ab; 6898 6899 cancel_delayed_work_sync(&arvif->connection_loss_work); 6900 6901 mutex_lock(&ar->conf_mutex); 6902 6903 ath12k_dbg(ab, ATH12K_DBG_MAC, "mac remove interface (vdev %d)\n", 6904 arvif->vdev_id); 6905 6906 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 6907 ret = ath12k_peer_delete(ar, arvif->vdev_id, vif->addr); 6908 if (ret) 6909 ath12k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n", 6910 arvif->vdev_id, ret); 6911 } 6912 6913 ath12k_mac_vdev_delete(ar, vif); 6914 6915 mutex_unlock(&ar->conf_mutex); 6916 } 6917 6918 /* FIXME: Has to be verified. */ 6919 #define SUPPORTED_FILTERS \ 6920 (FIF_ALLMULTI | \ 6921 FIF_CONTROL | \ 6922 FIF_PSPOLL | \ 6923 FIF_OTHER_BSS | \ 6924 FIF_BCN_PRBRESP_PROMISC | \ 6925 FIF_PROBE_REQ | \ 6926 FIF_FCSFAIL) 6927 6928 static void ath12k_mac_configure_filter(struct ath12k *ar, 6929 unsigned int total_flags) 6930 { 6931 bool reset_flag; 6932 int ret; 6933 6934 lockdep_assert_held(&ar->conf_mutex); 6935 6936 ar->filter_flags = total_flags; 6937 6938 /* For monitor mode */ 6939 reset_flag = !(ar->filter_flags & FIF_BCN_PRBRESP_PROMISC); 6940 6941 ret = ath12k_dp_tx_htt_monitor_mode_ring_config(ar, reset_flag); 6942 if (ret) 6943 ath12k_warn(ar->ab, 6944 "fail to set monitor filter: %d\n", ret); 6945 6946 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 6947 "total_flags:0x%x, reset_flag:%d\n", 6948 total_flags, reset_flag); 6949 } 6950 6951 static void ath12k_mac_op_configure_filter(struct ieee80211_hw *hw, 6952 unsigned int changed_flags, 6953 unsigned int *total_flags, 6954 u64 multicast) 6955 { 6956 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 6957 struct ath12k *ar; 6958 6959 ar = ath12k_ah_to_ar(ah, 0); 6960 6961 mutex_lock(&ar->conf_mutex); 6962 6963 *total_flags &= SUPPORTED_FILTERS; 6964 ath12k_mac_configure_filter(ar, *total_flags); 6965 6966 mutex_unlock(&ar->conf_mutex); 6967 } 6968 6969 static int ath12k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 6970 { 6971 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 6972 int antennas_rx = 0, antennas_tx = 0; 6973 struct ath12k *ar; 6974 int i; 6975 6976 for_each_ar(ah, ar, i) { 6977 mutex_lock(&ar->conf_mutex); 6978 antennas_rx = max_t(u32, antennas_rx, ar->cfg_rx_chainmask); 6979 antennas_tx = max_t(u32, antennas_tx, ar->cfg_tx_chainmask); 6980 mutex_unlock(&ar->conf_mutex); 6981 } 6982 6983 *tx_ant = antennas_tx; 6984 *rx_ant = antennas_rx; 6985 6986 return 0; 6987 } 6988 6989 static int ath12k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 6990 { 6991 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 6992 struct ath12k *ar; 6993 int ret = 0; 6994 int i; 6995 6996 for_each_ar(ah, ar, i) { 6997 mutex_lock(&ar->conf_mutex); 6998 ret = __ath12k_set_antenna(ar, tx_ant, rx_ant); 6999 mutex_unlock(&ar->conf_mutex); 7000 if (ret) 7001 break; 7002 } 7003 7004 return ret; 7005 } 7006 7007 static int ath12k_mac_ampdu_action(struct ath12k_vif *arvif, 7008 struct ieee80211_ampdu_params *params) 7009 { 7010 struct ath12k *ar = arvif->ar; 7011 int ret = -EINVAL; 7012 7013 lockdep_assert_held(&ar->conf_mutex); 7014 7015 switch (params->action) { 7016 case IEEE80211_AMPDU_RX_START: 7017 ret = ath12k_dp_rx_ampdu_start(ar, params); 7018 break; 7019 case IEEE80211_AMPDU_RX_STOP: 7020 ret = ath12k_dp_rx_ampdu_stop(ar, params); 7021 break; 7022 case IEEE80211_AMPDU_TX_START: 7023 case IEEE80211_AMPDU_TX_STOP_CONT: 7024 case IEEE80211_AMPDU_TX_STOP_FLUSH: 7025 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 7026 case IEEE80211_AMPDU_TX_OPERATIONAL: 7027 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211 7028 * Tx aggregation requests. 7029 */ 7030 ret = -EOPNOTSUPP; 7031 break; 7032 } 7033 7034 return ret; 7035 } 7036 7037 static int ath12k_mac_op_ampdu_action(struct ieee80211_hw *hw, 7038 struct ieee80211_vif *vif, 7039 struct ieee80211_ampdu_params *params) 7040 { 7041 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 7042 struct ath12k *ar; 7043 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 7044 int ret = -EINVAL; 7045 7046 ar = ath12k_get_ar_by_vif(hw, vif); 7047 if (!ar) 7048 return -EINVAL; 7049 7050 ar = ath12k_ah_to_ar(ah, 0); 7051 7052 mutex_lock(&ar->conf_mutex); 7053 ret = ath12k_mac_ampdu_action(arvif, params); 7054 mutex_unlock(&ar->conf_mutex); 7055 7056 if (ret) 7057 ath12k_warn(ar->ab, "pdev idx %d unable to perform ampdu action %d ret %d\n", 7058 ar->pdev_idx, params->action, ret); 7059 7060 return ret; 7061 } 7062 7063 static int ath12k_mac_op_add_chanctx(struct ieee80211_hw *hw, 7064 struct ieee80211_chanctx_conf *ctx) 7065 { 7066 struct ath12k *ar; 7067 struct ath12k_base *ab; 7068 7069 ar = ath12k_get_ar_by_ctx(hw, ctx); 7070 if (!ar) 7071 return -EINVAL; 7072 7073 ab = ar->ab; 7074 7075 ath12k_dbg(ab, ATH12K_DBG_MAC, 7076 "mac chanctx add freq %u width %d ptr %p\n", 7077 ctx->def.chan->center_freq, ctx->def.width, ctx); 7078 7079 mutex_lock(&ar->conf_mutex); 7080 7081 spin_lock_bh(&ar->data_lock); 7082 /* TODO: In case of multiple channel context, populate rx_channel from 7083 * Rx PPDU desc information. 7084 */ 7085 ar->rx_channel = ctx->def.chan; 7086 spin_unlock_bh(&ar->data_lock); 7087 7088 mutex_unlock(&ar->conf_mutex); 7089 7090 return 0; 7091 } 7092 7093 static void ath12k_mac_op_remove_chanctx(struct ieee80211_hw *hw, 7094 struct ieee80211_chanctx_conf *ctx) 7095 { 7096 struct ath12k *ar; 7097 struct ath12k_base *ab; 7098 7099 ar = ath12k_get_ar_by_ctx(hw, ctx); 7100 if (!ar) 7101 return; 7102 7103 ab = ar->ab; 7104 7105 ath12k_dbg(ab, ATH12K_DBG_MAC, 7106 "mac chanctx remove freq %u width %d ptr %p\n", 7107 ctx->def.chan->center_freq, ctx->def.width, ctx); 7108 7109 mutex_lock(&ar->conf_mutex); 7110 7111 spin_lock_bh(&ar->data_lock); 7112 /* TODO: In case of there is one more channel context left, populate 7113 * rx_channel with the channel of that remaining channel context. 7114 */ 7115 ar->rx_channel = NULL; 7116 spin_unlock_bh(&ar->data_lock); 7117 7118 mutex_unlock(&ar->conf_mutex); 7119 } 7120 7121 static enum wmi_phy_mode 7122 ath12k_mac_check_down_grade_phy_mode(struct ath12k *ar, 7123 enum wmi_phy_mode mode, 7124 enum nl80211_band band, 7125 enum nl80211_iftype type) 7126 { 7127 struct ieee80211_sta_eht_cap *eht_cap = NULL; 7128 enum wmi_phy_mode down_mode; 7129 int n = ar->mac.sbands[band].n_iftype_data; 7130 int i; 7131 struct ieee80211_sband_iftype_data *data; 7132 7133 if (mode < MODE_11BE_EHT20) 7134 return mode; 7135 7136 data = ar->mac.iftype[band]; 7137 for (i = 0; i < n; i++) { 7138 if (data[i].types_mask & BIT(type)) { 7139 eht_cap = &data[i].eht_cap; 7140 break; 7141 } 7142 } 7143 7144 if (eht_cap && eht_cap->has_eht) 7145 return mode; 7146 7147 switch (mode) { 7148 case MODE_11BE_EHT20: 7149 down_mode = MODE_11AX_HE20; 7150 break; 7151 case MODE_11BE_EHT40: 7152 down_mode = MODE_11AX_HE40; 7153 break; 7154 case MODE_11BE_EHT80: 7155 down_mode = MODE_11AX_HE80; 7156 break; 7157 case MODE_11BE_EHT80_80: 7158 down_mode = MODE_11AX_HE80_80; 7159 break; 7160 case MODE_11BE_EHT160: 7161 case MODE_11BE_EHT160_160: 7162 case MODE_11BE_EHT320: 7163 down_mode = MODE_11AX_HE160; 7164 break; 7165 case MODE_11BE_EHT20_2G: 7166 down_mode = MODE_11AX_HE20_2G; 7167 break; 7168 case MODE_11BE_EHT40_2G: 7169 down_mode = MODE_11AX_HE40_2G; 7170 break; 7171 default: 7172 down_mode = mode; 7173 break; 7174 } 7175 7176 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 7177 "mac vdev start phymode %s downgrade to %s\n", 7178 ath12k_mac_phymode_str(mode), 7179 ath12k_mac_phymode_str(down_mode)); 7180 7181 return down_mode; 7182 } 7183 7184 static int 7185 ath12k_mac_vdev_start_restart(struct ath12k_vif *arvif, 7186 struct ieee80211_chanctx_conf *ctx, 7187 bool restart) 7188 { 7189 struct ath12k *ar = arvif->ar; 7190 struct ath12k_base *ab = ar->ab; 7191 struct wmi_vdev_start_req_arg arg = {}; 7192 const struct cfg80211_chan_def *chandef = &ctx->def; 7193 int he_support = arvif->vif->bss_conf.he_support; 7194 int ret; 7195 7196 lockdep_assert_held(&ar->conf_mutex); 7197 7198 reinit_completion(&ar->vdev_setup_done); 7199 7200 arg.vdev_id = arvif->vdev_id; 7201 arg.dtim_period = arvif->dtim_period; 7202 arg.bcn_intval = arvif->beacon_interval; 7203 arg.punct_bitmap = ~arvif->punct_bitmap; 7204 7205 arg.freq = chandef->chan->center_freq; 7206 arg.band_center_freq1 = chandef->center_freq1; 7207 arg.band_center_freq2 = chandef->center_freq2; 7208 arg.mode = ath12k_phymodes[chandef->chan->band][chandef->width]; 7209 7210 arg.mode = ath12k_mac_check_down_grade_phy_mode(ar, arg.mode, 7211 chandef->chan->band, 7212 arvif->vif->type); 7213 arg.min_power = 0; 7214 arg.max_power = chandef->chan->max_power * 2; 7215 arg.max_reg_power = chandef->chan->max_reg_power * 2; 7216 arg.max_antenna_gain = chandef->chan->max_antenna_gain * 2; 7217 7218 arg.pref_tx_streams = ar->num_tx_chains; 7219 arg.pref_rx_streams = ar->num_rx_chains; 7220 7221 arg.mbssid_flags = WMI_VDEV_MBSSID_FLAGS_NON_MBSSID_AP; 7222 arg.mbssid_tx_vdev_id = 0; 7223 if (test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT, 7224 ar->ab->wmi_ab.svc_map)) { 7225 ret = ath12k_mac_setup_vdev_params_mbssid(arvif, 7226 &arg.mbssid_flags, 7227 &arg.mbssid_tx_vdev_id); 7228 if (ret) 7229 return ret; 7230 } 7231 7232 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 7233 arg.ssid = arvif->u.ap.ssid; 7234 arg.ssid_len = arvif->u.ap.ssid_len; 7235 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 7236 7237 /* For now allow DFS for AP mode */ 7238 arg.chan_radar = !!(chandef->chan->flags & IEEE80211_CHAN_RADAR); 7239 7240 arg.freq2_radar = ctx->radar_enabled; 7241 7242 arg.passive = arg.chan_radar; 7243 7244 spin_lock_bh(&ab->base_lock); 7245 arg.regdomain = ar->ab->dfs_region; 7246 spin_unlock_bh(&ab->base_lock); 7247 7248 /* TODO: Notify if secondary 80Mhz also needs radar detection */ 7249 if (he_support) { 7250 ret = ath12k_set_he_mu_sounding_mode(ar, arvif); 7251 if (ret) { 7252 ath12k_warn(ar->ab, "failed to set he mode vdev %i\n", 7253 arg.vdev_id); 7254 return ret; 7255 } 7256 } 7257 } 7258 7259 arg.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR); 7260 7261 ath12k_dbg(ab, ATH12K_DBG_MAC, 7262 "mac vdev %d start center_freq %d phymode %s punct_bitmap 0x%x\n", 7263 arg.vdev_id, arg.freq, 7264 ath12k_mac_phymode_str(arg.mode), arg.punct_bitmap); 7265 7266 ret = ath12k_wmi_vdev_start(ar, &arg, restart); 7267 if (ret) { 7268 ath12k_warn(ar->ab, "failed to %s WMI vdev %i\n", 7269 restart ? "restart" : "start", arg.vdev_id); 7270 return ret; 7271 } 7272 7273 ret = ath12k_mac_vdev_setup_sync(ar); 7274 if (ret) { 7275 ath12k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n", 7276 arg.vdev_id, restart ? "restart" : "start", ret); 7277 return ret; 7278 } 7279 7280 ar->num_started_vdevs++; 7281 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM started, vdev_id %d\n", 7282 arvif->vif->addr, arvif->vdev_id); 7283 7284 /* Enable CAC Flag in the driver by checking the channel DFS cac time, 7285 * i.e dfs_cac_ms value which will be valid only for radar channels 7286 * and state as NL80211_DFS_USABLE which indicates CAC needs to be 7287 * done before channel usage. This flags is used to drop rx packets. 7288 * during CAC. 7289 */ 7290 /* TODO: Set the flag for other interface types as required */ 7291 if (arvif->vdev_type == WMI_VDEV_TYPE_AP && 7292 chandef->chan->dfs_cac_ms && 7293 chandef->chan->dfs_state == NL80211_DFS_USABLE) { 7294 set_bit(ATH12K_CAC_RUNNING, &ar->dev_flags); 7295 ath12k_dbg(ab, ATH12K_DBG_MAC, 7296 "CAC Started in chan_freq %d for vdev %d\n", 7297 arg.freq, arg.vdev_id); 7298 } 7299 7300 ret = ath12k_mac_set_txbf_conf(arvif); 7301 if (ret) 7302 ath12k_warn(ab, "failed to set txbf conf for vdev %d: %d\n", 7303 arvif->vdev_id, ret); 7304 7305 return 0; 7306 } 7307 7308 static int ath12k_mac_vdev_start(struct ath12k_vif *arvif, 7309 struct ieee80211_chanctx_conf *ctx) 7310 { 7311 return ath12k_mac_vdev_start_restart(arvif, ctx, false); 7312 } 7313 7314 static int ath12k_mac_vdev_restart(struct ath12k_vif *arvif, 7315 struct ieee80211_chanctx_conf *ctx) 7316 { 7317 return ath12k_mac_vdev_start_restart(arvif, ctx, true); 7318 } 7319 7320 struct ath12k_mac_change_chanctx_arg { 7321 struct ieee80211_chanctx_conf *ctx; 7322 struct ieee80211_vif_chanctx_switch *vifs; 7323 int n_vifs; 7324 int next_vif; 7325 struct ath12k *ar; 7326 }; 7327 7328 static void 7329 ath12k_mac_change_chanctx_cnt_iter(void *data, u8 *mac, 7330 struct ieee80211_vif *vif) 7331 { 7332 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 7333 struct ath12k_mac_change_chanctx_arg *arg = data; 7334 7335 if (arvif->ar != arg->ar) 7336 return; 7337 7338 if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx) 7339 return; 7340 7341 arg->n_vifs++; 7342 } 7343 7344 static void 7345 ath12k_mac_change_chanctx_fill_iter(void *data, u8 *mac, 7346 struct ieee80211_vif *vif) 7347 { 7348 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 7349 struct ath12k_mac_change_chanctx_arg *arg = data; 7350 struct ieee80211_chanctx_conf *ctx; 7351 7352 if (arvif->ar != arg->ar) 7353 return; 7354 7355 ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf); 7356 if (ctx != arg->ctx) 7357 return; 7358 7359 if (WARN_ON(arg->next_vif == arg->n_vifs)) 7360 return; 7361 7362 arg->vifs[arg->next_vif].vif = vif; 7363 arg->vifs[arg->next_vif].old_ctx = ctx; 7364 arg->vifs[arg->next_vif].new_ctx = ctx; 7365 arg->next_vif++; 7366 } 7367 7368 static u32 ath12k_mac_nlwidth_to_wmiwidth(enum nl80211_chan_width width) 7369 { 7370 switch (width) { 7371 case NL80211_CHAN_WIDTH_20: 7372 return WMI_CHAN_WIDTH_20; 7373 case NL80211_CHAN_WIDTH_40: 7374 return WMI_CHAN_WIDTH_40; 7375 case NL80211_CHAN_WIDTH_80: 7376 return WMI_CHAN_WIDTH_80; 7377 case NL80211_CHAN_WIDTH_160: 7378 return WMI_CHAN_WIDTH_160; 7379 case NL80211_CHAN_WIDTH_80P80: 7380 return WMI_CHAN_WIDTH_80P80; 7381 case NL80211_CHAN_WIDTH_5: 7382 return WMI_CHAN_WIDTH_5; 7383 case NL80211_CHAN_WIDTH_10: 7384 return WMI_CHAN_WIDTH_10; 7385 case NL80211_CHAN_WIDTH_320: 7386 return WMI_CHAN_WIDTH_320; 7387 default: 7388 WARN_ON(1); 7389 return WMI_CHAN_WIDTH_20; 7390 } 7391 } 7392 7393 static int ath12k_mac_update_peer_puncturing_width(struct ath12k *ar, 7394 struct ath12k_vif *arvif, 7395 struct cfg80211_chan_def def) 7396 { 7397 u32 param_id, param_value; 7398 int ret; 7399 7400 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 7401 return 0; 7402 7403 param_id = WMI_PEER_CHWIDTH_PUNCTURE_20MHZ_BITMAP; 7404 param_value = ath12k_mac_nlwidth_to_wmiwidth(def.width) | 7405 u32_encode_bits((~def.punctured), 7406 WMI_PEER_PUNCTURE_BITMAP); 7407 7408 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 7409 "punctured bitmap %02x width %d vdev %d\n", 7410 def.punctured, def.width, arvif->vdev_id); 7411 7412 ret = ath12k_wmi_set_peer_param(ar, arvif->bssid, 7413 arvif->vdev_id, param_id, 7414 param_value); 7415 7416 return ret; 7417 } 7418 7419 static void 7420 ath12k_mac_update_vif_chan(struct ath12k *ar, 7421 struct ieee80211_vif_chanctx_switch *vifs, 7422 int n_vifs) 7423 { 7424 struct ath12k_wmi_vdev_up_params params = {}; 7425 struct ath12k_base *ab = ar->ab; 7426 struct ieee80211_vif *vif; 7427 struct ath12k_vif *arvif; 7428 int ret; 7429 int i; 7430 bool monitor_vif = false; 7431 7432 lockdep_assert_held(&ar->conf_mutex); 7433 7434 for (i = 0; i < n_vifs; i++) { 7435 vif = vifs[i].vif; 7436 arvif = ath12k_vif_to_arvif(vif); 7437 7438 if (vif->type == NL80211_IFTYPE_MONITOR) 7439 monitor_vif = true; 7440 7441 ath12k_dbg(ab, ATH12K_DBG_MAC, 7442 "mac chanctx switch vdev_id %i freq %u->%u width %d->%d\n", 7443 arvif->vdev_id, 7444 vifs[i].old_ctx->def.chan->center_freq, 7445 vifs[i].new_ctx->def.chan->center_freq, 7446 vifs[i].old_ctx->def.width, 7447 vifs[i].new_ctx->def.width); 7448 7449 if (WARN_ON(!arvif->is_started)) 7450 continue; 7451 7452 arvif->punct_bitmap = vifs[i].new_ctx->def.punctured; 7453 7454 /* Firmware expect vdev_restart only if vdev is up. 7455 * If vdev is down then it expect vdev_stop->vdev_start. 7456 */ 7457 if (arvif->is_up) { 7458 ret = ath12k_mac_vdev_restart(arvif, vifs[i].new_ctx); 7459 if (ret) { 7460 ath12k_warn(ab, "failed to restart vdev %d: %d\n", 7461 arvif->vdev_id, ret); 7462 continue; 7463 } 7464 } else { 7465 ret = ath12k_mac_vdev_stop(arvif); 7466 if (ret) { 7467 ath12k_warn(ab, "failed to stop vdev %d: %d\n", 7468 arvif->vdev_id, ret); 7469 continue; 7470 } 7471 7472 ret = ath12k_mac_vdev_start(arvif, vifs[i].new_ctx); 7473 if (ret) 7474 ath12k_warn(ab, "failed to start vdev %d: %d\n", 7475 arvif->vdev_id, ret); 7476 continue; 7477 } 7478 7479 ret = ath12k_mac_setup_bcn_tmpl(arvif); 7480 if (ret) 7481 ath12k_warn(ab, "failed to update bcn tmpl during csa: %d\n", 7482 ret); 7483 7484 memset(¶ms, 0, sizeof(params)); 7485 params.vdev_id = arvif->vdev_id; 7486 params.aid = arvif->aid; 7487 params.bssid = arvif->bssid; 7488 if (vif->mbssid_tx_vif) { 7489 params.tx_bssid = ath12k_vif_to_arvif(vif->mbssid_tx_vif)->bssid; 7490 params.nontx_profile_idx = vif->bss_conf.bssid_index; 7491 params.nontx_profile_cnt = 1 << vif->bss_conf.bssid_indicator; 7492 } 7493 ret = ath12k_wmi_vdev_up(arvif->ar, ¶ms); 7494 if (ret) { 7495 ath12k_warn(ab, "failed to bring vdev up %d: %d\n", 7496 arvif->vdev_id, ret); 7497 continue; 7498 } 7499 7500 ret = ath12k_mac_update_peer_puncturing_width(arvif->ar, arvif, 7501 vifs[i].new_ctx->def); 7502 if (ret) { 7503 ath12k_warn(ar->ab, 7504 "failed to update puncturing bitmap %02x and width %d: %d\n", 7505 vifs[i].new_ctx->def.punctured, 7506 vifs[i].new_ctx->def.width, ret); 7507 continue; 7508 } 7509 } 7510 7511 /* Restart the internal monitor vdev on new channel */ 7512 if (!monitor_vif && ar->monitor_vdev_created) { 7513 if (!ath12k_mac_monitor_stop(ar)) 7514 ath12k_mac_monitor_start(ar); 7515 } 7516 } 7517 7518 static void 7519 ath12k_mac_update_active_vif_chan(struct ath12k *ar, 7520 struct ieee80211_chanctx_conf *ctx) 7521 { 7522 struct ath12k_mac_change_chanctx_arg arg = { .ctx = ctx, .ar = ar }; 7523 struct ieee80211_hw *hw = ath12k_ar_to_hw(ar); 7524 7525 lockdep_assert_held(&ar->conf_mutex); 7526 7527 ieee80211_iterate_active_interfaces_atomic(hw, 7528 IEEE80211_IFACE_ITER_NORMAL, 7529 ath12k_mac_change_chanctx_cnt_iter, 7530 &arg); 7531 if (arg.n_vifs == 0) 7532 return; 7533 7534 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL); 7535 if (!arg.vifs) 7536 return; 7537 7538 ieee80211_iterate_active_interfaces_atomic(hw, 7539 IEEE80211_IFACE_ITER_NORMAL, 7540 ath12k_mac_change_chanctx_fill_iter, 7541 &arg); 7542 7543 ath12k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs); 7544 7545 kfree(arg.vifs); 7546 } 7547 7548 static void ath12k_mac_op_change_chanctx(struct ieee80211_hw *hw, 7549 struct ieee80211_chanctx_conf *ctx, 7550 u32 changed) 7551 { 7552 struct ath12k *ar; 7553 struct ath12k_base *ab; 7554 7555 ar = ath12k_get_ar_by_ctx(hw, ctx); 7556 if (!ar) 7557 return; 7558 7559 ab = ar->ab; 7560 7561 mutex_lock(&ar->conf_mutex); 7562 7563 ath12k_dbg(ab, ATH12K_DBG_MAC, 7564 "mac chanctx change freq %u width %d ptr %p changed %x\n", 7565 ctx->def.chan->center_freq, ctx->def.width, ctx, changed); 7566 7567 /* This shouldn't really happen because channel switching should use 7568 * switch_vif_chanctx(). 7569 */ 7570 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL)) 7571 goto unlock; 7572 7573 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH || 7574 changed & IEEE80211_CHANCTX_CHANGE_RADAR || 7575 changed & IEEE80211_CHANCTX_CHANGE_PUNCTURING) 7576 ath12k_mac_update_active_vif_chan(ar, ctx); 7577 7578 /* TODO: Recalc radar detection */ 7579 7580 unlock: 7581 mutex_unlock(&ar->conf_mutex); 7582 } 7583 7584 static int ath12k_start_vdev_delay(struct ath12k *ar, 7585 struct ath12k_vif *arvif) 7586 { 7587 struct ath12k_base *ab = ar->ab; 7588 struct ieee80211_vif *vif = arvif->vif; 7589 int ret; 7590 7591 if (WARN_ON(arvif->is_started)) 7592 return -EBUSY; 7593 7594 ret = ath12k_mac_vdev_start(arvif, &arvif->chanctx); 7595 if (ret) { 7596 ath12k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 7597 arvif->vdev_id, vif->addr, 7598 arvif->chanctx.def.chan->center_freq, ret); 7599 return ret; 7600 } 7601 7602 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7603 ret = ath12k_monitor_vdev_up(ar, arvif->vdev_id); 7604 if (ret) { 7605 ath12k_warn(ab, "failed put monitor up: %d\n", ret); 7606 return ret; 7607 } 7608 } 7609 7610 arvif->is_started = true; 7611 7612 /* TODO: Setup ps and cts/rts protection */ 7613 return 0; 7614 } 7615 7616 static int 7617 ath12k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw, 7618 struct ieee80211_vif *vif, 7619 struct ieee80211_bss_conf *link_conf, 7620 struct ieee80211_chanctx_conf *ctx) 7621 { 7622 struct ath12k *ar; 7623 struct ath12k_base *ab; 7624 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 7625 int ret; 7626 7627 /* For multi radio wiphy, the vdev was not created during add_interface 7628 * create now since we have a channel ctx now to assign to a specific ar/fw 7629 */ 7630 ar = ath12k_mac_assign_vif_to_vdev(hw, vif, ctx); 7631 if (!ar) { 7632 WARN_ON(1); 7633 return -EINVAL; 7634 } 7635 7636 ab = ar->ab; 7637 7638 mutex_lock(&ar->conf_mutex); 7639 7640 ath12k_dbg(ab, ATH12K_DBG_MAC, 7641 "mac chanctx assign ptr %p vdev_id %i\n", 7642 ctx, arvif->vdev_id); 7643 7644 arvif->punct_bitmap = ctx->def.punctured; 7645 7646 /* for some targets bss peer must be created before vdev_start */ 7647 if (ab->hw_params->vdev_start_delay && 7648 arvif->vdev_type != WMI_VDEV_TYPE_AP && 7649 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7650 !ath12k_peer_exist_by_vdev_id(ab, arvif->vdev_id)) { 7651 memcpy(&arvif->chanctx, ctx, sizeof(*ctx)); 7652 ret = 0; 7653 goto out; 7654 } 7655 7656 if (WARN_ON(arvif->is_started)) { 7657 ret = -EBUSY; 7658 goto out; 7659 } 7660 7661 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7662 ret = ath12k_mac_monitor_start(ar); 7663 if (ret) 7664 goto out; 7665 arvif->is_started = true; 7666 goto out; 7667 } 7668 7669 ret = ath12k_mac_vdev_start(arvif, ctx); 7670 if (ret) { 7671 ath12k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 7672 arvif->vdev_id, vif->addr, 7673 ctx->def.chan->center_freq, ret); 7674 goto out; 7675 } 7676 7677 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && ar->monitor_vdev_created) 7678 ath12k_mac_monitor_start(ar); 7679 7680 arvif->is_started = true; 7681 7682 /* TODO: Setup ps and cts/rts protection */ 7683 7684 out: 7685 mutex_unlock(&ar->conf_mutex); 7686 7687 return ret; 7688 } 7689 7690 static void 7691 ath12k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 7692 struct ieee80211_vif *vif, 7693 struct ieee80211_bss_conf *link_conf, 7694 struct ieee80211_chanctx_conf *ctx) 7695 { 7696 struct ath12k *ar; 7697 struct ath12k_base *ab; 7698 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 7699 int ret; 7700 7701 /* The vif is expected to be attached to an ar's VDEV. 7702 * We leave the vif/vdev in this function as is 7703 * and not delete the vdev symmetric to assign_vif_chanctx() 7704 * the VDEV will be deleted and unassigned either during 7705 * remove_interface() or when there is a change in channel 7706 * that moves the vif to a new ar 7707 */ 7708 if (!arvif->is_created) 7709 return; 7710 7711 ar = arvif->ar; 7712 ab = ar->ab; 7713 7714 mutex_lock(&ar->conf_mutex); 7715 7716 ath12k_dbg(ab, ATH12K_DBG_MAC, 7717 "mac chanctx unassign ptr %p vdev_id %i\n", 7718 ctx, arvif->vdev_id); 7719 7720 WARN_ON(!arvif->is_started); 7721 7722 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 7723 ret = ath12k_mac_monitor_stop(ar); 7724 if (ret) { 7725 mutex_unlock(&ar->conf_mutex); 7726 return; 7727 } 7728 7729 arvif->is_started = false; 7730 } 7731 7732 if (arvif->vdev_type != WMI_VDEV_TYPE_STA && 7733 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) { 7734 ath12k_bss_disassoc(ar, arvif); 7735 ret = ath12k_mac_vdev_stop(arvif); 7736 if (ret) 7737 ath12k_warn(ab, "failed to stop vdev %i: %d\n", 7738 arvif->vdev_id, ret); 7739 } 7740 arvif->is_started = false; 7741 7742 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 7743 ar->num_started_vdevs == 1 && ar->monitor_vdev_created) 7744 ath12k_mac_monitor_stop(ar); 7745 7746 mutex_unlock(&ar->conf_mutex); 7747 } 7748 7749 static int 7750 ath12k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw, 7751 struct ieee80211_vif_chanctx_switch *vifs, 7752 int n_vifs, 7753 enum ieee80211_chanctx_switch_mode mode) 7754 { 7755 struct ath12k *ar; 7756 7757 ar = ath12k_get_ar_by_ctx(hw, vifs->old_ctx); 7758 if (!ar) 7759 return -EINVAL; 7760 7761 mutex_lock(&ar->conf_mutex); 7762 7763 /* Switching channels across radio is not allowed */ 7764 if (ar != ath12k_get_ar_by_ctx(hw, vifs->new_ctx)) { 7765 mutex_unlock(&ar->conf_mutex); 7766 return -EINVAL; 7767 } 7768 7769 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 7770 "mac chanctx switch n_vifs %d mode %d\n", 7771 n_vifs, mode); 7772 ath12k_mac_update_vif_chan(ar, vifs, n_vifs); 7773 7774 mutex_unlock(&ar->conf_mutex); 7775 7776 return 0; 7777 } 7778 7779 static int 7780 ath12k_set_vdev_param_to_all_vifs(struct ath12k *ar, int param, u32 value) 7781 { 7782 struct ath12k_vif *arvif; 7783 int ret = 0; 7784 7785 mutex_lock(&ar->conf_mutex); 7786 list_for_each_entry(arvif, &ar->arvifs, list) { 7787 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "setting mac vdev %d param %d value %d\n", 7788 param, arvif->vdev_id, value); 7789 7790 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 7791 param, value); 7792 if (ret) { 7793 ath12k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n", 7794 param, arvif->vdev_id, ret); 7795 break; 7796 } 7797 } 7798 mutex_unlock(&ar->conf_mutex); 7799 return ret; 7800 } 7801 7802 /* mac80211 stores device specific RTS/Fragmentation threshold value, 7803 * this is set interface specific to firmware from ath12k driver 7804 */ 7805 static int ath12k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 7806 { 7807 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 7808 struct ath12k *ar; 7809 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD, ret = 0, i; 7810 7811 /* Currently we set the rts threshold value to all the vifs across 7812 * all radios of the single wiphy. 7813 * TODO Once support for vif specific RTS threshold in mac80211 is 7814 * available, ath12k can make use of it. 7815 */ 7816 for_each_ar(ah, ar, i) { 7817 ret = ath12k_set_vdev_param_to_all_vifs(ar, param_id, value); 7818 if (ret) { 7819 ath12k_warn(ar->ab, "failed to set RTS config for all vdevs of pdev %d", 7820 ar->pdev->pdev_id); 7821 break; 7822 } 7823 } 7824 7825 return ret; 7826 } 7827 7828 static int ath12k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 7829 { 7830 /* Even though there's a WMI vdev param for fragmentation threshold no 7831 * known firmware actually implements it. Moreover it is not possible to 7832 * rely frame fragmentation to mac80211 because firmware clears the 7833 * "more fragments" bit in frame control making it impossible for remote 7834 * devices to reassemble frames. 7835 * 7836 * Hence implement a dummy callback just to say fragmentation isn't 7837 * supported. This effectively prevents mac80211 from doing frame 7838 * fragmentation in software. 7839 */ 7840 return -EOPNOTSUPP; 7841 } 7842 7843 static int ath12k_mac_flush(struct ath12k *ar) 7844 { 7845 long time_left; 7846 int ret = 0; 7847 7848 time_left = wait_event_timeout(ar->dp.tx_empty_waitq, 7849 (atomic_read(&ar->dp.num_tx_pending) == 0), 7850 ATH12K_FLUSH_TIMEOUT); 7851 if (time_left == 0) { 7852 ath12k_warn(ar->ab, 7853 "failed to flush transmit queue, data pkts pending %d\n", 7854 atomic_read(&ar->dp.num_tx_pending)); 7855 ret = -ETIMEDOUT; 7856 } 7857 7858 time_left = wait_event_timeout(ar->txmgmt_empty_waitq, 7859 (atomic_read(&ar->num_pending_mgmt_tx) == 0), 7860 ATH12K_FLUSH_TIMEOUT); 7861 if (time_left == 0) { 7862 ath12k_warn(ar->ab, 7863 "failed to flush mgmt transmit queue, mgmt pkts pending %d\n", 7864 atomic_read(&ar->num_pending_mgmt_tx)); 7865 ret = -ETIMEDOUT; 7866 } 7867 7868 return ret; 7869 } 7870 7871 int ath12k_mac_wait_tx_complete(struct ath12k *ar) 7872 { 7873 ath12k_mac_drain_tx(ar); 7874 return ath12k_mac_flush(ar); 7875 } 7876 7877 static void ath12k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 7878 u32 queues, bool drop) 7879 { 7880 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 7881 struct ath12k *ar; 7882 int i; 7883 7884 if (drop) 7885 return; 7886 7887 /* vif can be NULL when flush() is considered for hw */ 7888 if (!vif) { 7889 for_each_ar(ah, ar, i) 7890 ath12k_mac_flush(ar); 7891 return; 7892 } 7893 7894 ar = ath12k_get_ar_by_vif(hw, vif); 7895 7896 if (!ar) 7897 return; 7898 7899 ath12k_mac_flush(ar); 7900 } 7901 7902 static int 7903 ath12k_mac_bitrate_mask_num_ht_rates(struct ath12k *ar, 7904 enum nl80211_band band, 7905 const struct cfg80211_bitrate_mask *mask) 7906 { 7907 int num_rates = 0; 7908 int i; 7909 7910 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) 7911 num_rates += hweight16(mask->control[band].ht_mcs[i]); 7912 7913 return num_rates; 7914 } 7915 7916 static bool 7917 ath12k_mac_has_single_legacy_rate(struct ath12k *ar, 7918 enum nl80211_band band, 7919 const struct cfg80211_bitrate_mask *mask) 7920 { 7921 int num_rates = 0; 7922 7923 num_rates = hweight32(mask->control[band].legacy); 7924 7925 if (ath12k_mac_bitrate_mask_num_ht_rates(ar, band, mask)) 7926 return false; 7927 7928 if (ath12k_mac_bitrate_mask_num_vht_rates(ar, band, mask)) 7929 return false; 7930 7931 return num_rates == 1; 7932 } 7933 7934 static bool 7935 ath12k_mac_bitrate_mask_get_single_nss(struct ath12k *ar, 7936 enum nl80211_band band, 7937 const struct cfg80211_bitrate_mask *mask, 7938 int *nss) 7939 { 7940 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 7941 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 7942 u8 ht_nss_mask = 0; 7943 u8 vht_nss_mask = 0; 7944 int i; 7945 7946 /* No need to consider legacy here. Basic rates are always present 7947 * in bitrate mask 7948 */ 7949 7950 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 7951 if (mask->control[band].ht_mcs[i] == 0) 7952 continue; 7953 else if (mask->control[band].ht_mcs[i] == 7954 sband->ht_cap.mcs.rx_mask[i]) 7955 ht_nss_mask |= BIT(i); 7956 else 7957 return false; 7958 } 7959 7960 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 7961 if (mask->control[band].vht_mcs[i] == 0) 7962 continue; 7963 else if (mask->control[band].vht_mcs[i] == 7964 ath12k_mac_get_max_vht_mcs_map(vht_mcs_map, i)) 7965 vht_nss_mask |= BIT(i); 7966 else 7967 return false; 7968 } 7969 7970 if (ht_nss_mask != vht_nss_mask) 7971 return false; 7972 7973 if (ht_nss_mask == 0) 7974 return false; 7975 7976 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask) 7977 return false; 7978 7979 *nss = fls(ht_nss_mask); 7980 7981 return true; 7982 } 7983 7984 static int 7985 ath12k_mac_get_single_legacy_rate(struct ath12k *ar, 7986 enum nl80211_band band, 7987 const struct cfg80211_bitrate_mask *mask, 7988 u32 *rate, u8 *nss) 7989 { 7990 int rate_idx; 7991 u16 bitrate; 7992 u8 preamble; 7993 u8 hw_rate; 7994 7995 if (hweight32(mask->control[band].legacy) != 1) 7996 return -EINVAL; 7997 7998 rate_idx = ffs(mask->control[band].legacy) - 1; 7999 8000 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ) 8001 rate_idx += ATH12K_MAC_FIRST_OFDM_RATE_IDX; 8002 8003 hw_rate = ath12k_legacy_rates[rate_idx].hw_value; 8004 bitrate = ath12k_legacy_rates[rate_idx].bitrate; 8005 8006 if (ath12k_mac_bitrate_is_cck(bitrate)) 8007 preamble = WMI_RATE_PREAMBLE_CCK; 8008 else 8009 preamble = WMI_RATE_PREAMBLE_OFDM; 8010 8011 *nss = 1; 8012 *rate = ATH12K_HW_RATE_CODE(hw_rate, 0, preamble); 8013 8014 return 0; 8015 } 8016 8017 static int ath12k_mac_set_fixed_rate_params(struct ath12k_vif *arvif, 8018 u32 rate, u8 nss, u8 sgi, u8 ldpc) 8019 { 8020 struct ath12k *ar = arvif->ar; 8021 u32 vdev_param; 8022 int ret; 8023 8024 lockdep_assert_held(&ar->conf_mutex); 8025 8026 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02x nss %u sgi %u\n", 8027 arvif->vdev_id, rate, nss, sgi); 8028 8029 vdev_param = WMI_VDEV_PARAM_FIXED_RATE; 8030 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8031 vdev_param, rate); 8032 if (ret) { 8033 ath12k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n", 8034 rate, ret); 8035 return ret; 8036 } 8037 8038 vdev_param = WMI_VDEV_PARAM_NSS; 8039 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8040 vdev_param, nss); 8041 if (ret) { 8042 ath12k_warn(ar->ab, "failed to set nss param %d: %d\n", 8043 nss, ret); 8044 return ret; 8045 } 8046 8047 vdev_param = WMI_VDEV_PARAM_SGI; 8048 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8049 vdev_param, sgi); 8050 if (ret) { 8051 ath12k_warn(ar->ab, "failed to set sgi param %d: %d\n", 8052 sgi, ret); 8053 return ret; 8054 } 8055 8056 vdev_param = WMI_VDEV_PARAM_LDPC; 8057 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 8058 vdev_param, ldpc); 8059 if (ret) { 8060 ath12k_warn(ar->ab, "failed to set ldpc param %d: %d\n", 8061 ldpc, ret); 8062 return ret; 8063 } 8064 8065 return 0; 8066 } 8067 8068 static bool 8069 ath12k_mac_vht_mcs_range_present(struct ath12k *ar, 8070 enum nl80211_band band, 8071 const struct cfg80211_bitrate_mask *mask) 8072 { 8073 int i; 8074 u16 vht_mcs; 8075 8076 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 8077 vht_mcs = mask->control[band].vht_mcs[i]; 8078 8079 switch (vht_mcs) { 8080 case 0: 8081 case BIT(8) - 1: 8082 case BIT(9) - 1: 8083 case BIT(10) - 1: 8084 break; 8085 default: 8086 return false; 8087 } 8088 } 8089 8090 return true; 8091 } 8092 8093 static void ath12k_mac_set_bitrate_mask_iter(void *data, 8094 struct ieee80211_sta *sta) 8095 { 8096 struct ath12k_vif *arvif = data; 8097 struct ath12k_sta *arsta = ath12k_sta_to_arsta(sta); 8098 struct ath12k *ar = arvif->ar; 8099 8100 if (arsta->arvif != arvif) 8101 return; 8102 8103 spin_lock_bh(&ar->data_lock); 8104 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED; 8105 spin_unlock_bh(&ar->data_lock); 8106 8107 ieee80211_queue_work(ath12k_ar_to_hw(ar), &arsta->update_wk); 8108 } 8109 8110 static void ath12k_mac_disable_peer_fixed_rate(void *data, 8111 struct ieee80211_sta *sta) 8112 { 8113 struct ath12k_sta *arsta = ath12k_sta_to_arsta(sta); 8114 struct ath12k_vif *arvif = data; 8115 struct ath12k *ar = arvif->ar; 8116 int ret; 8117 8118 if (arsta->arvif != arvif) 8119 return; 8120 8121 ret = ath12k_wmi_set_peer_param(ar, sta->addr, 8122 arvif->vdev_id, 8123 WMI_PEER_PARAM_FIXED_RATE, 8124 WMI_FIXED_RATE_NONE); 8125 if (ret) 8126 ath12k_warn(ar->ab, 8127 "failed to disable peer fixed rate for STA %pM ret %d\n", 8128 sta->addr, ret); 8129 } 8130 8131 static int 8132 ath12k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw, 8133 struct ieee80211_vif *vif, 8134 const struct cfg80211_bitrate_mask *mask) 8135 { 8136 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 8137 struct cfg80211_chan_def def; 8138 struct ath12k *ar = arvif->ar; 8139 enum nl80211_band band; 8140 const u8 *ht_mcs_mask; 8141 const u16 *vht_mcs_mask; 8142 u32 rate; 8143 u8 nss; 8144 u8 sgi; 8145 u8 ldpc; 8146 int single_nss; 8147 int ret; 8148 int num_rates; 8149 8150 if (ath12k_mac_vif_chan(vif, &def)) 8151 return -EPERM; 8152 8153 band = def.chan->band; 8154 ht_mcs_mask = mask->control[band].ht_mcs; 8155 vht_mcs_mask = mask->control[band].vht_mcs; 8156 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC); 8157 8158 sgi = mask->control[band].gi; 8159 if (sgi == NL80211_TXRATE_FORCE_LGI) { 8160 ret = -EINVAL; 8161 goto out; 8162 } 8163 8164 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it 8165 * requires passing at least one of used basic rates along with them. 8166 * Fixed rate setting across different preambles(legacy, HT, VHT) is 8167 * not supported by the FW. Hence use of FIXED_RATE vdev param is not 8168 * suitable for setting single HT/VHT rates. 8169 * But, there could be a single basic rate passed from userspace which 8170 * can be done through the FIXED_RATE param. 8171 */ 8172 if (ath12k_mac_has_single_legacy_rate(ar, band, mask)) { 8173 ret = ath12k_mac_get_single_legacy_rate(ar, band, mask, &rate, 8174 &nss); 8175 if (ret) { 8176 ath12k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n", 8177 arvif->vdev_id, ret); 8178 goto out; 8179 } 8180 ieee80211_iterate_stations_atomic(hw, 8181 ath12k_mac_disable_peer_fixed_rate, 8182 arvif); 8183 } else if (ath12k_mac_bitrate_mask_get_single_nss(ar, band, mask, 8184 &single_nss)) { 8185 rate = WMI_FIXED_RATE_NONE; 8186 nss = single_nss; 8187 } else { 8188 rate = WMI_FIXED_RATE_NONE; 8189 nss = min_t(u32, ar->num_tx_chains, 8190 max(ath12k_mac_max_ht_nss(ht_mcs_mask), 8191 ath12k_mac_max_vht_nss(vht_mcs_mask))); 8192 8193 /* If multiple rates across different preambles are given 8194 * we can reconfigure this info with all peers using PEER_ASSOC 8195 * command with the below exception cases. 8196 * - Single VHT Rate : peer_assoc command accommodates only MCS 8197 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211 8198 * mandates passing basic rates along with HT/VHT rates, FW 8199 * doesn't allow switching from VHT to Legacy. Hence instead of 8200 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd, 8201 * we could set this VHT rate as peer fixed rate param, which 8202 * will override FIXED rate and FW rate control algorithm. 8203 * If single VHT rate is passed along with HT rates, we select 8204 * the VHT rate as fixed rate for vht peers. 8205 * - Multiple VHT Rates : When Multiple VHT rates are given,this 8206 * can be set using RATEMASK CMD which uses FW rate-ctl alg. 8207 * TODO: Setting multiple VHT MCS and replacing peer_assoc with 8208 * RATEMASK_CMDID can cover all use cases of setting rates 8209 * across multiple preambles and rates within same type. 8210 * But requires more validation of the command at this point. 8211 */ 8212 8213 num_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band, 8214 mask); 8215 8216 if (!ath12k_mac_vht_mcs_range_present(ar, band, mask) && 8217 num_rates > 1) { 8218 /* TODO: Handle multiple VHT MCS values setting using 8219 * RATEMASK CMD 8220 */ 8221 ath12k_warn(ar->ab, 8222 "Setting more than one MCS Value in bitrate mask not supported\n"); 8223 ret = -EINVAL; 8224 goto out; 8225 } 8226 8227 ieee80211_iterate_stations_atomic(hw, 8228 ath12k_mac_disable_peer_fixed_rate, 8229 arvif); 8230 8231 mutex_lock(&ar->conf_mutex); 8232 8233 arvif->bitrate_mask = *mask; 8234 ieee80211_iterate_stations_atomic(hw, 8235 ath12k_mac_set_bitrate_mask_iter, 8236 arvif); 8237 8238 mutex_unlock(&ar->conf_mutex); 8239 } 8240 8241 mutex_lock(&ar->conf_mutex); 8242 8243 ret = ath12k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc); 8244 if (ret) { 8245 ath12k_warn(ar->ab, "failed to set fixed rate params on vdev %i: %d\n", 8246 arvif->vdev_id, ret); 8247 } 8248 8249 mutex_unlock(&ar->conf_mutex); 8250 8251 out: 8252 return ret; 8253 } 8254 8255 static void 8256 ath12k_mac_op_reconfig_complete(struct ieee80211_hw *hw, 8257 enum ieee80211_reconfig_type reconfig_type) 8258 { 8259 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 8260 struct ath12k *ar; 8261 struct ath12k_base *ab; 8262 struct ath12k_vif *arvif; 8263 int recovery_count, i; 8264 8265 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) 8266 return; 8267 8268 guard(mutex)(&ah->hw_mutex); 8269 8270 if (ah->state != ATH12K_HW_STATE_RESTARTED) 8271 return; 8272 8273 ah->state = ATH12K_HW_STATE_ON; 8274 ieee80211_wake_queues(hw); 8275 8276 for_each_ar(ah, ar, i) { 8277 mutex_lock(&ar->conf_mutex); 8278 8279 ab = ar->ab; 8280 8281 ath12k_warn(ar->ab, "pdev %d successfully recovered\n", 8282 ar->pdev->pdev_id); 8283 8284 if (ab->is_reset) { 8285 recovery_count = atomic_inc_return(&ab->recovery_count); 8286 8287 ath12k_dbg(ab, ATH12K_DBG_BOOT, "recovery count %d\n", 8288 recovery_count); 8289 8290 /* When there are multiple radios in an SOC, 8291 * the recovery has to be done for each radio 8292 */ 8293 if (recovery_count == ab->num_radios) { 8294 atomic_dec(&ab->reset_count); 8295 complete(&ab->reset_complete); 8296 ab->is_reset = false; 8297 atomic_set(&ab->fail_cont_count, 0); 8298 ath12k_dbg(ab, ATH12K_DBG_BOOT, "reset success\n"); 8299 } 8300 } 8301 8302 list_for_each_entry(arvif, &ar->arvifs, list) { 8303 ath12k_dbg(ab, ATH12K_DBG_BOOT, 8304 "reconfig cipher %d up %d vdev type %d\n", 8305 arvif->key_cipher, 8306 arvif->is_up, 8307 arvif->vdev_type); 8308 8309 /* After trigger disconnect, then upper layer will 8310 * trigger connect again, then the PN number of 8311 * upper layer will be reset to keep up with AP 8312 * side, hence PN number mismatch will not happen. 8313 */ 8314 if (arvif->is_up && 8315 arvif->vdev_type == WMI_VDEV_TYPE_STA && 8316 arvif->vdev_subtype == WMI_VDEV_SUBTYPE_NONE) { 8317 ieee80211_hw_restart_disconnect(arvif->vif); 8318 8319 ath12k_dbg(ab, ATH12K_DBG_BOOT, 8320 "restart disconnect\n"); 8321 } 8322 } 8323 8324 mutex_unlock(&ar->conf_mutex); 8325 } 8326 } 8327 8328 static void 8329 ath12k_mac_update_bss_chan_survey(struct ath12k *ar, 8330 struct ieee80211_channel *channel) 8331 { 8332 int ret; 8333 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ; 8334 8335 lockdep_assert_held(&ar->conf_mutex); 8336 8337 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) || 8338 ar->rx_channel != channel) 8339 return; 8340 8341 if (ar->scan.state != ATH12K_SCAN_IDLE) { 8342 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 8343 "ignoring bss chan info req while scanning..\n"); 8344 return; 8345 } 8346 8347 reinit_completion(&ar->bss_survey_done); 8348 8349 ret = ath12k_wmi_pdev_bss_chan_info_request(ar, type); 8350 if (ret) { 8351 ath12k_warn(ar->ab, "failed to send pdev bss chan info request\n"); 8352 return; 8353 } 8354 8355 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ); 8356 if (ret == 0) 8357 ath12k_warn(ar->ab, "bss channel survey timed out\n"); 8358 } 8359 8360 static int ath12k_mac_op_get_survey(struct ieee80211_hw *hw, int idx, 8361 struct survey_info *survey) 8362 { 8363 struct ath12k *ar; 8364 struct ieee80211_supported_band *sband; 8365 struct survey_info *ar_survey; 8366 8367 if (idx >= ATH12K_NUM_CHANS) 8368 return -ENOENT; 8369 8370 sband = hw->wiphy->bands[NL80211_BAND_2GHZ]; 8371 if (sband && idx >= sband->n_channels) { 8372 idx -= sband->n_channels; 8373 sband = NULL; 8374 } 8375 8376 if (!sband) 8377 sband = hw->wiphy->bands[NL80211_BAND_5GHZ]; 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_6GHZ]; 8385 8386 if (!sband || idx >= sband->n_channels) 8387 return -ENOENT; 8388 8389 ar = ath12k_mac_get_ar_by_chan(hw, &sband->channels[idx]); 8390 if (!ar) { 8391 if (sband->channels[idx].flags & IEEE80211_CHAN_DISABLED) { 8392 memset(survey, 0, sizeof(*survey)); 8393 return 0; 8394 } 8395 return -ENOENT; 8396 } 8397 8398 ar_survey = &ar->survey[idx]; 8399 8400 mutex_lock(&ar->conf_mutex); 8401 8402 ath12k_mac_update_bss_chan_survey(ar, &sband->channels[idx]); 8403 8404 spin_lock_bh(&ar->data_lock); 8405 memcpy(survey, ar_survey, sizeof(*survey)); 8406 spin_unlock_bh(&ar->data_lock); 8407 8408 survey->channel = &sband->channels[idx]; 8409 8410 if (ar->rx_channel == survey->channel) 8411 survey->filled |= SURVEY_INFO_IN_USE; 8412 8413 mutex_unlock(&ar->conf_mutex); 8414 return 0; 8415 } 8416 8417 static void ath12k_mac_op_sta_statistics(struct ieee80211_hw *hw, 8418 struct ieee80211_vif *vif, 8419 struct ieee80211_sta *sta, 8420 struct station_info *sinfo) 8421 { 8422 struct ath12k_sta *arsta = ath12k_sta_to_arsta(sta); 8423 8424 sinfo->rx_duration = arsta->rx_duration; 8425 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION); 8426 8427 sinfo->tx_duration = arsta->tx_duration; 8428 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION); 8429 8430 if (!arsta->txrate.legacy && !arsta->txrate.nss) 8431 return; 8432 8433 if (arsta->txrate.legacy) { 8434 sinfo->txrate.legacy = arsta->txrate.legacy; 8435 } else { 8436 sinfo->txrate.mcs = arsta->txrate.mcs; 8437 sinfo->txrate.nss = arsta->txrate.nss; 8438 sinfo->txrate.bw = arsta->txrate.bw; 8439 sinfo->txrate.he_gi = arsta->txrate.he_gi; 8440 sinfo->txrate.he_dcm = arsta->txrate.he_dcm; 8441 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc; 8442 } 8443 sinfo->txrate.flags = arsta->txrate.flags; 8444 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 8445 8446 /* TODO: Use real NF instead of default one. */ 8447 sinfo->signal = arsta->rssi_comb + ATH12K_DEFAULT_NOISE_FLOOR; 8448 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 8449 } 8450 8451 static int ath12k_mac_op_cancel_remain_on_channel(struct ieee80211_hw *hw, 8452 struct ieee80211_vif *vif) 8453 { 8454 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 8455 struct ath12k *ar; 8456 8457 ar = ath12k_ah_to_ar(ah, 0); 8458 8459 mutex_lock(&ar->conf_mutex); 8460 8461 spin_lock_bh(&ar->data_lock); 8462 ar->scan.roc_notify = false; 8463 spin_unlock_bh(&ar->data_lock); 8464 8465 ath12k_scan_abort(ar); 8466 8467 mutex_unlock(&ar->conf_mutex); 8468 8469 cancel_delayed_work_sync(&ar->scan.timeout); 8470 8471 return 0; 8472 } 8473 8474 static int ath12k_mac_op_remain_on_channel(struct ieee80211_hw *hw, 8475 struct ieee80211_vif *vif, 8476 struct ieee80211_channel *chan, 8477 int duration, 8478 enum ieee80211_roc_type type) 8479 { 8480 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 8481 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 8482 struct ath12k_wmi_scan_req_arg arg; 8483 struct ath12k *ar, *prev_ar; 8484 u32 scan_time_msec; 8485 bool create = true; 8486 int ret; 8487 8488 if (ah->num_radio == 1) { 8489 WARN_ON(!arvif->is_created); 8490 ar = ath12k_ah_to_ar(ah, 0); 8491 goto scan; 8492 } 8493 8494 ar = ath12k_mac_select_scan_device(hw, vif, chan->center_freq); 8495 if (!ar) 8496 return -EINVAL; 8497 8498 /* If the vif is already assigned to a specific vdev of an ar, 8499 * check whether its already started, vdev which is started 8500 * are not allowed to switch to a new radio. 8501 * If the vdev is not started, but was earlier created on a 8502 * different ar, delete that vdev and create a new one. We don't 8503 * delete at the scan stop as an optimization to avoid redundant 8504 * delete-create vdev's for the same ar, in case the request is 8505 * always on the same band for the vif 8506 */ 8507 if (arvif->is_created) { 8508 if (WARN_ON(!arvif->ar)) 8509 return -EINVAL; 8510 8511 if (ar != arvif->ar && arvif->is_started) 8512 return -EBUSY; 8513 8514 if (ar != arvif->ar) { 8515 /* backup the previously used ar ptr, since the vdev delete 8516 * would assign the arvif->ar to NULL after the call 8517 */ 8518 prev_ar = arvif->ar; 8519 mutex_lock(&prev_ar->conf_mutex); 8520 ret = ath12k_mac_vdev_delete(prev_ar, vif); 8521 mutex_unlock(&prev_ar->conf_mutex); 8522 if (ret) { 8523 ath12k_warn(prev_ar->ab, 8524 "unable to delete scan vdev for roc: %d\n", 8525 ret); 8526 return ret; 8527 } 8528 } else { 8529 create = false; 8530 } 8531 } 8532 8533 if (create) { 8534 mutex_lock(&ar->conf_mutex); 8535 ret = ath12k_mac_vdev_create(ar, vif); 8536 mutex_unlock(&ar->conf_mutex); 8537 if (ret) { 8538 ath12k_warn(ar->ab, "unable to create scan vdev for roc: %d\n", 8539 ret); 8540 return -EINVAL; 8541 } 8542 } 8543 8544 scan: 8545 mutex_lock(&ar->conf_mutex); 8546 spin_lock_bh(&ar->data_lock); 8547 8548 switch (ar->scan.state) { 8549 case ATH12K_SCAN_IDLE: 8550 reinit_completion(&ar->scan.started); 8551 reinit_completion(&ar->scan.completed); 8552 reinit_completion(&ar->scan.on_channel); 8553 ar->scan.state = ATH12K_SCAN_STARTING; 8554 ar->scan.is_roc = true; 8555 ar->scan.vdev_id = arvif->vdev_id; 8556 ar->scan.roc_freq = chan->center_freq; 8557 ar->scan.roc_notify = true; 8558 ret = 0; 8559 break; 8560 case ATH12K_SCAN_STARTING: 8561 case ATH12K_SCAN_RUNNING: 8562 case ATH12K_SCAN_ABORTING: 8563 ret = -EBUSY; 8564 break; 8565 } 8566 8567 spin_unlock_bh(&ar->data_lock); 8568 8569 if (ret) 8570 goto exit; 8571 8572 scan_time_msec = hw->wiphy->max_remain_on_channel_duration * 2; 8573 8574 memset(&arg, 0, sizeof(arg)); 8575 ath12k_wmi_start_scan_init(ar, &arg); 8576 arg.num_chan = 1; 8577 arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list), 8578 GFP_KERNEL); 8579 if (!arg.chan_list) { 8580 ret = -ENOMEM; 8581 goto exit; 8582 } 8583 8584 arg.vdev_id = arvif->vdev_id; 8585 arg.scan_id = ATH12K_SCAN_ID; 8586 arg.chan_list[0] = chan->center_freq; 8587 arg.dwell_time_active = scan_time_msec; 8588 arg.dwell_time_passive = scan_time_msec; 8589 arg.max_scan_time = scan_time_msec; 8590 arg.scan_f_passive = 1; 8591 arg.burst_duration = duration; 8592 8593 ret = ath12k_start_scan(ar, &arg); 8594 if (ret) { 8595 ath12k_warn(ar->ab, "failed to start roc scan: %d\n", ret); 8596 8597 spin_lock_bh(&ar->data_lock); 8598 ar->scan.state = ATH12K_SCAN_IDLE; 8599 spin_unlock_bh(&ar->data_lock); 8600 goto free_chan_list; 8601 } 8602 8603 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ); 8604 if (ret == 0) { 8605 ath12k_warn(ar->ab, "failed to switch to channel for roc scan\n"); 8606 ret = ath12k_scan_stop(ar); 8607 if (ret) 8608 ath12k_warn(ar->ab, "failed to stop scan: %d\n", ret); 8609 ret = -ETIMEDOUT; 8610 goto free_chan_list; 8611 } 8612 8613 ieee80211_queue_delayed_work(hw, &ar->scan.timeout, 8614 msecs_to_jiffies(duration)); 8615 8616 ret = 0; 8617 8618 free_chan_list: 8619 kfree(arg.chan_list); 8620 exit: 8621 mutex_unlock(&ar->conf_mutex); 8622 8623 return ret; 8624 } 8625 8626 static void ath12k_mac_op_set_rekey_data(struct ieee80211_hw *hw, 8627 struct ieee80211_vif *vif, 8628 struct cfg80211_gtk_rekey_data *data) 8629 { 8630 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 8631 struct ath12k_rekey_data *rekey_data = &arvif->rekey_data; 8632 struct ath12k_hw *ah = ath12k_hw_to_ah(hw); 8633 struct ath12k *ar = ath12k_ah_to_ar(ah, 0); 8634 8635 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac set rekey data vdev %d\n", 8636 arvif->vdev_id); 8637 8638 mutex_lock(&ar->conf_mutex); 8639 8640 memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN); 8641 memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN); 8642 8643 /* The supplicant works on big-endian, the firmware expects it on 8644 * little endian. 8645 */ 8646 rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr); 8647 8648 arvif->rekey_data.enable_offload = true; 8649 8650 ath12k_dbg_dump(ar->ab, ATH12K_DBG_MAC, "kck", NULL, 8651 rekey_data->kck, NL80211_KCK_LEN); 8652 ath12k_dbg_dump(ar->ab, ATH12K_DBG_MAC, "kek", NULL, 8653 rekey_data->kck, NL80211_KEK_LEN); 8654 ath12k_dbg_dump(ar->ab, ATH12K_DBG_MAC, "replay ctr", NULL, 8655 &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr)); 8656 8657 mutex_unlock(&ar->conf_mutex); 8658 } 8659 8660 static const struct ieee80211_ops ath12k_ops = { 8661 .tx = ath12k_mac_op_tx, 8662 .wake_tx_queue = ieee80211_handle_wake_tx_queue, 8663 .start = ath12k_mac_op_start, 8664 .stop = ath12k_mac_op_stop, 8665 .reconfig_complete = ath12k_mac_op_reconfig_complete, 8666 .add_interface = ath12k_mac_op_add_interface, 8667 .remove_interface = ath12k_mac_op_remove_interface, 8668 .update_vif_offload = ath12k_mac_op_update_vif_offload, 8669 .config = ath12k_mac_op_config, 8670 .bss_info_changed = ath12k_mac_op_bss_info_changed, 8671 .configure_filter = ath12k_mac_op_configure_filter, 8672 .hw_scan = ath12k_mac_op_hw_scan, 8673 .cancel_hw_scan = ath12k_mac_op_cancel_hw_scan, 8674 .set_key = ath12k_mac_op_set_key, 8675 .set_rekey_data = ath12k_mac_op_set_rekey_data, 8676 .sta_state = ath12k_mac_op_sta_state, 8677 .sta_set_txpwr = ath12k_mac_op_sta_set_txpwr, 8678 .sta_rc_update = ath12k_mac_op_sta_rc_update, 8679 .conf_tx = ath12k_mac_op_conf_tx, 8680 .set_antenna = ath12k_mac_op_set_antenna, 8681 .get_antenna = ath12k_mac_op_get_antenna, 8682 .ampdu_action = ath12k_mac_op_ampdu_action, 8683 .add_chanctx = ath12k_mac_op_add_chanctx, 8684 .remove_chanctx = ath12k_mac_op_remove_chanctx, 8685 .change_chanctx = ath12k_mac_op_change_chanctx, 8686 .assign_vif_chanctx = ath12k_mac_op_assign_vif_chanctx, 8687 .unassign_vif_chanctx = ath12k_mac_op_unassign_vif_chanctx, 8688 .switch_vif_chanctx = ath12k_mac_op_switch_vif_chanctx, 8689 .set_rts_threshold = ath12k_mac_op_set_rts_threshold, 8690 .set_frag_threshold = ath12k_mac_op_set_frag_threshold, 8691 .set_bitrate_mask = ath12k_mac_op_set_bitrate_mask, 8692 .get_survey = ath12k_mac_op_get_survey, 8693 .flush = ath12k_mac_op_flush, 8694 .sta_statistics = ath12k_mac_op_sta_statistics, 8695 .remain_on_channel = ath12k_mac_op_remain_on_channel, 8696 .cancel_remain_on_channel = ath12k_mac_op_cancel_remain_on_channel, 8697 8698 #ifdef CONFIG_PM 8699 .suspend = ath12k_wow_op_suspend, 8700 .resume = ath12k_wow_op_resume, 8701 .set_wakeup = ath12k_wow_op_set_wakeup, 8702 #endif 8703 }; 8704 8705 static void ath12k_mac_update_ch_list(struct ath12k *ar, 8706 struct ieee80211_supported_band *band, 8707 u32 freq_low, u32 freq_high) 8708 { 8709 int i; 8710 8711 if (!(freq_low && freq_high)) 8712 return; 8713 8714 for (i = 0; i < band->n_channels; i++) { 8715 if (band->channels[i].center_freq < freq_low || 8716 band->channels[i].center_freq > freq_high) 8717 band->channels[i].flags |= IEEE80211_CHAN_DISABLED; 8718 } 8719 8720 ar->freq_low = freq_low; 8721 ar->freq_high = freq_high; 8722 } 8723 8724 static u32 ath12k_get_phy_id(struct ath12k *ar, u32 band) 8725 { 8726 struct ath12k_pdev *pdev = ar->pdev; 8727 struct ath12k_pdev_cap *pdev_cap = &pdev->cap; 8728 8729 if (band == WMI_HOST_WLAN_2G_CAP) 8730 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id; 8731 8732 if (band == WMI_HOST_WLAN_5G_CAP) 8733 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id; 8734 8735 ath12k_warn(ar->ab, "unsupported phy cap:%d\n", band); 8736 8737 return 0; 8738 } 8739 8740 static int ath12k_mac_setup_channels_rates(struct ath12k *ar, 8741 u32 supported_bands, 8742 struct ieee80211_supported_band *bands[]) 8743 { 8744 struct ieee80211_supported_band *band; 8745 struct ath12k_wmi_hal_reg_capabilities_ext_arg *reg_cap; 8746 struct ath12k_hw *ah = ar->ah; 8747 void *channels; 8748 u32 phy_id; 8749 8750 BUILD_BUG_ON((ARRAY_SIZE(ath12k_2ghz_channels) + 8751 ARRAY_SIZE(ath12k_5ghz_channels) + 8752 ARRAY_SIZE(ath12k_6ghz_channels)) != 8753 ATH12K_NUM_CHANS); 8754 8755 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx]; 8756 8757 if (supported_bands & WMI_HOST_WLAN_2G_CAP) { 8758 channels = kmemdup(ath12k_2ghz_channels, 8759 sizeof(ath12k_2ghz_channels), 8760 GFP_KERNEL); 8761 if (!channels) 8762 return -ENOMEM; 8763 8764 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 8765 band->band = NL80211_BAND_2GHZ; 8766 band->n_channels = ARRAY_SIZE(ath12k_2ghz_channels); 8767 band->channels = channels; 8768 band->n_bitrates = ath12k_g_rates_size; 8769 band->bitrates = ath12k_g_rates; 8770 bands[NL80211_BAND_2GHZ] = band; 8771 8772 if (ar->ab->hw_params->single_pdev_only) { 8773 phy_id = ath12k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP); 8774 reg_cap = &ar->ab->hal_reg_cap[phy_id]; 8775 } 8776 ath12k_mac_update_ch_list(ar, band, 8777 reg_cap->low_2ghz_chan, 8778 reg_cap->high_2ghz_chan); 8779 } 8780 8781 if (supported_bands & WMI_HOST_WLAN_5G_CAP) { 8782 if (reg_cap->high_5ghz_chan >= ATH12K_MIN_6G_FREQ) { 8783 channels = kmemdup(ath12k_6ghz_channels, 8784 sizeof(ath12k_6ghz_channels), GFP_KERNEL); 8785 if (!channels) { 8786 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8787 return -ENOMEM; 8788 } 8789 8790 ar->supports_6ghz = true; 8791 band = &ar->mac.sbands[NL80211_BAND_6GHZ]; 8792 band->band = NL80211_BAND_6GHZ; 8793 band->n_channels = ARRAY_SIZE(ath12k_6ghz_channels); 8794 band->channels = channels; 8795 band->n_bitrates = ath12k_a_rates_size; 8796 band->bitrates = ath12k_a_rates; 8797 bands[NL80211_BAND_6GHZ] = band; 8798 ath12k_mac_update_ch_list(ar, band, 8799 reg_cap->low_5ghz_chan, 8800 reg_cap->high_5ghz_chan); 8801 ah->use_6ghz_regd = true; 8802 } 8803 8804 if (reg_cap->low_5ghz_chan < ATH12K_MIN_6G_FREQ) { 8805 channels = kmemdup(ath12k_5ghz_channels, 8806 sizeof(ath12k_5ghz_channels), 8807 GFP_KERNEL); 8808 if (!channels) { 8809 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8810 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 8811 return -ENOMEM; 8812 } 8813 8814 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 8815 band->band = NL80211_BAND_5GHZ; 8816 band->n_channels = ARRAY_SIZE(ath12k_5ghz_channels); 8817 band->channels = channels; 8818 band->n_bitrates = ath12k_a_rates_size; 8819 band->bitrates = ath12k_a_rates; 8820 bands[NL80211_BAND_5GHZ] = band; 8821 8822 if (ar->ab->hw_params->single_pdev_only) { 8823 phy_id = ath12k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP); 8824 reg_cap = &ar->ab->hal_reg_cap[phy_id]; 8825 } 8826 8827 ath12k_mac_update_ch_list(ar, band, 8828 reg_cap->low_5ghz_chan, 8829 reg_cap->high_5ghz_chan); 8830 } 8831 } 8832 8833 return 0; 8834 } 8835 8836 static u16 ath12k_mac_get_ifmodes(struct ath12k_hw *ah) 8837 { 8838 struct ath12k *ar; 8839 int i; 8840 u16 interface_modes = U16_MAX; 8841 8842 for_each_ar(ah, ar, i) 8843 interface_modes &= ar->ab->hw_params->interface_modes; 8844 8845 return interface_modes == U16_MAX ? 0 : interface_modes; 8846 } 8847 8848 static bool ath12k_mac_is_iface_mode_enable(struct ath12k_hw *ah, 8849 enum nl80211_iftype type) 8850 { 8851 struct ath12k *ar; 8852 int i; 8853 u16 interface_modes, mode; 8854 bool is_enable = true; 8855 8856 mode = BIT(type); 8857 for_each_ar(ah, ar, i) { 8858 interface_modes = ar->ab->hw_params->interface_modes; 8859 if (!(interface_modes & mode)) { 8860 is_enable = false; 8861 break; 8862 } 8863 } 8864 8865 return is_enable; 8866 } 8867 8868 static int ath12k_mac_setup_iface_combinations(struct ath12k_hw *ah) 8869 { 8870 struct wiphy *wiphy = ah->hw->wiphy; 8871 struct ieee80211_iface_combination *combinations; 8872 struct ieee80211_iface_limit *limits; 8873 int n_limits, max_interfaces; 8874 bool ap, mesh, p2p; 8875 8876 ap = ath12k_mac_is_iface_mode_enable(ah, NL80211_IFTYPE_AP); 8877 p2p = ath12k_mac_is_iface_mode_enable(ah, NL80211_IFTYPE_P2P_DEVICE); 8878 8879 mesh = IS_ENABLED(CONFIG_MAC80211_MESH) && 8880 ath12k_mac_is_iface_mode_enable(ah, NL80211_IFTYPE_MESH_POINT); 8881 8882 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL); 8883 if (!combinations) 8884 return -ENOMEM; 8885 8886 if ((ap || mesh) && !p2p) { 8887 n_limits = 2; 8888 max_interfaces = 16; 8889 } else if (p2p) { 8890 n_limits = 3; 8891 if (ap || mesh) 8892 max_interfaces = 16; 8893 else 8894 max_interfaces = 3; 8895 } else { 8896 n_limits = 1; 8897 max_interfaces = 1; 8898 } 8899 8900 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL); 8901 if (!limits) { 8902 kfree(combinations); 8903 return -ENOMEM; 8904 } 8905 8906 limits[0].max = 1; 8907 limits[0].types |= BIT(NL80211_IFTYPE_STATION); 8908 8909 if (ap || mesh || p2p) 8910 limits[1].max = max_interfaces; 8911 8912 if (ap) 8913 limits[1].types |= BIT(NL80211_IFTYPE_AP); 8914 8915 if (mesh) 8916 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT); 8917 8918 if (p2p) { 8919 limits[1].types |= BIT(NL80211_IFTYPE_P2P_CLIENT) | 8920 BIT(NL80211_IFTYPE_P2P_GO); 8921 limits[2].max = 1; 8922 limits[2].types |= BIT(NL80211_IFTYPE_P2P_DEVICE); 8923 } 8924 8925 combinations[0].limits = limits; 8926 combinations[0].n_limits = n_limits; 8927 combinations[0].max_interfaces = max_interfaces; 8928 combinations[0].num_different_channels = 1; 8929 combinations[0].beacon_int_infra_match = true; 8930 combinations[0].beacon_int_min_gcd = 100; 8931 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 8932 BIT(NL80211_CHAN_WIDTH_20) | 8933 BIT(NL80211_CHAN_WIDTH_40) | 8934 BIT(NL80211_CHAN_WIDTH_80); 8935 8936 wiphy->iface_combinations = combinations; 8937 wiphy->n_iface_combinations = 1; 8938 8939 return 0; 8940 } 8941 8942 static const u8 ath12k_if_types_ext_capa[] = { 8943 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 8944 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT, 8945 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 8946 }; 8947 8948 static const u8 ath12k_if_types_ext_capa_sta[] = { 8949 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 8950 [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT, 8951 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 8952 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT, 8953 }; 8954 8955 static const u8 ath12k_if_types_ext_capa_ap[] = { 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_RESPONDER_SUPPORT, 8960 [10] = WLAN_EXT_CAPA11_EMA_SUPPORT, 8961 }; 8962 8963 static const struct wiphy_iftype_ext_capab ath12k_iftypes_ext_capa[] = { 8964 { 8965 .extended_capabilities = ath12k_if_types_ext_capa, 8966 .extended_capabilities_mask = ath12k_if_types_ext_capa, 8967 .extended_capabilities_len = sizeof(ath12k_if_types_ext_capa), 8968 }, { 8969 .iftype = NL80211_IFTYPE_STATION, 8970 .extended_capabilities = ath12k_if_types_ext_capa_sta, 8971 .extended_capabilities_mask = ath12k_if_types_ext_capa_sta, 8972 .extended_capabilities_len = 8973 sizeof(ath12k_if_types_ext_capa_sta), 8974 }, { 8975 .iftype = NL80211_IFTYPE_AP, 8976 .extended_capabilities = ath12k_if_types_ext_capa_ap, 8977 .extended_capabilities_mask = ath12k_if_types_ext_capa_ap, 8978 .extended_capabilities_len = 8979 sizeof(ath12k_if_types_ext_capa_ap), 8980 }, 8981 }; 8982 8983 static void ath12k_mac_cleanup_unregister(struct ath12k *ar) 8984 { 8985 idr_for_each(&ar->txmgmt_idr, ath12k_mac_tx_mgmt_pending_free, ar); 8986 idr_destroy(&ar->txmgmt_idr); 8987 8988 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 8989 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 8990 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 8991 } 8992 8993 static void ath12k_mac_hw_unregister(struct ath12k_hw *ah) 8994 { 8995 struct ieee80211_hw *hw = ah->hw; 8996 struct wiphy *wiphy = hw->wiphy; 8997 struct ath12k *ar; 8998 int i; 8999 9000 for_each_ar(ah, ar, i) { 9001 cancel_work_sync(&ar->regd_update_work); 9002 ath12k_debugfs_unregister(ar); 9003 } 9004 9005 ieee80211_unregister_hw(hw); 9006 9007 for_each_ar(ah, ar, i) 9008 ath12k_mac_cleanup_unregister(ar); 9009 9010 kfree(wiphy->iface_combinations[0].limits); 9011 kfree(wiphy->iface_combinations); 9012 9013 SET_IEEE80211_DEV(hw, NULL); 9014 } 9015 9016 static int ath12k_mac_setup_register(struct ath12k *ar, 9017 u32 *ht_cap, 9018 struct ieee80211_supported_band *bands[]) 9019 { 9020 struct ath12k_pdev_cap *cap = &ar->pdev->cap; 9021 int ret; 9022 9023 init_waitqueue_head(&ar->txmgmt_empty_waitq); 9024 idr_init(&ar->txmgmt_idr); 9025 spin_lock_init(&ar->txmgmt_idr_lock); 9026 9027 ath12k_pdev_caps_update(ar); 9028 9029 ret = ath12k_mac_setup_channels_rates(ar, 9030 cap->supported_bands, 9031 bands); 9032 if (ret) 9033 return ret; 9034 9035 ath12k_mac_setup_ht_vht_cap(ar, cap, ht_cap); 9036 ath12k_mac_setup_sband_iftype_data(ar, cap); 9037 9038 ar->max_num_stations = ath12k_core_get_max_station_per_radio(ar->ab); 9039 ar->max_num_peers = ath12k_core_get_max_peers_per_radio(ar->ab); 9040 9041 return 0; 9042 } 9043 9044 static int ath12k_mac_hw_register(struct ath12k_hw *ah) 9045 { 9046 struct ieee80211_hw *hw = ah->hw; 9047 struct wiphy *wiphy = hw->wiphy; 9048 struct ath12k *ar = ath12k_ah_to_ar(ah, 0); 9049 struct ath12k_base *ab = ar->ab; 9050 struct ath12k_pdev *pdev; 9051 struct ath12k_pdev_cap *cap; 9052 static const u32 cipher_suites[] = { 9053 WLAN_CIPHER_SUITE_TKIP, 9054 WLAN_CIPHER_SUITE_CCMP, 9055 WLAN_CIPHER_SUITE_AES_CMAC, 9056 WLAN_CIPHER_SUITE_BIP_CMAC_256, 9057 WLAN_CIPHER_SUITE_BIP_GMAC_128, 9058 WLAN_CIPHER_SUITE_BIP_GMAC_256, 9059 WLAN_CIPHER_SUITE_GCMP, 9060 WLAN_CIPHER_SUITE_GCMP_256, 9061 WLAN_CIPHER_SUITE_CCMP_256, 9062 }; 9063 int ret, i, j; 9064 u32 ht_cap = U32_MAX, antennas_rx = 0, antennas_tx = 0; 9065 bool is_6ghz = false, is_raw_mode = false, is_monitor_disable = false; 9066 u8 *mac_addr = NULL; 9067 u8 mbssid_max_interfaces = 0; 9068 9069 wiphy->max_ap_assoc_sta = 0; 9070 9071 for_each_ar(ah, ar, i) { 9072 u32 ht_cap_info = 0; 9073 9074 pdev = ar->pdev; 9075 if (ar->ab->pdevs_macaddr_valid) { 9076 ether_addr_copy(ar->mac_addr, pdev->mac_addr); 9077 } else { 9078 ether_addr_copy(ar->mac_addr, ar->ab->mac_addr); 9079 ar->mac_addr[4] += ar->pdev_idx; 9080 } 9081 9082 ret = ath12k_mac_setup_register(ar, &ht_cap_info, hw->wiphy->bands); 9083 if (ret) 9084 goto err_cleanup_unregister; 9085 9086 ht_cap &= ht_cap_info; 9087 wiphy->max_ap_assoc_sta += ar->max_num_stations; 9088 9089 /* Advertise the max antenna support of all radios, driver can handle 9090 * per pdev specific antenna setting based on pdev cap when antenna 9091 * changes are made 9092 */ 9093 cap = &pdev->cap; 9094 9095 antennas_rx = max_t(u32, antennas_rx, cap->rx_chain_mask); 9096 antennas_tx = max_t(u32, antennas_tx, cap->tx_chain_mask); 9097 9098 if (ar->supports_6ghz) 9099 is_6ghz = true; 9100 9101 if (test_bit(ATH12K_FLAG_RAW_MODE, &ar->ab->dev_flags)) 9102 is_raw_mode = true; 9103 9104 if (!ar->ab->hw_params->supports_monitor) 9105 is_monitor_disable = true; 9106 9107 if (i == 0) 9108 mac_addr = ar->mac_addr; 9109 else 9110 mac_addr = ab->mac_addr; 9111 9112 mbssid_max_interfaces += TARGET_NUM_VDEVS; 9113 } 9114 9115 wiphy->available_antennas_rx = antennas_rx; 9116 wiphy->available_antennas_tx = antennas_tx; 9117 9118 SET_IEEE80211_PERM_ADDR(hw, mac_addr); 9119 SET_IEEE80211_DEV(hw, ab->dev); 9120 9121 ret = ath12k_mac_setup_iface_combinations(ah); 9122 if (ret) { 9123 ath12k_err(ab, "failed to setup interface combinations: %d\n", ret); 9124 goto err_complete_cleanup_unregister; 9125 } 9126 9127 wiphy->interface_modes = ath12k_mac_get_ifmodes(ah); 9128 9129 if (ah->num_radio == 1 && 9130 wiphy->bands[NL80211_BAND_2GHZ] && 9131 wiphy->bands[NL80211_BAND_5GHZ] && 9132 wiphy->bands[NL80211_BAND_6GHZ]) 9133 ieee80211_hw_set(hw, SINGLE_SCAN_ON_ALL_BANDS); 9134 9135 ieee80211_hw_set(hw, SIGNAL_DBM); 9136 ieee80211_hw_set(hw, SUPPORTS_PS); 9137 ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS); 9138 ieee80211_hw_set(hw, MFP_CAPABLE); 9139 ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS); 9140 ieee80211_hw_set(hw, HAS_RATE_CONTROL); 9141 ieee80211_hw_set(hw, AP_LINK_PS); 9142 ieee80211_hw_set(hw, SPECTRUM_MGMT); 9143 ieee80211_hw_set(hw, CONNECTION_MONITOR); 9144 ieee80211_hw_set(hw, SUPPORTS_PER_STA_GTK); 9145 ieee80211_hw_set(hw, CHANCTX_STA_CSA); 9146 ieee80211_hw_set(hw, QUEUE_CONTROL); 9147 ieee80211_hw_set(hw, SUPPORTS_TX_FRAG); 9148 ieee80211_hw_set(hw, REPORTS_LOW_ACK); 9149 9150 if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) { 9151 ieee80211_hw_set(hw, AMPDU_AGGREGATION); 9152 ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW); 9153 ieee80211_hw_set(hw, SUPPORTS_REORDERING_BUFFER); 9154 ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU); 9155 ieee80211_hw_set(hw, USES_RSS); 9156 } 9157 9158 wiphy->features |= NL80211_FEATURE_STATIC_SMPS; 9159 wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 9160 9161 /* TODO: Check if HT capability advertised from firmware is different 9162 * for each band for a dual band capable radio. It will be tricky to 9163 * handle it when the ht capability different for each band. 9164 */ 9165 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS || 9166 (ar->supports_6ghz && ab->hw_params->supports_dynamic_smps_6ghz)) 9167 wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS; 9168 9169 wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 9170 wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 9171 9172 hw->max_listen_interval = ATH12K_MAX_HW_LISTEN_INTERVAL; 9173 9174 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 9175 wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 9176 wiphy->max_remain_on_channel_duration = 5000; 9177 9178 wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 9179 wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 9180 NL80211_FEATURE_AP_SCAN; 9181 9182 /* MLO is not yet supported so disable Wireless Extensions for now 9183 * to make sure ath12k users don't use it. This flag can be removed 9184 * once WIPHY_FLAG_SUPPORTS_MLO is enabled. 9185 */ 9186 wiphy->flags |= WIPHY_FLAG_DISABLE_WEXT; 9187 9188 hw->queues = ATH12K_HW_MAX_QUEUES; 9189 wiphy->tx_queue_len = ATH12K_QUEUE_LEN; 9190 hw->offchannel_tx_hw_queue = ATH12K_HW_MAX_QUEUES - 1; 9191 hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_EHT; 9192 9193 hw->vif_data_size = sizeof(struct ath12k_vif); 9194 hw->sta_data_size = sizeof(struct ath12k_sta); 9195 hw->extra_tx_headroom = ab->hw_params->iova_mask; 9196 9197 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 9198 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_STA_TX_PWR); 9199 9200 wiphy->cipher_suites = cipher_suites; 9201 wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 9202 9203 wiphy->iftype_ext_capab = ath12k_iftypes_ext_capa; 9204 wiphy->num_iftype_ext_capab = ARRAY_SIZE(ath12k_iftypes_ext_capa); 9205 9206 wiphy->mbssid_max_interfaces = mbssid_max_interfaces; 9207 wiphy->ema_max_profile_periodicity = TARGET_EMA_MAX_PROFILE_PERIOD; 9208 9209 if (is_6ghz) { 9210 wiphy_ext_feature_set(wiphy, 9211 NL80211_EXT_FEATURE_FILS_DISCOVERY); 9212 wiphy_ext_feature_set(wiphy, 9213 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP); 9214 } 9215 9216 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_PUNCT); 9217 9218 ath12k_reg_init(hw); 9219 9220 if (!is_raw_mode) { 9221 hw->netdev_features = NETIF_F_HW_CSUM; 9222 ieee80211_hw_set(hw, SW_CRYPTO_CONTROL); 9223 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT); 9224 } 9225 9226 if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) { 9227 wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS; 9228 wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS; 9229 wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH; 9230 wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS; 9231 wiphy->max_sched_scan_plan_interval = 9232 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT; 9233 wiphy->max_sched_scan_plan_iterations = 9234 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS; 9235 wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR; 9236 } 9237 9238 ret = ath12k_wow_init(ar); 9239 if (ret) { 9240 ath12k_warn(ar->ab, "failed to init wow: %d\n", ret); 9241 goto err_free_if_combs; 9242 } 9243 9244 ret = ieee80211_register_hw(hw); 9245 if (ret) { 9246 ath12k_err(ab, "ieee80211 registration failed: %d\n", ret); 9247 goto err_free_if_combs; 9248 } 9249 9250 if (is_monitor_disable) 9251 /* There's a race between calling ieee80211_register_hw() 9252 * and here where the monitor mode is enabled for a little 9253 * while. But that time is so short and in practise it make 9254 * a difference in real life. 9255 */ 9256 wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR); 9257 9258 for_each_ar(ah, ar, i) { 9259 /* Apply the regd received during initialization */ 9260 ret = ath12k_regd_update(ar, true); 9261 if (ret) { 9262 ath12k_err(ar->ab, "ath12k regd update failed: %d\n", ret); 9263 goto err_unregister_hw; 9264 } 9265 9266 ath12k_debugfs_register(ar); 9267 } 9268 9269 return 0; 9270 9271 err_unregister_hw: 9272 for_each_ar(ah, ar, i) 9273 ath12k_debugfs_unregister(ar); 9274 9275 ieee80211_unregister_hw(hw); 9276 9277 err_free_if_combs: 9278 kfree(wiphy->iface_combinations[0].limits); 9279 kfree(wiphy->iface_combinations); 9280 9281 err_complete_cleanup_unregister: 9282 i = ah->num_radio; 9283 9284 err_cleanup_unregister: 9285 for (j = 0; j < i; j++) { 9286 ar = ath12k_ah_to_ar(ah, j); 9287 ath12k_mac_cleanup_unregister(ar); 9288 } 9289 9290 SET_IEEE80211_DEV(hw, NULL); 9291 9292 return ret; 9293 } 9294 9295 static void ath12k_mac_setup(struct ath12k *ar) 9296 { 9297 struct ath12k_base *ab = ar->ab; 9298 struct ath12k_pdev *pdev = ar->pdev; 9299 u8 pdev_idx = ar->pdev_idx; 9300 9301 ar->lmac_id = ath12k_hw_get_mac_from_pdev_id(ab->hw_params, pdev_idx); 9302 9303 ar->wmi = &ab->wmi_ab.wmi[pdev_idx]; 9304 /* FIXME: wmi[0] is already initialized during attach, 9305 * Should we do this again? 9306 */ 9307 ath12k_wmi_pdev_attach(ab, pdev_idx); 9308 9309 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask; 9310 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask; 9311 ar->num_tx_chains = hweight32(pdev->cap.tx_chain_mask); 9312 ar->num_rx_chains = hweight32(pdev->cap.rx_chain_mask); 9313 9314 spin_lock_init(&ar->data_lock); 9315 INIT_LIST_HEAD(&ar->arvifs); 9316 INIT_LIST_HEAD(&ar->ppdu_stats_info); 9317 mutex_init(&ar->conf_mutex); 9318 init_completion(&ar->vdev_setup_done); 9319 init_completion(&ar->vdev_delete_done); 9320 init_completion(&ar->peer_assoc_done); 9321 init_completion(&ar->peer_delete_done); 9322 init_completion(&ar->install_key_done); 9323 init_completion(&ar->bss_survey_done); 9324 init_completion(&ar->scan.started); 9325 init_completion(&ar->scan.completed); 9326 init_completion(&ar->scan.on_channel); 9327 9328 INIT_DELAYED_WORK(&ar->scan.timeout, ath12k_scan_timeout_work); 9329 INIT_WORK(&ar->regd_update_work, ath12k_regd_update_work); 9330 9331 INIT_WORK(&ar->wmi_mgmt_tx_work, ath12k_mgmt_over_wmi_tx_work); 9332 skb_queue_head_init(&ar->wmi_mgmt_tx_queue); 9333 } 9334 9335 int ath12k_mac_register(struct ath12k_base *ab) 9336 { 9337 struct ath12k_hw *ah; 9338 int i; 9339 int ret; 9340 9341 if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags)) 9342 return 0; 9343 9344 /* Initialize channel counters frequency value in hertz */ 9345 ab->cc_freq_hz = 320000; 9346 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1; 9347 9348 for (i = 0; i < ab->num_hw; i++) { 9349 ah = ab->ah[i]; 9350 9351 ret = ath12k_mac_hw_register(ah); 9352 if (ret) 9353 goto err; 9354 } 9355 9356 return 0; 9357 9358 err: 9359 for (i = i - 1; i >= 0; i--) { 9360 ah = ab->ah[i]; 9361 if (!ah) 9362 continue; 9363 9364 ath12k_mac_hw_unregister(ah); 9365 } 9366 9367 return ret; 9368 } 9369 9370 void ath12k_mac_unregister(struct ath12k_base *ab) 9371 { 9372 struct ath12k_hw *ah; 9373 int i; 9374 9375 for (i = ab->num_hw - 1; i >= 0; i--) { 9376 ah = ab->ah[i]; 9377 if (!ah) 9378 continue; 9379 9380 ath12k_mac_hw_unregister(ah); 9381 } 9382 } 9383 9384 static void ath12k_mac_hw_destroy(struct ath12k_hw *ah) 9385 { 9386 ieee80211_free_hw(ah->hw); 9387 } 9388 9389 static struct ath12k_hw *ath12k_mac_hw_allocate(struct ath12k_base *ab, 9390 struct ath12k_pdev_map *pdev_map, 9391 u8 num_pdev_map) 9392 { 9393 struct ieee80211_hw *hw; 9394 struct ath12k *ar; 9395 struct ath12k_pdev *pdev; 9396 struct ath12k_hw *ah; 9397 int i; 9398 u8 pdev_idx; 9399 9400 hw = ieee80211_alloc_hw(struct_size(ah, radio, num_pdev_map), 9401 &ath12k_ops); 9402 if (!hw) 9403 return NULL; 9404 9405 ah = ath12k_hw_to_ah(hw); 9406 ah->hw = hw; 9407 ah->num_radio = num_pdev_map; 9408 9409 mutex_init(&ah->hw_mutex); 9410 9411 for (i = 0; i < num_pdev_map; i++) { 9412 ab = pdev_map[i].ab; 9413 pdev_idx = pdev_map[i].pdev_idx; 9414 pdev = &ab->pdevs[pdev_idx]; 9415 9416 ar = ath12k_ah_to_ar(ah, i); 9417 ar->ah = ah; 9418 ar->ab = ab; 9419 ar->hw_link_id = pdev->hw_link_id; 9420 ar->pdev = pdev; 9421 ar->pdev_idx = pdev_idx; 9422 pdev->ar = ar; 9423 9424 ath12k_mac_setup(ar); 9425 } 9426 9427 return ah; 9428 } 9429 9430 void ath12k_mac_destroy(struct ath12k_base *ab) 9431 { 9432 struct ath12k_pdev *pdev; 9433 int i; 9434 9435 for (i = 0; i < ab->num_radios; i++) { 9436 pdev = &ab->pdevs[i]; 9437 if (!pdev->ar) 9438 continue; 9439 9440 pdev->ar = NULL; 9441 } 9442 9443 for (i = 0; i < ab->num_hw; i++) { 9444 if (!ab->ah[i]) 9445 continue; 9446 9447 ath12k_mac_hw_destroy(ab->ah[i]); 9448 ab->ah[i] = NULL; 9449 } 9450 } 9451 9452 int ath12k_mac_allocate(struct ath12k_base *ab) 9453 { 9454 struct ath12k_hw *ah; 9455 struct ath12k_pdev_map pdev_map[MAX_RADIOS]; 9456 int ret, i, j; 9457 u8 radio_per_hw; 9458 9459 if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags)) 9460 return 0; 9461 9462 ab->num_hw = ab->num_radios; 9463 radio_per_hw = 1; 9464 9465 for (i = 0; i < ab->num_hw; i++) { 9466 for (j = 0; j < radio_per_hw; j++) { 9467 pdev_map[j].ab = ab; 9468 pdev_map[j].pdev_idx = (i * radio_per_hw) + j; 9469 } 9470 9471 ah = ath12k_mac_hw_allocate(ab, pdev_map, radio_per_hw); 9472 if (!ah) { 9473 ath12k_warn(ab, "failed to allocate mac80211 hw device for hw_idx %d\n", 9474 i); 9475 ret = -ENOMEM; 9476 goto err; 9477 } 9478 9479 ab->ah[i] = ah; 9480 } 9481 9482 ath12k_dp_pdev_pre_alloc(ab); 9483 9484 return 0; 9485 9486 err: 9487 for (i = i - 1; i >= 0; i--) { 9488 if (!ab->ah[i]) 9489 continue; 9490 9491 ath12k_mac_hw_destroy(ab->ah[i]); 9492 ab->ah[i] = NULL; 9493 } 9494 9495 return ret; 9496 } 9497 9498 int ath12k_mac_vif_set_keepalive(struct ath12k_vif *arvif, 9499 enum wmi_sta_keepalive_method method, 9500 u32 interval) 9501 { 9502 struct wmi_sta_keepalive_arg arg = {}; 9503 struct ath12k *ar = arvif->ar; 9504 int ret; 9505 9506 lockdep_assert_held(&ar->conf_mutex); 9507 9508 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 9509 return 0; 9510 9511 if (!test_bit(WMI_TLV_SERVICE_STA_KEEP_ALIVE, ar->ab->wmi_ab.svc_map)) 9512 return 0; 9513 9514 arg.vdev_id = arvif->vdev_id; 9515 arg.enabled = 1; 9516 arg.method = method; 9517 arg.interval = interval; 9518 9519 ret = ath12k_wmi_sta_keepalive(ar, &arg); 9520 if (ret) { 9521 ath12k_warn(ar->ab, "failed to set keepalive on vdev %i: %d\n", 9522 arvif->vdev_id, ret); 9523 return ret; 9524 } 9525 9526 return 0; 9527 } 9528