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