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