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