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