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