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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_sta_to_arsta(sta); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_sta_to_arsta(sta); 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 = ath12k_sta_to_arsta(sta); 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 = ath12k_vif_to_arvif(vif); 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 = ath12k_sta_to_arsta(sta); 3896 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 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 = ath12k_vif_to_arvif(vif); 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 4558 ath12k_mac_filter_eht_cap_mesh(struct ieee80211_eht_cap_elem_fixed 4559 *eht_cap_elem) 4560 { 4561 u8 m; 4562 4563 m = IEEE80211_EHT_MAC_CAP0_EPCS_PRIO_ACCESS; 4564 eht_cap_elem->mac_cap_info[0] &= ~m; 4565 4566 m = IEEE80211_EHT_PHY_CAP0_PARTIAL_BW_UL_MU_MIMO; 4567 eht_cap_elem->phy_cap_info[0] &= ~m; 4568 4569 m = IEEE80211_EHT_PHY_CAP3_NG_16_MU_FEEDBACK | 4570 IEEE80211_EHT_PHY_CAP3_CODEBOOK_7_5_MU_FDBK | 4571 IEEE80211_EHT_PHY_CAP3_TRIG_MU_BF_PART_BW_FDBK | 4572 IEEE80211_EHT_PHY_CAP3_TRIG_CQI_FDBK; 4573 eht_cap_elem->phy_cap_info[3] &= ~m; 4574 4575 m = IEEE80211_EHT_PHY_CAP4_PART_BW_DL_MU_MIMO | 4576 IEEE80211_EHT_PHY_CAP4_PSR_SR_SUPP | 4577 IEEE80211_EHT_PHY_CAP4_POWER_BOOST_FACT_SUPP | 4578 IEEE80211_EHT_PHY_CAP4_EHT_MU_PPDU_4_EHT_LTF_08_GI; 4579 eht_cap_elem->phy_cap_info[4] &= ~m; 4580 4581 m = IEEE80211_EHT_PHY_CAP5_NON_TRIG_CQI_FEEDBACK | 4582 IEEE80211_EHT_PHY_CAP5_TX_LESS_242_TONE_RU_SUPP | 4583 IEEE80211_EHT_PHY_CAP5_RX_LESS_242_TONE_RU_SUPP | 4584 IEEE80211_EHT_PHY_CAP5_MAX_NUM_SUPP_EHT_LTF_MASK; 4585 eht_cap_elem->phy_cap_info[5] &= ~m; 4586 4587 m = IEEE80211_EHT_PHY_CAP6_MAX_NUM_SUPP_EHT_LTF_MASK; 4588 eht_cap_elem->phy_cap_info[6] &= ~m; 4589 4590 m = IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_80MHZ | 4591 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_160MHZ | 4592 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_320MHZ | 4593 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_80MHZ | 4594 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_160MHZ | 4595 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_320MHZ; 4596 eht_cap_elem->phy_cap_info[7] &= ~m; 4597 } 4598 4599 static void ath12k_mac_copy_eht_cap(struct ath12k *ar, 4600 struct ath12k_band_cap *band_cap, 4601 struct ieee80211_he_cap_elem *he_cap_elem, 4602 int iftype, 4603 struct ieee80211_sta_eht_cap *eht_cap) 4604 { 4605 struct ieee80211_eht_cap_elem_fixed *eht_cap_elem = &eht_cap->eht_cap_elem; 4606 4607 memset(eht_cap, 0, sizeof(struct ieee80211_sta_eht_cap)); 4608 4609 if (!(test_bit(WMI_TLV_SERVICE_11BE, ar->ab->wmi_ab.svc_map))) 4610 return; 4611 4612 eht_cap->has_eht = true; 4613 memcpy(eht_cap_elem->mac_cap_info, band_cap->eht_cap_mac_info, 4614 sizeof(eht_cap_elem->mac_cap_info)); 4615 memcpy(eht_cap_elem->phy_cap_info, band_cap->eht_cap_phy_info, 4616 sizeof(eht_cap_elem->phy_cap_info)); 4617 4618 switch (iftype) { 4619 case NL80211_IFTYPE_AP: 4620 eht_cap_elem->phy_cap_info[0] &= 4621 ~IEEE80211_EHT_PHY_CAP0_242_TONE_RU_GT20MHZ; 4622 eht_cap_elem->phy_cap_info[4] &= 4623 ~IEEE80211_EHT_PHY_CAP4_PART_BW_DL_MU_MIMO; 4624 eht_cap_elem->phy_cap_info[5] &= 4625 ~IEEE80211_EHT_PHY_CAP5_TX_LESS_242_TONE_RU_SUPP; 4626 break; 4627 case NL80211_IFTYPE_STATION: 4628 eht_cap_elem->phy_cap_info[7] &= 4629 ~(IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_80MHZ | 4630 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_160MHZ | 4631 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_320MHZ); 4632 eht_cap_elem->phy_cap_info[7] &= 4633 ~(IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_80MHZ | 4634 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_160MHZ | 4635 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_320MHZ); 4636 break; 4637 case NL80211_IFTYPE_MESH_POINT: 4638 ath12k_mac_filter_eht_cap_mesh(eht_cap_elem); 4639 break; 4640 default: 4641 break; 4642 } 4643 4644 ath12k_mac_copy_eht_mcs_nss(band_cap, &eht_cap->eht_mcs_nss_supp, 4645 he_cap_elem, eht_cap_elem); 4646 4647 if (eht_cap_elem->phy_cap_info[5] & 4648 IEEE80211_EHT_PHY_CAP5_PPE_THRESHOLD_PRESENT) 4649 ath12k_mac_copy_eht_ppe_thresh(&band_cap->eht_ppet, eht_cap); 4650 } 4651 4652 static int ath12k_mac_copy_sband_iftype_data(struct ath12k *ar, 4653 struct ath12k_pdev_cap *cap, 4654 struct ieee80211_sband_iftype_data *data, 4655 int band) 4656 { 4657 struct ath12k_band_cap *band_cap = &cap->band[band]; 4658 int i, idx = 0; 4659 4660 for (i = 0; i < NUM_NL80211_IFTYPES; i++) { 4661 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap; 4662 4663 switch (i) { 4664 case NL80211_IFTYPE_STATION: 4665 case NL80211_IFTYPE_AP: 4666 case NL80211_IFTYPE_MESH_POINT: 4667 break; 4668 4669 default: 4670 continue; 4671 } 4672 4673 data[idx].types_mask = BIT(i); 4674 4675 ath12k_mac_copy_he_cap(band_cap, i, ar->num_tx_chains, he_cap); 4676 if (band == NL80211_BAND_6GHZ) { 4677 data[idx].he_6ghz_capa.capa = 4678 ath12k_mac_setup_he_6ghz_cap(cap, band_cap); 4679 } 4680 ath12k_mac_copy_eht_cap(ar, band_cap, &he_cap->he_cap_elem, i, 4681 &data[idx].eht_cap); 4682 idx++; 4683 } 4684 4685 return idx; 4686 } 4687 4688 static void ath12k_mac_setup_sband_iftype_data(struct ath12k *ar, 4689 struct ath12k_pdev_cap *cap) 4690 { 4691 struct ieee80211_supported_band *sband; 4692 enum nl80211_band band; 4693 int count; 4694 4695 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) { 4696 band = NL80211_BAND_2GHZ; 4697 count = ath12k_mac_copy_sband_iftype_data(ar, cap, 4698 ar->mac.iftype[band], 4699 band); 4700 sband = &ar->mac.sbands[band]; 4701 _ieee80211_set_sband_iftype_data(sband, ar->mac.iftype[band], 4702 count); 4703 } 4704 4705 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) { 4706 band = NL80211_BAND_5GHZ; 4707 count = ath12k_mac_copy_sband_iftype_data(ar, cap, 4708 ar->mac.iftype[band], 4709 band); 4710 sband = &ar->mac.sbands[band]; 4711 _ieee80211_set_sband_iftype_data(sband, ar->mac.iftype[band], 4712 count); 4713 } 4714 4715 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP && 4716 ar->supports_6ghz) { 4717 band = NL80211_BAND_6GHZ; 4718 count = ath12k_mac_copy_sband_iftype_data(ar, cap, 4719 ar->mac.iftype[band], 4720 band); 4721 sband = &ar->mac.sbands[band]; 4722 _ieee80211_set_sband_iftype_data(sband, ar->mac.iftype[band], 4723 count); 4724 } 4725 } 4726 4727 static int __ath12k_set_antenna(struct ath12k *ar, u32 tx_ant, u32 rx_ant) 4728 { 4729 int ret; 4730 4731 lockdep_assert_held(&ar->conf_mutex); 4732 4733 if (ath12k_check_chain_mask(ar, tx_ant, true)) 4734 return -EINVAL; 4735 4736 if (ath12k_check_chain_mask(ar, rx_ant, false)) 4737 return -EINVAL; 4738 4739 ar->cfg_tx_chainmask = tx_ant; 4740 ar->cfg_rx_chainmask = rx_ant; 4741 4742 if (ar->state != ATH12K_STATE_ON && 4743 ar->state != ATH12K_STATE_RESTARTED) 4744 return 0; 4745 4746 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK, 4747 tx_ant, ar->pdev->pdev_id); 4748 if (ret) { 4749 ath12k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n", 4750 ret, tx_ant); 4751 return ret; 4752 } 4753 4754 ar->num_tx_chains = hweight32(tx_ant); 4755 4756 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK, 4757 rx_ant, ar->pdev->pdev_id); 4758 if (ret) { 4759 ath12k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n", 4760 ret, rx_ant); 4761 return ret; 4762 } 4763 4764 ar->num_rx_chains = hweight32(rx_ant); 4765 4766 /* Reload HT/VHT/HE capability */ 4767 ath12k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL); 4768 ath12k_mac_setup_sband_iftype_data(ar, &ar->pdev->cap); 4769 4770 return 0; 4771 } 4772 4773 static void ath12k_mgmt_over_wmi_tx_drop(struct ath12k *ar, struct sk_buff *skb) 4774 { 4775 int num_mgmt; 4776 4777 ieee80211_free_txskb(ar->hw, skb); 4778 4779 num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx); 4780 4781 if (num_mgmt < 0) 4782 WARN_ON_ONCE(1); 4783 4784 if (!num_mgmt) 4785 wake_up(&ar->txmgmt_empty_waitq); 4786 } 4787 4788 int ath12k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx) 4789 { 4790 struct sk_buff *msdu = skb; 4791 struct ieee80211_tx_info *info; 4792 struct ath12k *ar = ctx; 4793 struct ath12k_base *ab = ar->ab; 4794 4795 spin_lock_bh(&ar->txmgmt_idr_lock); 4796 idr_remove(&ar->txmgmt_idr, buf_id); 4797 spin_unlock_bh(&ar->txmgmt_idr_lock); 4798 dma_unmap_single(ab->dev, ATH12K_SKB_CB(msdu)->paddr, msdu->len, 4799 DMA_TO_DEVICE); 4800 4801 info = IEEE80211_SKB_CB(msdu); 4802 memset(&info->status, 0, sizeof(info->status)); 4803 4804 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 4805 4806 return 0; 4807 } 4808 4809 static int ath12k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx) 4810 { 4811 struct ieee80211_vif *vif = ctx; 4812 struct ath12k_skb_cb *skb_cb = ATH12K_SKB_CB(skb); 4813 struct sk_buff *msdu = skb; 4814 struct ath12k *ar = skb_cb->ar; 4815 struct ath12k_base *ab = ar->ab; 4816 4817 if (skb_cb->vif == vif) { 4818 spin_lock_bh(&ar->txmgmt_idr_lock); 4819 idr_remove(&ar->txmgmt_idr, buf_id); 4820 spin_unlock_bh(&ar->txmgmt_idr_lock); 4821 dma_unmap_single(ab->dev, skb_cb->paddr, msdu->len, 4822 DMA_TO_DEVICE); 4823 } 4824 4825 return 0; 4826 } 4827 4828 static int ath12k_mac_mgmt_tx_wmi(struct ath12k *ar, struct ath12k_vif *arvif, 4829 struct sk_buff *skb) 4830 { 4831 struct ath12k_base *ab = ar->ab; 4832 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 4833 struct ieee80211_tx_info *info; 4834 dma_addr_t paddr; 4835 int buf_id; 4836 int ret; 4837 4838 ATH12K_SKB_CB(skb)->ar = ar; 4839 spin_lock_bh(&ar->txmgmt_idr_lock); 4840 buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0, 4841 ATH12K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC); 4842 spin_unlock_bh(&ar->txmgmt_idr_lock); 4843 if (buf_id < 0) 4844 return -ENOSPC; 4845 4846 info = IEEE80211_SKB_CB(skb); 4847 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) { 4848 if ((ieee80211_is_action(hdr->frame_control) || 4849 ieee80211_is_deauth(hdr->frame_control) || 4850 ieee80211_is_disassoc(hdr->frame_control)) && 4851 ieee80211_has_protected(hdr->frame_control)) { 4852 skb_put(skb, IEEE80211_CCMP_MIC_LEN); 4853 } 4854 } 4855 4856 paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE); 4857 if (dma_mapping_error(ab->dev, paddr)) { 4858 ath12k_warn(ab, "failed to DMA map mgmt Tx buffer\n"); 4859 ret = -EIO; 4860 goto err_free_idr; 4861 } 4862 4863 ATH12K_SKB_CB(skb)->paddr = paddr; 4864 4865 ret = ath12k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb); 4866 if (ret) { 4867 ath12k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret); 4868 goto err_unmap_buf; 4869 } 4870 4871 return 0; 4872 4873 err_unmap_buf: 4874 dma_unmap_single(ab->dev, ATH12K_SKB_CB(skb)->paddr, 4875 skb->len, DMA_TO_DEVICE); 4876 err_free_idr: 4877 spin_lock_bh(&ar->txmgmt_idr_lock); 4878 idr_remove(&ar->txmgmt_idr, buf_id); 4879 spin_unlock_bh(&ar->txmgmt_idr_lock); 4880 4881 return ret; 4882 } 4883 4884 static void ath12k_mgmt_over_wmi_tx_purge(struct ath12k *ar) 4885 { 4886 struct sk_buff *skb; 4887 4888 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) 4889 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 4890 } 4891 4892 static void ath12k_mgmt_over_wmi_tx_work(struct work_struct *work) 4893 { 4894 struct ath12k *ar = container_of(work, struct ath12k, wmi_mgmt_tx_work); 4895 struct ath12k_skb_cb *skb_cb; 4896 struct ath12k_vif *arvif; 4897 struct sk_buff *skb; 4898 int ret; 4899 4900 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) { 4901 skb_cb = ATH12K_SKB_CB(skb); 4902 if (!skb_cb->vif) { 4903 ath12k_warn(ar->ab, "no vif found for mgmt frame\n"); 4904 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 4905 continue; 4906 } 4907 4908 arvif = ath12k_vif_to_arvif(skb_cb->vif); 4909 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id) && 4910 arvif->is_started) { 4911 ret = ath12k_mac_mgmt_tx_wmi(ar, arvif, skb); 4912 if (ret) { 4913 ath12k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n", 4914 arvif->vdev_id, ret); 4915 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 4916 } 4917 } else { 4918 ath12k_warn(ar->ab, 4919 "dropping mgmt frame for vdev %d, is_started %d\n", 4920 arvif->vdev_id, 4921 arvif->is_started); 4922 ath12k_mgmt_over_wmi_tx_drop(ar, skb); 4923 } 4924 } 4925 } 4926 4927 static int ath12k_mac_mgmt_tx(struct ath12k *ar, struct sk_buff *skb, 4928 bool is_prb_rsp) 4929 { 4930 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue; 4931 4932 if (test_bit(ATH12K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags)) 4933 return -ESHUTDOWN; 4934 4935 /* Drop probe response packets when the pending management tx 4936 * count has reached a certain threshold, so as to prioritize 4937 * other mgmt packets like auth and assoc to be sent on time 4938 * for establishing successful connections. 4939 */ 4940 if (is_prb_rsp && 4941 atomic_read(&ar->num_pending_mgmt_tx) > ATH12K_PRB_RSP_DROP_THRESHOLD) { 4942 ath12k_warn(ar->ab, 4943 "dropping probe response as pending queue is almost full\n"); 4944 return -ENOSPC; 4945 } 4946 4947 if (skb_queue_len_lockless(q) >= ATH12K_TX_MGMT_NUM_PENDING_MAX) { 4948 ath12k_warn(ar->ab, "mgmt tx queue is full\n"); 4949 return -ENOSPC; 4950 } 4951 4952 skb_queue_tail(q, skb); 4953 atomic_inc(&ar->num_pending_mgmt_tx); 4954 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work); 4955 4956 return 0; 4957 } 4958 4959 static void ath12k_mac_op_tx(struct ieee80211_hw *hw, 4960 struct ieee80211_tx_control *control, 4961 struct sk_buff *skb) 4962 { 4963 struct ath12k_skb_cb *skb_cb = ATH12K_SKB_CB(skb); 4964 struct ath12k *ar = hw->priv; 4965 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 4966 struct ieee80211_vif *vif = info->control.vif; 4967 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 4968 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 4969 struct ieee80211_key_conf *key = info->control.hw_key; 4970 u32 info_flags = info->flags; 4971 bool is_prb_rsp; 4972 int ret; 4973 4974 memset(skb_cb, 0, sizeof(*skb_cb)); 4975 skb_cb->vif = vif; 4976 4977 if (key) { 4978 skb_cb->cipher = key->cipher; 4979 skb_cb->flags |= ATH12K_SKB_CIPHER_SET; 4980 } 4981 4982 if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) { 4983 skb_cb->flags |= ATH12K_SKB_HW_80211_ENCAP; 4984 } else if (ieee80211_is_mgmt(hdr->frame_control)) { 4985 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control); 4986 ret = ath12k_mac_mgmt_tx(ar, skb, is_prb_rsp); 4987 if (ret) { 4988 ath12k_warn(ar->ab, "failed to queue management frame %d\n", 4989 ret); 4990 ieee80211_free_txskb(ar->hw, skb); 4991 } 4992 return; 4993 } 4994 4995 ret = ath12k_dp_tx(ar, arvif, skb); 4996 if (ret) { 4997 ath12k_warn(ar->ab, "failed to transmit frame %d\n", ret); 4998 ieee80211_free_txskb(ar->hw, skb); 4999 } 5000 } 5001 5002 void ath12k_mac_drain_tx(struct ath12k *ar) 5003 { 5004 /* make sure rcu-protected mac80211 tx path itself is drained */ 5005 synchronize_net(); 5006 5007 cancel_work_sync(&ar->wmi_mgmt_tx_work); 5008 ath12k_mgmt_over_wmi_tx_purge(ar); 5009 } 5010 5011 static int ath12k_mac_config_mon_status_default(struct ath12k *ar, bool enable) 5012 { 5013 return -ENOTSUPP; 5014 /* TODO: Need to support new monitor mode */ 5015 } 5016 5017 static void ath12k_mac_wait_reconfigure(struct ath12k_base *ab) 5018 { 5019 int recovery_start_count; 5020 5021 if (!ab->is_reset) 5022 return; 5023 5024 recovery_start_count = atomic_inc_return(&ab->recovery_start_count); 5025 5026 ath12k_dbg(ab, ATH12K_DBG_MAC, "recovery start count %d\n", recovery_start_count); 5027 5028 if (recovery_start_count == ab->num_radios) { 5029 complete(&ab->recovery_start); 5030 ath12k_dbg(ab, ATH12K_DBG_MAC, "recovery started success\n"); 5031 } 5032 5033 ath12k_dbg(ab, ATH12K_DBG_MAC, "waiting reconfigure...\n"); 5034 5035 wait_for_completion_timeout(&ab->reconfigure_complete, 5036 ATH12K_RECONFIGURE_TIMEOUT_HZ); 5037 } 5038 5039 static int ath12k_mac_op_start(struct ieee80211_hw *hw) 5040 { 5041 struct ath12k *ar = hw->priv; 5042 struct ath12k_base *ab = ar->ab; 5043 struct ath12k_pdev *pdev = ar->pdev; 5044 int ret; 5045 5046 ath12k_mac_drain_tx(ar); 5047 mutex_lock(&ar->conf_mutex); 5048 5049 switch (ar->state) { 5050 case ATH12K_STATE_OFF: 5051 ar->state = ATH12K_STATE_ON; 5052 break; 5053 case ATH12K_STATE_RESTARTING: 5054 ar->state = ATH12K_STATE_RESTARTED; 5055 ath12k_mac_wait_reconfigure(ab); 5056 break; 5057 case ATH12K_STATE_RESTARTED: 5058 case ATH12K_STATE_WEDGED: 5059 case ATH12K_STATE_ON: 5060 WARN_ON(1); 5061 ret = -EINVAL; 5062 goto err; 5063 } 5064 5065 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 5066 1, pdev->pdev_id); 5067 5068 if (ret) { 5069 ath12k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret); 5070 goto err; 5071 } 5072 5073 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1, 5074 pdev->pdev_id); 5075 if (ret) { 5076 ath12k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret); 5077 goto err; 5078 } 5079 5080 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE, 5081 0, pdev->pdev_id); 5082 if (ret) { 5083 ath12k_err(ab, "failed to set ac override for ARP: %d\n", 5084 ret); 5085 goto err; 5086 } 5087 5088 ret = ath12k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id); 5089 if (ret) { 5090 ath12k_err(ab, "failed to offload radar detection: %d\n", 5091 ret); 5092 goto err; 5093 } 5094 5095 ret = ath12k_dp_tx_htt_h2t_ppdu_stats_req(ar, 5096 HTT_PPDU_STATS_TAG_DEFAULT); 5097 if (ret) { 5098 ath12k_err(ab, "failed to req ppdu stats: %d\n", ret); 5099 goto err; 5100 } 5101 5102 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE, 5103 1, pdev->pdev_id); 5104 5105 if (ret) { 5106 ath12k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret); 5107 goto err; 5108 } 5109 5110 __ath12k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask); 5111 5112 /* TODO: Do we need to enable ANI? */ 5113 5114 ath12k_reg_update_chan_list(ar); 5115 5116 ar->num_started_vdevs = 0; 5117 ar->num_created_vdevs = 0; 5118 ar->num_peers = 0; 5119 ar->allocated_vdev_map = 0; 5120 5121 /* Configure monitor status ring with default rx_filter to get rx status 5122 * such as rssi, rx_duration. 5123 */ 5124 ret = ath12k_mac_config_mon_status_default(ar, true); 5125 if (ret && (ret != -ENOTSUPP)) { 5126 ath12k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n", 5127 ret); 5128 goto err; 5129 } 5130 5131 if (ret == -ENOTSUPP) 5132 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 5133 "monitor status config is not yet supported"); 5134 5135 /* Configure the hash seed for hash based reo dest ring selection */ 5136 ath12k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id); 5137 5138 /* allow device to enter IMPS */ 5139 if (ab->hw_params->idle_ps) { 5140 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG, 5141 1, pdev->pdev_id); 5142 if (ret) { 5143 ath12k_err(ab, "failed to enable idle ps: %d\n", ret); 5144 goto err; 5145 } 5146 } 5147 5148 mutex_unlock(&ar->conf_mutex); 5149 5150 rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx], 5151 &ab->pdevs[ar->pdev_idx]); 5152 5153 return 0; 5154 5155 err: 5156 ar->state = ATH12K_STATE_OFF; 5157 mutex_unlock(&ar->conf_mutex); 5158 5159 return ret; 5160 } 5161 5162 int ath12k_mac_rfkill_config(struct ath12k *ar) 5163 { 5164 struct ath12k_base *ab = ar->ab; 5165 u32 param; 5166 int ret; 5167 5168 if (ab->hw_params->rfkill_pin == 0) 5169 return -EOPNOTSUPP; 5170 5171 ath12k_dbg(ab, ATH12K_DBG_MAC, 5172 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d", 5173 ab->hw_params->rfkill_pin, ab->hw_params->rfkill_cfg, 5174 ab->hw_params->rfkill_on_level); 5175 5176 param = u32_encode_bits(ab->hw_params->rfkill_on_level, 5177 WMI_RFKILL_CFG_RADIO_LEVEL) | 5178 u32_encode_bits(ab->hw_params->rfkill_pin, 5179 WMI_RFKILL_CFG_GPIO_PIN_NUM) | 5180 u32_encode_bits(ab->hw_params->rfkill_cfg, 5181 WMI_RFKILL_CFG_PIN_AS_GPIO); 5182 5183 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_HW_RFKILL_CONFIG, 5184 param, ar->pdev->pdev_id); 5185 if (ret) { 5186 ath12k_warn(ab, 5187 "failed to set rfkill config 0x%x: %d\n", 5188 param, ret); 5189 return ret; 5190 } 5191 5192 return 0; 5193 } 5194 5195 int ath12k_mac_rfkill_enable_radio(struct ath12k *ar, bool enable) 5196 { 5197 enum wmi_rfkill_enable_radio param; 5198 int ret; 5199 5200 if (enable) 5201 param = WMI_RFKILL_ENABLE_RADIO_ON; 5202 else 5203 param = WMI_RFKILL_ENABLE_RADIO_OFF; 5204 5205 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac %d rfkill enable %d", 5206 ar->pdev_idx, param); 5207 5208 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RFKILL_ENABLE, 5209 param, ar->pdev->pdev_id); 5210 if (ret) { 5211 ath12k_warn(ar->ab, "failed to set rfkill enable param %d: %d\n", 5212 param, ret); 5213 return ret; 5214 } 5215 5216 return 0; 5217 } 5218 5219 static void ath12k_mac_op_stop(struct ieee80211_hw *hw) 5220 { 5221 struct ath12k *ar = hw->priv; 5222 struct htt_ppdu_stats_info *ppdu_stats, *tmp; 5223 int ret; 5224 5225 ath12k_mac_drain_tx(ar); 5226 5227 mutex_lock(&ar->conf_mutex); 5228 ret = ath12k_mac_config_mon_status_default(ar, false); 5229 if (ret && (ret != -ENOTSUPP)) 5230 ath12k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n", 5231 ret); 5232 5233 clear_bit(ATH12K_CAC_RUNNING, &ar->dev_flags); 5234 ar->state = ATH12K_STATE_OFF; 5235 mutex_unlock(&ar->conf_mutex); 5236 5237 cancel_delayed_work_sync(&ar->scan.timeout); 5238 cancel_work_sync(&ar->regd_update_work); 5239 cancel_work_sync(&ar->ab->rfkill_work); 5240 5241 spin_lock_bh(&ar->data_lock); 5242 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) { 5243 list_del(&ppdu_stats->list); 5244 kfree(ppdu_stats); 5245 } 5246 spin_unlock_bh(&ar->data_lock); 5247 5248 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL); 5249 5250 synchronize_rcu(); 5251 5252 atomic_set(&ar->num_pending_mgmt_tx, 0); 5253 } 5254 5255 static u8 5256 ath12k_mac_get_vdev_stats_id(struct ath12k_vif *arvif) 5257 { 5258 struct ath12k_base *ab = arvif->ar->ab; 5259 u8 vdev_stats_id = 0; 5260 5261 do { 5262 if (ab->free_vdev_stats_id_map & (1LL << vdev_stats_id)) { 5263 vdev_stats_id++; 5264 if (vdev_stats_id <= ATH12K_INVAL_VDEV_STATS_ID) { 5265 vdev_stats_id = ATH12K_INVAL_VDEV_STATS_ID; 5266 break; 5267 } 5268 } else { 5269 ab->free_vdev_stats_id_map |= (1LL << vdev_stats_id); 5270 break; 5271 } 5272 } while (vdev_stats_id); 5273 5274 arvif->vdev_stats_id = vdev_stats_id; 5275 return vdev_stats_id; 5276 } 5277 5278 static void ath12k_mac_setup_vdev_create_arg(struct ath12k_vif *arvif, 5279 struct ath12k_wmi_vdev_create_arg *arg) 5280 { 5281 struct ath12k *ar = arvif->ar; 5282 struct ath12k_pdev *pdev = ar->pdev; 5283 5284 arg->if_id = arvif->vdev_id; 5285 arg->type = arvif->vdev_type; 5286 arg->subtype = arvif->vdev_subtype; 5287 arg->pdev_id = pdev->pdev_id; 5288 5289 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) { 5290 arg->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains; 5291 arg->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains; 5292 } 5293 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) { 5294 arg->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains; 5295 arg->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains; 5296 } 5297 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP && 5298 ar->supports_6ghz) { 5299 arg->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains; 5300 arg->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains; 5301 } 5302 5303 arg->if_stats_id = ath12k_mac_get_vdev_stats_id(arvif); 5304 } 5305 5306 static u32 5307 ath12k_mac_prepare_he_mode(struct ath12k_pdev *pdev, u32 viftype) 5308 { 5309 struct ath12k_pdev_cap *pdev_cap = &pdev->cap; 5310 struct ath12k_band_cap *cap_band = NULL; 5311 u32 *hecap_phy_ptr = NULL; 5312 u32 hemode; 5313 5314 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) 5315 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ]; 5316 else 5317 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ]; 5318 5319 hecap_phy_ptr = &cap_band->he_cap_phy_info[0]; 5320 5321 hemode = u32_encode_bits(HE_SU_BFEE_ENABLE, HE_MODE_SU_TX_BFEE) | 5322 u32_encode_bits(HECAP_PHY_SUBFMR_GET(hecap_phy_ptr), 5323 HE_MODE_SU_TX_BFER) | 5324 u32_encode_bits(HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr), 5325 HE_MODE_UL_MUMIMO); 5326 5327 /* TODO: WDS and other modes */ 5328 if (viftype == NL80211_IFTYPE_AP) { 5329 hemode |= u32_encode_bits(HECAP_PHY_MUBFMR_GET(hecap_phy_ptr), 5330 HE_MODE_MU_TX_BFER) | 5331 u32_encode_bits(HE_DL_MUOFDMA_ENABLE, HE_MODE_DL_OFDMA) | 5332 u32_encode_bits(HE_UL_MUOFDMA_ENABLE, HE_MODE_UL_OFDMA); 5333 } else { 5334 hemode |= u32_encode_bits(HE_MU_BFEE_ENABLE, HE_MODE_MU_TX_BFEE); 5335 } 5336 5337 return hemode; 5338 } 5339 5340 static int ath12k_set_he_mu_sounding_mode(struct ath12k *ar, 5341 struct ath12k_vif *arvif) 5342 { 5343 u32 param_id, param_value; 5344 struct ath12k_base *ab = ar->ab; 5345 int ret; 5346 5347 param_id = WMI_VDEV_PARAM_SET_HEMU_MODE; 5348 param_value = ath12k_mac_prepare_he_mode(ar->pdev, arvif->vif->type); 5349 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5350 param_id, param_value); 5351 if (ret) { 5352 ath12k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n", 5353 arvif->vdev_id, ret, param_value); 5354 return ret; 5355 } 5356 param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE; 5357 param_value = 5358 u32_encode_bits(HE_VHT_SOUNDING_MODE_ENABLE, HE_VHT_SOUNDING_MODE) | 5359 u32_encode_bits(HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE, 5360 HE_TRIG_NONTRIG_SOUNDING_MODE); 5361 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5362 param_id, param_value); 5363 if (ret) { 5364 ath12k_warn(ab, "failed to set vdev %d HE MU mode: %d\n", 5365 arvif->vdev_id, ret); 5366 return ret; 5367 } 5368 return ret; 5369 } 5370 5371 static void ath12k_mac_op_update_vif_offload(struct ieee80211_hw *hw, 5372 struct ieee80211_vif *vif) 5373 { 5374 struct ath12k *ar = hw->priv; 5375 struct ath12k_base *ab = ar->ab; 5376 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 5377 u32 param_id, param_value; 5378 int ret; 5379 5380 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE; 5381 if (vif->type != NL80211_IFTYPE_STATION && 5382 vif->type != NL80211_IFTYPE_AP) 5383 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED | 5384 IEEE80211_OFFLOAD_DECAP_ENABLED); 5385 5386 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED) 5387 arvif->tx_encap_type = ATH12K_HW_TXRX_ETHERNET; 5388 else if (test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) 5389 arvif->tx_encap_type = ATH12K_HW_TXRX_RAW; 5390 else 5391 arvif->tx_encap_type = ATH12K_HW_TXRX_NATIVE_WIFI; 5392 5393 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5394 param_id, arvif->tx_encap_type); 5395 if (ret) { 5396 ath12k_warn(ab, "failed to set vdev %d tx encap mode: %d\n", 5397 arvif->vdev_id, ret); 5398 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED; 5399 } 5400 5401 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE; 5402 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED) 5403 param_value = ATH12K_HW_TXRX_ETHERNET; 5404 else if (test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) 5405 param_value = ATH12K_HW_TXRX_RAW; 5406 else 5407 param_value = ATH12K_HW_TXRX_NATIVE_WIFI; 5408 5409 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5410 param_id, param_value); 5411 if (ret) { 5412 ath12k_warn(ab, "failed to set vdev %d rx decap mode: %d\n", 5413 arvif->vdev_id, ret); 5414 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED; 5415 } 5416 } 5417 5418 static int ath12k_mac_op_add_interface(struct ieee80211_hw *hw, 5419 struct ieee80211_vif *vif) 5420 { 5421 struct ath12k *ar = hw->priv; 5422 struct ath12k_base *ab = ar->ab; 5423 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 5424 struct ath12k_wmi_vdev_create_arg vdev_arg = {0}; 5425 struct ath12k_wmi_peer_create_arg peer_param; 5426 u32 param_id, param_value; 5427 u16 nss; 5428 int i; 5429 int ret; 5430 int bit; 5431 5432 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 5433 5434 mutex_lock(&ar->conf_mutex); 5435 5436 if (vif->type == NL80211_IFTYPE_AP && 5437 ar->num_peers > (ar->max_num_peers - 1)) { 5438 ath12k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n"); 5439 ret = -ENOBUFS; 5440 goto err; 5441 } 5442 5443 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS - 1)) { 5444 ath12k_warn(ab, "failed to create vdev, reached max vdev limit %d\n", 5445 TARGET_NUM_VDEVS); 5446 ret = -EBUSY; 5447 goto err; 5448 } 5449 5450 memset(arvif, 0, sizeof(*arvif)); 5451 5452 arvif->ar = ar; 5453 arvif->vif = vif; 5454 5455 INIT_LIST_HEAD(&arvif->list); 5456 5457 /* Should we initialize any worker to handle connection loss indication 5458 * from firmware in sta mode? 5459 */ 5460 5461 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) { 5462 arvif->bitrate_mask.control[i].legacy = 0xffffffff; 5463 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff, 5464 sizeof(arvif->bitrate_mask.control[i].ht_mcs)); 5465 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff, 5466 sizeof(arvif->bitrate_mask.control[i].vht_mcs)); 5467 } 5468 5469 bit = __ffs64(ab->free_vdev_map); 5470 5471 arvif->vdev_id = bit; 5472 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 5473 5474 switch (vif->type) { 5475 case NL80211_IFTYPE_UNSPECIFIED: 5476 case NL80211_IFTYPE_STATION: 5477 arvif->vdev_type = WMI_VDEV_TYPE_STA; 5478 break; 5479 case NL80211_IFTYPE_MESH_POINT: 5480 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S; 5481 fallthrough; 5482 case NL80211_IFTYPE_AP: 5483 arvif->vdev_type = WMI_VDEV_TYPE_AP; 5484 break; 5485 case NL80211_IFTYPE_MONITOR: 5486 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 5487 ar->monitor_vdev_id = bit; 5488 break; 5489 default: 5490 WARN_ON(1); 5491 break; 5492 } 5493 5494 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac add interface id %d type %d subtype %d map %llx\n", 5495 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype, 5496 ab->free_vdev_map); 5497 5498 vif->cab_queue = arvif->vdev_id % (ATH12K_HW_MAX_QUEUES - 1); 5499 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++) 5500 vif->hw_queue[i] = i % (ATH12K_HW_MAX_QUEUES - 1); 5501 5502 ath12k_mac_setup_vdev_create_arg(arvif, &vdev_arg); 5503 5504 ret = ath12k_wmi_vdev_create(ar, vif->addr, &vdev_arg); 5505 if (ret) { 5506 ath12k_warn(ab, "failed to create WMI vdev %d: %d\n", 5507 arvif->vdev_id, ret); 5508 goto err; 5509 } 5510 5511 ar->num_created_vdevs++; 5512 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM created, vdev_id %d\n", 5513 vif->addr, arvif->vdev_id); 5514 ar->allocated_vdev_map |= 1LL << arvif->vdev_id; 5515 ab->free_vdev_map &= ~(1LL << arvif->vdev_id); 5516 5517 spin_lock_bh(&ar->data_lock); 5518 list_add(&arvif->list, &ar->arvifs); 5519 spin_unlock_bh(&ar->data_lock); 5520 5521 ath12k_mac_op_update_vif_offload(hw, vif); 5522 5523 nss = hweight32(ar->cfg_tx_chainmask) ? : 1; 5524 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5525 WMI_VDEV_PARAM_NSS, nss); 5526 if (ret) { 5527 ath12k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n", 5528 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret); 5529 goto err_vdev_del; 5530 } 5531 5532 switch (arvif->vdev_type) { 5533 case WMI_VDEV_TYPE_AP: 5534 peer_param.vdev_id = arvif->vdev_id; 5535 peer_param.peer_addr = vif->addr; 5536 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT; 5537 ret = ath12k_peer_create(ar, arvif, NULL, &peer_param); 5538 if (ret) { 5539 ath12k_warn(ab, "failed to vdev %d create peer for AP: %d\n", 5540 arvif->vdev_id, ret); 5541 goto err_vdev_del; 5542 } 5543 5544 ret = ath12k_mac_set_kickout(arvif); 5545 if (ret) { 5546 ath12k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n", 5547 arvif->vdev_id, ret); 5548 goto err_peer_del; 5549 } 5550 break; 5551 case WMI_VDEV_TYPE_STA: 5552 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 5553 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 5554 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5555 param_id, param_value); 5556 if (ret) { 5557 ath12k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n", 5558 arvif->vdev_id, ret); 5559 goto err_peer_del; 5560 } 5561 5562 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 5563 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 5564 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5565 param_id, param_value); 5566 if (ret) { 5567 ath12k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n", 5568 arvif->vdev_id, ret); 5569 goto err_peer_del; 5570 } 5571 5572 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT; 5573 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 5574 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 5575 param_id, param_value); 5576 if (ret) { 5577 ath12k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n", 5578 arvif->vdev_id, ret); 5579 goto err_peer_del; 5580 } 5581 5582 ret = ath12k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, false); 5583 if (ret) { 5584 ath12k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n", 5585 arvif->vdev_id, ret); 5586 goto err_peer_del; 5587 } 5588 break; 5589 default: 5590 break; 5591 } 5592 5593 arvif->txpower = vif->bss_conf.txpower; 5594 ret = ath12k_mac_txpower_recalc(ar); 5595 if (ret) 5596 goto err_peer_del; 5597 5598 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 5599 param_value = ar->hw->wiphy->rts_threshold; 5600 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 5601 param_id, param_value); 5602 if (ret) { 5603 ath12k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n", 5604 arvif->vdev_id, ret); 5605 } 5606 5607 ath12k_dp_vdev_tx_attach(ar, arvif); 5608 5609 if (vif->type != NL80211_IFTYPE_MONITOR && ar->monitor_conf_enabled) 5610 ath12k_mac_monitor_vdev_create(ar); 5611 5612 mutex_unlock(&ar->conf_mutex); 5613 5614 return ret; 5615 5616 err_peer_del: 5617 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 5618 reinit_completion(&ar->peer_delete_done); 5619 5620 ret = ath12k_wmi_send_peer_delete_cmd(ar, vif->addr, 5621 arvif->vdev_id); 5622 if (ret) { 5623 ath12k_warn(ar->ab, "failed to delete peer vdev_id %d addr %pM\n", 5624 arvif->vdev_id, vif->addr); 5625 goto err; 5626 } 5627 5628 ret = ath12k_wait_for_peer_delete_done(ar, arvif->vdev_id, 5629 vif->addr); 5630 if (ret) 5631 goto err; 5632 5633 ar->num_peers--; 5634 } 5635 5636 err_vdev_del: 5637 ath12k_wmi_vdev_delete(ar, arvif->vdev_id); 5638 ar->num_created_vdevs--; 5639 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 5640 ab->free_vdev_map |= 1LL << arvif->vdev_id; 5641 ab->free_vdev_stats_id_map &= ~(1LL << arvif->vdev_stats_id); 5642 spin_lock_bh(&ar->data_lock); 5643 list_del(&arvif->list); 5644 spin_unlock_bh(&ar->data_lock); 5645 5646 err: 5647 mutex_unlock(&ar->conf_mutex); 5648 5649 return ret; 5650 } 5651 5652 static void ath12k_mac_vif_unref(struct ath12k_dp *dp, struct ieee80211_vif *vif) 5653 { 5654 struct ath12k_tx_desc_info *tx_desc_info; 5655 struct ath12k_skb_cb *skb_cb; 5656 struct sk_buff *skb; 5657 int i; 5658 5659 for (i = 0; i < ATH12K_HW_MAX_QUEUES; i++) { 5660 spin_lock_bh(&dp->tx_desc_lock[i]); 5661 5662 list_for_each_entry(tx_desc_info, &dp->tx_desc_used_list[i], 5663 list) { 5664 skb = tx_desc_info->skb; 5665 if (!skb) 5666 continue; 5667 5668 skb_cb = ATH12K_SKB_CB(skb); 5669 if (skb_cb->vif == vif) 5670 skb_cb->vif = NULL; 5671 } 5672 5673 spin_unlock_bh(&dp->tx_desc_lock[i]); 5674 } 5675 } 5676 5677 static void ath12k_mac_op_remove_interface(struct ieee80211_hw *hw, 5678 struct ieee80211_vif *vif) 5679 { 5680 struct ath12k *ar = hw->priv; 5681 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 5682 struct ath12k_base *ab = ar->ab; 5683 unsigned long time_left; 5684 int ret; 5685 5686 mutex_lock(&ar->conf_mutex); 5687 5688 ath12k_dbg(ab, ATH12K_DBG_MAC, "mac remove interface (vdev %d)\n", 5689 arvif->vdev_id); 5690 5691 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 5692 ret = ath12k_peer_delete(ar, arvif->vdev_id, vif->addr); 5693 if (ret) 5694 ath12k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n", 5695 arvif->vdev_id, ret); 5696 } 5697 5698 reinit_completion(&ar->vdev_delete_done); 5699 5700 ret = ath12k_wmi_vdev_delete(ar, arvif->vdev_id); 5701 if (ret) { 5702 ath12k_warn(ab, "failed to delete WMI vdev %d: %d\n", 5703 arvif->vdev_id, ret); 5704 goto err_vdev_del; 5705 } 5706 5707 time_left = wait_for_completion_timeout(&ar->vdev_delete_done, 5708 ATH12K_VDEV_DELETE_TIMEOUT_HZ); 5709 if (time_left == 0) { 5710 ath12k_warn(ab, "Timeout in receiving vdev delete response\n"); 5711 goto err_vdev_del; 5712 } 5713 5714 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 5715 ar->monitor_vdev_id = -1; 5716 ar->monitor_vdev_created = false; 5717 } else if (ar->monitor_vdev_created && !ar->monitor_started) { 5718 ret = ath12k_mac_monitor_vdev_delete(ar); 5719 } 5720 5721 ab->free_vdev_map |= 1LL << (arvif->vdev_id); 5722 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); 5723 ab->free_vdev_stats_id_map &= ~(1LL << arvif->vdev_stats_id); 5724 ar->num_created_vdevs--; 5725 5726 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n", 5727 vif->addr, arvif->vdev_id); 5728 5729 err_vdev_del: 5730 spin_lock_bh(&ar->data_lock); 5731 list_del(&arvif->list); 5732 spin_unlock_bh(&ar->data_lock); 5733 5734 ath12k_peer_cleanup(ar, arvif->vdev_id); 5735 5736 idr_for_each(&ar->txmgmt_idr, 5737 ath12k_mac_vif_txmgmt_idr_remove, vif); 5738 5739 ath12k_mac_vif_unref(&ab->dp, vif); 5740 ath12k_dp_tx_put_bank_profile(&ab->dp, arvif->bank_id); 5741 5742 /* Recalc txpower for remaining vdev */ 5743 ath12k_mac_txpower_recalc(ar); 5744 clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags); 5745 5746 /* TODO: recal traffic pause state based on the available vdevs */ 5747 5748 mutex_unlock(&ar->conf_mutex); 5749 } 5750 5751 /* FIXME: Has to be verified. */ 5752 #define SUPPORTED_FILTERS \ 5753 (FIF_ALLMULTI | \ 5754 FIF_CONTROL | \ 5755 FIF_PSPOLL | \ 5756 FIF_OTHER_BSS | \ 5757 FIF_BCN_PRBRESP_PROMISC | \ 5758 FIF_PROBE_REQ | \ 5759 FIF_FCSFAIL) 5760 5761 static void ath12k_mac_op_configure_filter(struct ieee80211_hw *hw, 5762 unsigned int changed_flags, 5763 unsigned int *total_flags, 5764 u64 multicast) 5765 { 5766 struct ath12k *ar = hw->priv; 5767 bool reset_flag; 5768 int ret; 5769 5770 mutex_lock(&ar->conf_mutex); 5771 5772 *total_flags &= SUPPORTED_FILTERS; 5773 ar->filter_flags = *total_flags; 5774 5775 /* For monitor mode */ 5776 reset_flag = !(ar->filter_flags & FIF_BCN_PRBRESP_PROMISC); 5777 5778 ret = ath12k_dp_tx_htt_monitor_mode_ring_config(ar, reset_flag); 5779 if (!ret) { 5780 if (!reset_flag) 5781 set_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags); 5782 else 5783 clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags); 5784 } else { 5785 ath12k_warn(ar->ab, 5786 "fail to set monitor filter: %d\n", ret); 5787 } 5788 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 5789 "total_flags:0x%x, reset_flag:%d\n", 5790 *total_flags, reset_flag); 5791 5792 mutex_unlock(&ar->conf_mutex); 5793 } 5794 5795 static int ath12k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 5796 { 5797 struct ath12k *ar = hw->priv; 5798 5799 mutex_lock(&ar->conf_mutex); 5800 5801 *tx_ant = ar->cfg_tx_chainmask; 5802 *rx_ant = ar->cfg_rx_chainmask; 5803 5804 mutex_unlock(&ar->conf_mutex); 5805 5806 return 0; 5807 } 5808 5809 static int ath12k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 5810 { 5811 struct ath12k *ar = hw->priv; 5812 int ret; 5813 5814 mutex_lock(&ar->conf_mutex); 5815 ret = __ath12k_set_antenna(ar, tx_ant, rx_ant); 5816 mutex_unlock(&ar->conf_mutex); 5817 5818 return ret; 5819 } 5820 5821 static int ath12k_mac_op_ampdu_action(struct ieee80211_hw *hw, 5822 struct ieee80211_vif *vif, 5823 struct ieee80211_ampdu_params *params) 5824 { 5825 struct ath12k *ar = hw->priv; 5826 int ret = -EINVAL; 5827 5828 mutex_lock(&ar->conf_mutex); 5829 5830 switch (params->action) { 5831 case IEEE80211_AMPDU_RX_START: 5832 ret = ath12k_dp_rx_ampdu_start(ar, params); 5833 break; 5834 case IEEE80211_AMPDU_RX_STOP: 5835 ret = ath12k_dp_rx_ampdu_stop(ar, params); 5836 break; 5837 case IEEE80211_AMPDU_TX_START: 5838 case IEEE80211_AMPDU_TX_STOP_CONT: 5839 case IEEE80211_AMPDU_TX_STOP_FLUSH: 5840 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 5841 case IEEE80211_AMPDU_TX_OPERATIONAL: 5842 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211 5843 * Tx aggregation requests. 5844 */ 5845 ret = -EOPNOTSUPP; 5846 break; 5847 } 5848 5849 mutex_unlock(&ar->conf_mutex); 5850 5851 return ret; 5852 } 5853 5854 static int ath12k_mac_op_add_chanctx(struct ieee80211_hw *hw, 5855 struct ieee80211_chanctx_conf *ctx) 5856 { 5857 struct ath12k *ar = hw->priv; 5858 struct ath12k_base *ab = ar->ab; 5859 5860 ath12k_dbg(ab, ATH12K_DBG_MAC, 5861 "mac chanctx add freq %u width %d ptr %pK\n", 5862 ctx->def.chan->center_freq, ctx->def.width, ctx); 5863 5864 mutex_lock(&ar->conf_mutex); 5865 5866 spin_lock_bh(&ar->data_lock); 5867 /* TODO: In case of multiple channel context, populate rx_channel from 5868 * Rx PPDU desc information. 5869 */ 5870 ar->rx_channel = ctx->def.chan; 5871 spin_unlock_bh(&ar->data_lock); 5872 5873 mutex_unlock(&ar->conf_mutex); 5874 5875 return 0; 5876 } 5877 5878 static void ath12k_mac_op_remove_chanctx(struct ieee80211_hw *hw, 5879 struct ieee80211_chanctx_conf *ctx) 5880 { 5881 struct ath12k *ar = hw->priv; 5882 struct ath12k_base *ab = ar->ab; 5883 5884 ath12k_dbg(ab, ATH12K_DBG_MAC, 5885 "mac chanctx remove freq %u width %d ptr %pK\n", 5886 ctx->def.chan->center_freq, ctx->def.width, ctx); 5887 5888 mutex_lock(&ar->conf_mutex); 5889 5890 spin_lock_bh(&ar->data_lock); 5891 /* TODO: In case of there is one more channel context left, populate 5892 * rx_channel with the channel of that remaining channel context. 5893 */ 5894 ar->rx_channel = NULL; 5895 spin_unlock_bh(&ar->data_lock); 5896 5897 mutex_unlock(&ar->conf_mutex); 5898 } 5899 5900 static enum wmi_phy_mode 5901 ath12k_mac_check_down_grade_phy_mode(struct ath12k *ar, 5902 enum wmi_phy_mode mode, 5903 enum nl80211_band band, 5904 enum nl80211_iftype type) 5905 { 5906 struct ieee80211_sta_eht_cap *eht_cap; 5907 enum wmi_phy_mode down_mode; 5908 5909 if (mode < MODE_11BE_EHT20) 5910 return mode; 5911 5912 eht_cap = &ar->mac.iftype[band][type].eht_cap; 5913 if (eht_cap->has_eht) 5914 return mode; 5915 5916 switch (mode) { 5917 case MODE_11BE_EHT20: 5918 down_mode = MODE_11AX_HE20; 5919 break; 5920 case MODE_11BE_EHT40: 5921 down_mode = MODE_11AX_HE40; 5922 break; 5923 case MODE_11BE_EHT80: 5924 down_mode = MODE_11AX_HE80; 5925 break; 5926 case MODE_11BE_EHT80_80: 5927 down_mode = MODE_11AX_HE80_80; 5928 break; 5929 case MODE_11BE_EHT160: 5930 case MODE_11BE_EHT160_160: 5931 case MODE_11BE_EHT320: 5932 down_mode = MODE_11AX_HE160; 5933 break; 5934 case MODE_11BE_EHT20_2G: 5935 down_mode = MODE_11AX_HE20_2G; 5936 break; 5937 case MODE_11BE_EHT40_2G: 5938 down_mode = MODE_11AX_HE40_2G; 5939 break; 5940 default: 5941 down_mode = mode; 5942 break; 5943 } 5944 5945 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 5946 "mac vdev start phymode %s downgrade to %s\n", 5947 ath12k_mac_phymode_str(mode), 5948 ath12k_mac_phymode_str(down_mode)); 5949 5950 return down_mode; 5951 } 5952 5953 static int 5954 ath12k_mac_vdev_start_restart(struct ath12k_vif *arvif, 5955 struct ieee80211_chanctx_conf *ctx, 5956 bool restart) 5957 { 5958 struct ath12k *ar = arvif->ar; 5959 struct ath12k_base *ab = ar->ab; 5960 struct wmi_vdev_start_req_arg arg = {}; 5961 const struct cfg80211_chan_def *chandef = &ctx->def; 5962 int he_support = arvif->vif->bss_conf.he_support; 5963 int ret; 5964 5965 lockdep_assert_held(&ar->conf_mutex); 5966 5967 reinit_completion(&ar->vdev_setup_done); 5968 5969 arg.vdev_id = arvif->vdev_id; 5970 arg.dtim_period = arvif->dtim_period; 5971 arg.bcn_intval = arvif->beacon_interval; 5972 arg.punct_bitmap = ~arvif->punct_bitmap; 5973 5974 arg.freq = chandef->chan->center_freq; 5975 arg.band_center_freq1 = chandef->center_freq1; 5976 arg.band_center_freq2 = chandef->center_freq2; 5977 arg.mode = ath12k_phymodes[chandef->chan->band][chandef->width]; 5978 5979 arg.mode = ath12k_mac_check_down_grade_phy_mode(ar, arg.mode, 5980 chandef->chan->band, 5981 arvif->vif->type); 5982 arg.min_power = 0; 5983 arg.max_power = chandef->chan->max_power * 2; 5984 arg.max_reg_power = chandef->chan->max_reg_power * 2; 5985 arg.max_antenna_gain = chandef->chan->max_antenna_gain * 2; 5986 5987 arg.pref_tx_streams = ar->num_tx_chains; 5988 arg.pref_rx_streams = ar->num_rx_chains; 5989 5990 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 5991 arg.ssid = arvif->u.ap.ssid; 5992 arg.ssid_len = arvif->u.ap.ssid_len; 5993 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 5994 5995 /* For now allow DFS for AP mode */ 5996 arg.chan_radar = !!(chandef->chan->flags & IEEE80211_CHAN_RADAR); 5997 5998 arg.freq2_radar = ctx->radar_enabled; 5999 6000 arg.passive = arg.chan_radar; 6001 6002 spin_lock_bh(&ab->base_lock); 6003 arg.regdomain = ar->ab->dfs_region; 6004 spin_unlock_bh(&ab->base_lock); 6005 6006 /* TODO: Notify if secondary 80Mhz also needs radar detection */ 6007 if (he_support) { 6008 ret = ath12k_set_he_mu_sounding_mode(ar, arvif); 6009 if (ret) { 6010 ath12k_warn(ar->ab, "failed to set he mode vdev %i\n", 6011 arg.vdev_id); 6012 return ret; 6013 } 6014 } 6015 } 6016 6017 arg.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR); 6018 6019 ath12k_dbg(ab, ATH12K_DBG_MAC, 6020 "mac vdev %d start center_freq %d phymode %s punct_bitmap 0x%x\n", 6021 arg.vdev_id, arg.freq, 6022 ath12k_mac_phymode_str(arg.mode), arg.punct_bitmap); 6023 6024 ret = ath12k_wmi_vdev_start(ar, &arg, restart); 6025 if (ret) { 6026 ath12k_warn(ar->ab, "failed to %s WMI vdev %i\n", 6027 restart ? "restart" : "start", arg.vdev_id); 6028 return ret; 6029 } 6030 6031 ret = ath12k_mac_vdev_setup_sync(ar); 6032 if (ret) { 6033 ath12k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n", 6034 arg.vdev_id, restart ? "restart" : "start", ret); 6035 return ret; 6036 } 6037 6038 ar->num_started_vdevs++; 6039 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM started, vdev_id %d\n", 6040 arvif->vif->addr, arvif->vdev_id); 6041 6042 /* Enable CAC Flag in the driver by checking the channel DFS cac time, 6043 * i.e dfs_cac_ms value which will be valid only for radar channels 6044 * and state as NL80211_DFS_USABLE which indicates CAC needs to be 6045 * done before channel usage. This flags is used to drop rx packets. 6046 * during CAC. 6047 */ 6048 /* TODO: Set the flag for other interface types as required */ 6049 if (arvif->vdev_type == WMI_VDEV_TYPE_AP && 6050 chandef->chan->dfs_cac_ms && 6051 chandef->chan->dfs_state == NL80211_DFS_USABLE) { 6052 set_bit(ATH12K_CAC_RUNNING, &ar->dev_flags); 6053 ath12k_dbg(ab, ATH12K_DBG_MAC, 6054 "CAC Started in chan_freq %d for vdev %d\n", 6055 arg.freq, arg.vdev_id); 6056 } 6057 6058 ret = ath12k_mac_set_txbf_conf(arvif); 6059 if (ret) 6060 ath12k_warn(ab, "failed to set txbf conf for vdev %d: %d\n", 6061 arvif->vdev_id, ret); 6062 6063 return 0; 6064 } 6065 6066 static int ath12k_mac_vdev_stop(struct ath12k_vif *arvif) 6067 { 6068 struct ath12k *ar = arvif->ar; 6069 int ret; 6070 6071 lockdep_assert_held(&ar->conf_mutex); 6072 6073 reinit_completion(&ar->vdev_setup_done); 6074 6075 ret = ath12k_wmi_vdev_stop(ar, arvif->vdev_id); 6076 if (ret) { 6077 ath12k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n", 6078 arvif->vdev_id, ret); 6079 goto err; 6080 } 6081 6082 ret = ath12k_mac_vdev_setup_sync(ar); 6083 if (ret) { 6084 ath12k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n", 6085 arvif->vdev_id, ret); 6086 goto err; 6087 } 6088 6089 WARN_ON(ar->num_started_vdevs == 0); 6090 6091 ar->num_started_vdevs--; 6092 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n", 6093 arvif->vif->addr, arvif->vdev_id); 6094 6095 if (test_bit(ATH12K_CAC_RUNNING, &ar->dev_flags)) { 6096 clear_bit(ATH12K_CAC_RUNNING, &ar->dev_flags); 6097 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "CAC Stopped for vdev %d\n", 6098 arvif->vdev_id); 6099 } 6100 6101 return 0; 6102 err: 6103 return ret; 6104 } 6105 6106 static int ath12k_mac_vdev_start(struct ath12k_vif *arvif, 6107 struct ieee80211_chanctx_conf *ctx) 6108 { 6109 return ath12k_mac_vdev_start_restart(arvif, ctx, false); 6110 } 6111 6112 static int ath12k_mac_vdev_restart(struct ath12k_vif *arvif, 6113 struct ieee80211_chanctx_conf *ctx) 6114 { 6115 return ath12k_mac_vdev_start_restart(arvif, ctx, true); 6116 } 6117 6118 struct ath12k_mac_change_chanctx_arg { 6119 struct ieee80211_chanctx_conf *ctx; 6120 struct ieee80211_vif_chanctx_switch *vifs; 6121 int n_vifs; 6122 int next_vif; 6123 }; 6124 6125 static void 6126 ath12k_mac_change_chanctx_cnt_iter(void *data, u8 *mac, 6127 struct ieee80211_vif *vif) 6128 { 6129 struct ath12k_mac_change_chanctx_arg *arg = data; 6130 6131 if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx) 6132 return; 6133 6134 arg->n_vifs++; 6135 } 6136 6137 static void 6138 ath12k_mac_change_chanctx_fill_iter(void *data, u8 *mac, 6139 struct ieee80211_vif *vif) 6140 { 6141 struct ath12k_mac_change_chanctx_arg *arg = data; 6142 struct ieee80211_chanctx_conf *ctx; 6143 6144 ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf); 6145 if (ctx != arg->ctx) 6146 return; 6147 6148 if (WARN_ON(arg->next_vif == arg->n_vifs)) 6149 return; 6150 6151 arg->vifs[arg->next_vif].vif = vif; 6152 arg->vifs[arg->next_vif].old_ctx = ctx; 6153 arg->vifs[arg->next_vif].new_ctx = ctx; 6154 arg->next_vif++; 6155 } 6156 6157 static void 6158 ath12k_mac_update_vif_chan(struct ath12k *ar, 6159 struct ieee80211_vif_chanctx_switch *vifs, 6160 int n_vifs) 6161 { 6162 struct ath12k_base *ab = ar->ab; 6163 struct ath12k_vif *arvif; 6164 int ret; 6165 int i; 6166 bool monitor_vif = false; 6167 6168 lockdep_assert_held(&ar->conf_mutex); 6169 6170 for (i = 0; i < n_vifs; i++) { 6171 arvif = ath12k_vif_to_arvif(vifs[i].vif); 6172 6173 if (vifs[i].vif->type == NL80211_IFTYPE_MONITOR) 6174 monitor_vif = true; 6175 6176 ath12k_dbg(ab, ATH12K_DBG_MAC, 6177 "mac chanctx switch vdev_id %i freq %u->%u width %d->%d\n", 6178 arvif->vdev_id, 6179 vifs[i].old_ctx->def.chan->center_freq, 6180 vifs[i].new_ctx->def.chan->center_freq, 6181 vifs[i].old_ctx->def.width, 6182 vifs[i].new_ctx->def.width); 6183 6184 if (WARN_ON(!arvif->is_started)) 6185 continue; 6186 6187 if (WARN_ON(!arvif->is_up)) 6188 continue; 6189 6190 ret = ath12k_wmi_vdev_down(ar, arvif->vdev_id); 6191 if (ret) { 6192 ath12k_warn(ab, "failed to down vdev %d: %d\n", 6193 arvif->vdev_id, ret); 6194 continue; 6195 } 6196 } 6197 6198 /* All relevant vdevs are downed and associated channel resources 6199 * should be available for the channel switch now. 6200 */ 6201 6202 /* TODO: Update ar->rx_channel */ 6203 6204 for (i = 0; i < n_vifs; i++) { 6205 arvif = ath12k_vif_to_arvif(vifs[i].vif); 6206 6207 if (WARN_ON(!arvif->is_started)) 6208 continue; 6209 6210 /* Firmware expect vdev_restart only if vdev is up. 6211 * If vdev is down then it expect vdev_stop->vdev_start. 6212 */ 6213 if (arvif->is_up) { 6214 ret = ath12k_mac_vdev_restart(arvif, vifs[i].new_ctx); 6215 if (ret) { 6216 ath12k_warn(ab, "failed to restart vdev %d: %d\n", 6217 arvif->vdev_id, ret); 6218 continue; 6219 } 6220 } else { 6221 ret = ath12k_mac_vdev_stop(arvif); 6222 if (ret) { 6223 ath12k_warn(ab, "failed to stop vdev %d: %d\n", 6224 arvif->vdev_id, ret); 6225 continue; 6226 } 6227 6228 ret = ath12k_mac_vdev_start(arvif, vifs[i].new_ctx); 6229 if (ret) 6230 ath12k_warn(ab, "failed to start vdev %d: %d\n", 6231 arvif->vdev_id, ret); 6232 continue; 6233 } 6234 6235 ret = ath12k_mac_setup_bcn_tmpl(arvif); 6236 if (ret) 6237 ath12k_warn(ab, "failed to update bcn tmpl during csa: %d\n", 6238 ret); 6239 6240 ret = ath12k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 6241 arvif->bssid); 6242 if (ret) { 6243 ath12k_warn(ab, "failed to bring vdev up %d: %d\n", 6244 arvif->vdev_id, ret); 6245 continue; 6246 } 6247 } 6248 6249 /* Restart the internal monitor vdev on new channel */ 6250 if (!monitor_vif && ar->monitor_vdev_created) { 6251 if (!ath12k_mac_monitor_stop(ar)) 6252 ath12k_mac_monitor_start(ar); 6253 } 6254 } 6255 6256 static void 6257 ath12k_mac_update_active_vif_chan(struct ath12k *ar, 6258 struct ieee80211_chanctx_conf *ctx) 6259 { 6260 struct ath12k_mac_change_chanctx_arg arg = { .ctx = ctx }; 6261 6262 lockdep_assert_held(&ar->conf_mutex); 6263 6264 ieee80211_iterate_active_interfaces_atomic(ar->hw, 6265 IEEE80211_IFACE_ITER_NORMAL, 6266 ath12k_mac_change_chanctx_cnt_iter, 6267 &arg); 6268 if (arg.n_vifs == 0) 6269 return; 6270 6271 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL); 6272 if (!arg.vifs) 6273 return; 6274 6275 ieee80211_iterate_active_interfaces_atomic(ar->hw, 6276 IEEE80211_IFACE_ITER_NORMAL, 6277 ath12k_mac_change_chanctx_fill_iter, 6278 &arg); 6279 6280 ath12k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs); 6281 6282 kfree(arg.vifs); 6283 } 6284 6285 static void ath12k_mac_op_change_chanctx(struct ieee80211_hw *hw, 6286 struct ieee80211_chanctx_conf *ctx, 6287 u32 changed) 6288 { 6289 struct ath12k *ar = hw->priv; 6290 struct ath12k_base *ab = ar->ab; 6291 6292 mutex_lock(&ar->conf_mutex); 6293 6294 ath12k_dbg(ab, ATH12K_DBG_MAC, 6295 "mac chanctx change freq %u width %d ptr %pK changed %x\n", 6296 ctx->def.chan->center_freq, ctx->def.width, ctx, changed); 6297 6298 /* This shouldn't really happen because channel switching should use 6299 * switch_vif_chanctx(). 6300 */ 6301 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL)) 6302 goto unlock; 6303 6304 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH || 6305 changed & IEEE80211_CHANCTX_CHANGE_RADAR) 6306 ath12k_mac_update_active_vif_chan(ar, ctx); 6307 6308 /* TODO: Recalc radar detection */ 6309 6310 unlock: 6311 mutex_unlock(&ar->conf_mutex); 6312 } 6313 6314 static int ath12k_start_vdev_delay(struct ieee80211_hw *hw, 6315 struct ieee80211_vif *vif) 6316 { 6317 struct ath12k *ar = hw->priv; 6318 struct ath12k_base *ab = ar->ab; 6319 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6320 int ret; 6321 6322 if (WARN_ON(arvif->is_started)) 6323 return -EBUSY; 6324 6325 ret = ath12k_mac_vdev_start(arvif, &arvif->chanctx); 6326 if (ret) { 6327 ath12k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 6328 arvif->vdev_id, vif->addr, 6329 arvif->chanctx.def.chan->center_freq, ret); 6330 return ret; 6331 } 6332 6333 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 6334 ret = ath12k_monitor_vdev_up(ar, arvif->vdev_id); 6335 if (ret) { 6336 ath12k_warn(ab, "failed put monitor up: %d\n", ret); 6337 return ret; 6338 } 6339 } 6340 6341 arvif->is_started = true; 6342 6343 /* TODO: Setup ps and cts/rts protection */ 6344 return 0; 6345 } 6346 6347 static int 6348 ath12k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw, 6349 struct ieee80211_vif *vif, 6350 struct ieee80211_bss_conf *link_conf, 6351 struct ieee80211_chanctx_conf *ctx) 6352 { 6353 struct ath12k *ar = hw->priv; 6354 struct ath12k_base *ab = ar->ab; 6355 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6356 int ret; 6357 struct ath12k_wmi_peer_create_arg param; 6358 6359 mutex_lock(&ar->conf_mutex); 6360 6361 ath12k_dbg(ab, ATH12K_DBG_MAC, 6362 "mac chanctx assign ptr %pK vdev_id %i\n", 6363 ctx, arvif->vdev_id); 6364 6365 arvif->punct_bitmap = link_conf->eht_puncturing; 6366 6367 /* for some targets bss peer must be created before vdev_start */ 6368 if (ab->hw_params->vdev_start_delay && 6369 arvif->vdev_type != WMI_VDEV_TYPE_AP && 6370 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 6371 !ath12k_peer_exist_by_vdev_id(ab, arvif->vdev_id)) { 6372 memcpy(&arvif->chanctx, ctx, sizeof(*ctx)); 6373 ret = 0; 6374 goto out; 6375 } 6376 6377 if (WARN_ON(arvif->is_started)) { 6378 ret = -EBUSY; 6379 goto out; 6380 } 6381 6382 if (ab->hw_params->vdev_start_delay && 6383 (arvif->vdev_type == WMI_VDEV_TYPE_AP || 6384 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)) { 6385 param.vdev_id = arvif->vdev_id; 6386 param.peer_type = WMI_PEER_TYPE_DEFAULT; 6387 param.peer_addr = ar->mac_addr; 6388 6389 ret = ath12k_peer_create(ar, arvif, NULL, ¶m); 6390 if (ret) { 6391 ath12k_warn(ab, "failed to create peer after vdev start delay: %d", 6392 ret); 6393 goto out; 6394 } 6395 } 6396 6397 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 6398 ret = ath12k_mac_monitor_start(ar); 6399 if (ret) 6400 goto out; 6401 arvif->is_started = true; 6402 goto out; 6403 } 6404 6405 ret = ath12k_mac_vdev_start(arvif, ctx); 6406 if (ret) { 6407 ath12k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n", 6408 arvif->vdev_id, vif->addr, 6409 ctx->def.chan->center_freq, ret); 6410 goto out; 6411 } 6412 6413 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && ar->monitor_vdev_created) 6414 ath12k_mac_monitor_start(ar); 6415 6416 arvif->is_started = true; 6417 6418 /* TODO: Setup ps and cts/rts protection */ 6419 6420 out: 6421 mutex_unlock(&ar->conf_mutex); 6422 6423 return ret; 6424 } 6425 6426 static void 6427 ath12k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 6428 struct ieee80211_vif *vif, 6429 struct ieee80211_bss_conf *link_conf, 6430 struct ieee80211_chanctx_conf *ctx) 6431 { 6432 struct ath12k *ar = hw->priv; 6433 struct ath12k_base *ab = ar->ab; 6434 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6435 int ret; 6436 6437 mutex_lock(&ar->conf_mutex); 6438 6439 ath12k_dbg(ab, ATH12K_DBG_MAC, 6440 "mac chanctx unassign ptr %pK vdev_id %i\n", 6441 ctx, arvif->vdev_id); 6442 6443 WARN_ON(!arvif->is_started); 6444 6445 if (ab->hw_params->vdev_start_delay && 6446 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR && 6447 ath12k_peer_find_by_addr(ab, ar->mac_addr)) 6448 ath12k_peer_delete(ar, arvif->vdev_id, ar->mac_addr); 6449 6450 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) { 6451 ret = ath12k_mac_monitor_stop(ar); 6452 if (ret) { 6453 mutex_unlock(&ar->conf_mutex); 6454 return; 6455 } 6456 6457 arvif->is_started = false; 6458 } 6459 6460 ret = ath12k_mac_vdev_stop(arvif); 6461 if (ret) 6462 ath12k_warn(ab, "failed to stop vdev %i: %d\n", 6463 arvif->vdev_id, ret); 6464 6465 arvif->is_started = false; 6466 6467 if (ab->hw_params->vdev_start_delay && 6468 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 6469 ath12k_wmi_vdev_down(ar, arvif->vdev_id); 6470 6471 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && 6472 ar->num_started_vdevs == 1 && ar->monitor_vdev_created) 6473 ath12k_mac_monitor_stop(ar); 6474 6475 mutex_unlock(&ar->conf_mutex); 6476 } 6477 6478 static int 6479 ath12k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw, 6480 struct ieee80211_vif_chanctx_switch *vifs, 6481 int n_vifs, 6482 enum ieee80211_chanctx_switch_mode mode) 6483 { 6484 struct ath12k *ar = hw->priv; 6485 6486 mutex_lock(&ar->conf_mutex); 6487 6488 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 6489 "mac chanctx switch n_vifs %d mode %d\n", 6490 n_vifs, mode); 6491 ath12k_mac_update_vif_chan(ar, vifs, n_vifs); 6492 6493 mutex_unlock(&ar->conf_mutex); 6494 6495 return 0; 6496 } 6497 6498 static int 6499 ath12k_set_vdev_param_to_all_vifs(struct ath12k *ar, int param, u32 value) 6500 { 6501 struct ath12k_vif *arvif; 6502 int ret = 0; 6503 6504 mutex_lock(&ar->conf_mutex); 6505 list_for_each_entry(arvif, &ar->arvifs, list) { 6506 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "setting mac vdev %d param %d value %d\n", 6507 param, arvif->vdev_id, value); 6508 6509 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6510 param, value); 6511 if (ret) { 6512 ath12k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n", 6513 param, arvif->vdev_id, ret); 6514 break; 6515 } 6516 } 6517 mutex_unlock(&ar->conf_mutex); 6518 return ret; 6519 } 6520 6521 /* mac80211 stores device specific RTS/Fragmentation threshold value, 6522 * this is set interface specific to firmware from ath12k driver 6523 */ 6524 static int ath12k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 6525 { 6526 struct ath12k *ar = hw->priv; 6527 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD; 6528 6529 return ath12k_set_vdev_param_to_all_vifs(ar, param_id, value); 6530 } 6531 6532 static int ath12k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 6533 { 6534 /* Even though there's a WMI vdev param for fragmentation threshold no 6535 * known firmware actually implements it. Moreover it is not possible to 6536 * rely frame fragmentation to mac80211 because firmware clears the 6537 * "more fragments" bit in frame control making it impossible for remote 6538 * devices to reassemble frames. 6539 * 6540 * Hence implement a dummy callback just to say fragmentation isn't 6541 * supported. This effectively prevents mac80211 from doing frame 6542 * fragmentation in software. 6543 */ 6544 return -EOPNOTSUPP; 6545 } 6546 6547 static void ath12k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 6548 u32 queues, bool drop) 6549 { 6550 struct ath12k *ar = hw->priv; 6551 long time_left; 6552 6553 if (drop) 6554 return; 6555 6556 time_left = wait_event_timeout(ar->dp.tx_empty_waitq, 6557 (atomic_read(&ar->dp.num_tx_pending) == 0), 6558 ATH12K_FLUSH_TIMEOUT); 6559 if (time_left == 0) 6560 ath12k_warn(ar->ab, "failed to flush transmit queue %ld\n", time_left); 6561 6562 time_left = wait_event_timeout(ar->txmgmt_empty_waitq, 6563 (atomic_read(&ar->num_pending_mgmt_tx) == 0), 6564 ATH12K_FLUSH_TIMEOUT); 6565 if (time_left == 0) 6566 ath12k_warn(ar->ab, "failed to flush mgmt transmit queue %ld\n", 6567 time_left); 6568 } 6569 6570 static int 6571 ath12k_mac_bitrate_mask_num_ht_rates(struct ath12k *ar, 6572 enum nl80211_band band, 6573 const struct cfg80211_bitrate_mask *mask) 6574 { 6575 int num_rates = 0; 6576 int i; 6577 6578 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) 6579 num_rates += hweight16(mask->control[band].ht_mcs[i]); 6580 6581 return num_rates; 6582 } 6583 6584 static bool 6585 ath12k_mac_has_single_legacy_rate(struct ath12k *ar, 6586 enum nl80211_band band, 6587 const struct cfg80211_bitrate_mask *mask) 6588 { 6589 int num_rates = 0; 6590 6591 num_rates = hweight32(mask->control[band].legacy); 6592 6593 if (ath12k_mac_bitrate_mask_num_ht_rates(ar, band, mask)) 6594 return false; 6595 6596 if (ath12k_mac_bitrate_mask_num_vht_rates(ar, band, mask)) 6597 return false; 6598 6599 return num_rates == 1; 6600 } 6601 6602 static bool 6603 ath12k_mac_bitrate_mask_get_single_nss(struct ath12k *ar, 6604 enum nl80211_band band, 6605 const struct cfg80211_bitrate_mask *mask, 6606 int *nss) 6607 { 6608 struct ieee80211_supported_band *sband = &ar->mac.sbands[band]; 6609 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 6610 u8 ht_nss_mask = 0; 6611 u8 vht_nss_mask = 0; 6612 int i; 6613 6614 /* No need to consider legacy here. Basic rates are always present 6615 * in bitrate mask 6616 */ 6617 6618 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) { 6619 if (mask->control[band].ht_mcs[i] == 0) 6620 continue; 6621 else if (mask->control[band].ht_mcs[i] == 6622 sband->ht_cap.mcs.rx_mask[i]) 6623 ht_nss_mask |= BIT(i); 6624 else 6625 return false; 6626 } 6627 6628 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) { 6629 if (mask->control[band].vht_mcs[i] == 0) 6630 continue; 6631 else if (mask->control[band].vht_mcs[i] == 6632 ath12k_mac_get_max_vht_mcs_map(vht_mcs_map, i)) 6633 vht_nss_mask |= BIT(i); 6634 else 6635 return false; 6636 } 6637 6638 if (ht_nss_mask != vht_nss_mask) 6639 return false; 6640 6641 if (ht_nss_mask == 0) 6642 return false; 6643 6644 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask) 6645 return false; 6646 6647 *nss = fls(ht_nss_mask); 6648 6649 return true; 6650 } 6651 6652 static int 6653 ath12k_mac_get_single_legacy_rate(struct ath12k *ar, 6654 enum nl80211_band band, 6655 const struct cfg80211_bitrate_mask *mask, 6656 u32 *rate, u8 *nss) 6657 { 6658 int rate_idx; 6659 u16 bitrate; 6660 u8 preamble; 6661 u8 hw_rate; 6662 6663 if (hweight32(mask->control[band].legacy) != 1) 6664 return -EINVAL; 6665 6666 rate_idx = ffs(mask->control[band].legacy) - 1; 6667 6668 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ) 6669 rate_idx += ATH12K_MAC_FIRST_OFDM_RATE_IDX; 6670 6671 hw_rate = ath12k_legacy_rates[rate_idx].hw_value; 6672 bitrate = ath12k_legacy_rates[rate_idx].bitrate; 6673 6674 if (ath12k_mac_bitrate_is_cck(bitrate)) 6675 preamble = WMI_RATE_PREAMBLE_CCK; 6676 else 6677 preamble = WMI_RATE_PREAMBLE_OFDM; 6678 6679 *nss = 1; 6680 *rate = ATH12K_HW_RATE_CODE(hw_rate, 0, preamble); 6681 6682 return 0; 6683 } 6684 6685 static int ath12k_mac_set_fixed_rate_params(struct ath12k_vif *arvif, 6686 u32 rate, u8 nss, u8 sgi, u8 ldpc) 6687 { 6688 struct ath12k *ar = arvif->ar; 6689 u32 vdev_param; 6690 int ret; 6691 6692 lockdep_assert_held(&ar->conf_mutex); 6693 6694 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02x nss %u sgi %u\n", 6695 arvif->vdev_id, rate, nss, sgi); 6696 6697 vdev_param = WMI_VDEV_PARAM_FIXED_RATE; 6698 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6699 vdev_param, rate); 6700 if (ret) { 6701 ath12k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n", 6702 rate, ret); 6703 return ret; 6704 } 6705 6706 vdev_param = WMI_VDEV_PARAM_NSS; 6707 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6708 vdev_param, nss); 6709 if (ret) { 6710 ath12k_warn(ar->ab, "failed to set nss param %d: %d\n", 6711 nss, ret); 6712 return ret; 6713 } 6714 6715 vdev_param = WMI_VDEV_PARAM_SGI; 6716 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6717 vdev_param, sgi); 6718 if (ret) { 6719 ath12k_warn(ar->ab, "failed to set sgi param %d: %d\n", 6720 sgi, ret); 6721 return ret; 6722 } 6723 6724 vdev_param = WMI_VDEV_PARAM_LDPC; 6725 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, 6726 vdev_param, ldpc); 6727 if (ret) { 6728 ath12k_warn(ar->ab, "failed to set ldpc param %d: %d\n", 6729 ldpc, ret); 6730 return ret; 6731 } 6732 6733 return 0; 6734 } 6735 6736 static bool 6737 ath12k_mac_vht_mcs_range_present(struct ath12k *ar, 6738 enum nl80211_band band, 6739 const struct cfg80211_bitrate_mask *mask) 6740 { 6741 int i; 6742 u16 vht_mcs; 6743 6744 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 6745 vht_mcs = mask->control[band].vht_mcs[i]; 6746 6747 switch (vht_mcs) { 6748 case 0: 6749 case BIT(8) - 1: 6750 case BIT(9) - 1: 6751 case BIT(10) - 1: 6752 break; 6753 default: 6754 return false; 6755 } 6756 } 6757 6758 return true; 6759 } 6760 6761 static void ath12k_mac_set_bitrate_mask_iter(void *data, 6762 struct ieee80211_sta *sta) 6763 { 6764 struct ath12k_vif *arvif = data; 6765 struct ath12k_sta *arsta = ath12k_sta_to_arsta(sta); 6766 struct ath12k *ar = arvif->ar; 6767 6768 spin_lock_bh(&ar->data_lock); 6769 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED; 6770 spin_unlock_bh(&ar->data_lock); 6771 6772 ieee80211_queue_work(ar->hw, &arsta->update_wk); 6773 } 6774 6775 static void ath12k_mac_disable_peer_fixed_rate(void *data, 6776 struct ieee80211_sta *sta) 6777 { 6778 struct ath12k_vif *arvif = data; 6779 struct ath12k *ar = arvif->ar; 6780 int ret; 6781 6782 ret = ath12k_wmi_set_peer_param(ar, sta->addr, 6783 arvif->vdev_id, 6784 WMI_PEER_PARAM_FIXED_RATE, 6785 WMI_FIXED_RATE_NONE); 6786 if (ret) 6787 ath12k_warn(ar->ab, 6788 "failed to disable peer fixed rate for STA %pM ret %d\n", 6789 sta->addr, ret); 6790 } 6791 6792 static int 6793 ath12k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw, 6794 struct ieee80211_vif *vif, 6795 const struct cfg80211_bitrate_mask *mask) 6796 { 6797 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif); 6798 struct cfg80211_chan_def def; 6799 struct ath12k *ar = arvif->ar; 6800 enum nl80211_band band; 6801 const u8 *ht_mcs_mask; 6802 const u16 *vht_mcs_mask; 6803 u32 rate; 6804 u8 nss; 6805 u8 sgi; 6806 u8 ldpc; 6807 int single_nss; 6808 int ret; 6809 int num_rates; 6810 6811 if (ath12k_mac_vif_chan(vif, &def)) 6812 return -EPERM; 6813 6814 band = def.chan->band; 6815 ht_mcs_mask = mask->control[band].ht_mcs; 6816 vht_mcs_mask = mask->control[band].vht_mcs; 6817 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC); 6818 6819 sgi = mask->control[band].gi; 6820 if (sgi == NL80211_TXRATE_FORCE_LGI) 6821 return -EINVAL; 6822 6823 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it 6824 * requires passing at least one of used basic rates along with them. 6825 * Fixed rate setting across different preambles(legacy, HT, VHT) is 6826 * not supported by the FW. Hence use of FIXED_RATE vdev param is not 6827 * suitable for setting single HT/VHT rates. 6828 * But, there could be a single basic rate passed from userspace which 6829 * can be done through the FIXED_RATE param. 6830 */ 6831 if (ath12k_mac_has_single_legacy_rate(ar, band, mask)) { 6832 ret = ath12k_mac_get_single_legacy_rate(ar, band, mask, &rate, 6833 &nss); 6834 if (ret) { 6835 ath12k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n", 6836 arvif->vdev_id, ret); 6837 return ret; 6838 } 6839 ieee80211_iterate_stations_atomic(ar->hw, 6840 ath12k_mac_disable_peer_fixed_rate, 6841 arvif); 6842 } else if (ath12k_mac_bitrate_mask_get_single_nss(ar, band, mask, 6843 &single_nss)) { 6844 rate = WMI_FIXED_RATE_NONE; 6845 nss = single_nss; 6846 } else { 6847 rate = WMI_FIXED_RATE_NONE; 6848 nss = min_t(u32, ar->num_tx_chains, 6849 max(ath12k_mac_max_ht_nss(ht_mcs_mask), 6850 ath12k_mac_max_vht_nss(vht_mcs_mask))); 6851 6852 /* If multiple rates across different preambles are given 6853 * we can reconfigure this info with all peers using PEER_ASSOC 6854 * command with the below exception cases. 6855 * - Single VHT Rate : peer_assoc command accommodates only MCS 6856 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211 6857 * mandates passing basic rates along with HT/VHT rates, FW 6858 * doesn't allow switching from VHT to Legacy. Hence instead of 6859 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd, 6860 * we could set this VHT rate as peer fixed rate param, which 6861 * will override FIXED rate and FW rate control algorithm. 6862 * If single VHT rate is passed along with HT rates, we select 6863 * the VHT rate as fixed rate for vht peers. 6864 * - Multiple VHT Rates : When Multiple VHT rates are given,this 6865 * can be set using RATEMASK CMD which uses FW rate-ctl alg. 6866 * TODO: Setting multiple VHT MCS and replacing peer_assoc with 6867 * RATEMASK_CMDID can cover all use cases of setting rates 6868 * across multiple preambles and rates within same type. 6869 * But requires more validation of the command at this point. 6870 */ 6871 6872 num_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band, 6873 mask); 6874 6875 if (!ath12k_mac_vht_mcs_range_present(ar, band, mask) && 6876 num_rates > 1) { 6877 /* TODO: Handle multiple VHT MCS values setting using 6878 * RATEMASK CMD 6879 */ 6880 ath12k_warn(ar->ab, 6881 "Setting more than one MCS Value in bitrate mask not supported\n"); 6882 return -EINVAL; 6883 } 6884 6885 ieee80211_iterate_stations_atomic(ar->hw, 6886 ath12k_mac_disable_peer_fixed_rate, 6887 arvif); 6888 6889 mutex_lock(&ar->conf_mutex); 6890 6891 arvif->bitrate_mask = *mask; 6892 ieee80211_iterate_stations_atomic(ar->hw, 6893 ath12k_mac_set_bitrate_mask_iter, 6894 arvif); 6895 6896 mutex_unlock(&ar->conf_mutex); 6897 } 6898 6899 mutex_lock(&ar->conf_mutex); 6900 6901 ret = ath12k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc); 6902 if (ret) { 6903 ath12k_warn(ar->ab, "failed to set fixed rate params on vdev %i: %d\n", 6904 arvif->vdev_id, ret); 6905 } 6906 6907 mutex_unlock(&ar->conf_mutex); 6908 6909 return ret; 6910 } 6911 6912 static void 6913 ath12k_mac_op_reconfig_complete(struct ieee80211_hw *hw, 6914 enum ieee80211_reconfig_type reconfig_type) 6915 { 6916 struct ath12k *ar = hw->priv; 6917 struct ath12k_base *ab = ar->ab; 6918 struct ath12k_vif *arvif; 6919 int recovery_count; 6920 6921 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) 6922 return; 6923 6924 mutex_lock(&ar->conf_mutex); 6925 6926 if (ar->state == ATH12K_STATE_RESTARTED) { 6927 ath12k_warn(ar->ab, "pdev %d successfully recovered\n", 6928 ar->pdev->pdev_id); 6929 ar->state = ATH12K_STATE_ON; 6930 ieee80211_wake_queues(ar->hw); 6931 6932 if (ab->is_reset) { 6933 recovery_count = atomic_inc_return(&ab->recovery_count); 6934 ath12k_dbg(ab, ATH12K_DBG_BOOT, "recovery count %d\n", 6935 recovery_count); 6936 /* When there are multiple radios in an SOC, 6937 * the recovery has to be done for each radio 6938 */ 6939 if (recovery_count == ab->num_radios) { 6940 atomic_dec(&ab->reset_count); 6941 complete(&ab->reset_complete); 6942 ab->is_reset = false; 6943 atomic_set(&ab->fail_cont_count, 0); 6944 ath12k_dbg(ab, ATH12K_DBG_BOOT, "reset success\n"); 6945 } 6946 } 6947 6948 list_for_each_entry(arvif, &ar->arvifs, list) { 6949 ath12k_dbg(ab, ATH12K_DBG_BOOT, 6950 "reconfig cipher %d up %d vdev type %d\n", 6951 arvif->key_cipher, 6952 arvif->is_up, 6953 arvif->vdev_type); 6954 /* After trigger disconnect, then upper layer will 6955 * trigger connect again, then the PN number of 6956 * upper layer will be reset to keep up with AP 6957 * side, hence PN number mismatch will not happen. 6958 */ 6959 if (arvif->is_up && 6960 arvif->vdev_type == WMI_VDEV_TYPE_STA && 6961 arvif->vdev_subtype == WMI_VDEV_SUBTYPE_NONE) { 6962 ieee80211_hw_restart_disconnect(arvif->vif); 6963 ath12k_dbg(ab, ATH12K_DBG_BOOT, 6964 "restart disconnect\n"); 6965 } 6966 } 6967 } 6968 6969 mutex_unlock(&ar->conf_mutex); 6970 } 6971 6972 static void 6973 ath12k_mac_update_bss_chan_survey(struct ath12k *ar, 6974 struct ieee80211_channel *channel) 6975 { 6976 int ret; 6977 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ; 6978 6979 lockdep_assert_held(&ar->conf_mutex); 6980 6981 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) || 6982 ar->rx_channel != channel) 6983 return; 6984 6985 if (ar->scan.state != ATH12K_SCAN_IDLE) { 6986 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 6987 "ignoring bss chan info req while scanning..\n"); 6988 return; 6989 } 6990 6991 reinit_completion(&ar->bss_survey_done); 6992 6993 ret = ath12k_wmi_pdev_bss_chan_info_request(ar, type); 6994 if (ret) { 6995 ath12k_warn(ar->ab, "failed to send pdev bss chan info request\n"); 6996 return; 6997 } 6998 6999 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ); 7000 if (ret == 0) 7001 ath12k_warn(ar->ab, "bss channel survey timed out\n"); 7002 } 7003 7004 static int ath12k_mac_op_get_survey(struct ieee80211_hw *hw, int idx, 7005 struct survey_info *survey) 7006 { 7007 struct ath12k *ar = hw->priv; 7008 struct ieee80211_supported_band *sband; 7009 struct survey_info *ar_survey; 7010 int ret = 0; 7011 7012 if (idx >= ATH12K_NUM_CHANS) 7013 return -ENOENT; 7014 7015 ar_survey = &ar->survey[idx]; 7016 7017 mutex_lock(&ar->conf_mutex); 7018 7019 sband = hw->wiphy->bands[NL80211_BAND_2GHZ]; 7020 if (sband && idx >= sband->n_channels) { 7021 idx -= sband->n_channels; 7022 sband = NULL; 7023 } 7024 7025 if (!sband) 7026 sband = hw->wiphy->bands[NL80211_BAND_5GHZ]; 7027 7028 if (!sband || idx >= sband->n_channels) { 7029 ret = -ENOENT; 7030 goto exit; 7031 } 7032 7033 ath12k_mac_update_bss_chan_survey(ar, &sband->channels[idx]); 7034 7035 spin_lock_bh(&ar->data_lock); 7036 memcpy(survey, ar_survey, sizeof(*survey)); 7037 spin_unlock_bh(&ar->data_lock); 7038 7039 survey->channel = &sband->channels[idx]; 7040 7041 if (ar->rx_channel == survey->channel) 7042 survey->filled |= SURVEY_INFO_IN_USE; 7043 7044 exit: 7045 mutex_unlock(&ar->conf_mutex); 7046 return ret; 7047 } 7048 7049 static void ath12k_mac_op_sta_statistics(struct ieee80211_hw *hw, 7050 struct ieee80211_vif *vif, 7051 struct ieee80211_sta *sta, 7052 struct station_info *sinfo) 7053 { 7054 struct ath12k_sta *arsta = ath12k_sta_to_arsta(sta); 7055 7056 sinfo->rx_duration = arsta->rx_duration; 7057 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION); 7058 7059 sinfo->tx_duration = arsta->tx_duration; 7060 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION); 7061 7062 if (!arsta->txrate.legacy && !arsta->txrate.nss) 7063 return; 7064 7065 if (arsta->txrate.legacy) { 7066 sinfo->txrate.legacy = arsta->txrate.legacy; 7067 } else { 7068 sinfo->txrate.mcs = arsta->txrate.mcs; 7069 sinfo->txrate.nss = arsta->txrate.nss; 7070 sinfo->txrate.bw = arsta->txrate.bw; 7071 sinfo->txrate.he_gi = arsta->txrate.he_gi; 7072 sinfo->txrate.he_dcm = arsta->txrate.he_dcm; 7073 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc; 7074 } 7075 sinfo->txrate.flags = arsta->txrate.flags; 7076 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 7077 7078 /* TODO: Use real NF instead of default one. */ 7079 sinfo->signal = arsta->rssi_comb + ATH12K_DEFAULT_NOISE_FLOOR; 7080 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 7081 } 7082 7083 static const struct ieee80211_ops ath12k_ops = { 7084 .tx = ath12k_mac_op_tx, 7085 .wake_tx_queue = ieee80211_handle_wake_tx_queue, 7086 .start = ath12k_mac_op_start, 7087 .stop = ath12k_mac_op_stop, 7088 .reconfig_complete = ath12k_mac_op_reconfig_complete, 7089 .add_interface = ath12k_mac_op_add_interface, 7090 .remove_interface = ath12k_mac_op_remove_interface, 7091 .update_vif_offload = ath12k_mac_op_update_vif_offload, 7092 .config = ath12k_mac_op_config, 7093 .bss_info_changed = ath12k_mac_op_bss_info_changed, 7094 .configure_filter = ath12k_mac_op_configure_filter, 7095 .hw_scan = ath12k_mac_op_hw_scan, 7096 .cancel_hw_scan = ath12k_mac_op_cancel_hw_scan, 7097 .set_key = ath12k_mac_op_set_key, 7098 .sta_state = ath12k_mac_op_sta_state, 7099 .sta_set_txpwr = ath12k_mac_op_sta_set_txpwr, 7100 .sta_rc_update = ath12k_mac_op_sta_rc_update, 7101 .conf_tx = ath12k_mac_op_conf_tx, 7102 .set_antenna = ath12k_mac_op_set_antenna, 7103 .get_antenna = ath12k_mac_op_get_antenna, 7104 .ampdu_action = ath12k_mac_op_ampdu_action, 7105 .add_chanctx = ath12k_mac_op_add_chanctx, 7106 .remove_chanctx = ath12k_mac_op_remove_chanctx, 7107 .change_chanctx = ath12k_mac_op_change_chanctx, 7108 .assign_vif_chanctx = ath12k_mac_op_assign_vif_chanctx, 7109 .unassign_vif_chanctx = ath12k_mac_op_unassign_vif_chanctx, 7110 .switch_vif_chanctx = ath12k_mac_op_switch_vif_chanctx, 7111 .set_rts_threshold = ath12k_mac_op_set_rts_threshold, 7112 .set_frag_threshold = ath12k_mac_op_set_frag_threshold, 7113 .set_bitrate_mask = ath12k_mac_op_set_bitrate_mask, 7114 .get_survey = ath12k_mac_op_get_survey, 7115 .flush = ath12k_mac_op_flush, 7116 .sta_statistics = ath12k_mac_op_sta_statistics, 7117 }; 7118 7119 static void ath12k_mac_update_ch_list(struct ath12k *ar, 7120 struct ieee80211_supported_band *band, 7121 u32 freq_low, u32 freq_high) 7122 { 7123 int i; 7124 7125 if (!(freq_low && freq_high)) 7126 return; 7127 7128 for (i = 0; i < band->n_channels; i++) { 7129 if (band->channels[i].center_freq < freq_low || 7130 band->channels[i].center_freq > freq_high) 7131 band->channels[i].flags |= IEEE80211_CHAN_DISABLED; 7132 } 7133 } 7134 7135 static u32 ath12k_get_phy_id(struct ath12k *ar, u32 band) 7136 { 7137 struct ath12k_pdev *pdev = ar->pdev; 7138 struct ath12k_pdev_cap *pdev_cap = &pdev->cap; 7139 7140 if (band == WMI_HOST_WLAN_2G_CAP) 7141 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id; 7142 7143 if (band == WMI_HOST_WLAN_5G_CAP) 7144 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id; 7145 7146 ath12k_warn(ar->ab, "unsupported phy cap:%d\n", band); 7147 7148 return 0; 7149 } 7150 7151 static int ath12k_mac_setup_channels_rates(struct ath12k *ar, 7152 u32 supported_bands) 7153 { 7154 struct ieee80211_supported_band *band; 7155 struct ath12k_wmi_hal_reg_capabilities_ext_arg *reg_cap; 7156 void *channels; 7157 u32 phy_id; 7158 7159 BUILD_BUG_ON((ARRAY_SIZE(ath12k_2ghz_channels) + 7160 ARRAY_SIZE(ath12k_5ghz_channels) + 7161 ARRAY_SIZE(ath12k_6ghz_channels)) != 7162 ATH12K_NUM_CHANS); 7163 7164 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx]; 7165 7166 if (supported_bands & WMI_HOST_WLAN_2G_CAP) { 7167 channels = kmemdup(ath12k_2ghz_channels, 7168 sizeof(ath12k_2ghz_channels), 7169 GFP_KERNEL); 7170 if (!channels) 7171 return -ENOMEM; 7172 7173 band = &ar->mac.sbands[NL80211_BAND_2GHZ]; 7174 band->band = NL80211_BAND_2GHZ; 7175 band->n_channels = ARRAY_SIZE(ath12k_2ghz_channels); 7176 band->channels = channels; 7177 band->n_bitrates = ath12k_g_rates_size; 7178 band->bitrates = ath12k_g_rates; 7179 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band; 7180 7181 if (ar->ab->hw_params->single_pdev_only) { 7182 phy_id = ath12k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP); 7183 reg_cap = &ar->ab->hal_reg_cap[phy_id]; 7184 } 7185 ath12k_mac_update_ch_list(ar, band, 7186 reg_cap->low_2ghz_chan, 7187 reg_cap->high_2ghz_chan); 7188 } 7189 7190 if (supported_bands & WMI_HOST_WLAN_5G_CAP) { 7191 if (reg_cap->high_5ghz_chan >= ATH12K_MAX_6G_FREQ) { 7192 channels = kmemdup(ath12k_6ghz_channels, 7193 sizeof(ath12k_6ghz_channels), GFP_KERNEL); 7194 if (!channels) { 7195 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 7196 return -ENOMEM; 7197 } 7198 7199 ar->supports_6ghz = true; 7200 band = &ar->mac.sbands[NL80211_BAND_6GHZ]; 7201 band->band = NL80211_BAND_6GHZ; 7202 band->n_channels = ARRAY_SIZE(ath12k_6ghz_channels); 7203 band->channels = channels; 7204 band->n_bitrates = ath12k_a_rates_size; 7205 band->bitrates = ath12k_a_rates; 7206 ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band; 7207 ath12k_mac_update_ch_list(ar, band, 7208 reg_cap->low_5ghz_chan, 7209 reg_cap->high_5ghz_chan); 7210 } 7211 7212 if (reg_cap->low_5ghz_chan < ATH12K_MIN_6G_FREQ) { 7213 channels = kmemdup(ath12k_5ghz_channels, 7214 sizeof(ath12k_5ghz_channels), 7215 GFP_KERNEL); 7216 if (!channels) { 7217 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 7218 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 7219 return -ENOMEM; 7220 } 7221 7222 band = &ar->mac.sbands[NL80211_BAND_5GHZ]; 7223 band->band = NL80211_BAND_5GHZ; 7224 band->n_channels = ARRAY_SIZE(ath12k_5ghz_channels); 7225 band->channels = channels; 7226 band->n_bitrates = ath12k_a_rates_size; 7227 band->bitrates = ath12k_a_rates; 7228 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band; 7229 7230 if (ar->ab->hw_params->single_pdev_only) { 7231 phy_id = ath12k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP); 7232 reg_cap = &ar->ab->hal_reg_cap[phy_id]; 7233 } 7234 7235 ath12k_mac_update_ch_list(ar, band, 7236 reg_cap->low_5ghz_chan, 7237 reg_cap->high_5ghz_chan); 7238 } 7239 } 7240 7241 return 0; 7242 } 7243 7244 static int ath12k_mac_setup_iface_combinations(struct ath12k *ar) 7245 { 7246 struct ath12k_base *ab = ar->ab; 7247 struct ieee80211_iface_combination *combinations; 7248 struct ieee80211_iface_limit *limits; 7249 int n_limits, max_interfaces; 7250 bool ap, mesh; 7251 7252 ap = ab->hw_params->interface_modes & BIT(NL80211_IFTYPE_AP); 7253 7254 mesh = IS_ENABLED(CONFIG_MAC80211_MESH) && 7255 ab->hw_params->interface_modes & BIT(NL80211_IFTYPE_MESH_POINT); 7256 7257 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL); 7258 if (!combinations) 7259 return -ENOMEM; 7260 7261 if (ap || mesh) { 7262 n_limits = 2; 7263 max_interfaces = 16; 7264 } else { 7265 n_limits = 1; 7266 max_interfaces = 1; 7267 } 7268 7269 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL); 7270 if (!limits) { 7271 kfree(combinations); 7272 return -ENOMEM; 7273 } 7274 7275 limits[0].max = 1; 7276 limits[0].types |= BIT(NL80211_IFTYPE_STATION); 7277 7278 if (ap) { 7279 limits[1].max = max_interfaces; 7280 limits[1].types |= BIT(NL80211_IFTYPE_AP); 7281 } 7282 7283 if (mesh) 7284 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT); 7285 7286 combinations[0].limits = limits; 7287 combinations[0].n_limits = n_limits; 7288 combinations[0].max_interfaces = max_interfaces; 7289 combinations[0].num_different_channels = 1; 7290 combinations[0].beacon_int_infra_match = true; 7291 combinations[0].beacon_int_min_gcd = 100; 7292 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 7293 BIT(NL80211_CHAN_WIDTH_20) | 7294 BIT(NL80211_CHAN_WIDTH_40) | 7295 BIT(NL80211_CHAN_WIDTH_80); 7296 7297 ar->hw->wiphy->iface_combinations = combinations; 7298 ar->hw->wiphy->n_iface_combinations = 1; 7299 7300 return 0; 7301 } 7302 7303 static const u8 ath12k_if_types_ext_capa[] = { 7304 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 7305 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 7306 }; 7307 7308 static const u8 ath12k_if_types_ext_capa_sta[] = { 7309 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 7310 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 7311 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT, 7312 }; 7313 7314 static const u8 ath12k_if_types_ext_capa_ap[] = { 7315 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING, 7316 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF, 7317 [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT, 7318 }; 7319 7320 static const struct wiphy_iftype_ext_capab ath12k_iftypes_ext_capa[] = { 7321 { 7322 .extended_capabilities = ath12k_if_types_ext_capa, 7323 .extended_capabilities_mask = ath12k_if_types_ext_capa, 7324 .extended_capabilities_len = sizeof(ath12k_if_types_ext_capa), 7325 }, { 7326 .iftype = NL80211_IFTYPE_STATION, 7327 .extended_capabilities = ath12k_if_types_ext_capa_sta, 7328 .extended_capabilities_mask = ath12k_if_types_ext_capa_sta, 7329 .extended_capabilities_len = 7330 sizeof(ath12k_if_types_ext_capa_sta), 7331 }, { 7332 .iftype = NL80211_IFTYPE_AP, 7333 .extended_capabilities = ath12k_if_types_ext_capa_ap, 7334 .extended_capabilities_mask = ath12k_if_types_ext_capa_ap, 7335 .extended_capabilities_len = 7336 sizeof(ath12k_if_types_ext_capa_ap), 7337 }, 7338 }; 7339 7340 static void __ath12k_mac_unregister(struct ath12k *ar) 7341 { 7342 cancel_work_sync(&ar->regd_update_work); 7343 7344 ieee80211_unregister_hw(ar->hw); 7345 7346 idr_for_each(&ar->txmgmt_idr, ath12k_mac_tx_mgmt_pending_free, ar); 7347 idr_destroy(&ar->txmgmt_idr); 7348 7349 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 7350 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 7351 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 7352 7353 kfree(ar->hw->wiphy->iface_combinations[0].limits); 7354 kfree(ar->hw->wiphy->iface_combinations); 7355 7356 SET_IEEE80211_DEV(ar->hw, NULL); 7357 } 7358 7359 void ath12k_mac_unregister(struct ath12k_base *ab) 7360 { 7361 struct ath12k *ar; 7362 struct ath12k_pdev *pdev; 7363 int i; 7364 7365 for (i = 0; i < ab->num_radios; i++) { 7366 pdev = &ab->pdevs[i]; 7367 ar = pdev->ar; 7368 if (!ar) 7369 continue; 7370 7371 __ath12k_mac_unregister(ar); 7372 } 7373 } 7374 7375 static int __ath12k_mac_register(struct ath12k *ar) 7376 { 7377 struct ath12k_base *ab = ar->ab; 7378 struct ath12k_pdev_cap *cap = &ar->pdev->cap; 7379 static const u32 cipher_suites[] = { 7380 WLAN_CIPHER_SUITE_TKIP, 7381 WLAN_CIPHER_SUITE_CCMP, 7382 WLAN_CIPHER_SUITE_AES_CMAC, 7383 WLAN_CIPHER_SUITE_BIP_CMAC_256, 7384 WLAN_CIPHER_SUITE_BIP_GMAC_128, 7385 WLAN_CIPHER_SUITE_BIP_GMAC_256, 7386 WLAN_CIPHER_SUITE_GCMP, 7387 WLAN_CIPHER_SUITE_GCMP_256, 7388 WLAN_CIPHER_SUITE_CCMP_256, 7389 }; 7390 int ret; 7391 u32 ht_cap = 0; 7392 7393 ath12k_pdev_caps_update(ar); 7394 7395 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 7396 7397 SET_IEEE80211_DEV(ar->hw, ab->dev); 7398 7399 ret = ath12k_mac_setup_channels_rates(ar, 7400 cap->supported_bands); 7401 if (ret) 7402 goto err; 7403 7404 ath12k_mac_setup_ht_vht_cap(ar, cap, &ht_cap); 7405 ath12k_mac_setup_sband_iftype_data(ar, cap); 7406 7407 ret = ath12k_mac_setup_iface_combinations(ar); 7408 if (ret) { 7409 ath12k_err(ar->ab, "failed to setup interface combinations: %d\n", ret); 7410 goto err_free_channels; 7411 } 7412 7413 ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask; 7414 ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask; 7415 7416 ar->hw->wiphy->interface_modes = ab->hw_params->interface_modes; 7417 7418 if (ar->hw->wiphy->bands[NL80211_BAND_2GHZ] && 7419 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] && 7420 ar->hw->wiphy->bands[NL80211_BAND_6GHZ]) 7421 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS); 7422 7423 ieee80211_hw_set(ar->hw, SIGNAL_DBM); 7424 ieee80211_hw_set(ar->hw, SUPPORTS_PS); 7425 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS); 7426 ieee80211_hw_set(ar->hw, MFP_CAPABLE); 7427 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS); 7428 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL); 7429 ieee80211_hw_set(ar->hw, AP_LINK_PS); 7430 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT); 7431 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR); 7432 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK); 7433 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA); 7434 ieee80211_hw_set(ar->hw, QUEUE_CONTROL); 7435 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG); 7436 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK); 7437 7438 if (ht_cap & WMI_HT_CAP_ENABLED) { 7439 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION); 7440 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW); 7441 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER); 7442 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU); 7443 ieee80211_hw_set(ar->hw, USES_RSS); 7444 } 7445 7446 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS; 7447 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 7448 7449 /* TODO: Check if HT capability advertised from firmware is different 7450 * for each band for a dual band capable radio. It will be tricky to 7451 * handle it when the ht capability different for each band. 7452 */ 7453 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) 7454 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS; 7455 7456 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 7457 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 7458 7459 ar->hw->max_listen_interval = ATH12K_MAX_HW_LISTEN_INTERVAL; 7460 7461 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 7462 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 7463 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 7464 7465 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 7466 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE | 7467 NL80211_FEATURE_AP_SCAN; 7468 7469 ar->max_num_stations = TARGET_NUM_STATIONS; 7470 ar->max_num_peers = TARGET_NUM_PEERS_PDEV; 7471 7472 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations; 7473 7474 ar->hw->queues = ATH12K_HW_MAX_QUEUES; 7475 ar->hw->wiphy->tx_queue_len = ATH12K_QUEUE_LEN; 7476 ar->hw->offchannel_tx_hw_queue = ATH12K_HW_MAX_QUEUES - 1; 7477 ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE; 7478 7479 ar->hw->vif_data_size = sizeof(struct ath12k_vif); 7480 ar->hw->sta_data_size = sizeof(struct ath12k_sta); 7481 7482 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 7483 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR); 7484 7485 ar->hw->wiphy->cipher_suites = cipher_suites; 7486 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 7487 7488 ar->hw->wiphy->iftype_ext_capab = ath12k_iftypes_ext_capa; 7489 ar->hw->wiphy->num_iftype_ext_capab = 7490 ARRAY_SIZE(ath12k_iftypes_ext_capa); 7491 7492 if (ar->supports_6ghz) { 7493 wiphy_ext_feature_set(ar->hw->wiphy, 7494 NL80211_EXT_FEATURE_FILS_DISCOVERY); 7495 wiphy_ext_feature_set(ar->hw->wiphy, 7496 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP); 7497 } 7498 7499 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_PUNCT); 7500 7501 ath12k_reg_init(ar); 7502 7503 if (!test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) { 7504 ar->hw->netdev_features = NETIF_F_HW_CSUM; 7505 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL); 7506 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT); 7507 } 7508 7509 ret = ieee80211_register_hw(ar->hw); 7510 if (ret) { 7511 ath12k_err(ar->ab, "ieee80211 registration failed: %d\n", ret); 7512 goto err_free_if_combs; 7513 } 7514 7515 if (!ab->hw_params->supports_monitor) 7516 /* There's a race between calling ieee80211_register_hw() 7517 * and here where the monitor mode is enabled for a little 7518 * while. But that time is so short and in practise it make 7519 * a difference in real life. 7520 */ 7521 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR); 7522 7523 /* Apply the regd received during initialization */ 7524 ret = ath12k_regd_update(ar, true); 7525 if (ret) { 7526 ath12k_err(ar->ab, "ath12k regd update failed: %d\n", ret); 7527 goto err_unregister_hw; 7528 } 7529 7530 return 0; 7531 7532 err_unregister_hw: 7533 ieee80211_unregister_hw(ar->hw); 7534 7535 err_free_if_combs: 7536 kfree(ar->hw->wiphy->iface_combinations[0].limits); 7537 kfree(ar->hw->wiphy->iface_combinations); 7538 7539 err_free_channels: 7540 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels); 7541 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels); 7542 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels); 7543 7544 err: 7545 SET_IEEE80211_DEV(ar->hw, NULL); 7546 return ret; 7547 } 7548 7549 int ath12k_mac_register(struct ath12k_base *ab) 7550 { 7551 struct ath12k *ar; 7552 struct ath12k_pdev *pdev; 7553 int i; 7554 int ret; 7555 7556 if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags)) 7557 return 0; 7558 7559 for (i = 0; i < ab->num_radios; i++) { 7560 pdev = &ab->pdevs[i]; 7561 ar = pdev->ar; 7562 if (ab->pdevs_macaddr_valid) { 7563 ether_addr_copy(ar->mac_addr, pdev->mac_addr); 7564 } else { 7565 ether_addr_copy(ar->mac_addr, ab->mac_addr); 7566 ar->mac_addr[4] += i; 7567 } 7568 7569 ret = __ath12k_mac_register(ar); 7570 if (ret) 7571 goto err_cleanup; 7572 7573 init_waitqueue_head(&ar->txmgmt_empty_waitq); 7574 idr_init(&ar->txmgmt_idr); 7575 spin_lock_init(&ar->txmgmt_idr_lock); 7576 } 7577 7578 /* Initialize channel counters frequency value in hertz */ 7579 ab->cc_freq_hz = 320000; 7580 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1; 7581 7582 return 0; 7583 7584 err_cleanup: 7585 for (i = i - 1; i >= 0; i--) { 7586 pdev = &ab->pdevs[i]; 7587 ar = pdev->ar; 7588 __ath12k_mac_unregister(ar); 7589 } 7590 7591 return ret; 7592 } 7593 7594 int ath12k_mac_allocate(struct ath12k_base *ab) 7595 { 7596 struct ieee80211_hw *hw; 7597 struct ath12k *ar; 7598 struct ath12k_pdev *pdev; 7599 int ret; 7600 int i; 7601 7602 if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags)) 7603 return 0; 7604 7605 for (i = 0; i < ab->num_radios; i++) { 7606 pdev = &ab->pdevs[i]; 7607 hw = ieee80211_alloc_hw(sizeof(struct ath12k), &ath12k_ops); 7608 if (!hw) { 7609 ath12k_warn(ab, "failed to allocate mac80211 hw device\n"); 7610 ret = -ENOMEM; 7611 goto err_free_mac; 7612 } 7613 7614 ar = hw->priv; 7615 ar->hw = hw; 7616 ar->ab = ab; 7617 ar->pdev = pdev; 7618 ar->pdev_idx = i; 7619 ar->lmac_id = ath12k_hw_get_mac_from_pdev_id(ab->hw_params, i); 7620 7621 ar->wmi = &ab->wmi_ab.wmi[i]; 7622 /* FIXME: wmi[0] is already initialized during attach, 7623 * Should we do this again? 7624 */ 7625 ath12k_wmi_pdev_attach(ab, i); 7626 7627 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask; 7628 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask; 7629 ar->num_tx_chains = hweight32(pdev->cap.tx_chain_mask); 7630 ar->num_rx_chains = hweight32(pdev->cap.rx_chain_mask); 7631 7632 pdev->ar = ar; 7633 spin_lock_init(&ar->data_lock); 7634 INIT_LIST_HEAD(&ar->arvifs); 7635 INIT_LIST_HEAD(&ar->ppdu_stats_info); 7636 mutex_init(&ar->conf_mutex); 7637 init_completion(&ar->vdev_setup_done); 7638 init_completion(&ar->vdev_delete_done); 7639 init_completion(&ar->peer_assoc_done); 7640 init_completion(&ar->peer_delete_done); 7641 init_completion(&ar->install_key_done); 7642 init_completion(&ar->bss_survey_done); 7643 init_completion(&ar->scan.started); 7644 init_completion(&ar->scan.completed); 7645 7646 INIT_DELAYED_WORK(&ar->scan.timeout, ath12k_scan_timeout_work); 7647 INIT_WORK(&ar->regd_update_work, ath12k_regd_update_work); 7648 7649 INIT_WORK(&ar->wmi_mgmt_tx_work, ath12k_mgmt_over_wmi_tx_work); 7650 skb_queue_head_init(&ar->wmi_mgmt_tx_queue); 7651 clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags); 7652 } 7653 7654 return 0; 7655 7656 err_free_mac: 7657 ath12k_mac_destroy(ab); 7658 7659 return ret; 7660 } 7661 7662 void ath12k_mac_destroy(struct ath12k_base *ab) 7663 { 7664 struct ath12k *ar; 7665 struct ath12k_pdev *pdev; 7666 int i; 7667 7668 for (i = 0; i < ab->num_radios; i++) { 7669 pdev = &ab->pdevs[i]; 7670 ar = pdev->ar; 7671 if (!ar) 7672 continue; 7673 7674 ieee80211_free_hw(ar->hw); 7675 pdev->ar = NULL; 7676 } 7677 } 7678