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