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