1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. 4 * Copyright (c) 2021-2022 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, rx_mcs_80, rx_mcs_160, max_nss; 1618 u16 mcs_160_map, mcs_80_map; 1619 bool support_160; 1620 u16 v; 1621 1622 if (!he_cap->has_he) 1623 return; 1624 1625 arg->he_flag = true; 1626 1627 support_160 = !!(he_cap->he_cap_elem.phy_cap_info[0] & 1628 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G); 1629 1630 /* Supported HE-MCS and NSS Set of peer he_cap is intersection with self he_cp */ 1631 mcs_160_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160); 1632 mcs_80_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80); 1633 1634 if (support_160) { 1635 for (i = 7; i >= 0; i--) { 1636 u8 mcs_160 = (mcs_160_map >> (2 * i)) & 3; 1637 1638 if (mcs_160 != IEEE80211_HE_MCS_NOT_SUPPORTED) { 1639 rx_mcs_160 = i + 1; 1640 break; 1641 } 1642 } 1643 } 1644 1645 for (i = 7; i >= 0; i--) { 1646 u8 mcs_80 = (mcs_80_map >> (2 * i)) & 3; 1647 1648 if (mcs_80 != IEEE80211_HE_MCS_NOT_SUPPORTED) { 1649 rx_mcs_80 = i + 1; 1650 break; 1651 } 1652 } 1653 1654 if (support_160) 1655 max_nss = min(rx_mcs_80, rx_mcs_160); 1656 else 1657 max_nss = rx_mcs_80; 1658 1659 arg->peer_nss = min(sta->deflink.rx_nss, max_nss); 1660 1661 memcpy(&arg->peer_he_cap_macinfo, he_cap->he_cap_elem.mac_cap_info, 1662 sizeof(he_cap->he_cap_elem.mac_cap_info)); 1663 memcpy(&arg->peer_he_cap_phyinfo, he_cap->he_cap_elem.phy_cap_info, 1664 sizeof(he_cap->he_cap_elem.phy_cap_info)); 1665 arg->peer_he_ops = vif->bss_conf.he_oper.params; 1666 1667 /* the top most byte is used to indicate BSS color info */ 1668 arg->peer_he_ops &= 0xffffff; 1669 1670 /* As per section 26.6.1 IEEE Std 802.11ax‐2022, if the Max AMPDU 1671 * Exponent Extension in HE cap is zero, use the arg->peer_max_mpdu 1672 * as calculated while parsing VHT caps(if VHT caps is present) 1673 * or HT caps (if VHT caps is not present). 1674 * 1675 * For non-zero value of Max AMPDU Exponent Extension in HE MAC caps, 1676 * if a HE STA sends VHT cap and HE cap IE in assoc request then, use 1677 * MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length. 1678 * If a HE STA that does not send VHT cap, but HE and HT cap in assoc 1679 * request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu 1680 * length. 1681 */ 1682 ampdu_factor = (he_cap->he_cap_elem.mac_cap_info[3] & 1683 IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK) >> 1684 IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK; 1685 1686 if (ampdu_factor) { 1687 if (sta->deflink.vht_cap.vht_supported) 1688 arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR + 1689 ampdu_factor)) - 1; 1690 else if (sta->deflink.ht_cap.ht_supported) 1691 arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR + 1692 ampdu_factor)) - 1; 1693 } 1694 1695 if (he_cap->he_cap_elem.phy_cap_info[6] & 1696 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) { 1697 int bit = 7; 1698 int nss, ru; 1699 1700 arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0] & 1701 IEEE80211_PPE_THRES_NSS_MASK; 1702 arg->peer_ppet.ru_bit_mask = 1703 (he_cap->ppe_thres[0] & 1704 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >> 1705 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS; 1706 1707 for (nss = 0; nss <= arg->peer_ppet.numss_m1; nss++) { 1708 for (ru = 0; ru < 4; ru++) { 1709 u32 val = 0; 1710 int i; 1711 1712 if ((arg->peer_ppet.ru_bit_mask & BIT(ru)) == 0) 1713 continue; 1714 for (i = 0; i < 6; i++) { 1715 val >>= 1; 1716 val |= ((he_cap->ppe_thres[bit / 8] >> 1717 (bit % 8)) & 0x1) << 5; 1718 bit++; 1719 } 1720 arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |= 1721 val << (ru * 6); 1722 } 1723 } 1724 } 1725 1726 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_RES) 1727 arg->twt_responder = true; 1728 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_REQ) 1729 arg->twt_requester = true; 1730 1731 switch (sta->deflink.bandwidth) { 1732 case IEEE80211_STA_RX_BW_160: 1733 if (he_cap->he_cap_elem.phy_cap_info[0] & 1734 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) { 1735 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80); 1736 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v; 1737 1738 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80p80); 1739 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v; 1740 1741 arg->peer_he_mcs_count++; 1742 } 1743 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160); 1744 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v; 1745 1746 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_160); 1747 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v; 1748 1749 arg->peer_he_mcs_count++; 1750 fallthrough; 1751 1752 default: 1753 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80); 1754 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v; 1755 1756 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80); 1757 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v; 1758 1759 arg->peer_he_mcs_count++; 1760 break; 1761 } 1762 } 1763 1764 static void ath12k_peer_assoc_h_smps(struct ieee80211_sta *sta, 1765 struct ath12k_wmi_peer_assoc_arg *arg) 1766 { 1767 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap; 1768 int smps; 1769 1770 if (!ht_cap->ht_supported) 1771 return; 1772 1773 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 1774 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 1775 1776 switch (smps) { 1777 case WLAN_HT_CAP_SM_PS_STATIC: 1778 arg->static_mimops_flag = true; 1779 break; 1780 case WLAN_HT_CAP_SM_PS_DYNAMIC: 1781 arg->dynamic_mimops_flag = true; 1782 break; 1783 case WLAN_HT_CAP_SM_PS_DISABLED: 1784 arg->spatial_mux_flag = true; 1785 break; 1786 default: 1787 break; 1788 } 1789 } 1790 1791 static void ath12k_peer_assoc_h_qos(struct ath12k *ar, 1792 struct ieee80211_vif *vif, 1793 struct ieee80211_sta *sta, 1794 struct ath12k_wmi_peer_assoc_arg *arg) 1795 { 1796 struct ath12k_vif *arvif = (void *)vif->drv_priv; 1797 1798 switch (arvif->vdev_type) { 1799 case WMI_VDEV_TYPE_AP: 1800 if (sta->wme) { 1801 /* TODO: Check WME vs QoS */ 1802 arg->is_wme_set = true; 1803 arg->qos_flag = true; 1804 } 1805 1806 if (sta->wme && sta->uapsd_queues) { 1807 /* TODO: Check WME vs QoS */ 1808 arg->is_wme_set = true; 1809 arg->apsd_flag = true; 1810 arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG; 1811 } 1812 break; 1813 case WMI_VDEV_TYPE_STA: 1814 if (sta->wme) { 1815 arg->is_wme_set = true; 1816 arg->qos_flag = true; 1817 } 1818 break; 1819 default: 1820 break; 1821 } 1822 1823 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac peer %pM qos %d\n", 1824 sta->addr, arg->qos_flag); 1825 } 1826 1827 static int ath12k_peer_assoc_qos_ap(struct ath12k *ar, 1828 struct ath12k_vif *arvif, 1829 struct ieee80211_sta *sta) 1830 { 1831 struct ath12k_wmi_ap_ps_arg arg; 1832 u32 max_sp; 1833 u32 uapsd; 1834 int ret; 1835 1836 lockdep_assert_held(&ar->conf_mutex); 1837 1838 arg.vdev_id = arvif->vdev_id; 1839 1840 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n", 1841 sta->uapsd_queues, sta->max_sp); 1842 1843 uapsd = 0; 1844 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) 1845 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN | 1846 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN; 1847 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) 1848 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN | 1849 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN; 1850 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) 1851 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN | 1852 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN; 1853 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) 1854 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN | 1855 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN; 1856 1857 max_sp = 0; 1858 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP) 1859 max_sp = sta->max_sp; 1860 1861 arg.param = WMI_AP_PS_PEER_PARAM_UAPSD; 1862 arg.value = uapsd; 1863 ret = ath12k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &arg); 1864 if (ret) 1865 goto err; 1866 1867 arg.param = WMI_AP_PS_PEER_PARAM_MAX_SP; 1868 arg.value = max_sp; 1869 ret = ath12k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &arg); 1870 if (ret) 1871 goto err; 1872 1873 /* TODO: revisit during testing */ 1874 arg.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE; 1875 arg.value = DISABLE_SIFS_RESPONSE_TRIGGER; 1876 ret = ath12k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &arg); 1877 if (ret) 1878 goto err; 1879 1880 arg.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD; 1881 arg.value = DISABLE_SIFS_RESPONSE_TRIGGER; 1882 ret = ath12k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &arg); 1883 if (ret) 1884 goto err; 1885 1886 return 0; 1887 1888 err: 1889 ath12k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n", 1890 arg.param, arvif->vdev_id, ret); 1891 return ret; 1892 } 1893 1894 static bool ath12k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta) 1895 { 1896 return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >> 1897 ATH12K_MAC_FIRST_OFDM_RATE_IDX; 1898 } 1899 1900 static enum wmi_phy_mode ath12k_mac_get_phymode_vht(struct ath12k *ar, 1901 struct ieee80211_sta *sta) 1902 { 1903 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) { 1904 switch (sta->deflink.vht_cap.cap & 1905 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) { 1906 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ: 1907 return MODE_11AC_VHT160; 1908 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ: 1909 return MODE_11AC_VHT80_80; 1910 default: 1911 /* not sure if this is a valid case? */ 1912 return MODE_11AC_VHT160; 1913 } 1914 } 1915 1916 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80) 1917 return MODE_11AC_VHT80; 1918 1919 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 1920 return MODE_11AC_VHT40; 1921 1922 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20) 1923 return MODE_11AC_VHT20; 1924 1925 return MODE_UNKNOWN; 1926 } 1927 1928 static enum wmi_phy_mode ath12k_mac_get_phymode_he(struct ath12k *ar, 1929 struct ieee80211_sta *sta) 1930 { 1931 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) { 1932 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] & 1933 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) 1934 return MODE_11AX_HE160; 1935 else if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] & 1936 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 1937 return MODE_11AX_HE80_80; 1938 /* not sure if this is a valid case? */ 1939 return MODE_11AX_HE160; 1940 } 1941 1942 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80) 1943 return MODE_11AX_HE80; 1944 1945 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 1946 return MODE_11AX_HE40; 1947 1948 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20) 1949 return MODE_11AX_HE20; 1950 1951 return MODE_UNKNOWN; 1952 } 1953 1954 static enum wmi_phy_mode ath12k_mac_get_phymode_eht(struct ath12k *ar, 1955 struct ieee80211_sta *sta) 1956 { 1957 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_320) 1958 if (sta->deflink.eht_cap.eht_cap_elem.phy_cap_info[0] & 1959 IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ) 1960 return MODE_11BE_EHT320; 1961 1962 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) { 1963 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] & 1964 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) 1965 return MODE_11BE_EHT160; 1966 1967 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] & 1968 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) 1969 return MODE_11BE_EHT80_80; 1970 1971 ath12k_warn(ar->ab, "invalid EHT PHY capability info for 160 Mhz: %d\n", 1972 sta->deflink.he_cap.he_cap_elem.phy_cap_info[0]); 1973 1974 return MODE_11BE_EHT160; 1975 } 1976 1977 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80) 1978 return MODE_11BE_EHT80; 1979 1980 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 1981 return MODE_11BE_EHT40; 1982 1983 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20) 1984 return MODE_11BE_EHT20; 1985 1986 return MODE_UNKNOWN; 1987 } 1988 1989 static void ath12k_peer_assoc_h_phymode(struct ath12k *ar, 1990 struct ieee80211_vif *vif, 1991 struct ieee80211_sta *sta, 1992 struct ath12k_wmi_peer_assoc_arg *arg) 1993 { 1994 struct ath12k_vif *arvif = (void *)vif->drv_priv; 1995 struct cfg80211_chan_def def; 1996 enum nl80211_band band; 1997 const u8 *ht_mcs_mask; 1998 const u16 *vht_mcs_mask; 1999 enum wmi_phy_mode phymode = MODE_UNKNOWN; 2000 2001 if (WARN_ON(ath12k_mac_vif_chan(vif, &def))) 2002 return; 2003 2004 band = def.chan->band; 2005 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 2006 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 2007 2008 switch (band) { 2009 case NL80211_BAND_2GHZ: 2010 if (sta->deflink.eht_cap.has_eht) { 2011 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2012 phymode = MODE_11BE_EHT40_2G; 2013 else 2014 phymode = MODE_11BE_EHT20_2G; 2015 } else if (sta->deflink.he_cap.has_he) { 2016 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80) 2017 phymode = MODE_11AX_HE80_2G; 2018 else if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2019 phymode = MODE_11AX_HE40_2G; 2020 else 2021 phymode = MODE_11AX_HE20_2G; 2022 } else if (sta->deflink.vht_cap.vht_supported && 2023 !ath12k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2024 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2025 phymode = MODE_11AC_VHT40; 2026 else 2027 phymode = MODE_11AC_VHT20; 2028 } else if (sta->deflink.ht_cap.ht_supported && 2029 !ath12k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2030 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40) 2031 phymode = MODE_11NG_HT40; 2032 else 2033 phymode = MODE_11NG_HT20; 2034 } else if (ath12k_mac_sta_has_ofdm_only(sta)) { 2035 phymode = MODE_11G; 2036 } else { 2037 phymode = MODE_11B; 2038 } 2039 break; 2040 case NL80211_BAND_5GHZ: 2041 case NL80211_BAND_6GHZ: 2042 /* Check EHT first */ 2043 if (sta->deflink.eht_cap.has_eht) { 2044 phymode = ath12k_mac_get_phymode_eht(ar, sta); 2045 } else if (sta->deflink.he_cap.has_he) { 2046 phymode = ath12k_mac_get_phymode_he(ar, sta); 2047 } else if (sta->deflink.vht_cap.vht_supported && 2048 !ath12k_peer_assoc_h_vht_masked(vht_mcs_mask)) { 2049 phymode = ath12k_mac_get_phymode_vht(ar, sta); 2050 } else if (sta->deflink.ht_cap.ht_supported && 2051 !ath12k_peer_assoc_h_ht_masked(ht_mcs_mask)) { 2052 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) 2053 phymode = MODE_11NA_HT40; 2054 else 2055 phymode = MODE_11NA_HT20; 2056 } else { 2057 phymode = MODE_11A; 2058 } 2059 break; 2060 default: 2061 break; 2062 } 2063 2064 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac peer %pM phymode %s\n", 2065 sta->addr, ath12k_mac_phymode_str(phymode)); 2066 2067 arg->peer_phymode = phymode; 2068 WARN_ON(phymode == MODE_UNKNOWN); 2069 } 2070 2071 static void ath12k_mac_set_eht_mcs(u8 rx_tx_mcs7, u8 rx_tx_mcs9, 2072 u8 rx_tx_mcs11, u8 rx_tx_mcs13, 2073 u32 *rx_mcs, u32 *tx_mcs) 2074 { 2075 *rx_mcs = 0; 2076 u32p_replace_bits(rx_mcs, 2077 u8_get_bits(rx_tx_mcs7, IEEE80211_EHT_MCS_NSS_RX), 2078 WMI_EHT_MCS_NSS_0_7); 2079 u32p_replace_bits(rx_mcs, 2080 u8_get_bits(rx_tx_mcs9, IEEE80211_EHT_MCS_NSS_RX), 2081 WMI_EHT_MCS_NSS_8_9); 2082 u32p_replace_bits(rx_mcs, 2083 u8_get_bits(rx_tx_mcs11, IEEE80211_EHT_MCS_NSS_RX), 2084 WMI_EHT_MCS_NSS_10_11); 2085 u32p_replace_bits(rx_mcs, 2086 u8_get_bits(rx_tx_mcs13, IEEE80211_EHT_MCS_NSS_RX), 2087 WMI_EHT_MCS_NSS_12_13); 2088 2089 *tx_mcs = 0; 2090 u32p_replace_bits(tx_mcs, 2091 u8_get_bits(rx_tx_mcs7, IEEE80211_EHT_MCS_NSS_TX), 2092 WMI_EHT_MCS_NSS_0_7); 2093 u32p_replace_bits(tx_mcs, 2094 u8_get_bits(rx_tx_mcs9, IEEE80211_EHT_MCS_NSS_TX), 2095 WMI_EHT_MCS_NSS_8_9); 2096 u32p_replace_bits(tx_mcs, 2097 u8_get_bits(rx_tx_mcs11, IEEE80211_EHT_MCS_NSS_TX), 2098 WMI_EHT_MCS_NSS_10_11); 2099 u32p_replace_bits(tx_mcs, 2100 u8_get_bits(rx_tx_mcs13, IEEE80211_EHT_MCS_NSS_TX), 2101 WMI_EHT_MCS_NSS_12_13); 2102 } 2103 2104 static void ath12k_mac_set_eht_ppe_threshold(const u8 *ppe_thres, 2105 struct ath12k_wmi_ppe_threshold_arg *ppet) 2106 { 2107 u32 bit_pos = IEEE80211_EHT_PPE_THRES_INFO_HEADER_SIZE, val; 2108 u8 nss, ru, i; 2109 u8 ppet_bit_len_per_ru = IEEE80211_EHT_PPE_THRES_INFO_PPET_SIZE * 2; 2110 2111 ppet->numss_m1 = u8_get_bits(ppe_thres[0], IEEE80211_EHT_PPE_THRES_NSS_MASK); 2112 ppet->ru_bit_mask = u16_get_bits(get_unaligned_le16(ppe_thres), 2113 IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK); 2114 2115 for (nss = 0; nss <= ppet->numss_m1; nss++) { 2116 for (ru = 0; 2117 ru < hweight16(IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK); 2118 ru++) { 2119 if ((ppet->ru_bit_mask & BIT(ru)) == 0) 2120 continue; 2121 2122 val = 0; 2123 for (i = 0; i < ppet_bit_len_per_ru; i++) { 2124 val |= (((ppe_thres[bit_pos / 8] >> 2125 (bit_pos % 8)) & 0x1) << i); 2126 bit_pos++; 2127 } 2128 ppet->ppet16_ppet8_ru3_ru0[nss] |= 2129 (val << (ru * ppet_bit_len_per_ru)); 2130 } 2131 } 2132 } 2133 2134 static void ath12k_peer_assoc_h_eht(struct ath12k *ar, 2135 struct ieee80211_vif *vif, 2136 struct ieee80211_sta *sta, 2137 struct ath12k_wmi_peer_assoc_arg *arg) 2138 { 2139 const struct ieee80211_sta_eht_cap *eht_cap = &sta->deflink.eht_cap; 2140 const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap; 2141 const struct ieee80211_eht_mcs_nss_supp_20mhz_only *bw_20; 2142 const struct ieee80211_eht_mcs_nss_supp_bw *bw; 2143 struct ath12k_vif *arvif = (struct ath12k_vif *)vif->drv_priv; 2144 u32 *rx_mcs, *tx_mcs; 2145 2146 if (!sta->deflink.he_cap.has_he || !eht_cap->has_eht) 2147 return; 2148 2149 arg->eht_flag = true; 2150 2151 if ((eht_cap->eht_cap_elem.phy_cap_info[5] & 2152 IEEE80211_EHT_PHY_CAP5_PPE_THRESHOLD_PRESENT) && 2153 eht_cap->eht_ppe_thres[0] != 0) 2154 ath12k_mac_set_eht_ppe_threshold(eht_cap->eht_ppe_thres, 2155 &arg->peer_eht_ppet); 2156 2157 memcpy(arg->peer_eht_cap_mac, eht_cap->eht_cap_elem.mac_cap_info, 2158 sizeof(eht_cap->eht_cap_elem.mac_cap_info)); 2159 memcpy(arg->peer_eht_cap_phy, eht_cap->eht_cap_elem.phy_cap_info, 2160 sizeof(eht_cap->eht_cap_elem.phy_cap_info)); 2161 2162 rx_mcs = arg->peer_eht_rx_mcs_set; 2163 tx_mcs = arg->peer_eht_tx_mcs_set; 2164 2165 switch (sta->deflink.bandwidth) { 2166 case IEEE80211_STA_RX_BW_320: 2167 bw = &eht_cap->eht_mcs_nss_supp.bw._320; 2168 ath12k_mac_set_eht_mcs(bw->rx_tx_mcs9_max_nss, 2169 bw->rx_tx_mcs9_max_nss, 2170 bw->rx_tx_mcs11_max_nss, 2171 bw->rx_tx_mcs13_max_nss, 2172 &rx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_320], 2173 &tx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_320]); 2174 arg->peer_eht_mcs_count++; 2175 fallthrough; 2176 case IEEE80211_STA_RX_BW_160: 2177 bw = &eht_cap->eht_mcs_nss_supp.bw._160; 2178 ath12k_mac_set_eht_mcs(bw->rx_tx_mcs9_max_nss, 2179 bw->rx_tx_mcs9_max_nss, 2180 bw->rx_tx_mcs11_max_nss, 2181 bw->rx_tx_mcs13_max_nss, 2182 &rx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_160], 2183 &tx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_160]); 2184 arg->peer_eht_mcs_count++; 2185 fallthrough; 2186 default: 2187 if ((he_cap->he_cap_elem.phy_cap_info[0] & 2188 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G | 2189 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G | 2190 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G | 2191 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)) == 0) { 2192 bw_20 = &eht_cap->eht_mcs_nss_supp.only_20mhz; 2193 2194 ath12k_mac_set_eht_mcs(bw_20->rx_tx_mcs7_max_nss, 2195 bw_20->rx_tx_mcs9_max_nss, 2196 bw_20->rx_tx_mcs11_max_nss, 2197 bw_20->rx_tx_mcs13_max_nss, 2198 &rx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_80], 2199 &tx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_80]); 2200 } else { 2201 bw = &eht_cap->eht_mcs_nss_supp.bw._80; 2202 ath12k_mac_set_eht_mcs(bw->rx_tx_mcs9_max_nss, 2203 bw->rx_tx_mcs9_max_nss, 2204 bw->rx_tx_mcs11_max_nss, 2205 bw->rx_tx_mcs13_max_nss, 2206 &rx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_80], 2207 &tx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_80]); 2208 } 2209 2210 arg->peer_eht_mcs_count++; 2211 break; 2212 } 2213 2214 arg->punct_bitmap = ~arvif->punct_bitmap; 2215 } 2216 2217 static void ath12k_peer_assoc_prepare(struct ath12k *ar, 2218 struct ieee80211_vif *vif, 2219 struct ieee80211_sta *sta, 2220 struct ath12k_wmi_peer_assoc_arg *arg, 2221 bool reassoc) 2222 { 2223 lockdep_assert_held(&ar->conf_mutex); 2224 2225 memset(arg, 0, sizeof(*arg)); 2226 2227 reinit_completion(&ar->peer_assoc_done); 2228 2229 arg->peer_new_assoc = !reassoc; 2230 ath12k_peer_assoc_h_basic(ar, vif, sta, arg); 2231 ath12k_peer_assoc_h_crypto(ar, vif, sta, arg); 2232 ath12k_peer_assoc_h_rates(ar, vif, sta, arg); 2233 ath12k_peer_assoc_h_ht(ar, vif, sta, arg); 2234 ath12k_peer_assoc_h_vht(ar, vif, sta, arg); 2235 ath12k_peer_assoc_h_he(ar, vif, sta, arg); 2236 ath12k_peer_assoc_h_eht(ar, vif, sta, arg); 2237 ath12k_peer_assoc_h_qos(ar, vif, sta, arg); 2238 ath12k_peer_assoc_h_phymode(ar, vif, sta, arg); 2239 ath12k_peer_assoc_h_smps(sta, arg); 2240 2241 /* TODO: amsdu_disable req? */ 2242 } 2243 2244 static int ath12k_setup_peer_smps(struct ath12k *ar, struct ath12k_vif *arvif, 2245 const u8 *addr, 2246 const struct ieee80211_sta_ht_cap *ht_cap) 2247 { 2248 int smps; 2249 2250 if (!ht_cap->ht_supported) 2251 return 0; 2252 2253 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 2254 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 2255 2256 if (smps >= ARRAY_SIZE(ath12k_smps_map)) 2257 return -EINVAL; 2258 2259 return ath12k_wmi_set_peer_param(ar, addr, arvif->vdev_id, 2260 WMI_PEER_MIMO_PS_STATE, 2261 ath12k_smps_map[smps]); 2262 } 2263 2264 static void ath12k_bss_assoc(struct ieee80211_hw *hw, 2265 struct ieee80211_vif *vif, 2266 struct ieee80211_bss_conf *bss_conf) 2267 { 2268 struct ath12k *ar = hw->priv; 2269 struct ath12k_vif *arvif = (void *)vif->drv_priv; 2270 struct ath12k_wmi_peer_assoc_arg peer_arg; 2271 struct ieee80211_sta *ap_sta; 2272 struct ath12k_peer *peer; 2273 bool is_auth = false; 2274 int ret; 2275 2276 lockdep_assert_held(&ar->conf_mutex); 2277 2278 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n", 2279 arvif->vdev_id, arvif->bssid, arvif->aid); 2280 2281 rcu_read_lock(); 2282 2283 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid); 2284 if (!ap_sta) { 2285 ath12k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n", 2286 bss_conf->bssid, arvif->vdev_id); 2287 rcu_read_unlock(); 2288 return; 2289 } 2290 2291 ath12k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false); 2292 2293 rcu_read_unlock(); 2294 2295 ret = ath12k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 2296 if (ret) { 2297 ath12k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n", 2298 bss_conf->bssid, arvif->vdev_id, ret); 2299 return; 2300 } 2301 2302 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 2303 ath12k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 2304 bss_conf->bssid, arvif->vdev_id); 2305 return; 2306 } 2307 2308 ret = ath12k_setup_peer_smps(ar, arvif, bss_conf->bssid, 2309 &ap_sta->deflink.ht_cap); 2310 if (ret) { 2311 ath12k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n", 2312 arvif->vdev_id, ret); 2313 return; 2314 } 2315 2316 WARN_ON(arvif->is_up); 2317 2318 arvif->aid = vif->cfg.aid; 2319 ether_addr_copy(arvif->bssid, bss_conf->bssid); 2320 2321 ret = ath12k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid); 2322 if (ret) { 2323 ath12k_warn(ar->ab, "failed to set vdev %d up: %d\n", 2324 arvif->vdev_id, ret); 2325 return; 2326 } 2327 2328 arvif->is_up = true; 2329 2330 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 2331 "mac vdev %d up (associated) bssid %pM aid %d\n", 2332 arvif->vdev_id, bss_conf->bssid, vif->cfg.aid); 2333 2334 spin_lock_bh(&ar->ab->base_lock); 2335 2336 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid); 2337 if (peer && peer->is_authorized) 2338 is_auth = true; 2339 2340 spin_unlock_bh(&ar->ab->base_lock); 2341 2342 /* Authorize BSS Peer */ 2343 if (is_auth) { 2344 ret = ath12k_wmi_set_peer_param(ar, arvif->bssid, 2345 arvif->vdev_id, 2346 WMI_PEER_AUTHORIZE, 2347 1); 2348 if (ret) 2349 ath12k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret); 2350 } 2351 2352 ret = ath12k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id, 2353 &bss_conf->he_obss_pd); 2354 if (ret) 2355 ath12k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n", 2356 arvif->vdev_id, ret); 2357 } 2358 2359 static void ath12k_bss_disassoc(struct ieee80211_hw *hw, 2360 struct ieee80211_vif *vif) 2361 { 2362 struct ath12k *ar = hw->priv; 2363 struct ath12k_vif *arvif = (void *)vif->drv_priv; 2364 int ret; 2365 2366 lockdep_assert_held(&ar->conf_mutex); 2367 2368 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n", 2369 arvif->vdev_id, arvif->bssid); 2370 2371 ret = ath12k_wmi_vdev_down(ar, arvif->vdev_id); 2372 if (ret) 2373 ath12k_warn(ar->ab, "failed to down vdev %i: %d\n", 2374 arvif->vdev_id, ret); 2375 2376 arvif->is_up = false; 2377 2378 /* TODO: cancel connection_loss_work */ 2379 } 2380 2381 static u32 ath12k_mac_get_rate_hw_value(int bitrate) 2382 { 2383 u32 preamble; 2384 u16 hw_value; 2385 int rate; 2386 size_t i; 2387 2388 if (ath12k_mac_bitrate_is_cck(bitrate)) 2389 preamble = WMI_RATE_PREAMBLE_CCK; 2390 else 2391 preamble = WMI_RATE_PREAMBLE_OFDM; 2392 2393 for (i = 0; i < ARRAY_SIZE(ath12k_legacy_rates); i++) { 2394 if (ath12k_legacy_rates[i].bitrate != bitrate) 2395 continue; 2396 2397 hw_value = ath12k_legacy_rates[i].hw_value; 2398 rate = ATH12K_HW_RATE_CODE(hw_value, 0, preamble); 2399 2400 return rate; 2401 } 2402 2403 return -EINVAL; 2404 } 2405 2406 static void ath12k_recalculate_mgmt_rate(struct ath12k *ar, 2407 struct ieee80211_vif *vif, 2408 struct cfg80211_chan_def *def) 2409 { 2410 struct ath12k_vif *arvif = (void *)vif->drv_priv; 2411 const struct ieee80211_supported_band *sband; 2412 u8 basic_rate_idx; 2413 int hw_rate_code; 2414 u32 vdev_param; 2415 u16 bitrate; 2416 int ret; 2417 2418 lockdep_assert_held(&ar->conf_mutex); 2419 2420 sband = ar->hw->wiphy->bands[def->chan->band]; 2421 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1; 2422 bitrate = sband->bitrates[basic_rate_idx].bitrate; 2423 2424 hw_rate_code = ath12k_mac_get_rate_hw_value(bitrate); 2425 if (hw_rate_code < 0) { 2426 ath12k_warn(ar->ab, "bitrate not supported %d\n", bitrate); 2427 return; 2428 } 2429 2430 vdev_param = WMI_VDEV_PARAM_MGMT_RATE; 2431 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 2432 hw_rate_code); 2433 if (ret) 2434 ath12k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret); 2435 2436 vdev_param = WMI_VDEV_PARAM_BEACON_RATE; 2437 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param, 2438 hw_rate_code); 2439 if (ret) 2440 ath12k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret); 2441 } 2442 2443 static int ath12k_mac_fils_discovery(struct ath12k_vif *arvif, 2444 struct ieee80211_bss_conf *info) 2445 { 2446 struct ath12k *ar = arvif->ar; 2447 struct sk_buff *tmpl; 2448 int ret; 2449 u32 interval; 2450 bool unsol_bcast_probe_resp_enabled = false; 2451 2452 if (info->fils_discovery.max_interval) { 2453 interval = info->fils_discovery.max_interval; 2454 2455 tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif); 2456 if (tmpl) 2457 ret = ath12k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id, 2458 tmpl); 2459 } else if (info->unsol_bcast_probe_resp_interval) { 2460 unsol_bcast_probe_resp_enabled = 1; 2461 interval = info->unsol_bcast_probe_resp_interval; 2462 2463 tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw, 2464 arvif->vif); 2465 if (tmpl) 2466 ret = ath12k_wmi_probe_resp_tmpl(ar, arvif->vdev_id, 2467 tmpl); 2468 } else { /* Disable */ 2469 return ath12k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false); 2470 } 2471 2472 if (!tmpl) { 2473 ath12k_warn(ar->ab, 2474 "mac vdev %i failed to retrieve %s template\n", 2475 arvif->vdev_id, (unsol_bcast_probe_resp_enabled ? 2476 "unsolicited broadcast probe response" : 2477 "FILS discovery")); 2478 return -EPERM; 2479 } 2480 kfree_skb(tmpl); 2481 2482 if (!ret) 2483 ret = ath12k_wmi_fils_discovery(ar, arvif->vdev_id, interval, 2484 unsol_bcast_probe_resp_enabled); 2485 2486 return ret; 2487 } 2488 2489 static void ath12k_mac_op_bss_info_changed(struct ieee80211_hw *hw, 2490 struct ieee80211_vif *vif, 2491 struct ieee80211_bss_conf *info, 2492 u64 changed) 2493 { 2494 struct ath12k *ar = hw->priv; 2495 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 2496 struct cfg80211_chan_def def; 2497 u32 param_id, param_value; 2498 enum nl80211_band band; 2499 u32 vdev_param; 2500 int mcast_rate; 2501 u32 preamble; 2502 u16 hw_value; 2503 u16 bitrate; 2504 int ret; 2505 u8 rateidx; 2506 u32 rate; 2507 2508 mutex_lock(&ar->conf_mutex); 2509 2510 if (changed & BSS_CHANGED_BEACON_INT) { 2511 arvif->beacon_interval = info->beacon_int; 2512 2513 param_id = WMI_VDEV_PARAM_BEACON_INTERVAL; 2514 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2515 param_id, 2516 arvif->beacon_interval); 2517 if (ret) 2518 ath12k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n", 2519 arvif->vdev_id); 2520 else 2521 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 2522 "Beacon interval: %d set for VDEV: %d\n", 2523 arvif->beacon_interval, arvif->vdev_id); 2524 } 2525 2526 if (changed & BSS_CHANGED_BEACON) { 2527 param_id = WMI_PDEV_PARAM_BEACON_TX_MODE; 2528 param_value = WMI_BEACON_BURST_MODE; 2529 ret = ath12k_wmi_pdev_set_param(ar, param_id, 2530 param_value, ar->pdev->pdev_id); 2531 if (ret) 2532 ath12k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n", 2533 arvif->vdev_id); 2534 else 2535 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 2536 "Set burst beacon mode for VDEV: %d\n", 2537 arvif->vdev_id); 2538 2539 ret = ath12k_mac_setup_bcn_tmpl(arvif); 2540 if (ret) 2541 ath12k_warn(ar->ab, "failed to update bcn template: %d\n", 2542 ret); 2543 } 2544 2545 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) { 2546 arvif->dtim_period = info->dtim_period; 2547 2548 param_id = WMI_VDEV_PARAM_DTIM_PERIOD; 2549 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2550 param_id, 2551 arvif->dtim_period); 2552 2553 if (ret) 2554 ath12k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n", 2555 arvif->vdev_id, ret); 2556 else 2557 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 2558 "DTIM period: %d set for VDEV: %d\n", 2559 arvif->dtim_period, arvif->vdev_id); 2560 } 2561 2562 if (changed & BSS_CHANGED_SSID && 2563 vif->type == NL80211_IFTYPE_AP) { 2564 arvif->u.ap.ssid_len = vif->cfg.ssid_len; 2565 if (vif->cfg.ssid_len) 2566 memcpy(arvif->u.ap.ssid, vif->cfg.ssid, vif->cfg.ssid_len); 2567 arvif->u.ap.hidden_ssid = info->hidden_ssid; 2568 } 2569 2570 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid)) 2571 ether_addr_copy(arvif->bssid, info->bssid); 2572 2573 if (changed & BSS_CHANGED_BEACON_ENABLED) { 2574 ath12k_control_beaconing(arvif, info); 2575 2576 if (arvif->is_up && vif->bss_conf.he_support && 2577 vif->bss_conf.he_oper.params) { 2578 /* TODO: Extend to support 1024 BA Bitmap size */ 2579 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2580 WMI_VDEV_PARAM_BA_MODE, 2581 WMI_BA_MODE_BUFFER_SIZE_256); 2582 if (ret) 2583 ath12k_warn(ar->ab, 2584 "failed to set BA BUFFER SIZE 256 for vdev: %d\n", 2585 arvif->vdev_id); 2586 2587 param_id = WMI_VDEV_PARAM_HEOPS_0_31; 2588 param_value = vif->bss_conf.he_oper.params; 2589 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2590 param_id, param_value); 2591 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 2592 "he oper param: %x set for VDEV: %d\n", 2593 param_value, arvif->vdev_id); 2594 2595 if (ret) 2596 ath12k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n", 2597 param_value, arvif->vdev_id, ret); 2598 } 2599 } 2600 2601 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 2602 u32 cts_prot; 2603 2604 cts_prot = !!(info->use_cts_prot); 2605 param_id = WMI_VDEV_PARAM_PROTECTION_MODE; 2606 2607 if (arvif->is_started) { 2608 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2609 param_id, cts_prot); 2610 if (ret) 2611 ath12k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n", 2612 arvif->vdev_id); 2613 else 2614 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n", 2615 cts_prot, arvif->vdev_id); 2616 } else { 2617 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n"); 2618 } 2619 } 2620 2621 if (changed & BSS_CHANGED_ERP_SLOT) { 2622 u32 slottime; 2623 2624 if (info->use_short_slot) 2625 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 2626 2627 else 2628 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 2629 2630 param_id = WMI_VDEV_PARAM_SLOT_TIME; 2631 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2632 param_id, slottime); 2633 if (ret) 2634 ath12k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n", 2635 arvif->vdev_id); 2636 else 2637 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 2638 "Set slottime: %d for VDEV: %d\n", 2639 slottime, arvif->vdev_id); 2640 } 2641 2642 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 2643 u32 preamble; 2644 2645 if (info->use_short_preamble) 2646 preamble = WMI_VDEV_PREAMBLE_SHORT; 2647 else 2648 preamble = WMI_VDEV_PREAMBLE_LONG; 2649 2650 param_id = WMI_VDEV_PARAM_PREAMBLE; 2651 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2652 param_id, preamble); 2653 if (ret) 2654 ath12k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n", 2655 arvif->vdev_id); 2656 else 2657 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 2658 "Set preamble: %d for VDEV: %d\n", 2659 preamble, arvif->vdev_id); 2660 } 2661 2662 if (changed & BSS_CHANGED_ASSOC) { 2663 if (vif->cfg.assoc) 2664 ath12k_bss_assoc(hw, vif, info); 2665 else 2666 ath12k_bss_disassoc(hw, vif); 2667 } 2668 2669 if (changed & BSS_CHANGED_TXPOWER) { 2670 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vdev_id %i txpower %d\n", 2671 arvif->vdev_id, info->txpower); 2672 2673 arvif->txpower = info->txpower; 2674 ath12k_mac_txpower_recalc(ar); 2675 } 2676 2677 if (changed & BSS_CHANGED_MCAST_RATE && 2678 !ath12k_mac_vif_chan(arvif->vif, &def)) { 2679 band = def.chan->band; 2680 mcast_rate = vif->bss_conf.mcast_rate[band]; 2681 2682 if (mcast_rate > 0) 2683 rateidx = mcast_rate - 1; 2684 else 2685 rateidx = ffs(vif->bss_conf.basic_rates) - 1; 2686 2687 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) 2688 rateidx += ATH12K_MAC_FIRST_OFDM_RATE_IDX; 2689 2690 bitrate = ath12k_legacy_rates[rateidx].bitrate; 2691 hw_value = ath12k_legacy_rates[rateidx].hw_value; 2692 2693 if (ath12k_mac_bitrate_is_cck(bitrate)) 2694 preamble = WMI_RATE_PREAMBLE_CCK; 2695 else 2696 preamble = WMI_RATE_PREAMBLE_OFDM; 2697 2698 rate = ATH12K_HW_RATE_CODE(hw_value, 0, preamble); 2699 2700 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 2701 "mac vdev %d mcast_rate %x\n", 2702 arvif->vdev_id, rate); 2703 2704 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE; 2705 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2706 vdev_param, rate); 2707 if (ret) 2708 ath12k_warn(ar->ab, 2709 "failed to set mcast rate on vdev %i: %d\n", 2710 arvif->vdev_id, ret); 2711 2712 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE; 2713 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 2714 vdev_param, rate); 2715 if (ret) 2716 ath12k_warn(ar->ab, 2717 "failed to set bcast rate on vdev %i: %d\n", 2718 arvif->vdev_id, ret); 2719 } 2720 2721 if (changed & BSS_CHANGED_BASIC_RATES && 2722 !ath12k_mac_vif_chan(arvif->vif, &def)) 2723 ath12k_recalculate_mgmt_rate(ar, vif, &def); 2724 2725 if (changed & BSS_CHANGED_TWT) { 2726 if (info->twt_requester || info->twt_responder) 2727 ath12k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id); 2728 else 2729 ath12k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id); 2730 } 2731 2732 if (changed & BSS_CHANGED_HE_OBSS_PD) 2733 ath12k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id, 2734 &info->he_obss_pd); 2735 2736 if (changed & BSS_CHANGED_HE_BSS_COLOR) { 2737 if (vif->type == NL80211_IFTYPE_AP) { 2738 ret = ath12k_wmi_obss_color_cfg_cmd(ar, 2739 arvif->vdev_id, 2740 info->he_bss_color.color, 2741 ATH12K_BSS_COLOR_AP_PERIODS, 2742 info->he_bss_color.enabled); 2743 if (ret) 2744 ath12k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n", 2745 arvif->vdev_id, ret); 2746 } else if (vif->type == NL80211_IFTYPE_STATION) { 2747 ret = ath12k_wmi_send_bss_color_change_enable_cmd(ar, 2748 arvif->vdev_id, 2749 1); 2750 if (ret) 2751 ath12k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n", 2752 arvif->vdev_id, ret); 2753 ret = ath12k_wmi_obss_color_cfg_cmd(ar, 2754 arvif->vdev_id, 2755 0, 2756 ATH12K_BSS_COLOR_STA_PERIODS, 2757 1); 2758 if (ret) 2759 ath12k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n", 2760 arvif->vdev_id, ret); 2761 } 2762 } 2763 2764 ath12k_mac_fils_discovery(arvif, info); 2765 2766 if (changed & BSS_CHANGED_EHT_PUNCTURING) 2767 arvif->punct_bitmap = info->eht_puncturing; 2768 2769 mutex_unlock(&ar->conf_mutex); 2770 } 2771 2772 void __ath12k_mac_scan_finish(struct ath12k *ar) 2773 { 2774 lockdep_assert_held(&ar->data_lock); 2775 2776 switch (ar->scan.state) { 2777 case ATH12K_SCAN_IDLE: 2778 break; 2779 case ATH12K_SCAN_RUNNING: 2780 case ATH12K_SCAN_ABORTING: 2781 if (ar->scan.is_roc && ar->scan.roc_notify) 2782 ieee80211_remain_on_channel_expired(ar->hw); 2783 fallthrough; 2784 case ATH12K_SCAN_STARTING: 2785 if (!ar->scan.is_roc) { 2786 struct cfg80211_scan_info info = { 2787 .aborted = ((ar->scan.state == 2788 ATH12K_SCAN_ABORTING) || 2789 (ar->scan.state == 2790 ATH12K_SCAN_STARTING)), 2791 }; 2792 2793 ieee80211_scan_completed(ar->hw, &info); 2794 } 2795 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 ret = ath12k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 3360 if (ret) { 3361 ath12k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 3362 sta->addr, arvif->vdev_id, ret); 3363 return ret; 3364 } 3365 3366 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) { 3367 ath12k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 3368 sta->addr, arvif->vdev_id); 3369 return -ETIMEDOUT; 3370 } 3371 3372 num_vht_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band, mask); 3373 3374 /* If single VHT rate is configured (by set_bitrate_mask()), 3375 * peer_assoc will disable VHT. This is now enabled by a peer specific 3376 * fixed param. 3377 * Note that all other rates and NSS will be disabled for this peer. 3378 */ 3379 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) { 3380 ret = ath12k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 3381 band); 3382 if (ret) 3383 return ret; 3384 } 3385 3386 /* Re-assoc is run only to update supported rates for given station. It 3387 * doesn't make much sense to reconfigure the peer completely. 3388 */ 3389 if (reassoc) 3390 return 0; 3391 3392 ret = ath12k_setup_peer_smps(ar, arvif, sta->addr, 3393 &sta->deflink.ht_cap); 3394 if (ret) { 3395 ath12k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n", 3396 arvif->vdev_id, ret); 3397 return ret; 3398 } 3399 3400 if (!sta->wme) { 3401 arvif->num_legacy_stations++; 3402 ret = ath12k_recalc_rtscts_prot(arvif); 3403 if (ret) 3404 return ret; 3405 } 3406 3407 if (sta->wme && sta->uapsd_queues) { 3408 ret = ath12k_peer_assoc_qos_ap(ar, arvif, sta); 3409 if (ret) { 3410 ath12k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n", 3411 sta->addr, arvif->vdev_id, ret); 3412 return ret; 3413 } 3414 } 3415 3416 return 0; 3417 } 3418 3419 static int ath12k_station_disassoc(struct ath12k *ar, 3420 struct ieee80211_vif *vif, 3421 struct ieee80211_sta *sta) 3422 { 3423 struct ath12k_vif *arvif = (void *)vif->drv_priv; 3424 int ret; 3425 3426 lockdep_assert_held(&ar->conf_mutex); 3427 3428 if (!sta->wme) { 3429 arvif->num_legacy_stations--; 3430 ret = ath12k_recalc_rtscts_prot(arvif); 3431 if (ret) 3432 return ret; 3433 } 3434 3435 ret = ath12k_clear_peer_keys(arvif, sta->addr); 3436 if (ret) { 3437 ath12k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n", 3438 arvif->vdev_id, ret); 3439 return ret; 3440 } 3441 return 0; 3442 } 3443 3444 static void ath12k_sta_rc_update_wk(struct work_struct *wk) 3445 { 3446 struct ath12k *ar; 3447 struct ath12k_vif *arvif; 3448 struct ath12k_sta *arsta; 3449 struct ieee80211_sta *sta; 3450 struct cfg80211_chan_def def; 3451 enum nl80211_band band; 3452 const u8 *ht_mcs_mask; 3453 const u16 *vht_mcs_mask; 3454 u32 changed, bw, nss, smps, bw_prev; 3455 int err, num_vht_rates; 3456 const struct cfg80211_bitrate_mask *mask; 3457 struct ath12k_wmi_peer_assoc_arg peer_arg; 3458 enum wmi_phy_mode peer_phymode; 3459 3460 arsta = container_of(wk, struct ath12k_sta, update_wk); 3461 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 3462 arvif = arsta->arvif; 3463 ar = arvif->ar; 3464 3465 if (WARN_ON(ath12k_mac_vif_chan(arvif->vif, &def))) 3466 return; 3467 3468 band = def.chan->band; 3469 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; 3470 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; 3471 3472 spin_lock_bh(&ar->data_lock); 3473 3474 changed = arsta->changed; 3475 arsta->changed = 0; 3476 3477 bw = arsta->bw; 3478 bw_prev = arsta->bw_prev; 3479 nss = arsta->nss; 3480 smps = arsta->smps; 3481 3482 spin_unlock_bh(&ar->data_lock); 3483 3484 mutex_lock(&ar->conf_mutex); 3485 3486 nss = max_t(u32, 1, nss); 3487 nss = min(nss, max(ath12k_mac_max_ht_nss(ht_mcs_mask), 3488 ath12k_mac_max_vht_nss(vht_mcs_mask))); 3489 3490 if (changed & IEEE80211_RC_BW_CHANGED) { 3491 ath12k_peer_assoc_h_phymode(ar, arvif->vif, sta, &peer_arg); 3492 peer_phymode = peer_arg.peer_phymode; 3493 3494 if (bw > bw_prev) { 3495 /* Phymode shows maximum supported channel width, if we 3496 * upgrade bandwidth then due to sanity check of firmware, 3497 * we have to send WMI_PEER_PHYMODE followed by 3498 * WMI_PEER_CHWIDTH 3499 */ 3500 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac bandwidth upgrade for sta %pM new %d old %d\n", 3501 sta->addr, bw, bw_prev); 3502 err = ath12k_wmi_set_peer_param(ar, sta->addr, 3503 arvif->vdev_id, WMI_PEER_PHYMODE, 3504 peer_phymode); 3505 if (err) { 3506 ath12k_warn(ar->ab, "failed to update STA %pM to peer phymode %d: %d\n", 3507 sta->addr, peer_phymode, err); 3508 goto err_rc_bw_changed; 3509 } 3510 err = ath12k_wmi_set_peer_param(ar, sta->addr, 3511 arvif->vdev_id, WMI_PEER_CHWIDTH, 3512 bw); 3513 if (err) 3514 ath12k_warn(ar->ab, "failed to update STA %pM to peer bandwidth %d: %d\n", 3515 sta->addr, bw, err); 3516 } else { 3517 /* When we downgrade bandwidth this will conflict with phymode 3518 * and cause to trigger firmware crash. In this case we send 3519 * WMI_PEER_CHWIDTH followed by WMI_PEER_PHYMODE 3520 */ 3521 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac bandwidth downgrade for sta %pM new %d old %d\n", 3522 sta->addr, bw, bw_prev); 3523 err = ath12k_wmi_set_peer_param(ar, sta->addr, 3524 arvif->vdev_id, WMI_PEER_CHWIDTH, 3525 bw); 3526 if (err) { 3527 ath12k_warn(ar->ab, "failed to update STA %pM peer to bandwidth %d: %d\n", 3528 sta->addr, bw, err); 3529 goto err_rc_bw_changed; 3530 } 3531 err = ath12k_wmi_set_peer_param(ar, sta->addr, 3532 arvif->vdev_id, WMI_PEER_PHYMODE, 3533 peer_phymode); 3534 if (err) 3535 ath12k_warn(ar->ab, "failed to update STA %pM to peer phymode %d: %d\n", 3536 sta->addr, peer_phymode, err); 3537 } 3538 } 3539 3540 if (changed & IEEE80211_RC_NSS_CHANGED) { 3541 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac update sta %pM nss %d\n", 3542 sta->addr, nss); 3543 3544 err = ath12k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 3545 WMI_PEER_NSS, nss); 3546 if (err) 3547 ath12k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n", 3548 sta->addr, nss, err); 3549 } 3550 3551 if (changed & IEEE80211_RC_SMPS_CHANGED) { 3552 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac update sta %pM smps %d\n", 3553 sta->addr, smps); 3554 3555 err = ath12k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 3556 WMI_PEER_MIMO_PS_STATE, smps); 3557 if (err) 3558 ath12k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n", 3559 sta->addr, smps, err); 3560 } 3561 3562 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) { 3563 mask = &arvif->bitrate_mask; 3564 num_vht_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band, 3565 mask); 3566 3567 /* Peer_assoc_prepare will reject vht rates in 3568 * bitrate_mask if its not available in range format and 3569 * sets vht tx_rateset as unsupported. So multiple VHT MCS 3570 * setting(eg. MCS 4,5,6) per peer is not supported here. 3571 * But, Single rate in VHT mask can be set as per-peer 3572 * fixed rate. But even if any HT rates are configured in 3573 * the bitrate mask, device will not switch to those rates 3574 * when per-peer Fixed rate is set. 3575 * TODO: Check RATEMASK_CMDID to support auto rates selection 3576 * across HT/VHT and for multiple VHT MCS support. 3577 */ 3578 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) { 3579 ath12k_mac_set_peer_vht_fixed_rate(arvif, sta, mask, 3580 band); 3581 } else { 3582 /* If the peer is non-VHT or no fixed VHT rate 3583 * is provided in the new bitrate mask we set the 3584 * other rates using peer_assoc command. 3585 */ 3586 ath12k_peer_assoc_prepare(ar, arvif->vif, sta, 3587 &peer_arg, true); 3588 3589 err = ath12k_wmi_send_peer_assoc_cmd(ar, &peer_arg); 3590 if (err) 3591 ath12k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n", 3592 sta->addr, arvif->vdev_id, err); 3593 3594 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) 3595 ath12k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n", 3596 sta->addr, arvif->vdev_id); 3597 } 3598 } 3599 err_rc_bw_changed: 3600 mutex_unlock(&ar->conf_mutex); 3601 } 3602 3603 static int ath12k_mac_inc_num_stations(struct ath12k_vif *arvif, 3604 struct ieee80211_sta *sta) 3605 { 3606 struct ath12k *ar = arvif->ar; 3607 3608 lockdep_assert_held(&ar->conf_mutex); 3609 3610 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 3611 return 0; 3612 3613 if (ar->num_stations >= ar->max_num_stations) 3614 return -ENOBUFS; 3615 3616 ar->num_stations++; 3617 3618 return 0; 3619 } 3620 3621 static void ath12k_mac_dec_num_stations(struct ath12k_vif *arvif, 3622 struct ieee80211_sta *sta) 3623 { 3624 struct ath12k *ar = arvif->ar; 3625 3626 lockdep_assert_held(&ar->conf_mutex); 3627 3628 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls) 3629 return; 3630 3631 ar->num_stations--; 3632 } 3633 3634 static int ath12k_mac_station_add(struct ath12k *ar, 3635 struct ieee80211_vif *vif, 3636 struct ieee80211_sta *sta) 3637 { 3638 struct ath12k_base *ab = ar->ab; 3639 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 3640 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv; 3641 struct ath12k_wmi_peer_create_arg peer_param; 3642 int ret; 3643 3644 lockdep_assert_held(&ar->conf_mutex); 3645 3646 ret = ath12k_mac_inc_num_stations(arvif, sta); 3647 if (ret) { 3648 ath12k_warn(ab, "refusing to associate station: too many connected already (%d)\n", 3649 ar->max_num_stations); 3650 goto exit; 3651 } 3652 3653 arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL); 3654 if (!arsta->rx_stats) { 3655 ret = -ENOMEM; 3656 goto dec_num_station; 3657 } 3658 3659 peer_param.vdev_id = arvif->vdev_id; 3660 peer_param.peer_addr = sta->addr; 3661 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 3662 3663 ret = ath12k_peer_create(ar, arvif, sta, &peer_param); 3664 if (ret) { 3665 ath12k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n", 3666 sta->addr, arvif->vdev_id); 3667 goto free_peer; 3668 } 3669 3670 ath12k_dbg(ab, ATH12K_DBG_MAC, "Added peer: %pM for VDEV: %d\n", 3671 sta->addr, arvif->vdev_id); 3672 3673 if (ieee80211_vif_is_mesh(vif)) { 3674 ret = ath12k_wmi_set_peer_param(ar, sta->addr, 3675 arvif->vdev_id, 3676 WMI_PEER_USE_4ADDR, 1); 3677 if (ret) { 3678 ath12k_warn(ab, "failed to STA %pM 4addr capability: %d\n", 3679 sta->addr, ret); 3680 goto free_peer; 3681 } 3682 } 3683 3684 ret = ath12k_dp_peer_setup(ar, arvif->vdev_id, sta->addr); 3685 if (ret) { 3686 ath12k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n", 3687 sta->addr, arvif->vdev_id, ret); 3688 goto free_peer; 3689 } 3690 3691 if (ab->hw_params->vdev_start_delay && 3692 !arvif->is_started && 3693 arvif->vdev_type != WMI_VDEV_TYPE_AP) { 3694 ret = ath12k_start_vdev_delay(ar->hw, vif); 3695 if (ret) { 3696 ath12k_warn(ab, "failed to delay vdev start: %d\n", ret); 3697 goto free_peer; 3698 } 3699 } 3700 3701 return 0; 3702 3703 free_peer: 3704 ath12k_peer_delete(ar, arvif->vdev_id, sta->addr); 3705 dec_num_station: 3706 ath12k_mac_dec_num_stations(arvif, sta); 3707 exit: 3708 return ret; 3709 } 3710 3711 static u32 ath12k_mac_ieee80211_sta_bw_to_wmi(struct ath12k *ar, 3712 struct ieee80211_sta *sta) 3713 { 3714 u32 bw = WMI_PEER_CHWIDTH_20MHZ; 3715 3716 switch (sta->deflink.bandwidth) { 3717 case IEEE80211_STA_RX_BW_20: 3718 bw = WMI_PEER_CHWIDTH_20MHZ; 3719 break; 3720 case IEEE80211_STA_RX_BW_40: 3721 bw = WMI_PEER_CHWIDTH_40MHZ; 3722 break; 3723 case IEEE80211_STA_RX_BW_80: 3724 bw = WMI_PEER_CHWIDTH_80MHZ; 3725 break; 3726 case IEEE80211_STA_RX_BW_160: 3727 bw = WMI_PEER_CHWIDTH_160MHZ; 3728 break; 3729 default: 3730 ath12k_warn(ar->ab, "Invalid bandwidth %d in rc update for %pM\n", 3731 sta->deflink.bandwidth, sta->addr); 3732 bw = WMI_PEER_CHWIDTH_20MHZ; 3733 break; 3734 } 3735 3736 return bw; 3737 } 3738 3739 static int ath12k_mac_op_sta_state(struct ieee80211_hw *hw, 3740 struct ieee80211_vif *vif, 3741 struct ieee80211_sta *sta, 3742 enum ieee80211_sta_state old_state, 3743 enum ieee80211_sta_state new_state) 3744 { 3745 struct ath12k *ar = hw->priv; 3746 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 3747 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv; 3748 struct ath12k_peer *peer; 3749 int ret = 0; 3750 3751 /* cancel must be done outside the mutex to avoid deadlock */ 3752 if ((old_state == IEEE80211_STA_NONE && 3753 new_state == IEEE80211_STA_NOTEXIST)) 3754 cancel_work_sync(&arsta->update_wk); 3755 3756 mutex_lock(&ar->conf_mutex); 3757 3758 if (old_state == IEEE80211_STA_NOTEXIST && 3759 new_state == IEEE80211_STA_NONE) { 3760 memset(arsta, 0, sizeof(*arsta)); 3761 arsta->arvif = arvif; 3762 INIT_WORK(&arsta->update_wk, ath12k_sta_rc_update_wk); 3763 3764 ret = ath12k_mac_station_add(ar, vif, sta); 3765 if (ret) 3766 ath12k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n", 3767 sta->addr, arvif->vdev_id); 3768 } else if ((old_state == IEEE80211_STA_NONE && 3769 new_state == IEEE80211_STA_NOTEXIST)) { 3770 ath12k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr); 3771 3772 ret = ath12k_peer_delete(ar, arvif->vdev_id, sta->addr); 3773 if (ret) 3774 ath12k_warn(ar->ab, "Failed to delete peer: %pM for VDEV: %d\n", 3775 sta->addr, arvif->vdev_id); 3776 else 3777 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "Removed peer: %pM for VDEV: %d\n", 3778 sta->addr, arvif->vdev_id); 3779 3780 ath12k_mac_dec_num_stations(arvif, sta); 3781 spin_lock_bh(&ar->ab->base_lock); 3782 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 3783 if (peer && peer->sta == sta) { 3784 ath12k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n", 3785 vif->addr, arvif->vdev_id); 3786 peer->sta = NULL; 3787 list_del(&peer->list); 3788 kfree(peer); 3789 ar->num_peers--; 3790 } 3791 spin_unlock_bh(&ar->ab->base_lock); 3792 3793 kfree(arsta->rx_stats); 3794 arsta->rx_stats = NULL; 3795 } else if (old_state == IEEE80211_STA_AUTH && 3796 new_state == IEEE80211_STA_ASSOC && 3797 (vif->type == NL80211_IFTYPE_AP || 3798 vif->type == NL80211_IFTYPE_MESH_POINT || 3799 vif->type == NL80211_IFTYPE_ADHOC)) { 3800 ret = ath12k_station_assoc(ar, vif, sta, false); 3801 if (ret) 3802 ath12k_warn(ar->ab, "Failed to associate station: %pM\n", 3803 sta->addr); 3804 3805 spin_lock_bh(&ar->data_lock); 3806 3807 arsta->bw = ath12k_mac_ieee80211_sta_bw_to_wmi(ar, sta); 3808 arsta->bw_prev = sta->deflink.bandwidth; 3809 3810 spin_unlock_bh(&ar->data_lock); 3811 } else if (old_state == IEEE80211_STA_ASSOC && 3812 new_state == IEEE80211_STA_AUTHORIZED) { 3813 spin_lock_bh(&ar->ab->base_lock); 3814 3815 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 3816 if (peer) 3817 peer->is_authorized = true; 3818 3819 spin_unlock_bh(&ar->ab->base_lock); 3820 3821 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) { 3822 ret = ath12k_wmi_set_peer_param(ar, sta->addr, 3823 arvif->vdev_id, 3824 WMI_PEER_AUTHORIZE, 3825 1); 3826 if (ret) 3827 ath12k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n", 3828 sta->addr, arvif->vdev_id, ret); 3829 } 3830 } else if (old_state == IEEE80211_STA_AUTHORIZED && 3831 new_state == IEEE80211_STA_ASSOC) { 3832 spin_lock_bh(&ar->ab->base_lock); 3833 3834 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 3835 if (peer) 3836 peer->is_authorized = false; 3837 3838 spin_unlock_bh(&ar->ab->base_lock); 3839 } else if (old_state == IEEE80211_STA_ASSOC && 3840 new_state == IEEE80211_STA_AUTH && 3841 (vif->type == NL80211_IFTYPE_AP || 3842 vif->type == NL80211_IFTYPE_MESH_POINT || 3843 vif->type == NL80211_IFTYPE_ADHOC)) { 3844 ret = ath12k_station_disassoc(ar, vif, sta); 3845 if (ret) 3846 ath12k_warn(ar->ab, "Failed to disassociate station: %pM\n", 3847 sta->addr); 3848 } 3849 3850 mutex_unlock(&ar->conf_mutex); 3851 return ret; 3852 } 3853 3854 static int ath12k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw, 3855 struct ieee80211_vif *vif, 3856 struct ieee80211_sta *sta) 3857 { 3858 struct ath12k *ar = hw->priv; 3859 struct ath12k_vif *arvif = (void *)vif->drv_priv; 3860 int ret; 3861 s16 txpwr; 3862 3863 if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) { 3864 txpwr = 0; 3865 } else { 3866 txpwr = sta->deflink.txpwr.power; 3867 if (!txpwr) 3868 return -EINVAL; 3869 } 3870 3871 if (txpwr > ATH12K_TX_POWER_MAX_VAL || txpwr < ATH12K_TX_POWER_MIN_VAL) 3872 return -EINVAL; 3873 3874 mutex_lock(&ar->conf_mutex); 3875 3876 ret = ath12k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id, 3877 WMI_PEER_USE_FIXED_PWR, txpwr); 3878 if (ret) { 3879 ath12k_warn(ar->ab, "failed to set tx power for station ret: %d\n", 3880 ret); 3881 goto out; 3882 } 3883 3884 out: 3885 mutex_unlock(&ar->conf_mutex); 3886 return ret; 3887 } 3888 3889 static void ath12k_mac_op_sta_rc_update(struct ieee80211_hw *hw, 3890 struct ieee80211_vif *vif, 3891 struct ieee80211_sta *sta, 3892 u32 changed) 3893 { 3894 struct ath12k *ar = hw->priv; 3895 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv; 3896 struct ath12k_vif *arvif = (void *)vif->drv_priv; 3897 struct ath12k_peer *peer; 3898 u32 bw, smps; 3899 3900 spin_lock_bh(&ar->ab->base_lock); 3901 3902 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr); 3903 if (!peer) { 3904 spin_unlock_bh(&ar->ab->base_lock); 3905 ath12k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n", 3906 sta->addr, arvif->vdev_id); 3907 return; 3908 } 3909 3910 spin_unlock_bh(&ar->ab->base_lock); 3911 3912 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 3913 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 3914 sta->addr, changed, sta->deflink.bandwidth, sta->deflink.rx_nss, 3915 sta->deflink.smps_mode); 3916 3917 spin_lock_bh(&ar->data_lock); 3918 3919 if (changed & IEEE80211_RC_BW_CHANGED) { 3920 bw = ath12k_mac_ieee80211_sta_bw_to_wmi(ar, sta); 3921 arsta->bw_prev = arsta->bw; 3922 arsta->bw = bw; 3923 } 3924 3925 if (changed & IEEE80211_RC_NSS_CHANGED) 3926 arsta->nss = sta->deflink.rx_nss; 3927 3928 if (changed & IEEE80211_RC_SMPS_CHANGED) { 3929 smps = WMI_PEER_SMPS_PS_NONE; 3930 3931 switch (sta->deflink.smps_mode) { 3932 case IEEE80211_SMPS_AUTOMATIC: 3933 case IEEE80211_SMPS_OFF: 3934 smps = WMI_PEER_SMPS_PS_NONE; 3935 break; 3936 case IEEE80211_SMPS_STATIC: 3937 smps = WMI_PEER_SMPS_STATIC; 3938 break; 3939 case IEEE80211_SMPS_DYNAMIC: 3940 smps = WMI_PEER_SMPS_DYNAMIC; 3941 break; 3942 default: 3943 ath12k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n", 3944 sta->deflink.smps_mode, sta->addr); 3945 smps = WMI_PEER_SMPS_PS_NONE; 3946 break; 3947 } 3948 3949 arsta->smps = smps; 3950 } 3951 3952 arsta->changed |= changed; 3953 3954 spin_unlock_bh(&ar->data_lock); 3955 3956 ieee80211_queue_work(hw, &arsta->update_wk); 3957 } 3958 3959 static int ath12k_conf_tx_uapsd(struct ath12k *ar, struct ieee80211_vif *vif, 3960 u16 ac, bool enable) 3961 { 3962 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 3963 u32 value; 3964 int ret; 3965 3966 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 3967 return 0; 3968 3969 switch (ac) { 3970 case IEEE80211_AC_VO: 3971 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 3972 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 3973 break; 3974 case IEEE80211_AC_VI: 3975 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 3976 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 3977 break; 3978 case IEEE80211_AC_BE: 3979 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 3980 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 3981 break; 3982 case IEEE80211_AC_BK: 3983 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 3984 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 3985 break; 3986 } 3987 3988 if (enable) 3989 arvif->u.sta.uapsd |= value; 3990 else 3991 arvif->u.sta.uapsd &= ~value; 3992 3993 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 3994 WMI_STA_PS_PARAM_UAPSD, 3995 arvif->u.sta.uapsd); 3996 if (ret) { 3997 ath12k_warn(ar->ab, "could not set uapsd params %d\n", ret); 3998 goto exit; 3999 } 4000 4001 if (arvif->u.sta.uapsd) 4002 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 4003 else 4004 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 4005 4006 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 4007 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 4008 value); 4009 if (ret) 4010 ath12k_warn(ar->ab, "could not set rx wake param %d\n", ret); 4011 4012 exit: 4013 return ret; 4014 } 4015 4016 static int ath12k_mac_op_conf_tx(struct ieee80211_hw *hw, 4017 struct ieee80211_vif *vif, 4018 unsigned int link_id, u16 ac, 4019 const struct ieee80211_tx_queue_params *params) 4020 { 4021 struct ath12k *ar = hw->priv; 4022 struct ath12k_vif *arvif = (void *)vif->drv_priv; 4023 struct wmi_wmm_params_arg *p = NULL; 4024 int ret; 4025 4026 mutex_lock(&ar->conf_mutex); 4027 4028 switch (ac) { 4029 case IEEE80211_AC_VO: 4030 p = &arvif->wmm_params.ac_vo; 4031 break; 4032 case IEEE80211_AC_VI: 4033 p = &arvif->wmm_params.ac_vi; 4034 break; 4035 case IEEE80211_AC_BE: 4036 p = &arvif->wmm_params.ac_be; 4037 break; 4038 case IEEE80211_AC_BK: 4039 p = &arvif->wmm_params.ac_bk; 4040 break; 4041 } 4042 4043 if (WARN_ON(!p)) { 4044 ret = -EINVAL; 4045 goto exit; 4046 } 4047 4048 p->cwmin = params->cw_min; 4049 p->cwmax = params->cw_max; 4050 p->aifs = params->aifs; 4051 p->txop = params->txop; 4052 4053 ret = ath12k_wmi_send_wmm_update_cmd(ar, arvif->vdev_id, 4054 &arvif->wmm_params); 4055 if (ret) { 4056 ath12k_warn(ar->ab, "failed to set wmm params: %d\n", ret); 4057 goto exit; 4058 } 4059 4060 ret = ath12k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 4061 4062 if (ret) 4063 ath12k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret); 4064 4065 exit: 4066 mutex_unlock(&ar->conf_mutex); 4067 return ret; 4068 } 4069 4070 static struct ieee80211_sta_ht_cap 4071 ath12k_create_ht_cap(struct ath12k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask) 4072 { 4073 int i; 4074 struct ieee80211_sta_ht_cap ht_cap = {0}; 4075 u32 ar_vht_cap = ar->pdev->cap.vht_cap; 4076 4077 if (!(ar_ht_cap & WMI_HT_CAP_ENABLED)) 4078 return ht_cap; 4079 4080 ht_cap.ht_supported = 1; 4081 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 4082 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE; 4083 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 4084 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 4085 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT; 4086 4087 if (ar_ht_cap & WMI_HT_CAP_HT20_SGI) 4088 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 4089 4090 if (ar_ht_cap & WMI_HT_CAP_HT40_SGI) 4091 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 4092 4093 if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) { 4094 u32 smps; 4095 4096 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 4097 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 4098 4099 ht_cap.cap |= smps; 4100 } 4101 4102 if (ar_ht_cap & WMI_HT_CAP_TX_STBC) 4103 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 4104 4105 if (ar_ht_cap & WMI_HT_CAP_RX_STBC) { 4106 u32 stbc; 4107 4108 stbc = ar_ht_cap; 4109 stbc &= WMI_HT_CAP_RX_STBC; 4110 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 4111 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 4112 stbc &= IEEE80211_HT_CAP_RX_STBC; 4113 4114 ht_cap.cap |= stbc; 4115 } 4116 4117 if (ar_ht_cap & WMI_HT_CAP_RX_LDPC) 4118 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 4119 4120 if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT) 4121 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 4122 4123 if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 4124 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 4125 4126 for (i = 0; i < ar->num_rx_chains; i++) { 4127 if (rate_cap_rx_chainmask & BIT(i)) 4128 ht_cap.mcs.rx_mask[i] = 0xFF; 4129 } 4130 4131 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 4132 4133 return ht_cap; 4134 } 4135 4136 static int ath12k_mac_set_txbf_conf(struct ath12k_vif *arvif) 4137 { 4138 u32 value = 0; 4139 struct ath12k *ar = arvif->ar; 4140 int nsts; 4141 int sound_dim; 4142 u32 vht_cap = ar->pdev->cap.vht_cap; 4143 u32 vdev_param = WMI_VDEV_PARAM_TXBF; 4144 4145 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) { 4146 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK; 4147 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT; 4148 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET); 4149 } 4150 4151 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) { 4152 sound_dim = vht_cap & 4153 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK; 4154 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT; 4155 if (sound_dim > (ar->num_tx_chains - 1)) 4156 sound_dim = ar->num_tx_chains - 1; 4157 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET); 4158 } 4159 4160 if (!value) 4161 return 0; 4162 4163 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) { 4164 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER; 4165 4166 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) && 4167 arvif->vdev_type == WMI_VDEV_TYPE_AP) 4168 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER; 4169 } 4170 4171 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) { 4172 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE; 4173 4174 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) && 4175 arvif->vdev_type == WMI_VDEV_TYPE_STA) 4176 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE; 4177 } 4178 4179 return ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 4180 vdev_param, value); 4181 } 4182 4183 static void ath12k_set_vht_txbf_cap(struct ath12k *ar, u32 *vht_cap) 4184 { 4185 bool subfer, subfee; 4186 int sound_dim = 0; 4187 4188 subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)); 4189 subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)); 4190 4191 if (ar->num_tx_chains < 2) { 4192 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE); 4193 subfer = false; 4194 } 4195 4196 /* If SU Beaformer is not set, then disable MU Beamformer Capability */ 4197 if (!subfer) 4198 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE); 4199 4200 /* If SU Beaformee is not set, then disable MU Beamformee Capability */ 4201 if (!subfee) 4202 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE); 4203 4204 sound_dim = u32_get_bits(*vht_cap, 4205 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK); 4206 *vht_cap = u32_replace_bits(*vht_cap, 0, 4207 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK); 4208 4209 /* TODO: Need to check invalid STS and Sound_dim values set by FW? */ 4210 4211 /* Enable Sounding Dimension Field only if SU BF is enabled */ 4212 if (subfer) { 4213 if (sound_dim > (ar->num_tx_chains - 1)) 4214 sound_dim = ar->num_tx_chains - 1; 4215 4216 *vht_cap = u32_replace_bits(*vht_cap, sound_dim, 4217 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK); 4218 } 4219 4220 /* Use the STS advertised by FW unless SU Beamformee is not supported*/ 4221 if (!subfee) 4222 *vht_cap &= ~(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK); 4223 } 4224 4225 static struct ieee80211_sta_vht_cap 4226 ath12k_create_vht_cap(struct ath12k *ar, u32 rate_cap_tx_chainmask, 4227 u32 rate_cap_rx_chainmask) 4228 { 4229 struct ieee80211_sta_vht_cap vht_cap = {0}; 4230 u16 txmcs_map, rxmcs_map; 4231 int i; 4232 4233 vht_cap.vht_supported = 1; 4234 vht_cap.cap = ar->pdev->cap.vht_cap; 4235 4236 ath12k_set_vht_txbf_cap(ar, &vht_cap.cap); 4237 4238 /* TODO: Enable back VHT160 mode once association issues are fixed */ 4239 /* Disabling VHT160 and VHT80+80 modes */ 4240 vht_cap.cap &= ~IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK; 4241 vht_cap.cap &= ~IEEE80211_VHT_CAP_SHORT_GI_160; 4242 4243 rxmcs_map = 0; 4244 txmcs_map = 0; 4245 for (i = 0; i < 8; i++) { 4246 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i)) 4247 txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 4248 else 4249 txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 4250 4251 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i)) 4252 rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2); 4253 else 4254 rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2); 4255 } 4256 4257 if (rate_cap_tx_chainmask <= 1) 4258 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC; 4259 4260 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map); 4261 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map); 4262 4263 return vht_cap; 4264 } 4265 4266 static void ath12k_mac_setup_ht_vht_cap(struct ath12k *ar, 4267 struct ath12k_pdev_cap *cap, 4268 u32 *ht_cap_info) 4269 { 4270 struct ieee80211_supported_band *band; 4271 u32 rate_cap_tx_chainmask; 4272 u32 rate_cap_rx_chainmask; 4273 u32 ht_cap; 4274 4275 rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift; 4276 rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift; 4277 4278 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 4279 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 4280 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info; 4281 if (ht_cap_info) 4282 *ht_cap_info = ht_cap; 4283 band->ht_cap = ath12k_create_ht_cap(ar, ht_cap, 4284 rate_cap_rx_chainmask); 4285 } 4286 4287 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 4288 (ar->ab->hw_params->single_pdev_only || 4289 !ar->supports_6ghz)) { 4290 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 4291 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info; 4292 if (ht_cap_info) 4293 *ht_cap_info = ht_cap; 4294 band->ht_cap = ath12k_create_ht_cap(ar, ht_cap, 4295 rate_cap_rx_chainmask); 4296 band->vht_cap = ath12k_create_vht_cap(ar, rate_cap_tx_chainmask, 4297 rate_cap_rx_chainmask); 4298 } 4299 } 4300 4301 static int ath12k_check_chain_mask(struct ath12k *ar, u32 ant, bool is_tx_ant) 4302 { 4303 /* TODO: Check the request chainmask against the supported 4304 * chainmask table which is advertised in extented_service_ready event 4305 */ 4306 4307 return 0; 4308 } 4309 4310 static void ath12k_gen_ppe_thresh(struct ath12k_wmi_ppe_threshold_arg *fw_ppet, 4311 u8 *he_ppet) 4312 { 4313 int nss, ru; 4314 u8 bit = 7; 4315 4316 he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK; 4317 he_ppet[0] |= (fw_ppet->ru_bit_mask << 4318 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) & 4319 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK; 4320 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) { 4321 for (ru = 0; ru < 4; ru++) { 4322 u8 val; 4323 int i; 4324 4325 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0) 4326 continue; 4327 val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) & 4328 0x3f; 4329 val = ((val >> 3) & 0x7) | ((val & 0x7) << 3); 4330 for (i = 5; i >= 0; i--) { 4331 he_ppet[bit / 8] |= 4332 ((val >> i) & 0x1) << ((bit % 8)); 4333 bit++; 4334 } 4335 } 4336 } 4337 } 4338 4339 static void 4340 ath12k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem) 4341 { 4342 u8 m; 4343 4344 m = IEEE80211_HE_MAC_CAP0_TWT_RES | 4345 IEEE80211_HE_MAC_CAP0_TWT_REQ; 4346 he_cap_elem->mac_cap_info[0] &= ~m; 4347 4348 m = IEEE80211_HE_MAC_CAP2_TRS | 4349 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 4350 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 4351 he_cap_elem->mac_cap_info[2] &= ~m; 4352 4353 m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED | 4354 IEEE80211_HE_MAC_CAP2_BCAST_TWT | 4355 IEEE80211_HE_MAC_CAP2_MU_CASCADING; 4356 he_cap_elem->mac_cap_info[3] &= ~m; 4357 4358 m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG | 4359 IEEE80211_HE_MAC_CAP4_BQR; 4360 he_cap_elem->mac_cap_info[4] &= ~m; 4361 4362 m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION | 4363 IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU | 4364 IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING | 4365 IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX; 4366 he_cap_elem->mac_cap_info[5] &= ~m; 4367 4368 m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO | 4369 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO; 4370 he_cap_elem->phy_cap_info[2] &= ~m; 4371 4372 m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU | 4373 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK | 4374 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK; 4375 he_cap_elem->phy_cap_info[3] &= ~m; 4376 4377 m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER; 4378 he_cap_elem->phy_cap_info[4] &= ~m; 4379 4380 m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK; 4381 he_cap_elem->phy_cap_info[5] &= ~m; 4382 4383 m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU | 4384 IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB | 4385 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB | 4386 IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO; 4387 he_cap_elem->phy_cap_info[6] &= ~m; 4388 4389 m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR | 4390 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP | 4391 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ | 4392 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ; 4393 he_cap_elem->phy_cap_info[7] &= ~m; 4394 4395 m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI | 4396 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G | 4397 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU | 4398 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU; 4399 he_cap_elem->phy_cap_info[8] &= ~m; 4400 4401 m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM | 4402 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK | 4403 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU | 4404 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU | 4405 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB | 4406 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB; 4407 he_cap_elem->phy_cap_info[9] &= ~m; 4408 } 4409 4410 static __le16 ath12k_mac_setup_he_6ghz_cap(struct ath12k_pdev_cap *pcap, 4411 struct ath12k_band_cap *bcap) 4412 { 4413 u8 val; 4414 4415 bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE; 4416 if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 4417 bcap->he_6ghz_capa |= 4418 u32_encode_bits(WLAN_HT_CAP_SM_PS_DYNAMIC, 4419 IEEE80211_HE_6GHZ_CAP_SM_PS); 4420 else 4421 bcap->he_6ghz_capa |= 4422 u32_encode_bits(WLAN_HT_CAP_SM_PS_DISABLED, 4423 IEEE80211_HE_6GHZ_CAP_SM_PS); 4424 val = u32_get_bits(pcap->vht_cap, 4425 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK); 4426 bcap->he_6ghz_capa |= 4427 u32_encode_bits(val, IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP); 4428 val = u32_get_bits(pcap->vht_cap, 4429 IEEE80211_VHT_CAP_MAX_MPDU_MASK); 4430 bcap->he_6ghz_capa |= 4431 u32_encode_bits(val, IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN); 4432 if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN) 4433 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS; 4434 if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN) 4435 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS; 4436 4437 return cpu_to_le16(bcap->he_6ghz_capa); 4438 } 4439 4440 static void ath12k_mac_copy_he_cap(struct ath12k_band_cap *band_cap, 4441 int iftype, u8 num_tx_chains, 4442 struct ieee80211_sta_he_cap *he_cap) 4443 { 4444 struct ieee80211_he_cap_elem *he_cap_elem = &he_cap->he_cap_elem; 4445 struct ieee80211_he_mcs_nss_supp *mcs_nss = &he_cap->he_mcs_nss_supp; 4446 4447 he_cap->has_he = true; 4448 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info, 4449 sizeof(he_cap_elem->mac_cap_info)); 4450 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info, 4451 sizeof(he_cap_elem->phy_cap_info)); 4452 4453 he_cap_elem->mac_cap_info[1] &= 4454 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK; 4455 4456 he_cap_elem->phy_cap_info[5] &= 4457 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK; 4458 he_cap_elem->phy_cap_info[5] &= 4459 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_MASK; 4460 he_cap_elem->phy_cap_info[5] |= num_tx_chains - 1; 4461 4462 switch (iftype) { 4463 case NL80211_IFTYPE_AP: 4464 he_cap_elem->phy_cap_info[3] &= 4465 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK; 4466 he_cap_elem->phy_cap_info[9] |= 4467 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU; 4468 break; 4469 case NL80211_IFTYPE_STATION: 4470 he_cap_elem->mac_cap_info[0] &= ~IEEE80211_HE_MAC_CAP0_TWT_RES; 4471 he_cap_elem->mac_cap_info[0] |= IEEE80211_HE_MAC_CAP0_TWT_REQ; 4472 he_cap_elem->phy_cap_info[9] |= 4473 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU; 4474 break; 4475 case NL80211_IFTYPE_MESH_POINT: 4476 ath12k_mac_filter_he_cap_mesh(he_cap_elem); 4477 break; 4478 } 4479 4480 mcs_nss->rx_mcs_80 = cpu_to_le16(band_cap->he_mcs & 0xffff); 4481 mcs_nss->tx_mcs_80 = cpu_to_le16(band_cap->he_mcs & 0xffff); 4482 mcs_nss->rx_mcs_160 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 4483 mcs_nss->tx_mcs_160 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 4484 mcs_nss->rx_mcs_80p80 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 4485 mcs_nss->tx_mcs_80p80 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff); 4486 4487 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres)); 4488 if (he_cap_elem->phy_cap_info[6] & 4489 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) 4490 ath12k_gen_ppe_thresh(&band_cap->he_ppet, he_cap->ppe_thres); 4491 } 4492 4493 static void 4494 ath12k_mac_copy_eht_mcs_nss(struct ath12k_band_cap *band_cap, 4495 struct ieee80211_eht_mcs_nss_supp *mcs_nss, 4496 const struct ieee80211_he_cap_elem *he_cap, 4497 const struct ieee80211_eht_cap_elem_fixed *eht_cap) 4498 { 4499 if ((he_cap->phy_cap_info[0] & 4500 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G | 4501 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G | 4502 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G | 4503 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)) == 0) 4504 memcpy(&mcs_nss->only_20mhz, &band_cap->eht_mcs_20_only, 4505 sizeof(struct ieee80211_eht_mcs_nss_supp_20mhz_only)); 4506 4507 if (he_cap->phy_cap_info[0] & 4508 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G | 4509 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G)) 4510 memcpy(&mcs_nss->bw._80, &band_cap->eht_mcs_80, 4511 sizeof(struct ieee80211_eht_mcs_nss_supp_bw)); 4512 4513 if (he_cap->phy_cap_info[0] & 4514 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) 4515 memcpy(&mcs_nss->bw._160, &band_cap->eht_mcs_160, 4516 sizeof(struct ieee80211_eht_mcs_nss_supp_bw)); 4517 4518 if (eht_cap->phy_cap_info[0] & IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ) 4519 memcpy(&mcs_nss->bw._320, &band_cap->eht_mcs_320, 4520 sizeof(struct ieee80211_eht_mcs_nss_supp_bw)); 4521 } 4522 4523 static void ath12k_mac_copy_eht_ppe_thresh(struct ath12k_wmi_ppe_threshold_arg *fw_ppet, 4524 struct ieee80211_sta_eht_cap *cap) 4525 { 4526 u16 bit = IEEE80211_EHT_PPE_THRES_INFO_HEADER_SIZE; 4527 u8 i, nss, ru, ppet_bit_len_per_ru = IEEE80211_EHT_PPE_THRES_INFO_PPET_SIZE * 2; 4528 4529 u8p_replace_bits(&cap->eht_ppe_thres[0], fw_ppet->numss_m1, 4530 IEEE80211_EHT_PPE_THRES_NSS_MASK); 4531 4532 u16p_replace_bits((u16 *)&cap->eht_ppe_thres[0], fw_ppet->ru_bit_mask, 4533 IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK); 4534 4535 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) { 4536 for (ru = 0; 4537 ru < hweight16(IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK); 4538 ru++) { 4539 u32 val = 0; 4540 4541 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0) 4542 continue; 4543 4544 u32p_replace_bits(&val, fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> 4545 (ru * ppet_bit_len_per_ru), 4546 GENMASK(ppet_bit_len_per_ru - 1, 0)); 4547 4548 for (i = 0; i < ppet_bit_len_per_ru; i++) { 4549 cap->eht_ppe_thres[bit / 8] |= 4550 (((val >> i) & 0x1) << ((bit % 8))); 4551 bit++; 4552 } 4553 } 4554 } 4555 } 4556 4557 static void ath12k_mac_copy_eht_cap(struct ath12k *ar, 4558 struct ath12k_band_cap *band_cap, 4559 struct ieee80211_he_cap_elem *he_cap_elem, 4560 int iftype, 4561 struct ieee80211_sta_eht_cap *eht_cap) 4562 { 4563 struct ieee80211_eht_cap_elem_fixed *eht_cap_elem = &eht_cap->eht_cap_elem; 4564 4565 memset(eht_cap, 0, sizeof(struct ieee80211_sta_eht_cap)); 4566 4567 if (!(test_bit(WMI_TLV_SERVICE_11BE, ar->ab->wmi_ab.svc_map))) 4568 return; 4569 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(ar, 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 _ieee80211_set_sband_iftype_data(sband, ar->mac.iftype[band], 4657 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 _ieee80211_set_sband_iftype_data(sband, ar->mac.iftype[band], 4667 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 _ieee80211_set_sband_iftype_data(sband, ar->mac.iftype[band], 4678 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 int ath12k_mac_rfkill_config(struct ath12k *ar) 5118 { 5119 struct ath12k_base *ab = ar->ab; 5120 u32 param; 5121 int ret; 5122 5123 if (ab->hw_params->rfkill_pin == 0) 5124 return -EOPNOTSUPP; 5125 5126 ath12k_dbg(ab, ATH12K_DBG_MAC, 5127 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d", 5128 ab->hw_params->rfkill_pin, ab->hw_params->rfkill_cfg, 5129 ab->hw_params->rfkill_on_level); 5130 5131 param = u32_encode_bits(ab->hw_params->rfkill_on_level, 5132 WMI_RFKILL_CFG_RADIO_LEVEL) | 5133 u32_encode_bits(ab->hw_params->rfkill_pin, 5134 WMI_RFKILL_CFG_GPIO_PIN_NUM) | 5135 u32_encode_bits(ab->hw_params->rfkill_cfg, 5136 WMI_RFKILL_CFG_PIN_AS_GPIO); 5137 5138 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_HW_RFKILL_CONFIG, 5139 param, ar->pdev->pdev_id); 5140 if (ret) { 5141 ath12k_warn(ab, 5142 "failed to set rfkill config 0x%x: %d\n", 5143 param, ret); 5144 return ret; 5145 } 5146 5147 return 0; 5148 } 5149 5150 int ath12k_mac_rfkill_enable_radio(struct ath12k *ar, bool enable) 5151 { 5152 enum wmi_rfkill_enable_radio param; 5153 int ret; 5154 5155 if (enable) 5156 param = WMI_RFKILL_ENABLE_RADIO_ON; 5157 else 5158 param = WMI_RFKILL_ENABLE_RADIO_OFF; 5159 5160 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac %d rfkill enable %d", 5161 ar->pdev_idx, param); 5162 5163 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RFKILL_ENABLE, 5164 param, ar->pdev->pdev_id); 5165 if (ret) { 5166 ath12k_warn(ar->ab, "failed to set rfkill enable param %d: %d\n", 5167 param, ret); 5168 return ret; 5169 } 5170 5171 return 0; 5172 } 5173 5174 static void ath12k_mac_op_stop(struct ieee80211_hw *hw) 5175 { 5176 struct ath12k *ar = hw->priv; 5177 struct htt_ppdu_stats_info *ppdu_stats, *tmp; 5178 int ret; 5179 5180 ath12k_mac_drain_tx(ar); 5181 5182 mutex_lock(&ar->conf_mutex); 5183 ret = ath12k_mac_config_mon_status_default(ar, false); 5184 if (ret && (ret != -ENOTSUPP)) 5185 ath12k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n", 5186 ret); 5187 5188 clear_bit(ATH12K_CAC_RUNNING, &ar->dev_flags); 5189 ar->state = ATH12K_STATE_OFF; 5190 mutex_unlock(&ar->conf_mutex); 5191 5192 cancel_delayed_work_sync(&ar->scan.timeout); 5193 cancel_work_sync(&ar->regd_update_work); 5194 cancel_work_sync(&ar->ab->rfkill_work); 5195 5196 spin_lock_bh(&ar->data_lock); 5197 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) { 5198 list_del(&ppdu_stats->list); 5199 kfree(ppdu_stats); 5200 } 5201 spin_unlock_bh(&ar->data_lock); 5202 5203 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL); 5204 5205 synchronize_rcu(); 5206 5207 atomic_set(&ar->num_pending_mgmt_tx, 0); 5208 } 5209 5210 static u8 5211 ath12k_mac_get_vdev_stats_id(struct ath12k_vif *arvif) 5212 { 5213 struct ath12k_base *ab = arvif->ar->ab; 5214 u8 vdev_stats_id = 0; 5215 5216 do { 5217 if (ab->free_vdev_stats_id_map & (1LL << vdev_stats_id)) { 5218 vdev_stats_id++; 5219 if (vdev_stats_id <= ATH12K_INVAL_VDEV_STATS_ID) { 5220 vdev_stats_id = ATH12K_INVAL_VDEV_STATS_ID; 5221 break; 5222 } 5223 } else { 5224 ab->free_vdev_stats_id_map |= (1LL << vdev_stats_id); 5225 break; 5226 } 5227 } while (vdev_stats_id); 5228 5229 arvif->vdev_stats_id = vdev_stats_id; 5230 return vdev_stats_id; 5231 } 5232 5233 static void ath12k_mac_setup_vdev_create_arg(struct ath12k_vif *arvif, 5234 struct ath12k_wmi_vdev_create_arg *arg) 5235 { 5236 struct ath12k *ar = arvif->ar; 5237 struct ath12k_pdev *pdev = ar->pdev; 5238 5239 arg->if_id = arvif->vdev_id; 5240 arg->type = arvif->vdev_type; 5241 arg->subtype = arvif->vdev_subtype; 5242 arg->pdev_id = pdev->pdev_id; 5243 5244 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) { 5245 arg->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains; 5246 arg->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains; 5247 } 5248 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) { 5249 arg->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains; 5250 arg->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains; 5251 } 5252 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP && 5253 ar->supports_6ghz) { 5254 arg->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains; 5255 arg->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains; 5256 } 5257 5258 arg->if_stats_id = ath12k_mac_get_vdev_stats_id(arvif); 5259 } 5260 5261 static u32 5262 ath12k_mac_prepare_he_mode(struct ath12k_pdev *pdev, u32 viftype) 5263 { 5264 struct ath12k_pdev_cap *pdev_cap = &pdev->cap; 5265 struct ath12k_band_cap *cap_band = NULL; 5266 u32 *hecap_phy_ptr = NULL; 5267 u32 hemode; 5268 5269 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) 5270 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ]; 5271 else 5272 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ]; 5273 5274 hecap_phy_ptr = &cap_band->he_cap_phy_info[0]; 5275 5276 hemode = u32_encode_bits(HE_SU_BFEE_ENABLE, HE_MODE_SU_TX_BFEE) | 5277 u32_encode_bits(HECAP_PHY_SUBFMR_GET(hecap_phy_ptr), 5278 HE_MODE_SU_TX_BFER) | 5279 u32_encode_bits(HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr), 5280 HE_MODE_UL_MUMIMO); 5281 5282 /* TODO: WDS and other modes */ 5283 if (viftype == NL80211_IFTYPE_AP) { 5284 hemode |= u32_encode_bits(HECAP_PHY_MUBFMR_GET(hecap_phy_ptr), 5285 HE_MODE_MU_TX_BFER) | 5286 u32_encode_bits(HE_DL_MUOFDMA_ENABLE, HE_MODE_DL_OFDMA) | 5287 u32_encode_bits(HE_UL_MUOFDMA_ENABLE, HE_MODE_UL_OFDMA); 5288 } else { 5289 hemode |= u32_encode_bits(HE_MU_BFEE_ENABLE, HE_MODE_MU_TX_BFEE); 5290 } 5291 5292 return hemode; 5293 } 5294 5295 static int ath12k_set_he_mu_sounding_mode(struct ath12k *ar, 5296 struct ath12k_vif *arvif) 5297 { 5298 u32 param_id, param_value; 5299 struct ath12k_base *ab = ar->ab; 5300 int ret; 5301 5302 param_id = WMI_VDEV_PARAM_SET_HEMU_MODE; 5303 param_value = ath12k_mac_prepare_he_mode(ar->pdev, arvif->vif->type); 5304 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5305 param_id, param_value); 5306 if (ret) { 5307 ath12k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n", 5308 arvif->vdev_id, ret, param_value); 5309 return ret; 5310 } 5311 param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE; 5312 param_value = 5313 u32_encode_bits(HE_VHT_SOUNDING_MODE_ENABLE, HE_VHT_SOUNDING_MODE) | 5314 u32_encode_bits(HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE, 5315 HE_TRIG_NONTRIG_SOUNDING_MODE); 5316 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5317 param_id, param_value); 5318 if (ret) { 5319 ath12k_warn(ab, "failed to set vdev %d HE MU mode: %d\n", 5320 arvif->vdev_id, ret); 5321 return ret; 5322 } 5323 return ret; 5324 } 5325 5326 static void ath12k_mac_op_update_vif_offload(struct ieee80211_hw *hw, 5327 struct ieee80211_vif *vif) 5328 { 5329 struct ath12k *ar = hw->priv; 5330 struct ath12k_base *ab = ar->ab; 5331 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 5332 u32 param_id, param_value; 5333 int ret; 5334 5335 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE; 5336 if (vif->type != NL80211_IFTYPE_STATION && 5337 vif->type != NL80211_IFTYPE_AP) 5338 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED | 5339 IEEE80211_OFFLOAD_DECAP_ENABLED); 5340 5341 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED) 5342 arvif->tx_encap_type = ATH12K_HW_TXRX_ETHERNET; 5343 else if (test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) 5344 arvif->tx_encap_type = ATH12K_HW_TXRX_RAW; 5345 else 5346 arvif->tx_encap_type = ATH12K_HW_TXRX_NATIVE_WIFI; 5347 5348 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5349 param_id, arvif->tx_encap_type); 5350 if (ret) { 5351 ath12k_warn(ab, "failed to set vdev %d tx encap mode: %d\n", 5352 arvif->vdev_id, ret); 5353 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED; 5354 } 5355 5356 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE; 5357 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED) 5358 param_value = ATH12K_HW_TXRX_ETHERNET; 5359 else if (test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) 5360 param_value = ATH12K_HW_TXRX_RAW; 5361 else 5362 param_value = ATH12K_HW_TXRX_NATIVE_WIFI; 5363 5364 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5365 param_id, param_value); 5366 if (ret) { 5367 ath12k_warn(ab, "failed to set vdev %d rx decap mode: %d\n", 5368 arvif->vdev_id, ret); 5369 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED; 5370 } 5371 } 5372 5373 static int ath12k_mac_op_add_interface(struct ieee80211_hw *hw, 5374 struct ieee80211_vif *vif) 5375 { 5376 struct ath12k *ar = hw->priv; 5377 struct ath12k_base *ab = ar->ab; 5378 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 5379 struct ath12k_wmi_vdev_create_arg vdev_arg = {0}; 5380 struct ath12k_wmi_peer_create_arg peer_param; 5381 u32 param_id, param_value; 5382 u16 nss; 5383 int i; 5384 int ret; 5385 int bit; 5386 5387 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 5388 5389 mutex_lock(&ar->conf_mutex); 5390 5391 if (vif->type == NL80211_IFTYPE_AP && 5392 ar->num_peers > (ar->max_num_peers - 1)) { 5393 ath12k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n"); 5394 ret = -ENOBUFS; 5395 goto err; 5396 } 5397 5398 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS - 1)) { 5399 ath12k_warn(ab, "failed to create vdev, reached max vdev limit %d\n", 5400 TARGET_NUM_VDEVS); 5401 ret = -EBUSY; 5402 goto err; 5403 } 5404 5405 memset(arvif, 0, sizeof(*arvif)); 5406 5407 arvif->ar = ar; 5408 arvif->vif = vif; 5409 5410 INIT_LIST_HEAD(&arvif->list); 5411 5412 /* Should we initialize any worker to handle connection loss indication 5413 * from firmware in sta mode? 5414 */ 5415 5416 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) { 5417 arvif->bitrate_mask.control[i].legacy = 0xffffffff; 5418 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff, 5419 sizeof(arvif->bitrate_mask.control[i].ht_mcs)); 5420 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff, 5421 sizeof(arvif->bitrate_mask.control[i].vht_mcs)); 5422 } 5423 5424 bit = __ffs64(ab->free_vdev_map); 5425 5426 arvif->vdev_id = bit; 5427 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 5428 5429 switch (vif->type) { 5430 case NL80211_IFTYPE_UNSPECIFIED: 5431 case NL80211_IFTYPE_STATION: 5432 arvif->vdev_type = WMI_VDEV_TYPE_STA; 5433 break; 5434 case NL80211_IFTYPE_MESH_POINT: 5435 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S; 5436 fallthrough; 5437 case NL80211_IFTYPE_AP: 5438 arvif->vdev_type = WMI_VDEV_TYPE_AP; 5439 break; 5440 case NL80211_IFTYPE_MONITOR: 5441 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 5442 ar->monitor_vdev_id = bit; 5443 break; 5444 default: 5445 WARN_ON(1); 5446 break; 5447 } 5448 5449 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac add interface id %d type %d subtype %d map %llx\n", 5450 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype, 5451 ab->free_vdev_map); 5452 5453 vif->cab_queue = arvif->vdev_id % (ATH12K_HW_MAX_QUEUES - 1); 5454 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 5455 vif->hw_queue[i] = i % (ATH12K_HW_MAX_QUEUES - 1); 5456 5457 ath12k_mac_setup_vdev_create_arg(arvif, &vdev_arg); 5458 5459 ret = ath12k_wmi_vdev_create(ar, vif->addr, &vdev_arg); 5460 if (ret) { 5461 ath12k_warn(ab, "failed to create WMI vdev %d: %d\n", 5462 arvif->vdev_id, ret); 5463 goto err; 5464 } 5465 5466 ar->num_created_vdevs++; 5467 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM created, vdev_id %d\n", 5468 vif->addr, arvif->vdev_id); 5469 ar->allocated_vdev_map |= 1LL << arvif->vdev_id; 5470 ab->free_vdev_map &= ~(1LL << arvif->vdev_id); 5471 5472 spin_lock_bh(&ar->data_lock); 5473 list_add(&arvif->list, &ar->arvifs); 5474 spin_unlock_bh(&ar->data_lock); 5475 5476 ath12k_mac_op_update_vif_offload(hw, vif); 5477 5478 nss = hweight32(ar->cfg_tx_chainmask) ? : 1; 5479 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5480 WMI_VDEV_PARAM_NSS, nss); 5481 if (ret) { 5482 ath12k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n", 5483 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret); 5484 goto err_vdev_del; 5485 } 5486 5487 switch (arvif->vdev_type) { 5488 case WMI_VDEV_TYPE_AP: 5489 peer_param.vdev_id = arvif->vdev_id; 5490 peer_param.peer_addr = vif->addr; 5491 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 5492 ret = ath12k_peer_create(ar, arvif, NULL, &peer_param); 5493 if (ret) { 5494 ath12k_warn(ab, "failed to vdev %d create peer for AP: %d\n", 5495 arvif->vdev_id, ret); 5496 goto err_vdev_del; 5497 } 5498 5499 ret = ath12k_mac_set_kickout(arvif); 5500 if (ret) { 5501 ath12k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n", 5502 arvif->vdev_id, ret); 5503 goto err_peer_del; 5504 } 5505 break; 5506 case WMI_VDEV_TYPE_STA: 5507 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 5508 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 5509 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5510 param_id, param_value); 5511 if (ret) { 5512 ath12k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n", 5513 arvif->vdev_id, ret); 5514 goto err_peer_del; 5515 } 5516 5517 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 5518 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 5519 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5520 param_id, param_value); 5521 if (ret) { 5522 ath12k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n", 5523 arvif->vdev_id, ret); 5524 goto err_peer_del; 5525 } 5526 5527 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT; 5528 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 5529 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5530 param_id, param_value); 5531 if (ret) { 5532 ath12k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n", 5533 arvif->vdev_id, ret); 5534 goto err_peer_del; 5535 } 5536 5537 ret = ath12k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, false); 5538 if (ret) { 5539 ath12k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n", 5540 arvif->vdev_id, ret); 5541 goto err_peer_del; 5542 } 5543 break; 5544 default: 5545 break; 5546 } 5547 5548 arvif->txpower = vif->bss_conf.txpower; 5549 ret = ath12k_mac_txpower_recalc(ar); 5550 if (ret) 5551 goto err_peer_del; 5552 5553 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 5554 param_value = ar->hw->wiphy->rts_threshold; 5555 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5556 param_id, param_value); 5557 if (ret) { 5558 ath12k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n", 5559 arvif->vdev_id, ret); 5560 } 5561 5562 ath12k_dp_vdev_tx_attach(ar, arvif); 5563 5564 if (vif->type != NL80211_IFTYPE_MONITOR && ar->monitor_conf_enabled) 5565 ath12k_mac_monitor_vdev_create(ar); 5566 5567 mutex_unlock(&ar->conf_mutex); 5568 5569 return ret; 5570 5571 err_peer_del: 5572 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 5573 reinit_completion(&ar->peer_delete_done); 5574 5575 ret = ath12k_wmi_send_peer_delete_cmd(ar, vif->addr, 5576 arvif->vdev_id); 5577 if (ret) { 5578 ath12k_warn(ar->ab, "failed to delete peer vdev_id %d addr %pM\n", 5579 arvif->vdev_id, vif->addr); 5580 goto err; 5581 } 5582 5583 ret = ath12k_wait_for_peer_delete_done(ar, arvif->vdev_id, 5584 vif->addr); 5585 if (ret) 5586 goto err; 5587 5588 ar->num_peers--; 5589 } 5590 5591 err_vdev_del: 5592 ath12k_wmi_vdev_delete(ar, arvif->vdev_id); 5593 ar->num_created_vdevs--; 5594 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 5595 ab->free_vdev_map |= 1LL << arvif->vdev_id; 5596 ab->free_vdev_stats_id_map &= ~(1LL << arvif->vdev_stats_id); 5597 spin_lock_bh(&ar->data_lock); 5598 list_del(&arvif->list); 5599 spin_unlock_bh(&ar->data_lock); 5600 5601 err: 5602 mutex_unlock(&ar->conf_mutex); 5603 5604 return ret; 5605 } 5606 5607 static void ath12k_mac_vif_unref(struct ath12k_dp *dp, struct ieee80211_vif *vif) 5608 { 5609 struct ath12k_tx_desc_info *tx_desc_info; 5610 struct ath12k_skb_cb *skb_cb; 5611 struct sk_buff *skb; 5612 int i; 5613 5614 for (i = 0; i < ATH12K_HW_MAX_QUEUES; i++) { 5615 spin_lock_bh(&dp->tx_desc_lock[i]); 5616 5617 list_for_each_entry(tx_desc_info, &dp->tx_desc_used_list[i], 5618 list) { 5619 skb = tx_desc_info->skb; 5620 if (!skb) 5621 continue; 5622 5623 skb_cb = ATH12K_SKB_CB(skb); 5624 if (skb_cb->vif == vif) 5625 skb_cb->vif = NULL; 5626 } 5627 5628 spin_unlock_bh(&dp->tx_desc_lock[i]); 5629 } 5630 } 5631 5632 static void ath12k_mac_op_remove_interface(struct ieee80211_hw *hw, 5633 struct ieee80211_vif *vif) 5634 { 5635 struct ath12k *ar = hw->priv; 5636 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 5637 struct ath12k_base *ab = ar->ab; 5638 unsigned long time_left; 5639 int ret; 5640 5641 mutex_lock(&ar->conf_mutex); 5642 5643 ath12k_dbg(ab, ATH12K_DBG_MAC, "mac remove interface (vdev %d)\n", 5644 arvif->vdev_id); 5645 5646 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 5647 ret = ath12k_peer_delete(ar, arvif->vdev_id, vif->addr); 5648 if (ret) 5649 ath12k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n", 5650 arvif->vdev_id, ret); 5651 } 5652 5653 reinit_completion(&ar->vdev_delete_done); 5654 5655 ret = ath12k_wmi_vdev_delete(ar, arvif->vdev_id); 5656 if (ret) { 5657 ath12k_warn(ab, "failed to delete WMI vdev %d: %d\n", 5658 arvif->vdev_id, ret); 5659 goto err_vdev_del; 5660 } 5661 5662 time_left = wait_for_completion_timeout(&ar->vdev_delete_done, 5663 ATH12K_VDEV_DELETE_TIMEOUT_HZ); 5664 if (time_left == 0) { 5665 ath12k_warn(ab, "Timeout in receiving vdev delete response\n"); 5666 goto err_vdev_del; 5667 } 5668 5669 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 5670 ar->monitor_vdev_id = -1; 5671 ar->monitor_vdev_created = false; 5672 } else if (ar->monitor_vdev_created && !ar->monitor_started) { 5673 ret = ath12k_mac_monitor_vdev_delete(ar); 5674 } 5675 5676 ab->free_vdev_map |= 1LL << (arvif->vdev_id); 5677 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 5678 ab->free_vdev_stats_id_map &= ~(1LL << arvif->vdev_stats_id); 5679 ar->num_created_vdevs--; 5680 5681 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n", 5682 vif->addr, arvif->vdev_id); 5683 5684 err_vdev_del: 5685 spin_lock_bh(&ar->data_lock); 5686 list_del(&arvif->list); 5687 spin_unlock_bh(&ar->data_lock); 5688 5689 ath12k_peer_cleanup(ar, arvif->vdev_id); 5690 5691 idr_for_each(&ar->txmgmt_idr, 5692 ath12k_mac_vif_txmgmt_idr_remove, vif); 5693 5694 ath12k_mac_vif_unref(&ab->dp, vif); 5695 ath12k_dp_tx_put_bank_profile(&ab->dp, arvif->bank_id); 5696 5697 /* Recalc txpower for remaining vdev */ 5698 ath12k_mac_txpower_recalc(ar); 5699 clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags); 5700 5701 /* TODO: recal traffic pause state based on the available vdevs */ 5702 5703 mutex_unlock(&ar->conf_mutex); 5704 } 5705 5706 /* FIXME: Has to be verified. */ 5707 #define SUPPORTED_FILTERS \ 5708 (FIF_ALLMULTI | \ 5709 FIF_CONTROL | \ 5710 FIF_PSPOLL | \ 5711 FIF_OTHER_BSS | \ 5712 FIF_BCN_PRBRESP_PROMISC | \ 5713 FIF_PROBE_REQ | \ 5714 FIF_FCSFAIL) 5715 5716 static void ath12k_mac_op_configure_filter(struct ieee80211_hw *hw, 5717 unsigned int changed_flags, 5718 unsigned int *total_flags, 5719 u64 multicast) 5720 { 5721 struct ath12k *ar = hw->priv; 5722 bool reset_flag; 5723 int ret; 5724 5725 mutex_lock(&ar->conf_mutex); 5726 5727 *total_flags &= SUPPORTED_FILTERS; 5728 ar->filter_flags = *total_flags; 5729 5730 /* For monitor mode */ 5731 reset_flag = !(ar->filter_flags & FIF_BCN_PRBRESP_PROMISC); 5732 5733 ret = ath12k_dp_tx_htt_monitor_mode_ring_config(ar, reset_flag); 5734 if (!ret) { 5735 if (!reset_flag) 5736 set_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags); 5737 else 5738 clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags); 5739 } else { 5740 ath12k_warn(ar->ab, 5741 "fail to set monitor filter: %d\n", ret); 5742 } 5743 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 5744 "total_flags:0x%x, reset_flag:%d\n", 5745 *total_flags, reset_flag); 5746 5747 mutex_unlock(&ar->conf_mutex); 5748 } 5749 5750 static int ath12k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 5751 { 5752 struct ath12k *ar = hw->priv; 5753 5754 mutex_lock(&ar->conf_mutex); 5755 5756 *tx_ant = ar->cfg_tx_chainmask; 5757 *rx_ant = ar->cfg_rx_chainmask; 5758 5759 mutex_unlock(&ar->conf_mutex); 5760 5761 return 0; 5762 } 5763 5764 static int ath12k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 5765 { 5766 struct ath12k *ar = hw->priv; 5767 int ret; 5768 5769 mutex_lock(&ar->conf_mutex); 5770 ret = __ath12k_set_antenna(ar, tx_ant, rx_ant); 5771 mutex_unlock(&ar->conf_mutex); 5772 5773 return ret; 5774 } 5775 5776 static int ath12k_mac_op_ampdu_action(struct ieee80211_hw *hw, 5777 struct ieee80211_vif *vif, 5778 struct ieee80211_ampdu_params *params) 5779 { 5780 struct ath12k *ar = hw->priv; 5781 int ret = -EINVAL; 5782 5783 mutex_lock(&ar->conf_mutex); 5784 5785 switch (params->action) { 5786 case IEEE80211_AMPDU_RX_START: 5787 ret = ath12k_dp_rx_ampdu_start(ar, params); 5788 break; 5789 case IEEE80211_AMPDU_RX_STOP: 5790 ret = ath12k_dp_rx_ampdu_stop(ar, params); 5791 break; 5792 case IEEE80211_AMPDU_TX_START: 5793 case IEEE80211_AMPDU_TX_STOP_CONT: 5794 case IEEE80211_AMPDU_TX_STOP_FLUSH: 5795 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 5796 case IEEE80211_AMPDU_TX_OPERATIONAL: 5797 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211 5798 * Tx aggregation requests. 5799 */ 5800 ret = -EOPNOTSUPP; 5801 break; 5802 } 5803 5804 mutex_unlock(&ar->conf_mutex); 5805 5806 return ret; 5807 } 5808 5809 static int ath12k_mac_op_add_chanctx(struct ieee80211_hw *hw, 5810 struct ieee80211_chanctx_conf *ctx) 5811 { 5812 struct ath12k *ar = hw->priv; 5813 struct ath12k_base *ab = ar->ab; 5814 5815 ath12k_dbg(ab, ATH12K_DBG_MAC, 5816 "mac chanctx add freq %u width %d ptr %pK\n", 5817 ctx->def.chan->center_freq, ctx->def.width, ctx); 5818 5819 mutex_lock(&ar->conf_mutex); 5820 5821 spin_lock_bh(&ar->data_lock); 5822 /* TODO: In case of multiple channel context, populate rx_channel from 5823 * Rx PPDU desc information. 5824 */ 5825 ar->rx_channel = ctx->def.chan; 5826 spin_unlock_bh(&ar->data_lock); 5827 5828 mutex_unlock(&ar->conf_mutex); 5829 5830 return 0; 5831 } 5832 5833 static void ath12k_mac_op_remove_chanctx(struct ieee80211_hw *hw, 5834 struct ieee80211_chanctx_conf *ctx) 5835 { 5836 struct ath12k *ar = hw->priv; 5837 struct ath12k_base *ab = ar->ab; 5838 5839 ath12k_dbg(ab, ATH12K_DBG_MAC, 5840 "mac chanctx remove freq %u width %d ptr %pK\n", 5841 ctx->def.chan->center_freq, ctx->def.width, ctx); 5842 5843 mutex_lock(&ar->conf_mutex); 5844 5845 spin_lock_bh(&ar->data_lock); 5846 /* TODO: In case of there is one more channel context left, populate 5847 * rx_channel with the channel of that remaining channel context. 5848 */ 5849 ar->rx_channel = NULL; 5850 spin_unlock_bh(&ar->data_lock); 5851 5852 mutex_unlock(&ar->conf_mutex); 5853 } 5854 5855 static enum wmi_phy_mode 5856 ath12k_mac_check_down_grade_phy_mode(struct ath12k *ar, 5857 enum wmi_phy_mode mode, 5858 enum nl80211_band band, 5859 enum nl80211_iftype type) 5860 { 5861 struct ieee80211_sta_eht_cap *eht_cap; 5862 enum wmi_phy_mode down_mode; 5863 5864 if (mode < MODE_11BE_EHT20) 5865 return mode; 5866 5867 eht_cap = &ar->mac.iftype[band][type].eht_cap; 5868 if (eht_cap->has_eht) 5869 return mode; 5870 5871 switch (mode) { 5872 case MODE_11BE_EHT20: 5873 down_mode = MODE_11AX_HE20; 5874 break; 5875 case MODE_11BE_EHT40: 5876 down_mode = MODE_11AX_HE40; 5877 break; 5878 case MODE_11BE_EHT80: 5879 down_mode = MODE_11AX_HE80; 5880 break; 5881 case MODE_11BE_EHT80_80: 5882 down_mode = MODE_11AX_HE80_80; 5883 break; 5884 case MODE_11BE_EHT160: 5885 case MODE_11BE_EHT160_160: 5886 case MODE_11BE_EHT320: 5887 down_mode = MODE_11AX_HE160; 5888 break; 5889 case MODE_11BE_EHT20_2G: 5890 down_mode = MODE_11AX_HE20_2G; 5891 break; 5892 case MODE_11BE_EHT40_2G: 5893 down_mode = MODE_11AX_HE40_2G; 5894 break; 5895 default: 5896 down_mode = mode; 5897 break; 5898 } 5899 5900 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 5901 "mac vdev start phymode %s downgrade to %s\n", 5902 ath12k_mac_phymode_str(mode), 5903 ath12k_mac_phymode_str(down_mode)); 5904 5905 return down_mode; 5906 } 5907 5908 static int 5909 ath12k_mac_vdev_start_restart(struct ath12k_vif *arvif, 5910 struct ieee80211_chanctx_conf *ctx, 5911 bool restart) 5912 { 5913 struct ath12k *ar = arvif->ar; 5914 struct ath12k_base *ab = ar->ab; 5915 struct wmi_vdev_start_req_arg arg = {}; 5916 const struct cfg80211_chan_def *chandef = &ctx->def; 5917 int he_support = arvif->vif->bss_conf.he_support; 5918 int ret; 5919 5920 lockdep_assert_held(&ar->conf_mutex); 5921 5922 reinit_completion(&ar->vdev_setup_done); 5923 5924 arg.vdev_id = arvif->vdev_id; 5925 arg.dtim_period = arvif->dtim_period; 5926 arg.bcn_intval = arvif->beacon_interval; 5927 arg.punct_bitmap = ~arvif->punct_bitmap; 5928 5929 arg.freq = chandef->chan->center_freq; 5930 arg.band_center_freq1 = chandef->center_freq1; 5931 arg.band_center_freq2 = chandef->center_freq2; 5932 arg.mode = ath12k_phymodes[chandef->chan->band][chandef->width]; 5933 5934 arg.mode = ath12k_mac_check_down_grade_phy_mode(ar, arg.mode, 5935 chandef->chan->band, 5936 arvif->vif->type); 5937 arg.min_power = 0; 5938 arg.max_power = chandef->chan->max_power * 2; 5939 arg.max_reg_power = chandef->chan->max_reg_power * 2; 5940 arg.max_antenna_gain = chandef->chan->max_antenna_gain * 2; 5941 5942 arg.pref_tx_streams = ar->num_tx_chains; 5943 arg.pref_rx_streams = ar->num_rx_chains; 5944 5945 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 5946 arg.ssid = arvif->u.ap.ssid; 5947 arg.ssid_len = arvif->u.ap.ssid_len; 5948 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 5949 5950 /* For now allow DFS for AP mode */ 5951 arg.chan_radar = !!(chandef->chan->flags & IEEE80211_CHAN_RADAR); 5952 5953 arg.freq2_radar = ctx->radar_enabled; 5954 5955 arg.passive = arg.chan_radar; 5956 5957 spin_lock_bh(&ab->base_lock); 5958 arg.regdomain = ar->ab->dfs_region; 5959 spin_unlock_bh(&ab->base_lock); 5960 5961 /* TODO: Notify if secondary 80Mhz also needs radar detection */ 5962 if (he_support) { 5963 ret = ath12k_set_he_mu_sounding_mode(ar, arvif); 5964 if (ret) { 5965 ath12k_warn(ar->ab, "failed to set he mode vdev %i\n", 5966 arg.vdev_id); 5967 return ret; 5968 } 5969 } 5970 } 5971 5972 arg.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR); 5973 5974 ath12k_dbg(ab, ATH12K_DBG_MAC, 5975 "mac vdev %d start center_freq %d phymode %s punct_bitmap 0x%x\n", 5976 arg.vdev_id, arg.freq, 5977 ath12k_mac_phymode_str(arg.mode), arg.punct_bitmap); 5978 5979 ret = ath12k_wmi_vdev_start(ar, &arg, restart); 5980 if (ret) { 5981 ath12k_warn(ar->ab, "failed to %s WMI vdev %i\n", 5982 restart ? "restart" : "start", arg.vdev_id); 5983 return ret; 5984 } 5985 5986 ret = ath12k_mac_vdev_setup_sync(ar); 5987 if (ret) { 5988 ath12k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n", 5989 arg.vdev_id, restart ? "restart" : "start", ret); 5990 return ret; 5991 } 5992 5993 ar->num_started_vdevs++; 5994 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM started, vdev_id %d\n", 5995 arvif->vif->addr, arvif->vdev_id); 5996 5997 /* Enable CAC Flag in the driver by checking the channel DFS cac time, 5998 * i.e dfs_cac_ms value which will be valid only for radar channels 5999 * and state as NL80211_DFS_USABLE which indicates CAC needs to be 6000 * done before channel usage. This flags is used to drop rx packets. 6001 * during CAC. 6002 */ 6003 /* TODO: Set the flag for other interface types as required */ 6004 if (arvif->vdev_type == WMI_VDEV_TYPE_AP && 6005 chandef->chan->dfs_cac_ms && 6006 chandef->chan->dfs_state == NL80211_DFS_USABLE) { 6007 set_bit(ATH12K_CAC_RUNNING, &ar->dev_flags); 6008 ath12k_dbg(ab, ATH12K_DBG_MAC, 6009 "CAC Started in chan_freq %d for vdev %d\n", 6010 arg.freq, arg.vdev_id); 6011 } 6012 6013 ret = ath12k_mac_set_txbf_conf(arvif); 6014 if (ret) 6015 ath12k_warn(ab, "failed to set txbf conf for vdev %d: %d\n", 6016 arvif->vdev_id, ret); 6017 6018 return 0; 6019 } 6020 6021 static int ath12k_mac_vdev_stop(struct ath12k_vif *arvif) 6022 { 6023 struct ath12k *ar = arvif->ar; 6024 int ret; 6025 6026 lockdep_assert_held(&ar->conf_mutex); 6027 6028 reinit_completion(&ar->vdev_setup_done); 6029 6030 ret = ath12k_wmi_vdev_stop(ar, arvif->vdev_id); 6031 if (ret) { 6032 ath12k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n", 6033 arvif->vdev_id, ret); 6034 goto err; 6035 } 6036 6037 ret = ath12k_mac_vdev_setup_sync(ar); 6038 if (ret) { 6039 ath12k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n", 6040 arvif->vdev_id, ret); 6041 goto err; 6042 } 6043 6044 WARN_ON(ar->num_started_vdevs == 0); 6045 6046 ar->num_started_vdevs--; 6047 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n", 6048 arvif->vif->addr, arvif->vdev_id); 6049 6050 if (test_bit(ATH12K_CAC_RUNNING, &ar->dev_flags)) { 6051 clear_bit(ATH12K_CAC_RUNNING, &ar->dev_flags); 6052 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "CAC Stopped for vdev %d\n", 6053 arvif->vdev_id); 6054 } 6055 6056 return 0; 6057 err: 6058 return ret; 6059 } 6060 6061 static int ath12k_mac_vdev_start(struct ath12k_vif *arvif, 6062 struct ieee80211_chanctx_conf *ctx) 6063 { 6064 return ath12k_mac_vdev_start_restart(arvif, ctx, false); 6065 } 6066 6067 static int ath12k_mac_vdev_restart(struct ath12k_vif *arvif, 6068 struct ieee80211_chanctx_conf *ctx) 6069 { 6070 return ath12k_mac_vdev_start_restart(arvif, ctx, true); 6071 } 6072 6073 struct ath12k_mac_change_chanctx_arg { 6074 struct ieee80211_chanctx_conf *ctx; 6075 struct ieee80211_vif_chanctx_switch *vifs; 6076 int n_vifs; 6077 int next_vif; 6078 }; 6079 6080 static void 6081 ath12k_mac_change_chanctx_cnt_iter(void *data, u8 *mac, 6082 struct ieee80211_vif *vif) 6083 { 6084 struct ath12k_mac_change_chanctx_arg *arg = data; 6085 6086 if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx) 6087 return; 6088 6089 arg->n_vifs++; 6090 } 6091 6092 static void 6093 ath12k_mac_change_chanctx_fill_iter(void *data, u8 *mac, 6094 struct ieee80211_vif *vif) 6095 { 6096 struct ath12k_mac_change_chanctx_arg *arg = data; 6097 struct ieee80211_chanctx_conf *ctx; 6098 6099 ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf); 6100 if (ctx != arg->ctx) 6101 return; 6102 6103 if (WARN_ON(arg->next_vif == arg->n_vifs)) 6104 return; 6105 6106 arg->vifs[arg->next_vif].vif = vif; 6107 arg->vifs[arg->next_vif].old_ctx = ctx; 6108 arg->vifs[arg->next_vif].new_ctx = ctx; 6109 arg->next_vif++; 6110 } 6111 6112 static void 6113 ath12k_mac_update_vif_chan(struct ath12k *ar, 6114 struct ieee80211_vif_chanctx_switch *vifs, 6115 int n_vifs) 6116 { 6117 struct ath12k_base *ab = ar->ab; 6118 struct ath12k_vif *arvif; 6119 int ret; 6120 int i; 6121 bool monitor_vif = false; 6122 6123 lockdep_assert_held(&ar->conf_mutex); 6124 6125 for (i = 0; i < n_vifs; i++) { 6126 arvif = (void *)vifs[i].vif->drv_priv; 6127 6128 if (vifs[i].vif->type == NL80211_IFTYPE_MONITOR) 6129 monitor_vif = true; 6130 6131 ath12k_dbg(ab, ATH12K_DBG_MAC, 6132 "mac chanctx switch vdev_id %i freq %u->%u width %d->%d\n", 6133 arvif->vdev_id, 6134 vifs[i].old_ctx->def.chan->center_freq, 6135 vifs[i].new_ctx->def.chan->center_freq, 6136 vifs[i].old_ctx->def.width, 6137 vifs[i].new_ctx->def.width); 6138 6139 if (WARN_ON(!arvif->is_started)) 6140 continue; 6141 6142 if (WARN_ON(!arvif->is_up)) 6143 continue; 6144 6145 ret = ath12k_wmi_vdev_down(ar, arvif->vdev_id); 6146 if (ret) { 6147 ath12k_warn(ab, "failed to down vdev %d: %d\n", 6148 arvif->vdev_id, ret); 6149 continue; 6150 } 6151 } 6152 6153 /* All relevant vdevs are downed and associated channel resources 6154 * should be available for the channel switch now. 6155 */ 6156 6157 /* TODO: Update ar->rx_channel */ 6158 6159 for (i = 0; i < n_vifs; i++) { 6160 arvif = (void *)vifs[i].vif->drv_priv; 6161 6162 if (WARN_ON(!arvif->is_started)) 6163 continue; 6164 6165 /* Firmware expect vdev_restart only if vdev is up. 6166 * If vdev is down then it expect vdev_stop->vdev_start. 6167 */ 6168 if (arvif->is_up) { 6169 ret = ath12k_mac_vdev_restart(arvif, vifs[i].new_ctx); 6170 if (ret) { 6171 ath12k_warn(ab, "failed to restart vdev %d: %d\n", 6172 arvif->vdev_id, ret); 6173 continue; 6174 } 6175 } else { 6176 ret = ath12k_mac_vdev_stop(arvif); 6177 if (ret) { 6178 ath12k_warn(ab, "failed to stop vdev %d: %d\n", 6179 arvif->vdev_id, ret); 6180 continue; 6181 } 6182 6183 ret = ath12k_mac_vdev_start(arvif, vifs[i].new_ctx); 6184 if (ret) 6185 ath12k_warn(ab, "failed to start vdev %d: %d\n", 6186 arvif->vdev_id, ret); 6187 continue; 6188 } 6189 6190 ret = ath12k_mac_setup_bcn_tmpl(arvif); 6191 if (ret) 6192 ath12k_warn(ab, "failed to update bcn tmpl during csa: %d\n", 6193 ret); 6194 6195 ret = ath12k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 6196 arvif->bssid); 6197 if (ret) { 6198 ath12k_warn(ab, "failed to bring vdev up %d: %d\n", 6199 arvif->vdev_id, ret); 6200 continue; 6201 } 6202 } 6203 6204 /* Restart the internal monitor vdev on new channel */ 6205 if (!monitor_vif && ar->monitor_vdev_created) { 6206 if (!ath12k_mac_monitor_stop(ar)) 6207 ath12k_mac_monitor_start(ar); 6208 } 6209 } 6210 6211 static void 6212 ath12k_mac_update_active_vif_chan(struct ath12k *ar, 6213 struct ieee80211_chanctx_conf *ctx) 6214 { 6215 struct ath12k_mac_change_chanctx_arg arg = { .ctx = ctx }; 6216 6217 lockdep_assert_held(&ar->conf_mutex); 6218 6219 ieee80211_iterate_active_interfaces_atomic(ar->hw, 6220 IEEE80211_IFACE_ITER_NORMAL, 6221 ath12k_mac_change_chanctx_cnt_iter, 6222 &arg); 6223 if (arg.n_vifs == 0) 6224 return; 6225 6226 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL); 6227 if (!arg.vifs) 6228 return; 6229 6230 ieee80211_iterate_active_interfaces_atomic(ar->hw, 6231 IEEE80211_IFACE_ITER_NORMAL, 6232 ath12k_mac_change_chanctx_fill_iter, 6233 &arg); 6234 6235 ath12k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs); 6236 6237 kfree(arg.vifs); 6238 } 6239 6240 static void ath12k_mac_op_change_chanctx(struct ieee80211_hw *hw, 6241 struct ieee80211_chanctx_conf *ctx, 6242 u32 changed) 6243 { 6244 struct ath12k *ar = hw->priv; 6245 struct ath12k_base *ab = ar->ab; 6246 6247 mutex_lock(&ar->conf_mutex); 6248 6249 ath12k_dbg(ab, ATH12K_DBG_MAC, 6250 "mac chanctx change freq %u width %d ptr %pK changed %x\n", 6251 ctx->def.chan->center_freq, ctx->def.width, ctx, changed); 6252 6253 /* This shouldn't really happen because channel switching should use 6254 * switch_vif_chanctx(). 6255 */ 6256 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL)) 6257 goto unlock; 6258 6259 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH || 6260 changed & IEEE80211_CHANCTX_CHANGE_RADAR) 6261 ath12k_mac_update_active_vif_chan(ar, ctx); 6262 6263 /* TODO: Recalc radar detection */ 6264 6265 unlock: 6266 mutex_unlock(&ar->conf_mutex); 6267 } 6268 6269 static int ath12k_start_vdev_delay(struct ieee80211_hw *hw, 6270 struct ieee80211_vif *vif) 6271 { 6272 struct ath12k *ar = hw->priv; 6273 struct ath12k_base *ab = ar->ab; 6274 struct ath12k_vif *arvif = (void *)vif->drv_priv; 6275 int ret; 6276 6277 if (WARN_ON(arvif->is_started)) 6278 return -EBUSY; 6279 6280 ret = ath12k_mac_vdev_start(arvif, &arvif->chanctx); 6281 if (ret) { 6282 ath12k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 6283 arvif->vdev_id, vif->addr, 6284 arvif->chanctx.def.chan->center_freq, ret); 6285 return ret; 6286 } 6287 6288 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 6289 ret = ath12k_monitor_vdev_up(ar, arvif->vdev_id); 6290 if (ret) { 6291 ath12k_warn(ab, "failed put monitor up: %d\n", ret); 6292 return ret; 6293 } 6294 } 6295 6296 arvif->is_started = true; 6297 6298 /* TODO: Setup ps and cts/rts protection */ 6299 return 0; 6300 } 6301 6302 static int 6303 ath12k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw, 6304 struct ieee80211_vif *vif, 6305 struct ieee80211_bss_conf *link_conf, 6306 struct ieee80211_chanctx_conf *ctx) 6307 { 6308 struct ath12k *ar = hw->priv; 6309 struct ath12k_base *ab = ar->ab; 6310 struct ath12k_vif *arvif = (void *)vif->drv_priv; 6311 int ret; 6312 struct ath12k_wmi_peer_create_arg param; 6313 6314 mutex_lock(&ar->conf_mutex); 6315 6316 ath12k_dbg(ab, ATH12K_DBG_MAC, 6317 "mac chanctx assign ptr %pK vdev_id %i\n", 6318 ctx, arvif->vdev_id); 6319 6320 arvif->punct_bitmap = link_conf->eht_puncturing; 6321 6322 /* for some targets bss peer must be created before vdev_start */ 6323 if (ab->hw_params->vdev_start_delay && 6324 arvif->vdev_type != WMI_VDEV_TYPE_AP && 6325 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 6326 !ath12k_peer_exist_by_vdev_id(ab, arvif->vdev_id)) { 6327 memcpy(&arvif->chanctx, ctx, sizeof(*ctx)); 6328 ret = 0; 6329 goto out; 6330 } 6331 6332 if (WARN_ON(arvif->is_started)) { 6333 ret = -EBUSY; 6334 goto out; 6335 } 6336 6337 if (ab->hw_params->vdev_start_delay && 6338 (arvif->vdev_type == WMI_VDEV_TYPE_AP || 6339 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)) { 6340 param.vdev_id = arvif->vdev_id; 6341 param.peer_type = WMI_PEER_TYPE_DEFAULT; 6342 param.peer_addr = ar->mac_addr; 6343 6344 ret = ath12k_peer_create(ar, arvif, NULL, ¶m); 6345 if (ret) { 6346 ath12k_warn(ab, "failed to create peer after vdev start delay: %d", 6347 ret); 6348 goto out; 6349 } 6350 } 6351 6352 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 6353 ret = ath12k_mac_monitor_start(ar); 6354 if (ret) 6355 goto out; 6356 arvif->is_started = true; 6357 goto out; 6358 } 6359 6360 ret = ath12k_mac_vdev_start(arvif, ctx); 6361 if (ret) { 6362 ath12k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 6363 arvif->vdev_id, vif->addr, 6364 ctx->def.chan->center_freq, ret); 6365 goto out; 6366 } 6367 6368 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && ar->monitor_vdev_created) 6369 ath12k_mac_monitor_start(ar); 6370 6371 arvif->is_started = true; 6372 6373 /* TODO: Setup ps and cts/rts protection */ 6374 6375 out: 6376 mutex_unlock(&ar->conf_mutex); 6377 6378 return ret; 6379 } 6380 6381 static void 6382 ath12k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 6383 struct ieee80211_vif *vif, 6384 struct ieee80211_bss_conf *link_conf, 6385 struct ieee80211_chanctx_conf *ctx) 6386 { 6387 struct ath12k *ar = hw->priv; 6388 struct ath12k_base *ab = ar->ab; 6389 struct ath12k_vif *arvif = (void *)vif->drv_priv; 6390 int ret; 6391 6392 mutex_lock(&ar->conf_mutex); 6393 6394 ath12k_dbg(ab, ATH12K_DBG_MAC, 6395 "mac chanctx unassign ptr %pK vdev_id %i\n", 6396 ctx, arvif->vdev_id); 6397 6398 WARN_ON(!arvif->is_started); 6399 6400 if (ab->hw_params->vdev_start_delay && 6401 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR && 6402 ath12k_peer_find_by_addr(ab, ar->mac_addr)) 6403 ath12k_peer_delete(ar, arvif->vdev_id, ar->mac_addr); 6404 6405 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 6406 ret = ath12k_mac_monitor_stop(ar); 6407 if (ret) { 6408 mutex_unlock(&ar->conf_mutex); 6409 return; 6410 } 6411 6412 arvif->is_started = false; 6413 } 6414 6415 ret = ath12k_mac_vdev_stop(arvif); 6416 if (ret) 6417 ath12k_warn(ab, "failed to stop vdev %i: %d\n", 6418 arvif->vdev_id, ret); 6419 6420 arvif->is_started = false; 6421 6422 if (ab->hw_params->vdev_start_delay && 6423 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 6424 ath12k_wmi_vdev_down(ar, arvif->vdev_id); 6425 6426 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 6427 ar->num_started_vdevs == 1 && ar->monitor_vdev_created) 6428 ath12k_mac_monitor_stop(ar); 6429 6430 mutex_unlock(&ar->conf_mutex); 6431 } 6432 6433 static int 6434 ath12k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw, 6435 struct ieee80211_vif_chanctx_switch *vifs, 6436 int n_vifs, 6437 enum ieee80211_chanctx_switch_mode mode) 6438 { 6439 struct ath12k *ar = hw->priv; 6440 6441 mutex_lock(&ar->conf_mutex); 6442 6443 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 6444 "mac chanctx switch n_vifs %d mode %d\n", 6445 n_vifs, mode); 6446 ath12k_mac_update_vif_chan(ar, vifs, n_vifs); 6447 6448 mutex_unlock(&ar->conf_mutex); 6449 6450 return 0; 6451 } 6452 6453 static int 6454 ath12k_set_vdev_param_to_all_vifs(struct ath12k *ar, int param, u32 value) 6455 { 6456 struct ath12k_vif *arvif; 6457 int ret = 0; 6458 6459 mutex_lock(&ar->conf_mutex); 6460 list_for_each_entry(arvif, &ar->arvifs, list) { 6461 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "setting mac vdev %d param %d value %d\n", 6462 param, arvif->vdev_id, value); 6463 6464 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6465 param, value); 6466 if (ret) { 6467 ath12k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n", 6468 param, arvif->vdev_id, ret); 6469 break; 6470 } 6471 } 6472 mutex_unlock(&ar->conf_mutex); 6473 return ret; 6474 } 6475 6476 /* mac80211 stores device specific RTS/Fragmentation threshold value, 6477 * this is set interface specific to firmware from ath12k driver 6478 */ 6479 static int ath12k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 6480 { 6481 struct ath12k *ar = hw->priv; 6482 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 6483 6484 return ath12k_set_vdev_param_to_all_vifs(ar, param_id, value); 6485 } 6486 6487 static int ath12k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 6488 { 6489 /* Even though there's a WMI vdev param for fragmentation threshold no 6490 * known firmware actually implements it. Moreover it is not possible to 6491 * rely frame fragmentation to mac80211 because firmware clears the 6492 * "more fragments" bit in frame control making it impossible for remote 6493 * devices to reassemble frames. 6494 * 6495 * Hence implement a dummy callback just to say fragmentation isn't 6496 * supported. This effectively prevents mac80211 from doing frame 6497 * fragmentation in software. 6498 */ 6499 return -EOPNOTSUPP; 6500 } 6501 6502 static void ath12k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 6503 u32 queues, bool drop) 6504 { 6505 struct ath12k *ar = hw->priv; 6506 long time_left; 6507 6508 if (drop) 6509 return; 6510 6511 time_left = wait_event_timeout(ar->dp.tx_empty_waitq, 6512 (atomic_read(&ar->dp.num_tx_pending) == 0), 6513 ATH12K_FLUSH_TIMEOUT); 6514 if (time_left == 0) 6515 ath12k_warn(ar->ab, "failed to flush transmit queue %ld\n", time_left); 6516 6517 time_left = wait_event_timeout(ar->txmgmt_empty_waitq, 6518 (atomic_read(&ar->num_pending_mgmt_tx) == 0), 6519 ATH12K_FLUSH_TIMEOUT); 6520 if (time_left == 0) 6521 ath12k_warn(ar->ab, "failed to flush mgmt transmit queue %ld\n", 6522 time_left); 6523 } 6524 6525 static int 6526 ath12k_mac_bitrate_mask_num_ht_rates(struct ath12k *ar, 6527 enum nl80211_band band, 6528 const struct cfg80211_bitrate_mask *mask) 6529 { 6530 int num_rates = 0; 6531 int i; 6532 6533 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) 6534 num_rates += hweight16(mask->control[band].ht_mcs[i]); 6535 6536 return num_rates; 6537 } 6538 6539 static bool 6540 ath12k_mac_has_single_legacy_rate(struct ath12k *ar, 6541 enum nl80211_band band, 6542 const struct cfg80211_bitrate_mask *mask) 6543 { 6544 int num_rates = 0; 6545 6546 num_rates = hweight32(mask->control[band].legacy); 6547 6548 if (ath12k_mac_bitrate_mask_num_ht_rates(ar, band, mask)) 6549 return false; 6550 6551 if (ath12k_mac_bitrate_mask_num_vht_rates(ar, band, mask)) 6552 return false; 6553 6554 return num_rates == 1; 6555 } 6556 6557 static bool 6558 ath12k_mac_bitrate_mask_get_single_nss(struct ath12k *ar, 6559 enum nl80211_band band, 6560 const struct cfg80211_bitrate_mask *mask, 6561 int *nss) 6562 { 6563 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 6564 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 6565 u8 ht_nss_mask = 0; 6566 u8 vht_nss_mask = 0; 6567 int i; 6568 6569 /* No need to consider legacy here. Basic rates are always present 6570 * in bitrate mask 6571 */ 6572 6573 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 6574 if (mask->control[band].ht_mcs[i] == 0) 6575 continue; 6576 else if (mask->control[band].ht_mcs[i] == 6577 sband->ht_cap.mcs.rx_mask[i]) 6578 ht_nss_mask |= BIT(i); 6579 else 6580 return false; 6581 } 6582 6583 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 6584 if (mask->control[band].vht_mcs[i] == 0) 6585 continue; 6586 else if (mask->control[band].vht_mcs[i] == 6587 ath12k_mac_get_max_vht_mcs_map(vht_mcs_map, i)) 6588 vht_nss_mask |= BIT(i); 6589 else 6590 return false; 6591 } 6592 6593 if (ht_nss_mask != vht_nss_mask) 6594 return false; 6595 6596 if (ht_nss_mask == 0) 6597 return false; 6598 6599 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask) 6600 return false; 6601 6602 *nss = fls(ht_nss_mask); 6603 6604 return true; 6605 } 6606 6607 static int 6608 ath12k_mac_get_single_legacy_rate(struct ath12k *ar, 6609 enum nl80211_band band, 6610 const struct cfg80211_bitrate_mask *mask, 6611 u32 *rate, u8 *nss) 6612 { 6613 int rate_idx; 6614 u16 bitrate; 6615 u8 preamble; 6616 u8 hw_rate; 6617 6618 if (hweight32(mask->control[band].legacy) != 1) 6619 return -EINVAL; 6620 6621 rate_idx = ffs(mask->control[band].legacy) - 1; 6622 6623 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ) 6624 rate_idx += ATH12K_MAC_FIRST_OFDM_RATE_IDX; 6625 6626 hw_rate = ath12k_legacy_rates[rate_idx].hw_value; 6627 bitrate = ath12k_legacy_rates[rate_idx].bitrate; 6628 6629 if (ath12k_mac_bitrate_is_cck(bitrate)) 6630 preamble = WMI_RATE_PREAMBLE_CCK; 6631 else 6632 preamble = WMI_RATE_PREAMBLE_OFDM; 6633 6634 *nss = 1; 6635 *rate = ATH12K_HW_RATE_CODE(hw_rate, 0, preamble); 6636 6637 return 0; 6638 } 6639 6640 static int ath12k_mac_set_fixed_rate_params(struct ath12k_vif *arvif, 6641 u32 rate, u8 nss, u8 sgi, u8 ldpc) 6642 { 6643 struct ath12k *ar = arvif->ar; 6644 u32 vdev_param; 6645 int ret; 6646 6647 lockdep_assert_held(&ar->conf_mutex); 6648 6649 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02x nss %u sgi %u\n", 6650 arvif->vdev_id, rate, nss, sgi); 6651 6652 vdev_param = WMI_VDEV_PARAM_FIXED_RATE; 6653 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6654 vdev_param, rate); 6655 if (ret) { 6656 ath12k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n", 6657 rate, ret); 6658 return ret; 6659 } 6660 6661 vdev_param = WMI_VDEV_PARAM_NSS; 6662 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6663 vdev_param, nss); 6664 if (ret) { 6665 ath12k_warn(ar->ab, "failed to set nss param %d: %d\n", 6666 nss, ret); 6667 return ret; 6668 } 6669 6670 vdev_param = WMI_VDEV_PARAM_SGI; 6671 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6672 vdev_param, sgi); 6673 if (ret) { 6674 ath12k_warn(ar->ab, "failed to set sgi param %d: %d\n", 6675 sgi, ret); 6676 return ret; 6677 } 6678 6679 vdev_param = WMI_VDEV_PARAM_LDPC; 6680 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6681 vdev_param, ldpc); 6682 if (ret) { 6683 ath12k_warn(ar->ab, "failed to set ldpc param %d: %d\n", 6684 ldpc, ret); 6685 return ret; 6686 } 6687 6688 return 0; 6689 } 6690 6691 static bool 6692 ath12k_mac_vht_mcs_range_present(struct ath12k *ar, 6693 enum nl80211_band band, 6694 const struct cfg80211_bitrate_mask *mask) 6695 { 6696 int i; 6697 u16 vht_mcs; 6698 6699 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 6700 vht_mcs = mask->control[band].vht_mcs[i]; 6701 6702 switch (vht_mcs) { 6703 case 0: 6704 case BIT(8) - 1: 6705 case BIT(9) - 1: 6706 case BIT(10) - 1: 6707 break; 6708 default: 6709 return false; 6710 } 6711 } 6712 6713 return true; 6714 } 6715 6716 static void ath12k_mac_set_bitrate_mask_iter(void *data, 6717 struct ieee80211_sta *sta) 6718 { 6719 struct ath12k_vif *arvif = data; 6720 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv; 6721 struct ath12k *ar = arvif->ar; 6722 6723 spin_lock_bh(&ar->data_lock); 6724 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED; 6725 spin_unlock_bh(&ar->data_lock); 6726 6727 ieee80211_queue_work(ar->hw, &arsta->update_wk); 6728 } 6729 6730 static void ath12k_mac_disable_peer_fixed_rate(void *data, 6731 struct ieee80211_sta *sta) 6732 { 6733 struct ath12k_vif *arvif = data; 6734 struct ath12k *ar = arvif->ar; 6735 int ret; 6736 6737 ret = ath12k_wmi_set_peer_param(ar, sta->addr, 6738 arvif->vdev_id, 6739 WMI_PEER_PARAM_FIXED_RATE, 6740 WMI_FIXED_RATE_NONE); 6741 if (ret) 6742 ath12k_warn(ar->ab, 6743 "failed to disable peer fixed rate for STA %pM ret %d\n", 6744 sta->addr, ret); 6745 } 6746 6747 static int 6748 ath12k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw, 6749 struct ieee80211_vif *vif, 6750 const struct cfg80211_bitrate_mask *mask) 6751 { 6752 struct ath12k_vif *arvif = (void *)vif->drv_priv; 6753 struct cfg80211_chan_def def; 6754 struct ath12k *ar = arvif->ar; 6755 enum nl80211_band band; 6756 const u8 *ht_mcs_mask; 6757 const u16 *vht_mcs_mask; 6758 u32 rate; 6759 u8 nss; 6760 u8 sgi; 6761 u8 ldpc; 6762 int single_nss; 6763 int ret; 6764 int num_rates; 6765 6766 if (ath12k_mac_vif_chan(vif, &def)) 6767 return -EPERM; 6768 6769 band = def.chan->band; 6770 ht_mcs_mask = mask->control[band].ht_mcs; 6771 vht_mcs_mask = mask->control[band].vht_mcs; 6772 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC); 6773 6774 sgi = mask->control[band].gi; 6775 if (sgi == NL80211_TXRATE_FORCE_LGI) 6776 return -EINVAL; 6777 6778 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it 6779 * requires passing at least one of used basic rates along with them. 6780 * Fixed rate setting across different preambles(legacy, HT, VHT) is 6781 * not supported by the FW. Hence use of FIXED_RATE vdev param is not 6782 * suitable for setting single HT/VHT rates. 6783 * But, there could be a single basic rate passed from userspace which 6784 * can be done through the FIXED_RATE param. 6785 */ 6786 if (ath12k_mac_has_single_legacy_rate(ar, band, mask)) { 6787 ret = ath12k_mac_get_single_legacy_rate(ar, band, mask, &rate, 6788 &nss); 6789 if (ret) { 6790 ath12k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n", 6791 arvif->vdev_id, ret); 6792 return ret; 6793 } 6794 ieee80211_iterate_stations_atomic(ar->hw, 6795 ath12k_mac_disable_peer_fixed_rate, 6796 arvif); 6797 } else if (ath12k_mac_bitrate_mask_get_single_nss(ar, band, mask, 6798 &single_nss)) { 6799 rate = WMI_FIXED_RATE_NONE; 6800 nss = single_nss; 6801 } else { 6802 rate = WMI_FIXED_RATE_NONE; 6803 nss = min_t(u32, ar->num_tx_chains, 6804 max(ath12k_mac_max_ht_nss(ht_mcs_mask), 6805 ath12k_mac_max_vht_nss(vht_mcs_mask))); 6806 6807 /* If multiple rates across different preambles are given 6808 * we can reconfigure this info with all peers using PEER_ASSOC 6809 * command with the below exception cases. 6810 * - Single VHT Rate : peer_assoc command accommodates only MCS 6811 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211 6812 * mandates passing basic rates along with HT/VHT rates, FW 6813 * doesn't allow switching from VHT to Legacy. Hence instead of 6814 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd, 6815 * we could set this VHT rate as peer fixed rate param, which 6816 * will override FIXED rate and FW rate control algorithm. 6817 * If single VHT rate is passed along with HT rates, we select 6818 * the VHT rate as fixed rate for vht peers. 6819 * - Multiple VHT Rates : When Multiple VHT rates are given,this 6820 * can be set using RATEMASK CMD which uses FW rate-ctl alg. 6821 * TODO: Setting multiple VHT MCS and replacing peer_assoc with 6822 * RATEMASK_CMDID can cover all use cases of setting rates 6823 * across multiple preambles and rates within same type. 6824 * But requires more validation of the command at this point. 6825 */ 6826 6827 num_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band, 6828 mask); 6829 6830 if (!ath12k_mac_vht_mcs_range_present(ar, band, mask) && 6831 num_rates > 1) { 6832 /* TODO: Handle multiple VHT MCS values setting using 6833 * RATEMASK CMD 6834 */ 6835 ath12k_warn(ar->ab, 6836 "Setting more than one MCS Value in bitrate mask not supported\n"); 6837 return -EINVAL; 6838 } 6839 6840 ieee80211_iterate_stations_atomic(ar->hw, 6841 ath12k_mac_disable_peer_fixed_rate, 6842 arvif); 6843 6844 mutex_lock(&ar->conf_mutex); 6845 6846 arvif->bitrate_mask = *mask; 6847 ieee80211_iterate_stations_atomic(ar->hw, 6848 ath12k_mac_set_bitrate_mask_iter, 6849 arvif); 6850 6851 mutex_unlock(&ar->conf_mutex); 6852 } 6853 6854 mutex_lock(&ar->conf_mutex); 6855 6856 ret = ath12k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc); 6857 if (ret) { 6858 ath12k_warn(ar->ab, "failed to set fixed rate params on vdev %i: %d\n", 6859 arvif->vdev_id, ret); 6860 } 6861 6862 mutex_unlock(&ar->conf_mutex); 6863 6864 return ret; 6865 } 6866 6867 static void 6868 ath12k_mac_op_reconfig_complete(struct ieee80211_hw *hw, 6869 enum ieee80211_reconfig_type reconfig_type) 6870 { 6871 struct ath12k *ar = hw->priv; 6872 struct ath12k_base *ab = ar->ab; 6873 struct ath12k_vif *arvif; 6874 int recovery_count; 6875 6876 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) 6877 return; 6878 6879 mutex_lock(&ar->conf_mutex); 6880 6881 if (ar->state == ATH12K_STATE_RESTARTED) { 6882 ath12k_warn(ar->ab, "pdev %d successfully recovered\n", 6883 ar->pdev->pdev_id); 6884 ar->state = ATH12K_STATE_ON; 6885 ieee80211_wake_queues(ar->hw); 6886 6887 if (ab->is_reset) { 6888 recovery_count = atomic_inc_return(&ab->recovery_count); 6889 ath12k_dbg(ab, ATH12K_DBG_BOOT, "recovery count %d\n", 6890 recovery_count); 6891 /* When there are multiple radios in an SOC, 6892 * the recovery has to be done for each radio 6893 */ 6894 if (recovery_count == ab->num_radios) { 6895 atomic_dec(&ab->reset_count); 6896 complete(&ab->reset_complete); 6897 ab->is_reset = false; 6898 atomic_set(&ab->fail_cont_count, 0); 6899 ath12k_dbg(ab, ATH12K_DBG_BOOT, "reset success\n"); 6900 } 6901 } 6902 6903 list_for_each_entry(arvif, &ar->arvifs, list) { 6904 ath12k_dbg(ab, ATH12K_DBG_BOOT, 6905 "reconfig cipher %d up %d vdev type %d\n", 6906 arvif->key_cipher, 6907 arvif->is_up, 6908 arvif->vdev_type); 6909 /* After trigger disconnect, then upper layer will 6910 * trigger connect again, then the PN number of 6911 * upper layer will be reset to keep up with AP 6912 * side, hence PN number mismatch will not happen. 6913 */ 6914 if (arvif->is_up && 6915 arvif->vdev_type == WMI_VDEV_TYPE_STA && 6916 arvif->vdev_subtype == WMI_VDEV_SUBTYPE_NONE) { 6917 ieee80211_hw_restart_disconnect(arvif->vif); 6918 ath12k_dbg(ab, ATH12K_DBG_BOOT, 6919 "restart disconnect\n"); 6920 } 6921 } 6922 } 6923 6924 mutex_unlock(&ar->conf_mutex); 6925 } 6926 6927 static void 6928 ath12k_mac_update_bss_chan_survey(struct ath12k *ar, 6929 struct ieee80211_channel *channel) 6930 { 6931 int ret; 6932 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ; 6933 6934 lockdep_assert_held(&ar->conf_mutex); 6935 6936 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) || 6937 ar->rx_channel != channel) 6938 return; 6939 6940 if (ar->scan.state != ATH12K_SCAN_IDLE) { 6941 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 6942 "ignoring bss chan info req while scanning..\n"); 6943 return; 6944 } 6945 6946 reinit_completion(&ar->bss_survey_done); 6947 6948 ret = ath12k_wmi_pdev_bss_chan_info_request(ar, type); 6949 if (ret) { 6950 ath12k_warn(ar->ab, "failed to send pdev bss chan info request\n"); 6951 return; 6952 } 6953 6954 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ); 6955 if (ret == 0) 6956 ath12k_warn(ar->ab, "bss channel survey timed out\n"); 6957 } 6958 6959 static int ath12k_mac_op_get_survey(struct ieee80211_hw *hw, int idx, 6960 struct survey_info *survey) 6961 { 6962 struct ath12k *ar = hw->priv; 6963 struct ieee80211_supported_band *sband; 6964 struct survey_info *ar_survey; 6965 int ret = 0; 6966 6967 if (idx >= ATH12K_NUM_CHANS) 6968 return -ENOENT; 6969 6970 ar_survey = &ar->survey[idx]; 6971 6972 mutex_lock(&ar->conf_mutex); 6973 6974 sband = hw->wiphy->bands[NL80211_BAND_2GHZ]; 6975 if (sband && idx >= sband->n_channels) { 6976 idx -= sband->n_channels; 6977 sband = NULL; 6978 } 6979 6980 if (!sband) 6981 sband = hw->wiphy->bands[NL80211_BAND_5GHZ]; 6982 6983 if (!sband || idx >= sband->n_channels) { 6984 ret = -ENOENT; 6985 goto exit; 6986 } 6987 6988 ath12k_mac_update_bss_chan_survey(ar, &sband->channels[idx]); 6989 6990 spin_lock_bh(&ar->data_lock); 6991 memcpy(survey, ar_survey, sizeof(*survey)); 6992 spin_unlock_bh(&ar->data_lock); 6993 6994 survey->channel = &sband->channels[idx]; 6995 6996 if (ar->rx_channel == survey->channel) 6997 survey->filled |= SURVEY_INFO_IN_USE; 6998 6999 exit: 7000 mutex_unlock(&ar->conf_mutex); 7001 return ret; 7002 } 7003 7004 static void ath12k_mac_op_sta_statistics(struct ieee80211_hw *hw, 7005 struct ieee80211_vif *vif, 7006 struct ieee80211_sta *sta, 7007 struct station_info *sinfo) 7008 { 7009 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv; 7010 7011 sinfo->rx_duration = arsta->rx_duration; 7012 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION); 7013 7014 sinfo->tx_duration = arsta->tx_duration; 7015 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION); 7016 7017 if (!arsta->txrate.legacy && !arsta->txrate.nss) 7018 return; 7019 7020 if (arsta->txrate.legacy) { 7021 sinfo->txrate.legacy = arsta->txrate.legacy; 7022 } else { 7023 sinfo->txrate.mcs = arsta->txrate.mcs; 7024 sinfo->txrate.nss = arsta->txrate.nss; 7025 sinfo->txrate.bw = arsta->txrate.bw; 7026 sinfo->txrate.he_gi = arsta->txrate.he_gi; 7027 sinfo->txrate.he_dcm = arsta->txrate.he_dcm; 7028 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc; 7029 } 7030 sinfo->txrate.flags = arsta->txrate.flags; 7031 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 7032 7033 /* TODO: Use real NF instead of default one. */ 7034 sinfo->signal = arsta->rssi_comb + ATH12K_DEFAULT_NOISE_FLOOR; 7035 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 7036 } 7037 7038 static const struct ieee80211_ops ath12k_ops = { 7039 .tx = ath12k_mac_op_tx, 7040 .wake_tx_queue = ieee80211_handle_wake_tx_queue, 7041 .start = ath12k_mac_op_start, 7042 .stop = ath12k_mac_op_stop, 7043 .reconfig_complete = ath12k_mac_op_reconfig_complete, 7044 .add_interface = ath12k_mac_op_add_interface, 7045 .remove_interface = ath12k_mac_op_remove_interface, 7046 .update_vif_offload = ath12k_mac_op_update_vif_offload, 7047 .config = ath12k_mac_op_config, 7048 .bss_info_changed = ath12k_mac_op_bss_info_changed, 7049 .configure_filter = ath12k_mac_op_configure_filter, 7050 .hw_scan = ath12k_mac_op_hw_scan, 7051 .cancel_hw_scan = ath12k_mac_op_cancel_hw_scan, 7052 .set_key = ath12k_mac_op_set_key, 7053 .sta_state = ath12k_mac_op_sta_state, 7054 .sta_set_txpwr = ath12k_mac_op_sta_set_txpwr, 7055 .sta_rc_update = ath12k_mac_op_sta_rc_update, 7056 .conf_tx = ath12k_mac_op_conf_tx, 7057 .set_antenna = ath12k_mac_op_set_antenna, 7058 .get_antenna = ath12k_mac_op_get_antenna, 7059 .ampdu_action = ath12k_mac_op_ampdu_action, 7060 .add_chanctx = ath12k_mac_op_add_chanctx, 7061 .remove_chanctx = ath12k_mac_op_remove_chanctx, 7062 .change_chanctx = ath12k_mac_op_change_chanctx, 7063 .assign_vif_chanctx = ath12k_mac_op_assign_vif_chanctx, 7064 .unassign_vif_chanctx = ath12k_mac_op_unassign_vif_chanctx, 7065 .switch_vif_chanctx = ath12k_mac_op_switch_vif_chanctx, 7066 .set_rts_threshold = ath12k_mac_op_set_rts_threshold, 7067 .set_frag_threshold = ath12k_mac_op_set_frag_threshold, 7068 .set_bitrate_mask = ath12k_mac_op_set_bitrate_mask, 7069 .get_survey = ath12k_mac_op_get_survey, 7070 .flush = ath12k_mac_op_flush, 7071 .sta_statistics = ath12k_mac_op_sta_statistics, 7072 }; 7073 7074 static void ath12k_mac_update_ch_list(struct ath12k *ar, 7075 struct ieee80211_supported_band *band, 7076 u32 freq_low, u32 freq_high) 7077 { 7078 int i; 7079 7080 if (!(freq_low && freq_high)) 7081 return; 7082 7083 for (i = 0; i < band->n_channels; i++) { 7084 if (band->channels[i].center_freq < freq_low || 7085 band->channels[i].center_freq > freq_high) 7086 band->channels[i].flags |= IEEE80211_CHAN_DISABLED; 7087 } 7088 } 7089 7090 static u32 ath12k_get_phy_id(struct ath12k *ar, u32 band) 7091 { 7092 struct ath12k_pdev *pdev = ar->pdev; 7093 struct ath12k_pdev_cap *pdev_cap = &pdev->cap; 7094 7095 if (band == WMI_HOST_WLAN_2G_CAP) 7096 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id; 7097 7098 if (band == WMI_HOST_WLAN_5G_CAP) 7099 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id; 7100 7101 ath12k_warn(ar->ab, "unsupported phy cap:%d\n", band); 7102 7103 return 0; 7104 } 7105 7106 static int ath12k_mac_setup_channels_rates(struct ath12k *ar, 7107 u32 supported_bands) 7108 { 7109 struct ieee80211_supported_band *band; 7110 struct ath12k_wmi_hal_reg_capabilities_ext_arg *reg_cap; 7111 void *channels; 7112 u32 phy_id; 7113 7114 BUILD_BUG_ON((ARRAY_SIZE(ath12k_2ghz_channels) + 7115 ARRAY_SIZE(ath12k_5ghz_channels) + 7116 ARRAY_SIZE(ath12k_6ghz_channels)) != 7117 ATH12K_NUM_CHANS); 7118 7119 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx]; 7120 7121 if (supported_bands & WMI_HOST_WLAN_2G_CAP) { 7122 channels = kmemdup(ath12k_2ghz_channels, 7123 sizeof(ath12k_2ghz_channels), 7124 GFP_KERNEL); 7125 if (!channels) 7126 return -ENOMEM; 7127 7128 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 7129 band->band = NL80211_BAND_2GHZ; 7130 band->n_channels = ARRAY_SIZE(ath12k_2ghz_channels); 7131 band->channels = channels; 7132 band->n_bitrates = ath12k_g_rates_size; 7133 band->bitrates = ath12k_g_rates; 7134 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band; 7135 7136 if (ar->ab->hw_params->single_pdev_only) { 7137 phy_id = ath12k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP); 7138 reg_cap = &ar->ab->hal_reg_cap[phy_id]; 7139 } 7140 ath12k_mac_update_ch_list(ar, band, 7141 reg_cap->low_2ghz_chan, 7142 reg_cap->high_2ghz_chan); 7143 } 7144 7145 if (supported_bands & WMI_HOST_WLAN_5G_CAP) { 7146 if (reg_cap->high_5ghz_chan >= ATH12K_MAX_6G_FREQ) { 7147 channels = kmemdup(ath12k_6ghz_channels, 7148 sizeof(ath12k_6ghz_channels), GFP_KERNEL); 7149 if (!channels) { 7150 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 7151 return -ENOMEM; 7152 } 7153 7154 ar->supports_6ghz = true; 7155 band = &ar->mac.sbands[NL80211_BAND_6GHZ]; 7156 band->band = NL80211_BAND_6GHZ; 7157 band->n_channels = ARRAY_SIZE(ath12k_6ghz_channels); 7158 band->channels = channels; 7159 band->n_bitrates = ath12k_a_rates_size; 7160 band->bitrates = ath12k_a_rates; 7161 ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band; 7162 ath12k_mac_update_ch_list(ar, band, 7163 reg_cap->low_5ghz_chan, 7164 reg_cap->high_5ghz_chan); 7165 } 7166 7167 if (reg_cap->low_5ghz_chan < ATH12K_MIN_6G_FREQ) { 7168 channels = kmemdup(ath12k_5ghz_channels, 7169 sizeof(ath12k_5ghz_channels), 7170 GFP_KERNEL); 7171 if (!channels) { 7172 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 7173 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 7174 return -ENOMEM; 7175 } 7176 7177 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 7178 band->band = NL80211_BAND_5GHZ; 7179 band->n_channels = ARRAY_SIZE(ath12k_5ghz_channels); 7180 band->channels = channels; 7181 band->n_bitrates = ath12k_a_rates_size; 7182 band->bitrates = ath12k_a_rates; 7183 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band; 7184 7185 if (ar->ab->hw_params->single_pdev_only) { 7186 phy_id = ath12k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP); 7187 reg_cap = &ar->ab->hal_reg_cap[phy_id]; 7188 } 7189 7190 ath12k_mac_update_ch_list(ar, band, 7191 reg_cap->low_5ghz_chan, 7192 reg_cap->high_5ghz_chan); 7193 } 7194 } 7195 7196 return 0; 7197 } 7198 7199 static int ath12k_mac_setup_iface_combinations(struct ath12k *ar) 7200 { 7201 struct ath12k_base *ab = ar->ab; 7202 struct ieee80211_iface_combination *combinations; 7203 struct ieee80211_iface_limit *limits; 7204 int n_limits, max_interfaces; 7205 bool ap, mesh; 7206 7207 ap = ab->hw_params->interface_modes & BIT(NL80211_IFTYPE_AP); 7208 7209 mesh = IS_ENABLED(CONFIG_MAC80211_MESH) && 7210 ab->hw_params->interface_modes & BIT(NL80211_IFTYPE_MESH_POINT); 7211 7212 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL); 7213 if (!combinations) 7214 return -ENOMEM; 7215 7216 if (ap || mesh) { 7217 n_limits = 2; 7218 max_interfaces = 16; 7219 } else { 7220 n_limits = 1; 7221 max_interfaces = 1; 7222 } 7223 7224 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL); 7225 if (!limits) { 7226 kfree(combinations); 7227 return -ENOMEM; 7228 } 7229 7230 limits[0].max = 1; 7231 limits[0].types |= BIT(NL80211_IFTYPE_STATION); 7232 7233 if (ap) { 7234 limits[1].max = max_interfaces; 7235 limits[1].types |= BIT(NL80211_IFTYPE_AP); 7236 } 7237 7238 if (mesh) 7239 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT); 7240 7241 combinations[0].limits = limits; 7242 combinations[0].n_limits = n_limits; 7243 combinations[0].max_interfaces = max_interfaces; 7244 combinations[0].num_different_channels = 1; 7245 combinations[0].beacon_int_infra_match = true; 7246 combinations[0].beacon_int_min_gcd = 100; 7247 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 7248 BIT(NL80211_CHAN_WIDTH_20) | 7249 BIT(NL80211_CHAN_WIDTH_40) | 7250 BIT(NL80211_CHAN_WIDTH_80); 7251 7252 ar->hw->wiphy->iface_combinations = combinations; 7253 ar->hw->wiphy->n_iface_combinations = 1; 7254 7255 return 0; 7256 } 7257 7258 static const u8 ath12k_if_types_ext_capa[] = { 7259 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 7260 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 7261 }; 7262 7263 static const u8 ath12k_if_types_ext_capa_sta[] = { 7264 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 7265 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 7266 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT, 7267 }; 7268 7269 static const u8 ath12k_if_types_ext_capa_ap[] = { 7270 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 7271 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 7272 [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT, 7273 }; 7274 7275 static const struct wiphy_iftype_ext_capab ath12k_iftypes_ext_capa[] = { 7276 { 7277 .extended_capabilities = ath12k_if_types_ext_capa, 7278 .extended_capabilities_mask = ath12k_if_types_ext_capa, 7279 .extended_capabilities_len = sizeof(ath12k_if_types_ext_capa), 7280 }, { 7281 .iftype = NL80211_IFTYPE_STATION, 7282 .extended_capabilities = ath12k_if_types_ext_capa_sta, 7283 .extended_capabilities_mask = ath12k_if_types_ext_capa_sta, 7284 .extended_capabilities_len = 7285 sizeof(ath12k_if_types_ext_capa_sta), 7286 }, { 7287 .iftype = NL80211_IFTYPE_AP, 7288 .extended_capabilities = ath12k_if_types_ext_capa_ap, 7289 .extended_capabilities_mask = ath12k_if_types_ext_capa_ap, 7290 .extended_capabilities_len = 7291 sizeof(ath12k_if_types_ext_capa_ap), 7292 }, 7293 }; 7294 7295 static void __ath12k_mac_unregister(struct ath12k *ar) 7296 { 7297 cancel_work_sync(&ar->regd_update_work); 7298 7299 ieee80211_unregister_hw(ar->hw); 7300 7301 idr_for_each(&ar->txmgmt_idr, ath12k_mac_tx_mgmt_pending_free, ar); 7302 idr_destroy(&ar->txmgmt_idr); 7303 7304 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 7305 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 7306 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 7307 7308 kfree(ar->hw->wiphy->iface_combinations[0].limits); 7309 kfree(ar->hw->wiphy->iface_combinations); 7310 7311 SET_IEEE80211_DEV(ar->hw, NULL); 7312 } 7313 7314 void ath12k_mac_unregister(struct ath12k_base *ab) 7315 { 7316 struct ath12k *ar; 7317 struct ath12k_pdev *pdev; 7318 int i; 7319 7320 for (i = 0; i < ab->num_radios; i++) { 7321 pdev = &ab->pdevs[i]; 7322 ar = pdev->ar; 7323 if (!ar) 7324 continue; 7325 7326 __ath12k_mac_unregister(ar); 7327 } 7328 } 7329 7330 static int __ath12k_mac_register(struct ath12k *ar) 7331 { 7332 struct ath12k_base *ab = ar->ab; 7333 struct ath12k_pdev_cap *cap = &ar->pdev->cap; 7334 static const u32 cipher_suites[] = { 7335 WLAN_CIPHER_SUITE_TKIP, 7336 WLAN_CIPHER_SUITE_CCMP, 7337 WLAN_CIPHER_SUITE_AES_CMAC, 7338 WLAN_CIPHER_SUITE_BIP_CMAC_256, 7339 WLAN_CIPHER_SUITE_BIP_GMAC_128, 7340 WLAN_CIPHER_SUITE_BIP_GMAC_256, 7341 WLAN_CIPHER_SUITE_GCMP, 7342 WLAN_CIPHER_SUITE_GCMP_256, 7343 WLAN_CIPHER_SUITE_CCMP_256, 7344 }; 7345 int ret; 7346 u32 ht_cap = 0; 7347 7348 ath12k_pdev_caps_update(ar); 7349 7350 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 7351 7352 SET_IEEE80211_DEV(ar->hw, ab->dev); 7353 7354 ret = ath12k_mac_setup_channels_rates(ar, 7355 cap->supported_bands); 7356 if (ret) 7357 goto err; 7358 7359 ath12k_mac_setup_ht_vht_cap(ar, cap, &ht_cap); 7360 ath12k_mac_setup_sband_iftype_data(ar, cap); 7361 7362 ret = ath12k_mac_setup_iface_combinations(ar); 7363 if (ret) { 7364 ath12k_err(ar->ab, "failed to setup interface combinations: %d\n", ret); 7365 goto err_free_channels; 7366 } 7367 7368 ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask; 7369 ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask; 7370 7371 ar->hw->wiphy->interface_modes = ab->hw_params->interface_modes; 7372 7373 if (ar->hw->wiphy->bands[NL80211_BAND_2GHZ] && 7374 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] && 7375 ar->hw->wiphy->bands[NL80211_BAND_6GHZ]) 7376 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS); 7377 7378 ieee80211_hw_set(ar->hw, SIGNAL_DBM); 7379 ieee80211_hw_set(ar->hw, SUPPORTS_PS); 7380 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS); 7381 ieee80211_hw_set(ar->hw, MFP_CAPABLE); 7382 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS); 7383 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL); 7384 ieee80211_hw_set(ar->hw, AP_LINK_PS); 7385 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT); 7386 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR); 7387 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK); 7388 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA); 7389 ieee80211_hw_set(ar->hw, QUEUE_CONTROL); 7390 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG); 7391 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK); 7392 7393 if (ht_cap & WMI_HT_CAP_ENABLED) { 7394 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION); 7395 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW); 7396 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER); 7397 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU); 7398 ieee80211_hw_set(ar->hw, USES_RSS); 7399 } 7400 7401 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS; 7402 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 7403 7404 /* TODO: Check if HT capability advertised from firmware is different 7405 * for each band for a dual band capable radio. It will be tricky to 7406 * handle it when the ht capability different for each band. 7407 */ 7408 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) 7409 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS; 7410 7411 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 7412 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 7413 7414 ar->hw->max_listen_interval = ATH12K_MAX_HW_LISTEN_INTERVAL; 7415 7416 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 7417 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 7418 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 7419 7420 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 7421 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 7422 NL80211_FEATURE_AP_SCAN; 7423 7424 ar->max_num_stations = TARGET_NUM_STATIONS; 7425 ar->max_num_peers = TARGET_NUM_PEERS_PDEV; 7426 7427 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations; 7428 7429 ar->hw->queues = ATH12K_HW_MAX_QUEUES; 7430 ar->hw->wiphy->tx_queue_len = ATH12K_QUEUE_LEN; 7431 ar->hw->offchannel_tx_hw_queue = ATH12K_HW_MAX_QUEUES - 1; 7432 ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE; 7433 7434 ar->hw->vif_data_size = sizeof(struct ath12k_vif); 7435 ar->hw->sta_data_size = sizeof(struct ath12k_sta); 7436 7437 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 7438 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR); 7439 7440 ar->hw->wiphy->cipher_suites = cipher_suites; 7441 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 7442 7443 ar->hw->wiphy->iftype_ext_capab = ath12k_iftypes_ext_capa; 7444 ar->hw->wiphy->num_iftype_ext_capab = 7445 ARRAY_SIZE(ath12k_iftypes_ext_capa); 7446 7447 if (ar->supports_6ghz) { 7448 wiphy_ext_feature_set(ar->hw->wiphy, 7449 NL80211_EXT_FEATURE_FILS_DISCOVERY); 7450 wiphy_ext_feature_set(ar->hw->wiphy, 7451 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP); 7452 } 7453 7454 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_PUNCT); 7455 7456 ath12k_reg_init(ar); 7457 7458 if (!test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) { 7459 ar->hw->netdev_features = NETIF_F_HW_CSUM; 7460 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL); 7461 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT); 7462 } 7463 7464 ret = ieee80211_register_hw(ar->hw); 7465 if (ret) { 7466 ath12k_err(ar->ab, "ieee80211 registration failed: %d\n", ret); 7467 goto err_free_if_combs; 7468 } 7469 7470 if (!ab->hw_params->supports_monitor) 7471 /* There's a race between calling ieee80211_register_hw() 7472 * and here where the monitor mode is enabled for a little 7473 * while. But that time is so short and in practise it make 7474 * a difference in real life. 7475 */ 7476 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR); 7477 7478 /* Apply the regd received during initialization */ 7479 ret = ath12k_regd_update(ar, true); 7480 if (ret) { 7481 ath12k_err(ar->ab, "ath12k regd update failed: %d\n", ret); 7482 goto err_unregister_hw; 7483 } 7484 7485 return 0; 7486 7487 err_unregister_hw: 7488 ieee80211_unregister_hw(ar->hw); 7489 7490 err_free_if_combs: 7491 kfree(ar->hw->wiphy->iface_combinations[0].limits); 7492 kfree(ar->hw->wiphy->iface_combinations); 7493 7494 err_free_channels: 7495 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 7496 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 7497 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 7498 7499 err: 7500 SET_IEEE80211_DEV(ar->hw, NULL); 7501 return ret; 7502 } 7503 7504 int ath12k_mac_register(struct ath12k_base *ab) 7505 { 7506 struct ath12k *ar; 7507 struct ath12k_pdev *pdev; 7508 int i; 7509 int ret; 7510 7511 if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags)) 7512 return 0; 7513 7514 for (i = 0; i < ab->num_radios; i++) { 7515 pdev = &ab->pdevs[i]; 7516 ar = pdev->ar; 7517 if (ab->pdevs_macaddr_valid) { 7518 ether_addr_copy(ar->mac_addr, pdev->mac_addr); 7519 } else { 7520 ether_addr_copy(ar->mac_addr, ab->mac_addr); 7521 ar->mac_addr[4] += i; 7522 } 7523 7524 ret = __ath12k_mac_register(ar); 7525 if (ret) 7526 goto err_cleanup; 7527 7528 init_waitqueue_head(&ar->txmgmt_empty_waitq); 7529 idr_init(&ar->txmgmt_idr); 7530 spin_lock_init(&ar->txmgmt_idr_lock); 7531 } 7532 7533 /* Initialize channel counters frequency value in hertz */ 7534 ab->cc_freq_hz = 320000; 7535 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1; 7536 7537 return 0; 7538 7539 err_cleanup: 7540 for (i = i - 1; i >= 0; i--) { 7541 pdev = &ab->pdevs[i]; 7542 ar = pdev->ar; 7543 __ath12k_mac_unregister(ar); 7544 } 7545 7546 return ret; 7547 } 7548 7549 int ath12k_mac_allocate(struct ath12k_base *ab) 7550 { 7551 struct ieee80211_hw *hw; 7552 struct ath12k *ar; 7553 struct ath12k_pdev *pdev; 7554 int ret; 7555 int i; 7556 7557 if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags)) 7558 return 0; 7559 7560 for (i = 0; i < ab->num_radios; i++) { 7561 pdev = &ab->pdevs[i]; 7562 hw = ieee80211_alloc_hw(sizeof(struct ath12k), &ath12k_ops); 7563 if (!hw) { 7564 ath12k_warn(ab, "failed to allocate mac80211 hw device\n"); 7565 ret = -ENOMEM; 7566 goto err_free_mac; 7567 } 7568 7569 ar = hw->priv; 7570 ar->hw = hw; 7571 ar->ab = ab; 7572 ar->pdev = pdev; 7573 ar->pdev_idx = i; 7574 ar->lmac_id = ath12k_hw_get_mac_from_pdev_id(ab->hw_params, i); 7575 7576 ar->wmi = &ab->wmi_ab.wmi[i]; 7577 /* FIXME: wmi[0] is already initialized during attach, 7578 * Should we do this again? 7579 */ 7580 ath12k_wmi_pdev_attach(ab, i); 7581 7582 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask; 7583 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask; 7584 ar->num_tx_chains = hweight32(pdev->cap.tx_chain_mask); 7585 ar->num_rx_chains = hweight32(pdev->cap.rx_chain_mask); 7586 7587 pdev->ar = ar; 7588 spin_lock_init(&ar->data_lock); 7589 INIT_LIST_HEAD(&ar->arvifs); 7590 INIT_LIST_HEAD(&ar->ppdu_stats_info); 7591 mutex_init(&ar->conf_mutex); 7592 init_completion(&ar->vdev_setup_done); 7593 init_completion(&ar->vdev_delete_done); 7594 init_completion(&ar->peer_assoc_done); 7595 init_completion(&ar->peer_delete_done); 7596 init_completion(&ar->install_key_done); 7597 init_completion(&ar->bss_survey_done); 7598 init_completion(&ar->scan.started); 7599 init_completion(&ar->scan.completed); 7600 7601 INIT_DELAYED_WORK(&ar->scan.timeout, ath12k_scan_timeout_work); 7602 INIT_WORK(&ar->regd_update_work, ath12k_regd_update_work); 7603 7604 INIT_WORK(&ar->wmi_mgmt_tx_work, ath12k_mgmt_over_wmi_tx_work); 7605 skb_queue_head_init(&ar->wmi_mgmt_tx_queue); 7606 clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags); 7607 } 7608 7609 return 0; 7610 7611 err_free_mac: 7612 ath12k_mac_destroy(ab); 7613 7614 return ret; 7615 } 7616 7617 void ath12k_mac_destroy(struct ath12k_base *ab) 7618 { 7619 struct ath12k *ar; 7620 struct ath12k_pdev *pdev; 7621 int i; 7622 7623 for (i = 0; i < ab->num_radios; i++) { 7624 pdev = &ab->pdevs[i]; 7625 ar = pdev->ar; 7626 if (!ar) 7627 continue; 7628 7629 ieee80211_free_hw(ar->hw); 7630 pdev->ar = NULL; 7631 } 7632 } 7633