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