1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2019-2021 The Linux Foundation. All rights reserved. 4 * Copyright (c) 2021-2025 Qualcomm Innovation Center, Inc. All rights reserved. 5 */ 6 7 #include "dp_mon.h" 8 #include "debug.h" 9 #include "dp_rx.h" 10 #include "dp_tx.h" 11 #include "peer.h" 12 13 #define ATH12K_LE32_DEC_ENC(value, dec_bits, enc_bits) \ 14 u32_encode_bits(le32_get_bits(value, dec_bits), enc_bits) 15 16 #define ATH12K_LE64_DEC_ENC(value, dec_bits, enc_bits) \ 17 u32_encode_bits(le64_get_bits(value, dec_bits), enc_bits) 18 19 static void 20 ath12k_dp_mon_rx_handle_ofdma_info(const struct hal_rx_ppdu_end_user_stats *ppdu_end_user, 21 struct hal_rx_user_status *rx_user_status) 22 { 23 rx_user_status->ul_ofdma_user_v0_word0 = 24 __le32_to_cpu(ppdu_end_user->usr_resp_ref); 25 rx_user_status->ul_ofdma_user_v0_word1 = 26 __le32_to_cpu(ppdu_end_user->usr_resp_ref_ext); 27 } 28 29 static void 30 ath12k_dp_mon_rx_populate_byte_count(const struct hal_rx_ppdu_end_user_stats *stats, 31 void *ppduinfo, 32 struct hal_rx_user_status *rx_user_status) 33 { 34 rx_user_status->mpdu_ok_byte_count = 35 le32_get_bits(stats->info7, 36 HAL_RX_PPDU_END_USER_STATS_INFO7_MPDU_OK_BYTE_COUNT); 37 rx_user_status->mpdu_err_byte_count = 38 le32_get_bits(stats->info8, 39 HAL_RX_PPDU_END_USER_STATS_INFO8_MPDU_ERR_BYTE_COUNT); 40 } 41 42 static void 43 ath12k_dp_mon_rx_populate_mu_user_info(const struct hal_rx_ppdu_end_user_stats *rx_tlv, 44 struct hal_rx_mon_ppdu_info *ppdu_info, 45 struct hal_rx_user_status *rx_user_status) 46 { 47 rx_user_status->ast_index = ppdu_info->ast_index; 48 rx_user_status->tid = ppdu_info->tid; 49 rx_user_status->tcp_ack_msdu_count = 50 ppdu_info->tcp_ack_msdu_count; 51 rx_user_status->tcp_msdu_count = 52 ppdu_info->tcp_msdu_count; 53 rx_user_status->udp_msdu_count = 54 ppdu_info->udp_msdu_count; 55 rx_user_status->other_msdu_count = 56 ppdu_info->other_msdu_count; 57 rx_user_status->frame_control = ppdu_info->frame_control; 58 rx_user_status->frame_control_info_valid = 59 ppdu_info->frame_control_info_valid; 60 rx_user_status->data_sequence_control_info_valid = 61 ppdu_info->data_sequence_control_info_valid; 62 rx_user_status->first_data_seq_ctrl = 63 ppdu_info->first_data_seq_ctrl; 64 rx_user_status->preamble_type = ppdu_info->preamble_type; 65 rx_user_status->ht_flags = ppdu_info->ht_flags; 66 rx_user_status->vht_flags = ppdu_info->vht_flags; 67 rx_user_status->he_flags = ppdu_info->he_flags; 68 rx_user_status->rs_flags = ppdu_info->rs_flags; 69 70 rx_user_status->mpdu_cnt_fcs_ok = 71 ppdu_info->num_mpdu_fcs_ok; 72 rx_user_status->mpdu_cnt_fcs_err = 73 ppdu_info->num_mpdu_fcs_err; 74 memcpy(&rx_user_status->mpdu_fcs_ok_bitmap[0], &ppdu_info->mpdu_fcs_ok_bitmap[0], 75 HAL_RX_NUM_WORDS_PER_PPDU_BITMAP * 76 sizeof(ppdu_info->mpdu_fcs_ok_bitmap[0])); 77 78 ath12k_dp_mon_rx_populate_byte_count(rx_tlv, ppdu_info, rx_user_status); 79 } 80 81 static void ath12k_dp_mon_parse_vht_sig_a(const struct hal_rx_vht_sig_a_info *vht_sig, 82 struct hal_rx_mon_ppdu_info *ppdu_info) 83 { 84 u32 nsts, info0, info1; 85 u8 gi_setting; 86 87 info0 = __le32_to_cpu(vht_sig->info0); 88 info1 = __le32_to_cpu(vht_sig->info1); 89 90 ppdu_info->ldpc = u32_get_bits(info1, HAL_RX_VHT_SIG_A_INFO_INFO1_SU_MU_CODING); 91 ppdu_info->mcs = u32_get_bits(info1, HAL_RX_VHT_SIG_A_INFO_INFO1_MCS); 92 gi_setting = u32_get_bits(info1, HAL_RX_VHT_SIG_A_INFO_INFO1_GI_SETTING); 93 switch (gi_setting) { 94 case HAL_RX_VHT_SIG_A_NORMAL_GI: 95 ppdu_info->gi = HAL_RX_GI_0_8_US; 96 break; 97 case HAL_RX_VHT_SIG_A_SHORT_GI: 98 case HAL_RX_VHT_SIG_A_SHORT_GI_AMBIGUITY: 99 ppdu_info->gi = HAL_RX_GI_0_4_US; 100 break; 101 } 102 103 ppdu_info->is_stbc = u32_get_bits(info0, HAL_RX_VHT_SIG_A_INFO_INFO0_STBC); 104 nsts = u32_get_bits(info0, HAL_RX_VHT_SIG_A_INFO_INFO0_NSTS); 105 if (ppdu_info->is_stbc && nsts > 0) 106 nsts = ((nsts + 1) >> 1) - 1; 107 108 ppdu_info->nss = u32_get_bits(nsts, VHT_SIG_SU_NSS_MASK); 109 ppdu_info->bw = u32_get_bits(info0, HAL_RX_VHT_SIG_A_INFO_INFO0_BW); 110 ppdu_info->beamformed = u32_get_bits(info1, 111 HAL_RX_VHT_SIG_A_INFO_INFO1_BEAMFORMED); 112 ppdu_info->vht_flag_values5 = u32_get_bits(info0, 113 HAL_RX_VHT_SIG_A_INFO_INFO0_GROUP_ID); 114 ppdu_info->vht_flag_values3[0] = (((ppdu_info->mcs) << 4) | 115 ppdu_info->nss); 116 ppdu_info->vht_flag_values2 = ppdu_info->bw; 117 ppdu_info->vht_flag_values4 = 118 u32_get_bits(info1, HAL_RX_VHT_SIG_A_INFO_INFO1_SU_MU_CODING); 119 } 120 121 static void ath12k_dp_mon_parse_ht_sig(const struct hal_rx_ht_sig_info *ht_sig, 122 struct hal_rx_mon_ppdu_info *ppdu_info) 123 { 124 u32 info0 = __le32_to_cpu(ht_sig->info0); 125 u32 info1 = __le32_to_cpu(ht_sig->info1); 126 127 ppdu_info->mcs = u32_get_bits(info0, HAL_RX_HT_SIG_INFO_INFO0_MCS); 128 ppdu_info->bw = u32_get_bits(info0, HAL_RX_HT_SIG_INFO_INFO0_BW); 129 ppdu_info->is_stbc = u32_get_bits(info1, HAL_RX_HT_SIG_INFO_INFO1_STBC); 130 ppdu_info->ldpc = u32_get_bits(info1, HAL_RX_HT_SIG_INFO_INFO1_FEC_CODING); 131 ppdu_info->gi = u32_get_bits(info1, HAL_RX_HT_SIG_INFO_INFO1_GI); 132 ppdu_info->nss = (ppdu_info->mcs >> 3); 133 } 134 135 static void ath12k_dp_mon_parse_l_sig_b(const struct hal_rx_lsig_b_info *lsigb, 136 struct hal_rx_mon_ppdu_info *ppdu_info) 137 { 138 u32 info0 = __le32_to_cpu(lsigb->info0); 139 u8 rate; 140 141 rate = u32_get_bits(info0, HAL_RX_LSIG_B_INFO_INFO0_RATE); 142 switch (rate) { 143 case 1: 144 rate = HAL_RX_LEGACY_RATE_1_MBPS; 145 break; 146 case 2: 147 case 5: 148 rate = HAL_RX_LEGACY_RATE_2_MBPS; 149 break; 150 case 3: 151 case 6: 152 rate = HAL_RX_LEGACY_RATE_5_5_MBPS; 153 break; 154 case 4: 155 case 7: 156 rate = HAL_RX_LEGACY_RATE_11_MBPS; 157 break; 158 default: 159 rate = HAL_RX_LEGACY_RATE_INVALID; 160 } 161 162 ppdu_info->rate = rate; 163 ppdu_info->cck_flag = 1; 164 } 165 166 static void ath12k_dp_mon_parse_l_sig_a(const struct hal_rx_lsig_a_info *lsiga, 167 struct hal_rx_mon_ppdu_info *ppdu_info) 168 { 169 u32 info0 = __le32_to_cpu(lsiga->info0); 170 u8 rate; 171 172 rate = u32_get_bits(info0, HAL_RX_LSIG_A_INFO_INFO0_RATE); 173 switch (rate) { 174 case 8: 175 rate = HAL_RX_LEGACY_RATE_48_MBPS; 176 break; 177 case 9: 178 rate = HAL_RX_LEGACY_RATE_24_MBPS; 179 break; 180 case 10: 181 rate = HAL_RX_LEGACY_RATE_12_MBPS; 182 break; 183 case 11: 184 rate = HAL_RX_LEGACY_RATE_6_MBPS; 185 break; 186 case 12: 187 rate = HAL_RX_LEGACY_RATE_54_MBPS; 188 break; 189 case 13: 190 rate = HAL_RX_LEGACY_RATE_36_MBPS; 191 break; 192 case 14: 193 rate = HAL_RX_LEGACY_RATE_18_MBPS; 194 break; 195 case 15: 196 rate = HAL_RX_LEGACY_RATE_9_MBPS; 197 break; 198 default: 199 rate = HAL_RX_LEGACY_RATE_INVALID; 200 } 201 202 ppdu_info->rate = rate; 203 } 204 205 static void 206 ath12k_dp_mon_parse_he_sig_b2_ofdma(const struct hal_rx_he_sig_b2_ofdma_info *ofdma, 207 struct hal_rx_mon_ppdu_info *ppdu_info) 208 { 209 u32 info0, value; 210 211 info0 = __le32_to_cpu(ofdma->info0); 212 213 ppdu_info->he_data1 |= HE_MCS_KNOWN | HE_DCM_KNOWN | HE_CODING_KNOWN; 214 215 /* HE-data2 */ 216 ppdu_info->he_data2 |= HE_TXBF_KNOWN; 217 218 ppdu_info->mcs = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_MCS); 219 value = ppdu_info->mcs << HE_TRANSMIT_MCS_SHIFT; 220 ppdu_info->he_data3 |= value; 221 222 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_DCM); 223 value = value << HE_DCM_SHIFT; 224 ppdu_info->he_data3 |= value; 225 226 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_CODING); 227 ppdu_info->ldpc = value; 228 value = value << HE_CODING_SHIFT; 229 ppdu_info->he_data3 |= value; 230 231 /* HE-data4 */ 232 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_ID); 233 value = value << HE_STA_ID_SHIFT; 234 ppdu_info->he_data4 |= value; 235 236 ppdu_info->nss = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_NSTS); 237 ppdu_info->beamformed = u32_get_bits(info0, 238 HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_TXBF); 239 } 240 241 static void 242 ath12k_dp_mon_parse_he_sig_b2_mu(const struct hal_rx_he_sig_b2_mu_info *he_sig_b2_mu, 243 struct hal_rx_mon_ppdu_info *ppdu_info) 244 { 245 u32 info0, value; 246 247 info0 = __le32_to_cpu(he_sig_b2_mu->info0); 248 249 ppdu_info->he_data1 |= HE_MCS_KNOWN | HE_CODING_KNOWN; 250 251 ppdu_info->mcs = u32_get_bits(info0, HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_MCS); 252 value = ppdu_info->mcs << HE_TRANSMIT_MCS_SHIFT; 253 ppdu_info->he_data3 |= value; 254 255 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_CODING); 256 ppdu_info->ldpc = value; 257 value = value << HE_CODING_SHIFT; 258 ppdu_info->he_data3 |= value; 259 260 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_ID); 261 value = value << HE_STA_ID_SHIFT; 262 ppdu_info->he_data4 |= value; 263 264 ppdu_info->nss = u32_get_bits(info0, HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_NSTS); 265 } 266 267 static void 268 ath12k_dp_mon_parse_he_sig_b1_mu(const struct hal_rx_he_sig_b1_mu_info *he_sig_b1_mu, 269 struct hal_rx_mon_ppdu_info *ppdu_info) 270 { 271 u32 info0 = __le32_to_cpu(he_sig_b1_mu->info0); 272 u16 ru_tones; 273 274 ru_tones = u32_get_bits(info0, 275 HAL_RX_HE_SIG_B1_MU_INFO_INFO0_RU_ALLOCATION); 276 ppdu_info->ru_alloc = ath12k_he_ru_tones_to_nl80211_he_ru_alloc(ru_tones); 277 ppdu_info->he_RU[0] = ru_tones; 278 } 279 280 static void 281 ath12k_dp_mon_parse_he_sig_mu(const struct hal_rx_he_sig_a_mu_dl_info *he_sig_a_mu_dl, 282 struct hal_rx_mon_ppdu_info *ppdu_info) 283 { 284 u32 info0, info1, value; 285 u16 he_gi = 0, he_ltf = 0; 286 287 info0 = __le32_to_cpu(he_sig_a_mu_dl->info0); 288 info1 = __le32_to_cpu(he_sig_a_mu_dl->info1); 289 290 ppdu_info->he_mu_flags = 1; 291 292 ppdu_info->he_data1 = HE_MU_FORMAT_TYPE; 293 ppdu_info->he_data1 |= 294 HE_BSS_COLOR_KNOWN | 295 HE_DL_UL_KNOWN | 296 HE_LDPC_EXTRA_SYMBOL_KNOWN | 297 HE_STBC_KNOWN | 298 HE_DATA_BW_RU_KNOWN | 299 HE_DOPPLER_KNOWN; 300 301 ppdu_info->he_data2 = 302 HE_GI_KNOWN | 303 HE_LTF_SYMBOLS_KNOWN | 304 HE_PRE_FEC_PADDING_KNOWN | 305 HE_PE_DISAMBIGUITY_KNOWN | 306 HE_TXOP_KNOWN | 307 HE_MIDABLE_PERIODICITY_KNOWN; 308 309 /* data3 */ 310 ppdu_info->he_data3 = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_BSS_COLOR); 311 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_UL_FLAG); 312 value = value << HE_DL_UL_SHIFT; 313 ppdu_info->he_data3 |= value; 314 315 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_LDPC_EXTRA); 316 value = value << HE_LDPC_EXTRA_SYMBOL_SHIFT; 317 ppdu_info->he_data3 |= value; 318 319 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_STBC); 320 value = value << HE_STBC_SHIFT; 321 ppdu_info->he_data3 |= value; 322 323 /* data4 */ 324 ppdu_info->he_data4 = u32_get_bits(info0, 325 HAL_RX_HE_SIG_A_MU_DL_INFO0_SPATIAL_REUSE); 326 ppdu_info->he_data4 = value; 327 328 /* data5 */ 329 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_TRANSMIT_BW); 330 ppdu_info->he_data5 = value; 331 ppdu_info->bw = value; 332 333 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_CP_LTF_SIZE); 334 switch (value) { 335 case 0: 336 he_gi = HE_GI_0_8; 337 he_ltf = HE_LTF_4_X; 338 break; 339 case 1: 340 he_gi = HE_GI_0_8; 341 he_ltf = HE_LTF_2_X; 342 break; 343 case 2: 344 he_gi = HE_GI_1_6; 345 he_ltf = HE_LTF_2_X; 346 break; 347 case 3: 348 he_gi = HE_GI_3_2; 349 he_ltf = HE_LTF_4_X; 350 break; 351 } 352 353 ppdu_info->gi = he_gi; 354 value = he_gi << HE_GI_SHIFT; 355 ppdu_info->he_data5 |= value; 356 357 value = he_ltf << HE_LTF_SIZE_SHIFT; 358 ppdu_info->he_data5 |= value; 359 360 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_NUM_LTF_SYMB); 361 value = (value << HE_LTF_SYM_SHIFT); 362 ppdu_info->he_data5 |= value; 363 364 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_PKT_EXT_FACTOR); 365 value = value << HE_PRE_FEC_PAD_SHIFT; 366 ppdu_info->he_data5 |= value; 367 368 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_PKT_EXT_PE_DISAM); 369 value = value << HE_PE_DISAMBIGUITY_SHIFT; 370 ppdu_info->he_data5 |= value; 371 372 /*data6*/ 373 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_DOPPLER_INDICATION); 374 value = value << HE_DOPPLER_SHIFT; 375 ppdu_info->he_data6 |= value; 376 377 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_TXOP_DURATION); 378 value = value << HE_TXOP_SHIFT; 379 ppdu_info->he_data6 |= value; 380 381 /* HE-MU Flags */ 382 /* HE-MU-flags1 */ 383 ppdu_info->he_flags1 = 384 HE_SIG_B_MCS_KNOWN | 385 HE_SIG_B_DCM_KNOWN | 386 HE_SIG_B_COMPRESSION_FLAG_1_KNOWN | 387 HE_SIG_B_SYM_NUM_KNOWN | 388 HE_RU_0_KNOWN; 389 390 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_MCS_OF_SIGB); 391 ppdu_info->he_flags1 |= value; 392 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_DCM_OF_SIGB); 393 value = value << HE_DCM_FLAG_1_SHIFT; 394 ppdu_info->he_flags1 |= value; 395 396 /* HE-MU-flags2 */ 397 ppdu_info->he_flags2 = HE_BW_KNOWN; 398 399 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_TRANSMIT_BW); 400 ppdu_info->he_flags2 |= value; 401 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_COMP_MODE_SIGB); 402 value = value << HE_SIG_B_COMPRESSION_FLAG_2_SHIFT; 403 ppdu_info->he_flags2 |= value; 404 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_NUM_SIGB_SYMB); 405 value = value - 1; 406 value = value << HE_NUM_SIG_B_SYMBOLS_SHIFT; 407 ppdu_info->he_flags2 |= value; 408 409 ppdu_info->is_stbc = info1 & 410 HAL_RX_HE_SIG_A_MU_DL_INFO1_STBC; 411 } 412 413 static void ath12k_dp_mon_parse_he_sig_su(const struct hal_rx_he_sig_a_su_info *he_sig_a, 414 struct hal_rx_mon_ppdu_info *ppdu_info) 415 { 416 u32 info0, info1, value; 417 u32 dcm; 418 u8 he_dcm = 0, he_stbc = 0; 419 u16 he_gi = 0, he_ltf = 0; 420 421 ppdu_info->he_flags = 1; 422 423 info0 = __le32_to_cpu(he_sig_a->info0); 424 info1 = __le32_to_cpu(he_sig_a->info1); 425 426 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_FORMAT_IND); 427 if (value == 0) 428 ppdu_info->he_data1 = HE_TRIG_FORMAT_TYPE; 429 else 430 ppdu_info->he_data1 = HE_SU_FORMAT_TYPE; 431 432 ppdu_info->he_data1 |= 433 HE_BSS_COLOR_KNOWN | 434 HE_BEAM_CHANGE_KNOWN | 435 HE_DL_UL_KNOWN | 436 HE_MCS_KNOWN | 437 HE_DCM_KNOWN | 438 HE_CODING_KNOWN | 439 HE_LDPC_EXTRA_SYMBOL_KNOWN | 440 HE_STBC_KNOWN | 441 HE_DATA_BW_RU_KNOWN | 442 HE_DOPPLER_KNOWN; 443 444 ppdu_info->he_data2 |= 445 HE_GI_KNOWN | 446 HE_TXBF_KNOWN | 447 HE_PE_DISAMBIGUITY_KNOWN | 448 HE_TXOP_KNOWN | 449 HE_LTF_SYMBOLS_KNOWN | 450 HE_PRE_FEC_PADDING_KNOWN | 451 HE_MIDABLE_PERIODICITY_KNOWN; 452 453 ppdu_info->he_data3 = u32_get_bits(info0, 454 HAL_RX_HE_SIG_A_SU_INFO_INFO0_BSS_COLOR); 455 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_BEAM_CHANGE); 456 value = value << HE_BEAM_CHANGE_SHIFT; 457 ppdu_info->he_data3 |= value; 458 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_DL_UL_FLAG); 459 value = value << HE_DL_UL_SHIFT; 460 ppdu_info->he_data3 |= value; 461 462 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_MCS); 463 ppdu_info->mcs = value; 464 value = value << HE_TRANSMIT_MCS_SHIFT; 465 ppdu_info->he_data3 |= value; 466 467 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_DCM); 468 he_dcm = value; 469 value = value << HE_DCM_SHIFT; 470 ppdu_info->he_data3 |= value; 471 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_CODING); 472 value = value << HE_CODING_SHIFT; 473 ppdu_info->he_data3 |= value; 474 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_LDPC_EXTRA); 475 value = value << HE_LDPC_EXTRA_SYMBOL_SHIFT; 476 ppdu_info->he_data3 |= value; 477 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_STBC); 478 he_stbc = value; 479 value = value << HE_STBC_SHIFT; 480 ppdu_info->he_data3 |= value; 481 482 /* data4 */ 483 ppdu_info->he_data4 = u32_get_bits(info0, 484 HAL_RX_HE_SIG_A_SU_INFO_INFO0_SPATIAL_REUSE); 485 486 /* data5 */ 487 value = u32_get_bits(info0, 488 HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_BW); 489 ppdu_info->he_data5 = value; 490 ppdu_info->bw = value; 491 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_CP_LTF_SIZE); 492 switch (value) { 493 case 0: 494 he_gi = HE_GI_0_8; 495 he_ltf = HE_LTF_1_X; 496 break; 497 case 1: 498 he_gi = HE_GI_0_8; 499 he_ltf = HE_LTF_2_X; 500 break; 501 case 2: 502 he_gi = HE_GI_1_6; 503 he_ltf = HE_LTF_2_X; 504 break; 505 case 3: 506 if (he_dcm && he_stbc) { 507 he_gi = HE_GI_0_8; 508 he_ltf = HE_LTF_4_X; 509 } else { 510 he_gi = HE_GI_3_2; 511 he_ltf = HE_LTF_4_X; 512 } 513 break; 514 } 515 ppdu_info->gi = he_gi; 516 value = he_gi << HE_GI_SHIFT; 517 ppdu_info->he_data5 |= value; 518 value = he_ltf << HE_LTF_SIZE_SHIFT; 519 ppdu_info->ltf_size = he_ltf; 520 ppdu_info->he_data5 |= value; 521 522 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_NSTS); 523 value = (value << HE_LTF_SYM_SHIFT); 524 ppdu_info->he_data5 |= value; 525 526 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_PKT_EXT_FACTOR); 527 value = value << HE_PRE_FEC_PAD_SHIFT; 528 ppdu_info->he_data5 |= value; 529 530 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_TXBF); 531 value = value << HE_TXBF_SHIFT; 532 ppdu_info->he_data5 |= value; 533 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_PKT_EXT_PE_DISAM); 534 value = value << HE_PE_DISAMBIGUITY_SHIFT; 535 ppdu_info->he_data5 |= value; 536 537 /* data6 */ 538 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_NSTS); 539 value++; 540 ppdu_info->he_data6 = value; 541 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_DOPPLER_IND); 542 value = value << HE_DOPPLER_SHIFT; 543 ppdu_info->he_data6 |= value; 544 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_TXOP_DURATION); 545 value = value << HE_TXOP_SHIFT; 546 ppdu_info->he_data6 |= value; 547 548 ppdu_info->mcs = 549 u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_MCS); 550 ppdu_info->bw = 551 u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_BW); 552 ppdu_info->ldpc = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_CODING); 553 ppdu_info->is_stbc = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_STBC); 554 ppdu_info->beamformed = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_TXBF); 555 dcm = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_DCM); 556 ppdu_info->nss = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_NSTS); 557 ppdu_info->dcm = dcm; 558 } 559 560 static void 561 ath12k_dp_mon_hal_rx_parse_u_sig_cmn(const struct hal_mon_usig_cmn *cmn, 562 struct hal_rx_mon_ppdu_info *ppdu_info) 563 { 564 u32 common; 565 566 ppdu_info->u_sig_info.bw = le32_get_bits(cmn->info0, 567 HAL_RX_USIG_CMN_INFO0_BW); 568 ppdu_info->u_sig_info.ul_dl = le32_get_bits(cmn->info0, 569 HAL_RX_USIG_CMN_INFO0_UL_DL); 570 571 common = __le32_to_cpu(ppdu_info->u_sig_info.usig.common); 572 common |= IEEE80211_RADIOTAP_EHT_USIG_COMMON_PHY_VER_KNOWN | 573 IEEE80211_RADIOTAP_EHT_USIG_COMMON_BW_KNOWN | 574 IEEE80211_RADIOTAP_EHT_USIG_COMMON_UL_DL_KNOWN | 575 IEEE80211_RADIOTAP_EHT_USIG_COMMON_BSS_COLOR_KNOWN | 576 IEEE80211_RADIOTAP_EHT_USIG_COMMON_TXOP_KNOWN | 577 ATH12K_LE32_DEC_ENC(cmn->info0, 578 HAL_RX_USIG_CMN_INFO0_PHY_VERSION, 579 IEEE80211_RADIOTAP_EHT_USIG_COMMON_PHY_VER) | 580 u32_encode_bits(ppdu_info->u_sig_info.bw, 581 IEEE80211_RADIOTAP_EHT_USIG_COMMON_BW) | 582 u32_encode_bits(ppdu_info->u_sig_info.ul_dl, 583 IEEE80211_RADIOTAP_EHT_USIG_COMMON_UL_DL) | 584 ATH12K_LE32_DEC_ENC(cmn->info0, 585 HAL_RX_USIG_CMN_INFO0_BSS_COLOR, 586 IEEE80211_RADIOTAP_EHT_USIG_COMMON_BSS_COLOR) | 587 ATH12K_LE32_DEC_ENC(cmn->info0, 588 HAL_RX_USIG_CMN_INFO0_TXOP, 589 IEEE80211_RADIOTAP_EHT_USIG_COMMON_TXOP); 590 ppdu_info->u_sig_info.usig.common = cpu_to_le32(common); 591 592 switch (ppdu_info->u_sig_info.bw) { 593 default: 594 fallthrough; 595 case HAL_EHT_BW_20: 596 ppdu_info->bw = HAL_RX_BW_20MHZ; 597 break; 598 case HAL_EHT_BW_40: 599 ppdu_info->bw = HAL_RX_BW_40MHZ; 600 break; 601 case HAL_EHT_BW_80: 602 ppdu_info->bw = HAL_RX_BW_80MHZ; 603 break; 604 case HAL_EHT_BW_160: 605 ppdu_info->bw = HAL_RX_BW_160MHZ; 606 break; 607 case HAL_EHT_BW_320_1: 608 case HAL_EHT_BW_320_2: 609 ppdu_info->bw = HAL_RX_BW_320MHZ; 610 break; 611 } 612 } 613 614 static void 615 ath12k_dp_mon_hal_rx_parse_u_sig_tb(const struct hal_mon_usig_tb *usig_tb, 616 struct hal_rx_mon_ppdu_info *ppdu_info) 617 { 618 struct ieee80211_radiotap_eht_usig *usig = &ppdu_info->u_sig_info.usig; 619 enum ieee80211_radiotap_eht_usig_tb spatial_reuse1, spatial_reuse2; 620 u32 common, value, mask; 621 622 spatial_reuse1 = IEEE80211_RADIOTAP_EHT_USIG2_TB_B3_B6_SPATIAL_REUSE_1; 623 spatial_reuse2 = IEEE80211_RADIOTAP_EHT_USIG2_TB_B7_B10_SPATIAL_REUSE_2; 624 625 common = __le32_to_cpu(usig->common); 626 value = __le32_to_cpu(usig->value); 627 mask = __le32_to_cpu(usig->mask); 628 629 ppdu_info->u_sig_info.ppdu_type_comp_mode = 630 le32_get_bits(usig_tb->info0, 631 HAL_RX_USIG_TB_INFO0_PPDU_TYPE_COMP_MODE); 632 633 common |= ATH12K_LE32_DEC_ENC(usig_tb->info0, 634 HAL_RX_USIG_TB_INFO0_RX_INTEG_CHECK_PASS, 635 IEEE80211_RADIOTAP_EHT_USIG_COMMON_BAD_USIG_CRC); 636 637 value |= IEEE80211_RADIOTAP_EHT_USIG1_TB_B20_B25_DISREGARD | 638 u32_encode_bits(ppdu_info->u_sig_info.ppdu_type_comp_mode, 639 IEEE80211_RADIOTAP_EHT_USIG2_TB_B0_B1_PPDU_TYPE) | 640 IEEE80211_RADIOTAP_EHT_USIG2_TB_B2_VALIDATE | 641 ATH12K_LE32_DEC_ENC(usig_tb->info0, 642 HAL_RX_USIG_TB_INFO0_SPATIAL_REUSE_1, 643 spatial_reuse1) | 644 ATH12K_LE32_DEC_ENC(usig_tb->info0, 645 HAL_RX_USIG_TB_INFO0_SPATIAL_REUSE_2, 646 spatial_reuse2) | 647 IEEE80211_RADIOTAP_EHT_USIG2_TB_B11_B15_DISREGARD | 648 ATH12K_LE32_DEC_ENC(usig_tb->info0, 649 HAL_RX_USIG_TB_INFO0_CRC, 650 IEEE80211_RADIOTAP_EHT_USIG2_TB_B16_B19_CRC) | 651 ATH12K_LE32_DEC_ENC(usig_tb->info0, 652 HAL_RX_USIG_TB_INFO0_TAIL, 653 IEEE80211_RADIOTAP_EHT_USIG2_TB_B20_B25_TAIL); 654 655 mask |= IEEE80211_RADIOTAP_EHT_USIG1_TB_B20_B25_DISREGARD | 656 IEEE80211_RADIOTAP_EHT_USIG2_TB_B0_B1_PPDU_TYPE | 657 IEEE80211_RADIOTAP_EHT_USIG2_TB_B2_VALIDATE | 658 spatial_reuse1 | spatial_reuse2 | 659 IEEE80211_RADIOTAP_EHT_USIG2_TB_B11_B15_DISREGARD | 660 IEEE80211_RADIOTAP_EHT_USIG2_TB_B16_B19_CRC | 661 IEEE80211_RADIOTAP_EHT_USIG2_TB_B20_B25_TAIL; 662 663 usig->common = cpu_to_le32(common); 664 usig->value = cpu_to_le32(value); 665 usig->mask = cpu_to_le32(mask); 666 } 667 668 static void 669 ath12k_dp_mon_hal_rx_parse_u_sig_mu(const struct hal_mon_usig_mu *usig_mu, 670 struct hal_rx_mon_ppdu_info *ppdu_info) 671 { 672 struct ieee80211_radiotap_eht_usig *usig = &ppdu_info->u_sig_info.usig; 673 enum ieee80211_radiotap_eht_usig_mu sig_symb, punc; 674 u32 common, value, mask; 675 676 sig_symb = IEEE80211_RADIOTAP_EHT_USIG2_MU_B11_B15_EHT_SIG_SYMBOLS; 677 punc = IEEE80211_RADIOTAP_EHT_USIG2_MU_B3_B7_PUNCTURED_INFO; 678 679 common = __le32_to_cpu(usig->common); 680 value = __le32_to_cpu(usig->value); 681 mask = __le32_to_cpu(usig->mask); 682 683 ppdu_info->u_sig_info.ppdu_type_comp_mode = 684 le32_get_bits(usig_mu->info0, 685 HAL_RX_USIG_MU_INFO0_PPDU_TYPE_COMP_MODE); 686 ppdu_info->u_sig_info.eht_sig_mcs = 687 le32_get_bits(usig_mu->info0, 688 HAL_RX_USIG_MU_INFO0_EHT_SIG_MCS); 689 ppdu_info->u_sig_info.num_eht_sig_sym = 690 le32_get_bits(usig_mu->info0, 691 HAL_RX_USIG_MU_INFO0_NUM_EHT_SIG_SYM); 692 693 common |= ATH12K_LE32_DEC_ENC(usig_mu->info0, 694 HAL_RX_USIG_MU_INFO0_RX_INTEG_CHECK_PASS, 695 IEEE80211_RADIOTAP_EHT_USIG_COMMON_BAD_USIG_CRC); 696 697 value |= IEEE80211_RADIOTAP_EHT_USIG1_MU_B20_B24_DISREGARD | 698 IEEE80211_RADIOTAP_EHT_USIG1_MU_B25_VALIDATE | 699 u32_encode_bits(ppdu_info->u_sig_info.ppdu_type_comp_mode, 700 IEEE80211_RADIOTAP_EHT_USIG2_MU_B0_B1_PPDU_TYPE) | 701 IEEE80211_RADIOTAP_EHT_USIG2_MU_B2_VALIDATE | 702 ATH12K_LE32_DEC_ENC(usig_mu->info0, 703 HAL_RX_USIG_MU_INFO0_PUNC_CH_INFO, 704 punc) | 705 IEEE80211_RADIOTAP_EHT_USIG2_MU_B8_VALIDATE | 706 u32_encode_bits(ppdu_info->u_sig_info.eht_sig_mcs, 707 IEEE80211_RADIOTAP_EHT_USIG2_MU_B9_B10_SIG_MCS) | 708 u32_encode_bits(ppdu_info->u_sig_info.num_eht_sig_sym, 709 sig_symb) | 710 ATH12K_LE32_DEC_ENC(usig_mu->info0, 711 HAL_RX_USIG_MU_INFO0_CRC, 712 IEEE80211_RADIOTAP_EHT_USIG2_MU_B16_B19_CRC) | 713 ATH12K_LE32_DEC_ENC(usig_mu->info0, 714 HAL_RX_USIG_MU_INFO0_TAIL, 715 IEEE80211_RADIOTAP_EHT_USIG2_MU_B20_B25_TAIL); 716 717 mask |= IEEE80211_RADIOTAP_EHT_USIG1_MU_B20_B24_DISREGARD | 718 IEEE80211_RADIOTAP_EHT_USIG1_MU_B25_VALIDATE | 719 IEEE80211_RADIOTAP_EHT_USIG2_MU_B0_B1_PPDU_TYPE | 720 IEEE80211_RADIOTAP_EHT_USIG2_MU_B2_VALIDATE | 721 punc | 722 IEEE80211_RADIOTAP_EHT_USIG2_MU_B8_VALIDATE | 723 IEEE80211_RADIOTAP_EHT_USIG2_MU_B9_B10_SIG_MCS | 724 sig_symb | 725 IEEE80211_RADIOTAP_EHT_USIG2_MU_B16_B19_CRC | 726 IEEE80211_RADIOTAP_EHT_USIG2_MU_B20_B25_TAIL; 727 728 usig->common = cpu_to_le32(common); 729 usig->value = cpu_to_le32(value); 730 usig->mask = cpu_to_le32(mask); 731 } 732 733 static void 734 ath12k_dp_mon_hal_rx_parse_u_sig_hdr(const struct hal_mon_usig_hdr *usig, 735 struct hal_rx_mon_ppdu_info *ppdu_info) 736 { 737 u8 comp_mode; 738 739 ppdu_info->eht_usig = true; 740 741 ath12k_dp_mon_hal_rx_parse_u_sig_cmn(&usig->cmn, ppdu_info); 742 743 comp_mode = le32_get_bits(usig->non_cmn.mu.info0, 744 HAL_RX_USIG_MU_INFO0_PPDU_TYPE_COMP_MODE); 745 746 if (comp_mode == 0 && ppdu_info->u_sig_info.ul_dl) 747 ath12k_dp_mon_hal_rx_parse_u_sig_tb(&usig->non_cmn.tb, ppdu_info); 748 else 749 ath12k_dp_mon_hal_rx_parse_u_sig_mu(&usig->non_cmn.mu, ppdu_info); 750 } 751 752 static void 753 ath12k_dp_mon_hal_aggr_tlv(struct hal_rx_mon_ppdu_info *ppdu_info, 754 u16 tlv_len, const void *tlv_data) 755 { 756 if (tlv_len <= HAL_RX_MON_MAX_AGGR_SIZE - ppdu_info->tlv_aggr.cur_len) { 757 memcpy(ppdu_info->tlv_aggr.buf + ppdu_info->tlv_aggr.cur_len, 758 tlv_data, tlv_len); 759 ppdu_info->tlv_aggr.cur_len += tlv_len; 760 } 761 } 762 763 static inline bool 764 ath12k_dp_mon_hal_rx_is_frame_type_ndp(const struct hal_rx_u_sig_info *usig_info) 765 { 766 if (usig_info->ppdu_type_comp_mode == 1 && 767 usig_info->eht_sig_mcs == 0 && 768 usig_info->num_eht_sig_sym == 0) 769 return true; 770 771 return false; 772 } 773 774 static inline bool 775 ath12k_dp_mon_hal_rx_is_non_ofdma(const struct hal_rx_u_sig_info *usig_info) 776 { 777 u32 ppdu_type_comp_mode = usig_info->ppdu_type_comp_mode; 778 u32 ul_dl = usig_info->ul_dl; 779 780 if ((ppdu_type_comp_mode == HAL_RX_RECEPTION_TYPE_MU_MIMO && ul_dl == 0) || 781 (ppdu_type_comp_mode == HAL_RX_RECEPTION_TYPE_MU_OFDMA && ul_dl == 0) || 782 (ppdu_type_comp_mode == HAL_RX_RECEPTION_TYPE_MU_MIMO && ul_dl == 1)) 783 return true; 784 785 return false; 786 } 787 788 static inline bool 789 ath12k_dp_mon_hal_rx_is_ofdma(const struct hal_rx_u_sig_info *usig_info) 790 { 791 if (usig_info->ppdu_type_comp_mode == 0 && usig_info->ul_dl == 0) 792 return true; 793 794 return false; 795 } 796 797 static void 798 ath12k_dp_mon_hal_rx_parse_eht_sig_ndp(const struct hal_eht_sig_ndp_cmn_eb *eht_sig_ndp, 799 struct hal_rx_mon_ppdu_info *ppdu_info) 800 { 801 struct hal_rx_radiotap_eht *eht = &ppdu_info->eht_info.eht; 802 u32 known, data; 803 804 known = __le32_to_cpu(eht->known); 805 known |= IEEE80211_RADIOTAP_EHT_KNOWN_SPATIAL_REUSE | 806 IEEE80211_RADIOTAP_EHT_KNOWN_EHT_LTF | 807 IEEE80211_RADIOTAP_EHT_KNOWN_NSS_S | 808 IEEE80211_RADIOTAP_EHT_KNOWN_BEAMFORMED_S | 809 IEEE80211_RADIOTAP_EHT_KNOWN_DISREGARD_S | 810 IEEE80211_RADIOTAP_EHT_KNOWN_CRC1 | 811 IEEE80211_RADIOTAP_EHT_KNOWN_TAIL1; 812 eht->known = cpu_to_le32(known); 813 814 data = __le32_to_cpu(eht->data[0]); 815 data |= ATH12K_LE32_DEC_ENC(eht_sig_ndp->info0, 816 HAL_RX_EHT_SIG_NDP_CMN_INFO0_SPATIAL_REUSE, 817 IEEE80211_RADIOTAP_EHT_DATA0_SPATIAL_REUSE); 818 /* GI and LTF size are separately indicated in radiotap header 819 * and hence will be parsed from other TLV 820 */ 821 data |= ATH12K_LE32_DEC_ENC(eht_sig_ndp->info0, 822 HAL_RX_EHT_SIG_NDP_CMN_INFO0_NUM_LTF_SYM, 823 IEEE80211_RADIOTAP_EHT_DATA0_EHT_LTF); 824 825 data |= ATH12K_LE32_DEC_ENC(eht_sig_ndp->info0, 826 HAL_RX_EHT_SIG_NDP_CMN_INFO0_CRC, 827 IEEE80211_RADIOTAP_EHT_DATA0_CRC1_O); 828 829 data |= ATH12K_LE32_DEC_ENC(eht_sig_ndp->info0, 830 HAL_RX_EHT_SIG_NDP_CMN_INFO0_DISREGARD, 831 IEEE80211_RADIOTAP_EHT_DATA0_DISREGARD_S); 832 eht->data[0] = cpu_to_le32(data); 833 834 data = __le32_to_cpu(eht->data[7]); 835 data |= ATH12K_LE32_DEC_ENC(eht_sig_ndp->info0, 836 HAL_RX_EHT_SIG_NDP_CMN_INFO0_NSS, 837 IEEE80211_RADIOTAP_EHT_DATA7_NSS_S); 838 839 data |= ATH12K_LE32_DEC_ENC(eht_sig_ndp->info0, 840 HAL_RX_EHT_SIG_NDP_CMN_INFO0_BEAMFORMED, 841 IEEE80211_RADIOTAP_EHT_DATA7_BEAMFORMED_S); 842 eht->data[7] = cpu_to_le32(data); 843 } 844 845 static void 846 ath12k_dp_mon_hal_rx_parse_usig_overflow(const struct hal_eht_sig_usig_overflow *ovflow, 847 struct hal_rx_mon_ppdu_info *ppdu_info) 848 { 849 struct hal_rx_radiotap_eht *eht = &ppdu_info->eht_info.eht; 850 u32 known, data; 851 852 known = __le32_to_cpu(eht->known); 853 known |= IEEE80211_RADIOTAP_EHT_KNOWN_SPATIAL_REUSE | 854 IEEE80211_RADIOTAP_EHT_KNOWN_EHT_LTF | 855 IEEE80211_RADIOTAP_EHT_KNOWN_LDPC_EXTRA_SYM_OM | 856 IEEE80211_RADIOTAP_EHT_KNOWN_PRE_PADD_FACOR_OM | 857 IEEE80211_RADIOTAP_EHT_KNOWN_PE_DISAMBIGUITY_OM | 858 IEEE80211_RADIOTAP_EHT_KNOWN_DISREGARD_O; 859 eht->known = cpu_to_le32(known); 860 861 data = __le32_to_cpu(eht->data[0]); 862 data |= ATH12K_LE32_DEC_ENC(ovflow->info0, 863 HAL_RX_EHT_SIG_OVERFLOW_INFO0_SPATIAL_REUSE, 864 IEEE80211_RADIOTAP_EHT_DATA0_SPATIAL_REUSE); 865 866 /* GI and LTF size are separately indicated in radiotap header 867 * and hence will be parsed from other TLV 868 */ 869 data |= ATH12K_LE32_DEC_ENC(ovflow->info0, 870 HAL_RX_EHT_SIG_OVERFLOW_INFO0_NUM_LTF_SYM, 871 IEEE80211_RADIOTAP_EHT_DATA0_EHT_LTF); 872 873 data |= ATH12K_LE32_DEC_ENC(ovflow->info0, 874 HAL_RX_EHT_SIG_OVERFLOW_INFO0_LDPC_EXTA_SYM, 875 IEEE80211_RADIOTAP_EHT_DATA0_LDPC_EXTRA_SYM_OM); 876 877 data |= ATH12K_LE32_DEC_ENC(ovflow->info0, 878 HAL_RX_EHT_SIG_OVERFLOW_INFO0_PRE_FEC_PAD_FACTOR, 879 IEEE80211_RADIOTAP_EHT_DATA0_PRE_PADD_FACOR_OM); 880 881 data |= ATH12K_LE32_DEC_ENC(ovflow->info0, 882 HAL_RX_EHT_SIG_OVERFLOW_INFO0_DISAMBIGUITY, 883 IEEE80211_RADIOTAP_EHT_DATA0_PE_DISAMBIGUITY_OM); 884 885 data |= ATH12K_LE32_DEC_ENC(ovflow->info0, 886 HAL_RX_EHT_SIG_OVERFLOW_INFO0_DISREGARD, 887 IEEE80211_RADIOTAP_EHT_DATA0_DISREGARD_O); 888 eht->data[0] = cpu_to_le32(data); 889 } 890 891 static void 892 ath12k_dp_mon_hal_rx_parse_non_ofdma_users(const struct hal_eht_sig_non_ofdma_cmn_eb *eb, 893 struct hal_rx_mon_ppdu_info *ppdu_info) 894 { 895 struct hal_rx_radiotap_eht *eht = &ppdu_info->eht_info.eht; 896 u32 known, data; 897 898 known = __le32_to_cpu(eht->known); 899 known |= IEEE80211_RADIOTAP_EHT_KNOWN_NR_NON_OFDMA_USERS_M; 900 eht->known = cpu_to_le32(known); 901 902 data = __le32_to_cpu(eht->data[7]); 903 data |= ATH12K_LE32_DEC_ENC(eb->info0, 904 HAL_RX_EHT_SIG_NON_OFDMA_INFO0_NUM_USERS, 905 IEEE80211_RADIOTAP_EHT_DATA7_NUM_OF_NON_OFDMA_USERS); 906 eht->data[7] = cpu_to_le32(data); 907 } 908 909 static void 910 ath12k_dp_mon_hal_rx_parse_eht_mumimo_user(const struct hal_eht_sig_mu_mimo *user, 911 struct hal_rx_mon_ppdu_info *ppdu_info) 912 { 913 struct hal_rx_eht_info *eht_info = &ppdu_info->eht_info; 914 u32 user_idx; 915 916 if (eht_info->num_user_info >= ARRAY_SIZE(eht_info->user_info)) 917 return; 918 919 user_idx = eht_info->num_user_info++; 920 921 eht_info->user_info[user_idx] |= 922 IEEE80211_RADIOTAP_EHT_USER_INFO_STA_ID_KNOWN | 923 IEEE80211_RADIOTAP_EHT_USER_INFO_MCS_KNOWN | 924 IEEE80211_RADIOTAP_EHT_USER_INFO_CODING_KNOWN | 925 IEEE80211_RADIOTAP_EHT_USER_INFO_SPATIAL_CONFIG_KNOWN_M | 926 ATH12K_LE32_DEC_ENC(user->info0, 927 HAL_RX_EHT_SIG_MUMIMO_USER_INFO0_STA_ID, 928 IEEE80211_RADIOTAP_EHT_USER_INFO_STA_ID) | 929 ATH12K_LE32_DEC_ENC(user->info0, 930 HAL_RX_EHT_SIG_MUMIMO_USER_INFO0_CODING, 931 IEEE80211_RADIOTAP_EHT_USER_INFO_CODING) | 932 ATH12K_LE32_DEC_ENC(user->info0, 933 HAL_RX_EHT_SIG_MUMIMO_USER_INFO0_MCS, 934 IEEE80211_RADIOTAP_EHT_USER_INFO_MCS) | 935 ATH12K_LE32_DEC_ENC(user->info0, 936 HAL_RX_EHT_SIG_MUMIMO_USER_INFO0_SPATIAL_CODING, 937 IEEE80211_RADIOTAP_EHT_USER_INFO_SPATIAL_CONFIG_M); 938 939 ppdu_info->mcs = le32_get_bits(user->info0, 940 HAL_RX_EHT_SIG_MUMIMO_USER_INFO0_MCS); 941 } 942 943 static void 944 ath12k_dp_mon_hal_rx_parse_eht_non_mumimo_user(const struct hal_eht_sig_non_mu_mimo *user, 945 struct hal_rx_mon_ppdu_info *ppdu_info) 946 { 947 struct hal_rx_eht_info *eht_info = &ppdu_info->eht_info; 948 u32 user_idx; 949 950 if (eht_info->num_user_info >= ARRAY_SIZE(eht_info->user_info)) 951 return; 952 953 user_idx = eht_info->num_user_info++; 954 955 eht_info->user_info[user_idx] |= 956 IEEE80211_RADIOTAP_EHT_USER_INFO_STA_ID_KNOWN | 957 IEEE80211_RADIOTAP_EHT_USER_INFO_MCS_KNOWN | 958 IEEE80211_RADIOTAP_EHT_USER_INFO_CODING_KNOWN | 959 IEEE80211_RADIOTAP_EHT_USER_INFO_NSS_KNOWN_O | 960 IEEE80211_RADIOTAP_EHT_USER_INFO_BEAMFORMING_KNOWN_O | 961 ATH12K_LE32_DEC_ENC(user->info0, 962 HAL_RX_EHT_SIG_NON_MUMIMO_USER_INFO0_STA_ID, 963 IEEE80211_RADIOTAP_EHT_USER_INFO_STA_ID) | 964 ATH12K_LE32_DEC_ENC(user->info0, 965 HAL_RX_EHT_SIG_NON_MUMIMO_USER_INFO0_CODING, 966 IEEE80211_RADIOTAP_EHT_USER_INFO_CODING) | 967 ATH12K_LE32_DEC_ENC(user->info0, 968 HAL_RX_EHT_SIG_NON_MUMIMO_USER_INFO0_MCS, 969 IEEE80211_RADIOTAP_EHT_USER_INFO_MCS) | 970 ATH12K_LE32_DEC_ENC(user->info0, 971 HAL_RX_EHT_SIG_NON_MUMIMO_USER_INFO0_NSS, 972 IEEE80211_RADIOTAP_EHT_USER_INFO_NSS_O) | 973 ATH12K_LE32_DEC_ENC(user->info0, 974 HAL_RX_EHT_SIG_NON_MUMIMO_USER_INFO0_BEAMFORMED, 975 IEEE80211_RADIOTAP_EHT_USER_INFO_BEAMFORMING_O); 976 977 ppdu_info->mcs = le32_get_bits(user->info0, 978 HAL_RX_EHT_SIG_NON_MUMIMO_USER_INFO0_MCS); 979 980 ppdu_info->nss = le32_get_bits(user->info0, 981 HAL_RX_EHT_SIG_NON_MUMIMO_USER_INFO0_NSS) + 1; 982 } 983 984 static inline bool 985 ath12k_dp_mon_hal_rx_is_mu_mimo_user(const struct hal_rx_u_sig_info *usig_info) 986 { 987 if (usig_info->ppdu_type_comp_mode == HAL_RX_RECEPTION_TYPE_SU && 988 usig_info->ul_dl == 1) 989 return true; 990 991 return false; 992 } 993 994 static void 995 ath12k_dp_mon_hal_rx_parse_eht_sig_non_ofdma(const void *tlv, 996 struct hal_rx_mon_ppdu_info *ppdu_info) 997 { 998 const struct hal_eht_sig_non_ofdma_cmn_eb *eb = tlv; 999 1000 ath12k_dp_mon_hal_rx_parse_usig_overflow(tlv, ppdu_info); 1001 ath12k_dp_mon_hal_rx_parse_non_ofdma_users(eb, ppdu_info); 1002 1003 if (ath12k_dp_mon_hal_rx_is_mu_mimo_user(&ppdu_info->u_sig_info)) 1004 ath12k_dp_mon_hal_rx_parse_eht_mumimo_user(&eb->user_field.mu_mimo, 1005 ppdu_info); 1006 else 1007 ath12k_dp_mon_hal_rx_parse_eht_non_mumimo_user(&eb->user_field.n_mu_mimo, 1008 ppdu_info); 1009 } 1010 1011 static void 1012 ath12k_dp_mon_hal_rx_parse_ru_allocation(const struct hal_eht_sig_ofdma_cmn_eb *eb, 1013 struct hal_rx_mon_ppdu_info *ppdu_info) 1014 { 1015 const struct hal_eht_sig_ofdma_cmn_eb1 *ofdma_cmn_eb1 = &eb->eb1; 1016 const struct hal_eht_sig_ofdma_cmn_eb2 *ofdma_cmn_eb2 = &eb->eb2; 1017 struct hal_rx_radiotap_eht *eht = &ppdu_info->eht_info.eht; 1018 enum ieee80211_radiotap_eht_data ru_123, ru_124, ru_125, ru_126; 1019 enum ieee80211_radiotap_eht_data ru_121, ru_122, ru_112, ru_111; 1020 u32 data; 1021 1022 ru_123 = IEEE80211_RADIOTAP_EHT_DATA4_RU_ALLOC_CC_1_2_3; 1023 ru_124 = IEEE80211_RADIOTAP_EHT_DATA5_RU_ALLOC_CC_1_2_4; 1024 ru_125 = IEEE80211_RADIOTAP_EHT_DATA5_RU_ALLOC_CC_1_2_5; 1025 ru_126 = IEEE80211_RADIOTAP_EHT_DATA6_RU_ALLOC_CC_1_2_6; 1026 ru_121 = IEEE80211_RADIOTAP_EHT_DATA3_RU_ALLOC_CC_1_2_1; 1027 ru_122 = IEEE80211_RADIOTAP_EHT_DATA3_RU_ALLOC_CC_1_2_2; 1028 ru_112 = IEEE80211_RADIOTAP_EHT_DATA2_RU_ALLOC_CC_1_1_2; 1029 ru_111 = IEEE80211_RADIOTAP_EHT_DATA1_RU_ALLOC_CC_1_1_1; 1030 1031 switch (ppdu_info->u_sig_info.bw) { 1032 case HAL_EHT_BW_320_2: 1033 case HAL_EHT_BW_320_1: 1034 data = __le32_to_cpu(eht->data[4]); 1035 /* CC1 2::3 */ 1036 data |= IEEE80211_RADIOTAP_EHT_DATA4_RU_ALLOC_CC_1_2_3_KNOWN | 1037 ATH12K_LE64_DEC_ENC(ofdma_cmn_eb2->info0, 1038 HAL_RX_EHT_SIG_OFDMA_EB2_RU_ALLOC_2_3, 1039 ru_123); 1040 eht->data[4] = cpu_to_le32(data); 1041 1042 data = __le32_to_cpu(eht->data[5]); 1043 /* CC1 2::4 */ 1044 data |= IEEE80211_RADIOTAP_EHT_DATA5_RU_ALLOC_CC_1_2_4_KNOWN | 1045 ATH12K_LE64_DEC_ENC(ofdma_cmn_eb2->info0, 1046 HAL_RX_EHT_SIG_OFDMA_EB2_RU_ALLOC_2_4, 1047 ru_124); 1048 1049 /* CC1 2::5 */ 1050 data |= IEEE80211_RADIOTAP_EHT_DATA5_RU_ALLOC_CC_1_2_5_KNOWN | 1051 ATH12K_LE64_DEC_ENC(ofdma_cmn_eb2->info0, 1052 HAL_RX_EHT_SIG_OFDMA_EB2_RU_ALLOC_2_5, 1053 ru_125); 1054 eht->data[5] = cpu_to_le32(data); 1055 1056 data = __le32_to_cpu(eht->data[6]); 1057 /* CC1 2::6 */ 1058 data |= IEEE80211_RADIOTAP_EHT_DATA6_RU_ALLOC_CC_1_2_6_KNOWN | 1059 ATH12K_LE64_DEC_ENC(ofdma_cmn_eb2->info0, 1060 HAL_RX_EHT_SIG_OFDMA_EB2_RU_ALLOC_2_6, 1061 ru_126); 1062 eht->data[6] = cpu_to_le32(data); 1063 1064 fallthrough; 1065 case HAL_EHT_BW_160: 1066 data = __le32_to_cpu(eht->data[3]); 1067 /* CC1 2::1 */ 1068 data |= IEEE80211_RADIOTAP_EHT_DATA3_RU_ALLOC_CC_1_2_1_KNOWN | 1069 ATH12K_LE64_DEC_ENC(ofdma_cmn_eb2->info0, 1070 HAL_RX_EHT_SIG_OFDMA_EB2_RU_ALLOC_2_1, 1071 ru_121); 1072 /* CC1 2::2 */ 1073 data |= IEEE80211_RADIOTAP_EHT_DATA3_RU_ALLOC_CC_1_2_2_KNOWN | 1074 ATH12K_LE64_DEC_ENC(ofdma_cmn_eb2->info0, 1075 HAL_RX_EHT_SIG_OFDMA_EB2_RU_ALLOC_2_2, 1076 ru_122); 1077 eht->data[3] = cpu_to_le32(data); 1078 1079 fallthrough; 1080 case HAL_EHT_BW_80: 1081 data = __le32_to_cpu(eht->data[2]); 1082 /* CC1 1::2 */ 1083 data |= IEEE80211_RADIOTAP_EHT_DATA2_RU_ALLOC_CC_1_1_2_KNOWN | 1084 ATH12K_LE64_DEC_ENC(ofdma_cmn_eb1->info0, 1085 HAL_RX_EHT_SIG_OFDMA_EB1_RU_ALLOC_1_2, 1086 ru_112); 1087 eht->data[2] = cpu_to_le32(data); 1088 1089 fallthrough; 1090 case HAL_EHT_BW_40: 1091 fallthrough; 1092 case HAL_EHT_BW_20: 1093 data = __le32_to_cpu(eht->data[1]); 1094 /* CC1 1::1 */ 1095 data |= IEEE80211_RADIOTAP_EHT_DATA1_RU_ALLOC_CC_1_1_1_KNOWN | 1096 ATH12K_LE64_DEC_ENC(ofdma_cmn_eb1->info0, 1097 HAL_RX_EHT_SIG_OFDMA_EB1_RU_ALLOC_1_1, 1098 ru_111); 1099 eht->data[1] = cpu_to_le32(data); 1100 break; 1101 default: 1102 break; 1103 } 1104 } 1105 1106 static void 1107 ath12k_dp_mon_hal_rx_parse_eht_sig_ofdma(const void *tlv, 1108 struct hal_rx_mon_ppdu_info *ppdu_info) 1109 { 1110 const struct hal_eht_sig_ofdma_cmn_eb *ofdma = tlv; 1111 1112 ath12k_dp_mon_hal_rx_parse_usig_overflow(tlv, ppdu_info); 1113 ath12k_dp_mon_hal_rx_parse_ru_allocation(ofdma, ppdu_info); 1114 1115 ath12k_dp_mon_hal_rx_parse_eht_non_mumimo_user(&ofdma->user_field.n_mu_mimo, 1116 ppdu_info); 1117 } 1118 1119 static void 1120 ath12k_dp_mon_parse_eht_sig_hdr(struct hal_rx_mon_ppdu_info *ppdu_info, 1121 const void *tlv_data) 1122 { 1123 ppdu_info->is_eht = true; 1124 1125 if (ath12k_dp_mon_hal_rx_is_frame_type_ndp(&ppdu_info->u_sig_info)) 1126 ath12k_dp_mon_hal_rx_parse_eht_sig_ndp(tlv_data, ppdu_info); 1127 else if (ath12k_dp_mon_hal_rx_is_non_ofdma(&ppdu_info->u_sig_info)) 1128 ath12k_dp_mon_hal_rx_parse_eht_sig_non_ofdma(tlv_data, ppdu_info); 1129 else if (ath12k_dp_mon_hal_rx_is_ofdma(&ppdu_info->u_sig_info)) 1130 ath12k_dp_mon_hal_rx_parse_eht_sig_ofdma(tlv_data, ppdu_info); 1131 } 1132 1133 static inline enum ath12k_eht_ru_size 1134 hal_rx_mon_hal_ru_size_to_ath12k_ru_size(u32 hal_ru_size) 1135 { 1136 switch (hal_ru_size) { 1137 case HAL_EHT_RU_26: 1138 return ATH12K_EHT_RU_26; 1139 case HAL_EHT_RU_52: 1140 return ATH12K_EHT_RU_52; 1141 case HAL_EHT_RU_78: 1142 return ATH12K_EHT_RU_52_26; 1143 case HAL_EHT_RU_106: 1144 return ATH12K_EHT_RU_106; 1145 case HAL_EHT_RU_132: 1146 return ATH12K_EHT_RU_106_26; 1147 case HAL_EHT_RU_242: 1148 return ATH12K_EHT_RU_242; 1149 case HAL_EHT_RU_484: 1150 return ATH12K_EHT_RU_484; 1151 case HAL_EHT_RU_726: 1152 return ATH12K_EHT_RU_484_242; 1153 case HAL_EHT_RU_996: 1154 return ATH12K_EHT_RU_996; 1155 case HAL_EHT_RU_996x2: 1156 return ATH12K_EHT_RU_996x2; 1157 case HAL_EHT_RU_996x3: 1158 return ATH12K_EHT_RU_996x3; 1159 case HAL_EHT_RU_996x4: 1160 return ATH12K_EHT_RU_996x4; 1161 case HAL_EHT_RU_NONE: 1162 return ATH12K_EHT_RU_INVALID; 1163 case HAL_EHT_RU_996_484: 1164 return ATH12K_EHT_RU_996_484; 1165 case HAL_EHT_RU_996x2_484: 1166 return ATH12K_EHT_RU_996x2_484; 1167 case HAL_EHT_RU_996x3_484: 1168 return ATH12K_EHT_RU_996x3_484; 1169 case HAL_EHT_RU_996_484_242: 1170 return ATH12K_EHT_RU_996_484_242; 1171 default: 1172 return ATH12K_EHT_RU_INVALID; 1173 } 1174 } 1175 1176 static inline u32 1177 hal_rx_ul_ofdma_ru_size_to_width(enum ath12k_eht_ru_size ru_size) 1178 { 1179 switch (ru_size) { 1180 case ATH12K_EHT_RU_26: 1181 return RU_26; 1182 case ATH12K_EHT_RU_52: 1183 return RU_52; 1184 case ATH12K_EHT_RU_52_26: 1185 return RU_52_26; 1186 case ATH12K_EHT_RU_106: 1187 return RU_106; 1188 case ATH12K_EHT_RU_106_26: 1189 return RU_106_26; 1190 case ATH12K_EHT_RU_242: 1191 return RU_242; 1192 case ATH12K_EHT_RU_484: 1193 return RU_484; 1194 case ATH12K_EHT_RU_484_242: 1195 return RU_484_242; 1196 case ATH12K_EHT_RU_996: 1197 return RU_996; 1198 case ATH12K_EHT_RU_996_484: 1199 return RU_996_484; 1200 case ATH12K_EHT_RU_996_484_242: 1201 return RU_996_484_242; 1202 case ATH12K_EHT_RU_996x2: 1203 return RU_2X996; 1204 case ATH12K_EHT_RU_996x2_484: 1205 return RU_2X996_484; 1206 case ATH12K_EHT_RU_996x3: 1207 return RU_3X996; 1208 case ATH12K_EHT_RU_996x3_484: 1209 return RU_3X996_484; 1210 case ATH12K_EHT_RU_996x4: 1211 return RU_4X996; 1212 default: 1213 return RU_INVALID; 1214 } 1215 } 1216 1217 static void 1218 ath12k_dp_mon_hal_rx_parse_user_info(const struct hal_receive_user_info *rx_usr_info, 1219 u16 user_id, 1220 struct hal_rx_mon_ppdu_info *ppdu_info) 1221 { 1222 struct hal_rx_user_status *mon_rx_user_status = NULL; 1223 struct hal_rx_radiotap_eht *eht = &ppdu_info->eht_info.eht; 1224 enum ath12k_eht_ru_size rtap_ru_size = ATH12K_EHT_RU_INVALID; 1225 u32 ru_width, reception_type, ru_index = HAL_EHT_RU_INVALID; 1226 u32 ru_type_80_0, ru_start_index_80_0; 1227 u32 ru_type_80_1, ru_start_index_80_1; 1228 u32 ru_type_80_2, ru_start_index_80_2; 1229 u32 ru_type_80_3, ru_start_index_80_3; 1230 u32 ru_size = 0, num_80mhz_with_ru = 0; 1231 u64 ru_index_320mhz = 0; 1232 u32 ru_index_per80mhz; 1233 1234 reception_type = le32_get_bits(rx_usr_info->info0, 1235 HAL_RX_USR_INFO0_RECEPTION_TYPE); 1236 1237 switch (reception_type) { 1238 case HAL_RECEPTION_TYPE_SU: 1239 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_SU; 1240 break; 1241 case HAL_RECEPTION_TYPE_DL_MU_MIMO: 1242 case HAL_RECEPTION_TYPE_UL_MU_MIMO: 1243 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_MU_MIMO; 1244 break; 1245 case HAL_RECEPTION_TYPE_DL_MU_OFMA: 1246 case HAL_RECEPTION_TYPE_UL_MU_OFDMA: 1247 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_MU_OFDMA; 1248 break; 1249 case HAL_RECEPTION_TYPE_DL_MU_OFDMA_MIMO: 1250 case HAL_RECEPTION_TYPE_UL_MU_OFDMA_MIMO: 1251 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO; 1252 } 1253 1254 ppdu_info->is_stbc = le32_get_bits(rx_usr_info->info0, HAL_RX_USR_INFO0_STBC); 1255 ppdu_info->ldpc = le32_get_bits(rx_usr_info->info2, HAL_RX_USR_INFO2_LDPC); 1256 ppdu_info->dcm = le32_get_bits(rx_usr_info->info2, HAL_RX_USR_INFO2_STA_DCM); 1257 ppdu_info->bw = le32_get_bits(rx_usr_info->info1, HAL_RX_USR_INFO1_RX_BW); 1258 ppdu_info->mcs = le32_get_bits(rx_usr_info->info1, HAL_RX_USR_INFO1_MCS); 1259 ppdu_info->nss = le32_get_bits(rx_usr_info->info2, HAL_RX_USR_INFO2_NSS) + 1; 1260 1261 if (user_id < HAL_MAX_UL_MU_USERS) { 1262 mon_rx_user_status = &ppdu_info->userstats[user_id]; 1263 mon_rx_user_status->mcs = ppdu_info->mcs; 1264 mon_rx_user_status->nss = ppdu_info->nss; 1265 } 1266 1267 if (!(ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_MIMO || 1268 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA || 1269 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO)) 1270 return; 1271 1272 /* RU allocation present only for OFDMA reception */ 1273 ru_type_80_0 = le32_get_bits(rx_usr_info->info2, HAL_RX_USR_INFO2_RU_TYPE_80_0); 1274 ru_start_index_80_0 = le32_get_bits(rx_usr_info->info3, 1275 HAL_RX_USR_INFO3_RU_START_IDX_80_0); 1276 if (ru_type_80_0 != HAL_EHT_RU_NONE) { 1277 ru_size += ru_type_80_0; 1278 ru_index_per80mhz = ru_start_index_80_0; 1279 ru_index = ru_index_per80mhz; 1280 ru_index_320mhz |= HAL_RU_PER80(ru_type_80_0, 0, ru_index_per80mhz); 1281 num_80mhz_with_ru++; 1282 } 1283 1284 ru_type_80_1 = le32_get_bits(rx_usr_info->info2, HAL_RX_USR_INFO2_RU_TYPE_80_1); 1285 ru_start_index_80_1 = le32_get_bits(rx_usr_info->info3, 1286 HAL_RX_USR_INFO3_RU_START_IDX_80_1); 1287 if (ru_type_80_1 != HAL_EHT_RU_NONE) { 1288 ru_size += ru_type_80_1; 1289 ru_index_per80mhz = ru_start_index_80_1; 1290 ru_index = ru_index_per80mhz; 1291 ru_index_320mhz |= HAL_RU_PER80(ru_type_80_1, 1, ru_index_per80mhz); 1292 num_80mhz_with_ru++; 1293 } 1294 1295 ru_type_80_2 = le32_get_bits(rx_usr_info->info2, HAL_RX_USR_INFO2_RU_TYPE_80_2); 1296 ru_start_index_80_2 = le32_get_bits(rx_usr_info->info3, 1297 HAL_RX_USR_INFO3_RU_START_IDX_80_2); 1298 if (ru_type_80_2 != HAL_EHT_RU_NONE) { 1299 ru_size += ru_type_80_2; 1300 ru_index_per80mhz = ru_start_index_80_2; 1301 ru_index = ru_index_per80mhz; 1302 ru_index_320mhz |= HAL_RU_PER80(ru_type_80_2, 2, ru_index_per80mhz); 1303 num_80mhz_with_ru++; 1304 } 1305 1306 ru_type_80_3 = le32_get_bits(rx_usr_info->info2, HAL_RX_USR_INFO2_RU_TYPE_80_3); 1307 ru_start_index_80_3 = le32_get_bits(rx_usr_info->info2, 1308 HAL_RX_USR_INFO3_RU_START_IDX_80_3); 1309 if (ru_type_80_3 != HAL_EHT_RU_NONE) { 1310 ru_size += ru_type_80_3; 1311 ru_index_per80mhz = ru_start_index_80_3; 1312 ru_index = ru_index_per80mhz; 1313 ru_index_320mhz |= HAL_RU_PER80(ru_type_80_3, 3, ru_index_per80mhz); 1314 num_80mhz_with_ru++; 1315 } 1316 1317 if (num_80mhz_with_ru > 1) { 1318 /* Calculate the MRU index */ 1319 switch (ru_index_320mhz) { 1320 case HAL_EHT_RU_996_484_0: 1321 case HAL_EHT_RU_996x2_484_0: 1322 case HAL_EHT_RU_996x3_484_0: 1323 ru_index = 0; 1324 break; 1325 case HAL_EHT_RU_996_484_1: 1326 case HAL_EHT_RU_996x2_484_1: 1327 case HAL_EHT_RU_996x3_484_1: 1328 ru_index = 1; 1329 break; 1330 case HAL_EHT_RU_996_484_2: 1331 case HAL_EHT_RU_996x2_484_2: 1332 case HAL_EHT_RU_996x3_484_2: 1333 ru_index = 2; 1334 break; 1335 case HAL_EHT_RU_996_484_3: 1336 case HAL_EHT_RU_996x2_484_3: 1337 case HAL_EHT_RU_996x3_484_3: 1338 ru_index = 3; 1339 break; 1340 case HAL_EHT_RU_996_484_4: 1341 case HAL_EHT_RU_996x2_484_4: 1342 case HAL_EHT_RU_996x3_484_4: 1343 ru_index = 4; 1344 break; 1345 case HAL_EHT_RU_996_484_5: 1346 case HAL_EHT_RU_996x2_484_5: 1347 case HAL_EHT_RU_996x3_484_5: 1348 ru_index = 5; 1349 break; 1350 case HAL_EHT_RU_996_484_6: 1351 case HAL_EHT_RU_996x2_484_6: 1352 case HAL_EHT_RU_996x3_484_6: 1353 ru_index = 6; 1354 break; 1355 case HAL_EHT_RU_996_484_7: 1356 case HAL_EHT_RU_996x2_484_7: 1357 case HAL_EHT_RU_996x3_484_7: 1358 ru_index = 7; 1359 break; 1360 case HAL_EHT_RU_996x2_484_8: 1361 ru_index = 8; 1362 break; 1363 case HAL_EHT_RU_996x2_484_9: 1364 ru_index = 9; 1365 break; 1366 case HAL_EHT_RU_996x2_484_10: 1367 ru_index = 10; 1368 break; 1369 case HAL_EHT_RU_996x2_484_11: 1370 ru_index = 11; 1371 break; 1372 default: 1373 ru_index = HAL_EHT_RU_INVALID; 1374 break; 1375 } 1376 1377 ru_size += 4; 1378 } 1379 1380 rtap_ru_size = hal_rx_mon_hal_ru_size_to_ath12k_ru_size(ru_size); 1381 if (rtap_ru_size != ATH12K_EHT_RU_INVALID) { 1382 u32 known, data; 1383 1384 known = __le32_to_cpu(eht->known); 1385 known |= IEEE80211_RADIOTAP_EHT_KNOWN_RU_MRU_SIZE_OM; 1386 eht->known = cpu_to_le32(known); 1387 1388 data = __le32_to_cpu(eht->data[1]); 1389 data |= u32_encode_bits(rtap_ru_size, 1390 IEEE80211_RADIOTAP_EHT_DATA1_RU_SIZE); 1391 eht->data[1] = cpu_to_le32(data); 1392 } 1393 1394 if (ru_index != HAL_EHT_RU_INVALID) { 1395 u32 known, data; 1396 1397 known = __le32_to_cpu(eht->known); 1398 known |= IEEE80211_RADIOTAP_EHT_KNOWN_RU_MRU_INDEX_OM; 1399 eht->known = cpu_to_le32(known); 1400 1401 data = __le32_to_cpu(eht->data[1]); 1402 data |= u32_encode_bits(rtap_ru_size, 1403 IEEE80211_RADIOTAP_EHT_DATA1_RU_INDEX); 1404 eht->data[1] = cpu_to_le32(data); 1405 } 1406 1407 if (mon_rx_user_status && ru_index != HAL_EHT_RU_INVALID && 1408 rtap_ru_size != ATH12K_EHT_RU_INVALID) { 1409 mon_rx_user_status->ul_ofdma_ru_start_index = ru_index; 1410 mon_rx_user_status->ul_ofdma_ru_size = rtap_ru_size; 1411 1412 ru_width = hal_rx_ul_ofdma_ru_size_to_width(rtap_ru_size); 1413 1414 mon_rx_user_status->ul_ofdma_ru_width = ru_width; 1415 mon_rx_user_status->ofdma_info_valid = 1; 1416 } 1417 } 1418 1419 static enum hal_rx_mon_status 1420 ath12k_dp_mon_rx_parse_status_tlv(struct ath12k *ar, 1421 struct ath12k_mon_data *pmon, 1422 const struct hal_tlv_64_hdr *tlv) 1423 { 1424 struct hal_rx_mon_ppdu_info *ppdu_info = &pmon->mon_ppdu_info; 1425 const void *tlv_data = tlv->value; 1426 u32 info[7], userid; 1427 u16 tlv_tag, tlv_len; 1428 1429 tlv_tag = le64_get_bits(tlv->tl, HAL_TLV_64_HDR_TAG); 1430 tlv_len = le64_get_bits(tlv->tl, HAL_TLV_64_HDR_LEN); 1431 userid = le64_get_bits(tlv->tl, HAL_TLV_64_USR_ID); 1432 1433 if (ppdu_info->tlv_aggr.in_progress && ppdu_info->tlv_aggr.tlv_tag != tlv_tag) { 1434 ath12k_dp_mon_parse_eht_sig_hdr(ppdu_info, ppdu_info->tlv_aggr.buf); 1435 1436 ppdu_info->tlv_aggr.in_progress = false; 1437 ppdu_info->tlv_aggr.cur_len = 0; 1438 } 1439 1440 switch (tlv_tag) { 1441 case HAL_RX_PPDU_START: { 1442 const struct hal_rx_ppdu_start *ppdu_start = tlv_data; 1443 1444 u64 ppdu_ts = ath12k_le32hilo_to_u64(ppdu_start->ppdu_start_ts_63_32, 1445 ppdu_start->ppdu_start_ts_31_0); 1446 1447 info[0] = __le32_to_cpu(ppdu_start->info0); 1448 1449 ppdu_info->ppdu_id = u32_get_bits(info[0], 1450 HAL_RX_PPDU_START_INFO0_PPDU_ID); 1451 1452 info[1] = __le32_to_cpu(ppdu_start->info1); 1453 ppdu_info->chan_num = u32_get_bits(info[1], 1454 HAL_RX_PPDU_START_INFO1_CHAN_NUM); 1455 ppdu_info->freq = u32_get_bits(info[1], 1456 HAL_RX_PPDU_START_INFO1_CHAN_FREQ); 1457 ppdu_info->ppdu_ts = ppdu_ts; 1458 1459 if (ppdu_info->ppdu_id != ppdu_info->last_ppdu_id) { 1460 ppdu_info->last_ppdu_id = ppdu_info->ppdu_id; 1461 ppdu_info->num_users = 0; 1462 memset(&ppdu_info->mpdu_fcs_ok_bitmap, 0, 1463 HAL_RX_NUM_WORDS_PER_PPDU_BITMAP * 1464 sizeof(ppdu_info->mpdu_fcs_ok_bitmap[0])); 1465 } 1466 break; 1467 } 1468 case HAL_RX_PPDU_END_USER_STATS: { 1469 const struct hal_rx_ppdu_end_user_stats *eu_stats = tlv_data; 1470 u32 tid_bitmap; 1471 1472 info[0] = __le32_to_cpu(eu_stats->info0); 1473 info[1] = __le32_to_cpu(eu_stats->info1); 1474 info[2] = __le32_to_cpu(eu_stats->info2); 1475 info[4] = __le32_to_cpu(eu_stats->info4); 1476 info[5] = __le32_to_cpu(eu_stats->info5); 1477 info[6] = __le32_to_cpu(eu_stats->info6); 1478 1479 ppdu_info->ast_index = 1480 u32_get_bits(info[2], HAL_RX_PPDU_END_USER_STATS_INFO2_AST_INDEX); 1481 ppdu_info->fc_valid = 1482 u32_get_bits(info[1], HAL_RX_PPDU_END_USER_STATS_INFO1_FC_VALID); 1483 tid_bitmap = u32_get_bits(info[6], 1484 HAL_RX_PPDU_END_USER_STATS_INFO6_TID_BITMAP); 1485 ppdu_info->tid = ffs(tid_bitmap) - 1; 1486 ppdu_info->tcp_msdu_count = 1487 u32_get_bits(info[4], 1488 HAL_RX_PPDU_END_USER_STATS_INFO4_TCP_MSDU_CNT); 1489 ppdu_info->udp_msdu_count = 1490 u32_get_bits(info[4], 1491 HAL_RX_PPDU_END_USER_STATS_INFO4_UDP_MSDU_CNT); 1492 ppdu_info->other_msdu_count = 1493 u32_get_bits(info[5], 1494 HAL_RX_PPDU_END_USER_STATS_INFO5_OTHER_MSDU_CNT); 1495 ppdu_info->tcp_ack_msdu_count = 1496 u32_get_bits(info[5], 1497 HAL_RX_PPDU_END_USER_STATS_INFO5_TCP_ACK_MSDU_CNT); 1498 ppdu_info->preamble_type = 1499 u32_get_bits(info[1], 1500 HAL_RX_PPDU_END_USER_STATS_INFO1_PKT_TYPE); 1501 ppdu_info->num_mpdu_fcs_ok = 1502 u32_get_bits(info[1], 1503 HAL_RX_PPDU_END_USER_STATS_INFO1_MPDU_CNT_FCS_OK); 1504 ppdu_info->num_mpdu_fcs_err = 1505 u32_get_bits(info[0], 1506 HAL_RX_PPDU_END_USER_STATS_INFO0_MPDU_CNT_FCS_ERR); 1507 ppdu_info->peer_id = 1508 u32_get_bits(info[0], HAL_RX_PPDU_END_USER_STATS_INFO0_PEER_ID); 1509 1510 switch (ppdu_info->preamble_type) { 1511 case HAL_RX_PREAMBLE_11N: 1512 ppdu_info->ht_flags = 1; 1513 break; 1514 case HAL_RX_PREAMBLE_11AC: 1515 ppdu_info->vht_flags = 1; 1516 break; 1517 case HAL_RX_PREAMBLE_11AX: 1518 ppdu_info->he_flags = 1; 1519 break; 1520 case HAL_RX_PREAMBLE_11BE: 1521 ppdu_info->is_eht = true; 1522 break; 1523 default: 1524 break; 1525 } 1526 1527 if (userid < HAL_MAX_UL_MU_USERS) { 1528 struct hal_rx_user_status *rxuser_stats = 1529 &ppdu_info->userstats[userid]; 1530 1531 if (ppdu_info->num_mpdu_fcs_ok > 1 || 1532 ppdu_info->num_mpdu_fcs_err > 1) 1533 ppdu_info->userstats[userid].ampdu_present = true; 1534 1535 ppdu_info->num_users += 1; 1536 1537 ath12k_dp_mon_rx_handle_ofdma_info(eu_stats, rxuser_stats); 1538 ath12k_dp_mon_rx_populate_mu_user_info(eu_stats, ppdu_info, 1539 rxuser_stats); 1540 } 1541 ppdu_info->mpdu_fcs_ok_bitmap[0] = __le32_to_cpu(eu_stats->rsvd1[0]); 1542 ppdu_info->mpdu_fcs_ok_bitmap[1] = __le32_to_cpu(eu_stats->rsvd1[1]); 1543 break; 1544 } 1545 case HAL_RX_PPDU_END_USER_STATS_EXT: { 1546 const struct hal_rx_ppdu_end_user_stats_ext *eu_stats = tlv_data; 1547 1548 ppdu_info->mpdu_fcs_ok_bitmap[2] = __le32_to_cpu(eu_stats->info1); 1549 ppdu_info->mpdu_fcs_ok_bitmap[3] = __le32_to_cpu(eu_stats->info2); 1550 ppdu_info->mpdu_fcs_ok_bitmap[4] = __le32_to_cpu(eu_stats->info3); 1551 ppdu_info->mpdu_fcs_ok_bitmap[5] = __le32_to_cpu(eu_stats->info4); 1552 ppdu_info->mpdu_fcs_ok_bitmap[6] = __le32_to_cpu(eu_stats->info5); 1553 ppdu_info->mpdu_fcs_ok_bitmap[7] = __le32_to_cpu(eu_stats->info6); 1554 break; 1555 } 1556 case HAL_PHYRX_HT_SIG: 1557 ath12k_dp_mon_parse_ht_sig(tlv_data, ppdu_info); 1558 break; 1559 1560 case HAL_PHYRX_L_SIG_B: 1561 ath12k_dp_mon_parse_l_sig_b(tlv_data, ppdu_info); 1562 break; 1563 1564 case HAL_PHYRX_L_SIG_A: 1565 ath12k_dp_mon_parse_l_sig_a(tlv_data, ppdu_info); 1566 break; 1567 1568 case HAL_PHYRX_VHT_SIG_A: 1569 ath12k_dp_mon_parse_vht_sig_a(tlv_data, ppdu_info); 1570 break; 1571 1572 case HAL_PHYRX_HE_SIG_A_SU: 1573 ath12k_dp_mon_parse_he_sig_su(tlv_data, ppdu_info); 1574 break; 1575 1576 case HAL_PHYRX_HE_SIG_A_MU_DL: 1577 ath12k_dp_mon_parse_he_sig_mu(tlv_data, ppdu_info); 1578 break; 1579 1580 case HAL_PHYRX_HE_SIG_B1_MU: 1581 ath12k_dp_mon_parse_he_sig_b1_mu(tlv_data, ppdu_info); 1582 break; 1583 1584 case HAL_PHYRX_HE_SIG_B2_MU: 1585 ath12k_dp_mon_parse_he_sig_b2_mu(tlv_data, ppdu_info); 1586 break; 1587 1588 case HAL_PHYRX_HE_SIG_B2_OFDMA: 1589 ath12k_dp_mon_parse_he_sig_b2_ofdma(tlv_data, ppdu_info); 1590 break; 1591 1592 case HAL_PHYRX_RSSI_LEGACY: { 1593 const struct hal_rx_phyrx_rssi_legacy_info *rssi = tlv_data; 1594 1595 info[0] = __le32_to_cpu(rssi->info0); 1596 info[1] = __le32_to_cpu(rssi->info1); 1597 1598 /* TODO: Please note that the combined rssi will not be accurate 1599 * in MU case. Rssi in MU needs to be retrieved from 1600 * PHYRX_OTHER_RECEIVE_INFO TLV. 1601 */ 1602 ppdu_info->rssi_comb = 1603 u32_get_bits(info[1], 1604 HAL_RX_PHYRX_RSSI_LEGACY_INFO_INFO1_RSSI_COMB); 1605 1606 ppdu_info->bw = u32_get_bits(info[0], 1607 HAL_RX_PHYRX_RSSI_LEGACY_INFO_INFO0_RX_BW); 1608 break; 1609 } 1610 case HAL_PHYRX_OTHER_RECEIVE_INFO: { 1611 const struct hal_phyrx_common_user_info *cmn_usr_info = tlv_data; 1612 1613 ppdu_info->gi = le32_get_bits(cmn_usr_info->info0, 1614 HAL_RX_PHY_CMN_USER_INFO0_GI); 1615 break; 1616 } 1617 case HAL_RX_PPDU_START_USER_INFO: 1618 ath12k_dp_mon_hal_rx_parse_user_info(tlv_data, userid, ppdu_info); 1619 break; 1620 1621 case HAL_RXPCU_PPDU_END_INFO: { 1622 const struct hal_rx_ppdu_end_duration *ppdu_rx_duration = tlv_data; 1623 1624 info[0] = __le32_to_cpu(ppdu_rx_duration->info0); 1625 ppdu_info->rx_duration = 1626 u32_get_bits(info[0], HAL_RX_PPDU_END_DURATION); 1627 ppdu_info->tsft = __le32_to_cpu(ppdu_rx_duration->rsvd0[1]); 1628 ppdu_info->tsft = (ppdu_info->tsft << 32) | 1629 __le32_to_cpu(ppdu_rx_duration->rsvd0[0]); 1630 break; 1631 } 1632 case HAL_RX_MPDU_START: { 1633 const struct hal_rx_mpdu_start *mpdu_start = tlv_data; 1634 u16 peer_id; 1635 1636 info[1] = __le32_to_cpu(mpdu_start->info1); 1637 peer_id = u32_get_bits(info[1], HAL_RX_MPDU_START_INFO1_PEERID); 1638 if (peer_id) 1639 ppdu_info->peer_id = peer_id; 1640 1641 ppdu_info->mpdu_len += u32_get_bits(info[1], 1642 HAL_RX_MPDU_START_INFO2_MPDU_LEN); 1643 if (userid < HAL_MAX_UL_MU_USERS) { 1644 info[0] = __le32_to_cpu(mpdu_start->info0); 1645 ppdu_info->userid = userid; 1646 ppdu_info->userstats[userid].ampdu_id = 1647 u32_get_bits(info[0], HAL_RX_MPDU_START_INFO0_PPDU_ID); 1648 } 1649 1650 return HAL_RX_MON_STATUS_MPDU_START; 1651 } 1652 case HAL_RX_MSDU_START: 1653 /* TODO: add msdu start parsing logic */ 1654 break; 1655 case HAL_MON_BUF_ADDR: 1656 return HAL_RX_MON_STATUS_BUF_ADDR; 1657 case HAL_RX_MSDU_END: 1658 return HAL_RX_MON_STATUS_MSDU_END; 1659 case HAL_RX_MPDU_END: 1660 return HAL_RX_MON_STATUS_MPDU_END; 1661 case HAL_PHYRX_GENERIC_U_SIG: 1662 ath12k_dp_mon_hal_rx_parse_u_sig_hdr(tlv_data, ppdu_info); 1663 break; 1664 case HAL_PHYRX_GENERIC_EHT_SIG: 1665 /* Handle the case where aggregation is in progress 1666 * or the current TLV is one of the TLVs which should be 1667 * aggregated 1668 */ 1669 if (!ppdu_info->tlv_aggr.in_progress) { 1670 ppdu_info->tlv_aggr.in_progress = true; 1671 ppdu_info->tlv_aggr.tlv_tag = tlv_tag; 1672 ppdu_info->tlv_aggr.cur_len = 0; 1673 } 1674 1675 ppdu_info->is_eht = true; 1676 1677 ath12k_dp_mon_hal_aggr_tlv(ppdu_info, tlv_len, tlv_data); 1678 break; 1679 case HAL_DUMMY: 1680 return HAL_RX_MON_STATUS_BUF_DONE; 1681 case HAL_RX_PPDU_END_STATUS_DONE: 1682 case 0: 1683 return HAL_RX_MON_STATUS_PPDU_DONE; 1684 default: 1685 break; 1686 } 1687 1688 return HAL_RX_MON_STATUS_PPDU_NOT_DONE; 1689 } 1690 1691 static void 1692 ath12k_dp_mon_fill_rx_stats_info(struct ath12k *ar, 1693 struct hal_rx_mon_ppdu_info *ppdu_info, 1694 struct ieee80211_rx_status *rx_status) 1695 { 1696 u32 center_freq = ppdu_info->freq; 1697 1698 rx_status->freq = center_freq; 1699 rx_status->bw = ath12k_mac_bw_to_mac80211_bw(ppdu_info->bw); 1700 rx_status->nss = ppdu_info->nss; 1701 rx_status->rate_idx = 0; 1702 rx_status->encoding = RX_ENC_LEGACY; 1703 rx_status->flag |= RX_FLAG_NO_SIGNAL_VAL; 1704 1705 if (center_freq >= ATH12K_MIN_6GHZ_FREQ && 1706 center_freq <= ATH12K_MAX_6GHZ_FREQ) { 1707 rx_status->band = NL80211_BAND_6GHZ; 1708 } else if (center_freq >= ATH12K_MIN_2GHZ_FREQ && 1709 center_freq <= ATH12K_MAX_2GHZ_FREQ) { 1710 rx_status->band = NL80211_BAND_2GHZ; 1711 } else if (center_freq >= ATH12K_MIN_5GHZ_FREQ && 1712 center_freq <= ATH12K_MAX_5GHZ_FREQ) { 1713 rx_status->band = NL80211_BAND_5GHZ; 1714 } else { 1715 rx_status->band = NUM_NL80211_BANDS; 1716 } 1717 } 1718 1719 static void 1720 ath12k_dp_mon_fill_rx_rate(struct ath12k *ar, 1721 struct hal_rx_mon_ppdu_info *ppdu_info, 1722 struct ieee80211_rx_status *rx_status) 1723 { 1724 struct ieee80211_supported_band *sband; 1725 enum rx_msdu_start_pkt_type pkt_type; 1726 u8 rate_mcs, nss, sgi; 1727 bool is_cck; 1728 1729 pkt_type = ppdu_info->preamble_type; 1730 rate_mcs = ppdu_info->rate; 1731 nss = ppdu_info->nss; 1732 sgi = ppdu_info->gi; 1733 1734 switch (pkt_type) { 1735 case RX_MSDU_START_PKT_TYPE_11A: 1736 case RX_MSDU_START_PKT_TYPE_11B: 1737 is_cck = (pkt_type == RX_MSDU_START_PKT_TYPE_11B); 1738 if (rx_status->band < NUM_NL80211_BANDS) { 1739 sband = &ar->mac.sbands[rx_status->band]; 1740 rx_status->rate_idx = ath12k_mac_hw_rate_to_idx(sband, rate_mcs, 1741 is_cck); 1742 } 1743 break; 1744 case RX_MSDU_START_PKT_TYPE_11N: 1745 rx_status->encoding = RX_ENC_HT; 1746 if (rate_mcs > ATH12K_HT_MCS_MAX) { 1747 ath12k_warn(ar->ab, 1748 "Received with invalid mcs in HT mode %d\n", 1749 rate_mcs); 1750 break; 1751 } 1752 rx_status->rate_idx = rate_mcs + (8 * (nss - 1)); 1753 if (sgi) 1754 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI; 1755 break; 1756 case RX_MSDU_START_PKT_TYPE_11AC: 1757 rx_status->encoding = RX_ENC_VHT; 1758 rx_status->rate_idx = rate_mcs; 1759 if (rate_mcs > ATH12K_VHT_MCS_MAX) { 1760 ath12k_warn(ar->ab, 1761 "Received with invalid mcs in VHT mode %d\n", 1762 rate_mcs); 1763 break; 1764 } 1765 if (sgi) 1766 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI; 1767 break; 1768 case RX_MSDU_START_PKT_TYPE_11AX: 1769 rx_status->rate_idx = rate_mcs; 1770 if (rate_mcs > ATH12K_HE_MCS_MAX) { 1771 ath12k_warn(ar->ab, 1772 "Received with invalid mcs in HE mode %d\n", 1773 rate_mcs); 1774 break; 1775 } 1776 rx_status->encoding = RX_ENC_HE; 1777 rx_status->he_gi = ath12k_he_gi_to_nl80211_he_gi(sgi); 1778 break; 1779 case RX_MSDU_START_PKT_TYPE_11BE: 1780 rx_status->rate_idx = rate_mcs; 1781 if (rate_mcs > ATH12K_EHT_MCS_MAX) { 1782 ath12k_warn(ar->ab, 1783 "Received with invalid mcs in EHT mode %d\n", 1784 rate_mcs); 1785 break; 1786 } 1787 rx_status->encoding = RX_ENC_EHT; 1788 rx_status->he_gi = ath12k_he_gi_to_nl80211_he_gi(sgi); 1789 break; 1790 default: 1791 ath12k_dbg(ar->ab, ATH12K_DBG_DATA, 1792 "monitor receives invalid preamble type %d", 1793 pkt_type); 1794 break; 1795 } 1796 } 1797 1798 static struct sk_buff * 1799 ath12k_dp_mon_rx_merg_msdus(struct ath12k *ar, 1800 struct dp_mon_mpdu *mon_mpdu, 1801 struct hal_rx_mon_ppdu_info *ppdu_info, 1802 struct ieee80211_rx_status *rxs) 1803 { 1804 struct ath12k_base *ab = ar->ab; 1805 struct sk_buff *msdu, *mpdu_buf, *prev_buf, *head_frag_list; 1806 struct sk_buff *head_msdu; 1807 struct hal_rx_desc *rx_desc; 1808 u8 *hdr_desc, *dest, decap_format = mon_mpdu->decap_format; 1809 struct ieee80211_hdr_3addr *wh; 1810 struct ieee80211_channel *channel; 1811 u32 frag_list_sum_len = 0; 1812 u8 channel_num = ppdu_info->chan_num; 1813 1814 mpdu_buf = NULL; 1815 head_msdu = mon_mpdu->head; 1816 1817 if (!head_msdu) 1818 goto err_merge_fail; 1819 1820 ath12k_dp_mon_fill_rx_stats_info(ar, ppdu_info, rxs); 1821 1822 if (unlikely(rxs->band == NUM_NL80211_BANDS || 1823 !ath12k_ar_to_hw(ar)->wiphy->bands[rxs->band])) { 1824 ath12k_dbg(ar->ab, ATH12K_DBG_DATA, 1825 "sband is NULL for status band %d channel_num %d center_freq %d pdev_id %d\n", 1826 rxs->band, channel_num, ppdu_info->freq, ar->pdev_idx); 1827 1828 spin_lock_bh(&ar->data_lock); 1829 channel = ar->rx_channel; 1830 if (channel) { 1831 rxs->band = channel->band; 1832 channel_num = 1833 ieee80211_frequency_to_channel(channel->center_freq); 1834 } 1835 spin_unlock_bh(&ar->data_lock); 1836 } 1837 1838 if (rxs->band < NUM_NL80211_BANDS) 1839 rxs->freq = ieee80211_channel_to_frequency(channel_num, 1840 rxs->band); 1841 1842 ath12k_dp_mon_fill_rx_rate(ar, ppdu_info, rxs); 1843 1844 if (decap_format == DP_RX_DECAP_TYPE_RAW) { 1845 skb_pull(head_msdu, ATH12K_MON_RX_PKT_OFFSET); 1846 1847 prev_buf = head_msdu; 1848 msdu = head_msdu->next; 1849 head_frag_list = NULL; 1850 1851 while (msdu) { 1852 skb_pull(msdu, ATH12K_MON_RX_PKT_OFFSET); 1853 1854 if (!head_frag_list) 1855 head_frag_list = msdu; 1856 1857 frag_list_sum_len += msdu->len; 1858 prev_buf = msdu; 1859 msdu = msdu->next; 1860 } 1861 1862 prev_buf->next = NULL; 1863 1864 skb_trim(prev_buf, prev_buf->len); 1865 if (head_frag_list) { 1866 skb_shinfo(head_msdu)->frag_list = head_frag_list; 1867 head_msdu->data_len = frag_list_sum_len; 1868 head_msdu->len += head_msdu->data_len; 1869 head_msdu->next = NULL; 1870 } 1871 } else if (decap_format == DP_RX_DECAP_TYPE_NATIVE_WIFI) { 1872 u8 qos_pkt = 0; 1873 1874 rx_desc = (struct hal_rx_desc *)head_msdu->data; 1875 hdr_desc = 1876 ab->hal_rx_ops->rx_desc_get_msdu_payload(rx_desc); 1877 1878 /* Base size */ 1879 wh = (struct ieee80211_hdr_3addr *)hdr_desc; 1880 1881 if (ieee80211_is_data_qos(wh->frame_control)) 1882 qos_pkt = 1; 1883 1884 msdu = head_msdu; 1885 1886 while (msdu) { 1887 skb_pull(msdu, ATH12K_MON_RX_PKT_OFFSET); 1888 if (qos_pkt) { 1889 dest = skb_push(msdu, sizeof(__le16)); 1890 if (!dest) 1891 goto err_merge_fail; 1892 memcpy(dest, hdr_desc, sizeof(struct ieee80211_qos_hdr)); 1893 } 1894 prev_buf = msdu; 1895 msdu = msdu->next; 1896 } 1897 dest = skb_put(prev_buf, HAL_RX_FCS_LEN); 1898 if (!dest) 1899 goto err_merge_fail; 1900 1901 ath12k_dbg(ab, ATH12K_DBG_DATA, 1902 "mpdu_buf %p mpdu_buf->len %u", 1903 prev_buf, prev_buf->len); 1904 } else { 1905 ath12k_dbg(ab, ATH12K_DBG_DATA, 1906 "decap format %d is not supported!\n", 1907 decap_format); 1908 goto err_merge_fail; 1909 } 1910 1911 return head_msdu; 1912 1913 err_merge_fail: 1914 if (mpdu_buf && decap_format != DP_RX_DECAP_TYPE_RAW) { 1915 ath12k_dbg(ab, ATH12K_DBG_DATA, 1916 "err_merge_fail mpdu_buf %p", mpdu_buf); 1917 /* Free the head buffer */ 1918 dev_kfree_skb_any(mpdu_buf); 1919 } 1920 return NULL; 1921 } 1922 1923 static void 1924 ath12k_dp_mon_rx_update_radiotap_he(struct hal_rx_mon_ppdu_info *rx_status, 1925 u8 *rtap_buf) 1926 { 1927 u32 rtap_len = 0; 1928 1929 put_unaligned_le16(rx_status->he_data1, &rtap_buf[rtap_len]); 1930 rtap_len += 2; 1931 1932 put_unaligned_le16(rx_status->he_data2, &rtap_buf[rtap_len]); 1933 rtap_len += 2; 1934 1935 put_unaligned_le16(rx_status->he_data3, &rtap_buf[rtap_len]); 1936 rtap_len += 2; 1937 1938 put_unaligned_le16(rx_status->he_data4, &rtap_buf[rtap_len]); 1939 rtap_len += 2; 1940 1941 put_unaligned_le16(rx_status->he_data5, &rtap_buf[rtap_len]); 1942 rtap_len += 2; 1943 1944 put_unaligned_le16(rx_status->he_data6, &rtap_buf[rtap_len]); 1945 } 1946 1947 static void 1948 ath12k_dp_mon_rx_update_radiotap_he_mu(struct hal_rx_mon_ppdu_info *rx_status, 1949 u8 *rtap_buf) 1950 { 1951 u32 rtap_len = 0; 1952 1953 put_unaligned_le16(rx_status->he_flags1, &rtap_buf[rtap_len]); 1954 rtap_len += 2; 1955 1956 put_unaligned_le16(rx_status->he_flags2, &rtap_buf[rtap_len]); 1957 rtap_len += 2; 1958 1959 rtap_buf[rtap_len] = rx_status->he_RU[0]; 1960 rtap_len += 1; 1961 1962 rtap_buf[rtap_len] = rx_status->he_RU[1]; 1963 rtap_len += 1; 1964 1965 rtap_buf[rtap_len] = rx_status->he_RU[2]; 1966 rtap_len += 1; 1967 1968 rtap_buf[rtap_len] = rx_status->he_RU[3]; 1969 } 1970 1971 static void ath12k_dp_mon_update_radiotap(struct ath12k *ar, 1972 struct hal_rx_mon_ppdu_info *ppduinfo, 1973 struct sk_buff *mon_skb, 1974 struct ieee80211_rx_status *rxs) 1975 { 1976 struct ieee80211_supported_band *sband; 1977 u8 *ptr = NULL; 1978 1979 rxs->flag |= RX_FLAG_MACTIME_START; 1980 rxs->signal = ppduinfo->rssi_comb + ATH12K_DEFAULT_NOISE_FLOOR; 1981 rxs->nss = ppduinfo->nss + 1; 1982 1983 if (ppduinfo->userstats[ppduinfo->userid].ampdu_present) { 1984 rxs->flag |= RX_FLAG_AMPDU_DETAILS; 1985 rxs->ampdu_reference = ppduinfo->userstats[ppduinfo->userid].ampdu_id; 1986 } 1987 1988 if (ppduinfo->is_eht || ppduinfo->eht_usig) { 1989 struct ieee80211_radiotap_tlv *tlv; 1990 struct ieee80211_radiotap_eht *eht; 1991 struct ieee80211_radiotap_eht_usig *usig; 1992 u16 len = 0, i, eht_len, usig_len; 1993 u8 user; 1994 1995 if (ppduinfo->is_eht) { 1996 eht_len = struct_size(eht, 1997 user_info, 1998 ppduinfo->eht_info.num_user_info); 1999 len += sizeof(*tlv) + eht_len; 2000 } 2001 2002 if (ppduinfo->eht_usig) { 2003 usig_len = sizeof(*usig); 2004 len += sizeof(*tlv) + usig_len; 2005 } 2006 2007 rxs->flag |= RX_FLAG_RADIOTAP_TLV_AT_END; 2008 rxs->encoding = RX_ENC_EHT; 2009 2010 skb_reset_mac_header(mon_skb); 2011 2012 tlv = skb_push(mon_skb, len); 2013 2014 if (ppduinfo->is_eht) { 2015 tlv->type = cpu_to_le16(IEEE80211_RADIOTAP_EHT); 2016 tlv->len = cpu_to_le16(eht_len); 2017 2018 eht = (struct ieee80211_radiotap_eht *)tlv->data; 2019 eht->known = ppduinfo->eht_info.eht.known; 2020 2021 for (i = 0; 2022 i < ARRAY_SIZE(eht->data) && 2023 i < ARRAY_SIZE(ppduinfo->eht_info.eht.data); 2024 i++) 2025 eht->data[i] = ppduinfo->eht_info.eht.data[i]; 2026 2027 for (user = 0; user < ppduinfo->eht_info.num_user_info; user++) 2028 put_unaligned_le32(ppduinfo->eht_info.user_info[user], 2029 &eht->user_info[user]); 2030 2031 tlv = (struct ieee80211_radiotap_tlv *)&tlv->data[eht_len]; 2032 } 2033 2034 if (ppduinfo->eht_usig) { 2035 tlv->type = cpu_to_le16(IEEE80211_RADIOTAP_EHT_USIG); 2036 tlv->len = cpu_to_le16(usig_len); 2037 2038 usig = (struct ieee80211_radiotap_eht_usig *)tlv->data; 2039 *usig = ppduinfo->u_sig_info.usig; 2040 } 2041 } else if (ppduinfo->he_mu_flags) { 2042 rxs->flag |= RX_FLAG_RADIOTAP_HE_MU; 2043 rxs->encoding = RX_ENC_HE; 2044 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he_mu)); 2045 ath12k_dp_mon_rx_update_radiotap_he_mu(ppduinfo, ptr); 2046 } else if (ppduinfo->he_flags) { 2047 rxs->flag |= RX_FLAG_RADIOTAP_HE; 2048 rxs->encoding = RX_ENC_HE; 2049 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he)); 2050 ath12k_dp_mon_rx_update_radiotap_he(ppduinfo, ptr); 2051 rxs->rate_idx = ppduinfo->rate; 2052 } else if (ppduinfo->vht_flags) { 2053 rxs->encoding = RX_ENC_VHT; 2054 rxs->rate_idx = ppduinfo->rate; 2055 } else if (ppduinfo->ht_flags) { 2056 rxs->encoding = RX_ENC_HT; 2057 rxs->rate_idx = ppduinfo->rate; 2058 } else { 2059 rxs->encoding = RX_ENC_LEGACY; 2060 sband = &ar->mac.sbands[rxs->band]; 2061 rxs->rate_idx = ath12k_mac_hw_rate_to_idx(sband, ppduinfo->rate, 2062 ppduinfo->cck_flag); 2063 } 2064 2065 rxs->mactime = ppduinfo->tsft; 2066 } 2067 2068 static void ath12k_dp_mon_rx_deliver_msdu(struct ath12k *ar, struct napi_struct *napi, 2069 struct sk_buff *msdu, 2070 struct ieee80211_rx_status *status, 2071 u8 decap) 2072 { 2073 static const struct ieee80211_radiotap_he known = { 2074 .data1 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN | 2075 IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN), 2076 .data2 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN), 2077 }; 2078 struct ieee80211_rx_status *rx_status; 2079 struct ieee80211_radiotap_he *he = NULL; 2080 struct ieee80211_sta *pubsta = NULL; 2081 struct ath12k_peer *peer; 2082 struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu); 2083 struct ath12k_dp_rx_info rx_info; 2084 bool is_mcbc = rxcb->is_mcbc; 2085 bool is_eapol_tkip = rxcb->is_eapol; 2086 2087 status->link_valid = 0; 2088 2089 if ((status->encoding == RX_ENC_HE) && !(status->flag & RX_FLAG_RADIOTAP_HE) && 2090 !(status->flag & RX_FLAG_SKIP_MONITOR)) { 2091 he = skb_push(msdu, sizeof(known)); 2092 memcpy(he, &known, sizeof(known)); 2093 status->flag |= RX_FLAG_RADIOTAP_HE; 2094 } 2095 2096 spin_lock_bh(&ar->ab->base_lock); 2097 rx_info.addr2_present = false; 2098 peer = ath12k_dp_rx_h_find_peer(ar->ab, msdu, &rx_info); 2099 if (peer && peer->sta) { 2100 pubsta = peer->sta; 2101 if (pubsta->valid_links) { 2102 status->link_valid = 1; 2103 status->link_id = peer->link_id; 2104 } 2105 } 2106 2107 spin_unlock_bh(&ar->ab->base_lock); 2108 2109 ath12k_dbg(ar->ab, ATH12K_DBG_DATA, 2110 "rx skb %p len %u peer %pM %u %s %s%s%s%s%s%s%s%s %srate_idx %u vht_nss %u freq %u band %u flag 0x%x fcs-err %i mic-err %i amsdu-more %i\n", 2111 msdu, 2112 msdu->len, 2113 peer ? peer->addr : NULL, 2114 rxcb->tid, 2115 (is_mcbc) ? "mcast" : "ucast", 2116 (status->encoding == RX_ENC_LEGACY) ? "legacy" : "", 2117 (status->encoding == RX_ENC_HT) ? "ht" : "", 2118 (status->encoding == RX_ENC_VHT) ? "vht" : "", 2119 (status->encoding == RX_ENC_HE) ? "he" : "", 2120 (status->bw == RATE_INFO_BW_40) ? "40" : "", 2121 (status->bw == RATE_INFO_BW_80) ? "80" : "", 2122 (status->bw == RATE_INFO_BW_160) ? "160" : "", 2123 (status->bw == RATE_INFO_BW_320) ? "320" : "", 2124 status->enc_flags & RX_ENC_FLAG_SHORT_GI ? "sgi " : "", 2125 status->rate_idx, 2126 status->nss, 2127 status->freq, 2128 status->band, status->flag, 2129 !!(status->flag & RX_FLAG_FAILED_FCS_CRC), 2130 !!(status->flag & RX_FLAG_MMIC_ERROR), 2131 !!(status->flag & RX_FLAG_AMSDU_MORE)); 2132 2133 ath12k_dbg_dump(ar->ab, ATH12K_DBG_DP_RX, NULL, "dp rx msdu: ", 2134 msdu->data, msdu->len); 2135 rx_status = IEEE80211_SKB_RXCB(msdu); 2136 *rx_status = *status; 2137 2138 /* TODO: trace rx packet */ 2139 2140 /* PN for multicast packets are not validate in HW, 2141 * so skip 802.3 rx path 2142 * Also, fast_rx expects the STA to be authorized, hence 2143 * eapol packets are sent in slow path. 2144 */ 2145 if (decap == DP_RX_DECAP_TYPE_ETHERNET2_DIX && !is_eapol_tkip && 2146 !(is_mcbc && rx_status->flag & RX_FLAG_DECRYPTED)) 2147 rx_status->flag |= RX_FLAG_8023; 2148 2149 ieee80211_rx_napi(ath12k_ar_to_hw(ar), pubsta, msdu, napi); 2150 } 2151 2152 static int ath12k_dp_mon_rx_deliver(struct ath12k *ar, 2153 struct dp_mon_mpdu *mon_mpdu, 2154 struct hal_rx_mon_ppdu_info *ppduinfo, 2155 struct napi_struct *napi) 2156 { 2157 struct ath12k_pdev_dp *dp = &ar->dp; 2158 struct sk_buff *mon_skb, *skb_next, *header; 2159 struct ieee80211_rx_status *rxs = &dp->rx_status; 2160 u8 decap = DP_RX_DECAP_TYPE_RAW; 2161 2162 mon_skb = ath12k_dp_mon_rx_merg_msdus(ar, mon_mpdu, ppduinfo, rxs); 2163 if (!mon_skb) 2164 goto mon_deliver_fail; 2165 2166 header = mon_skb; 2167 rxs->flag = 0; 2168 2169 if (mon_mpdu->err_bitmap & HAL_RX_MPDU_ERR_FCS) 2170 rxs->flag = RX_FLAG_FAILED_FCS_CRC; 2171 2172 do { 2173 skb_next = mon_skb->next; 2174 if (!skb_next) 2175 rxs->flag &= ~RX_FLAG_AMSDU_MORE; 2176 else 2177 rxs->flag |= RX_FLAG_AMSDU_MORE; 2178 2179 if (mon_skb == header) { 2180 header = NULL; 2181 rxs->flag &= ~RX_FLAG_ALLOW_SAME_PN; 2182 } else { 2183 rxs->flag |= RX_FLAG_ALLOW_SAME_PN; 2184 } 2185 rxs->flag |= RX_FLAG_ONLY_MONITOR; 2186 2187 if (!(rxs->flag & RX_FLAG_ONLY_MONITOR)) 2188 decap = mon_mpdu->decap_format; 2189 2190 ath12k_dp_mon_update_radiotap(ar, ppduinfo, mon_skb, rxs); 2191 ath12k_dp_mon_rx_deliver_msdu(ar, napi, mon_skb, rxs, decap); 2192 mon_skb = skb_next; 2193 } while (mon_skb); 2194 rxs->flag = 0; 2195 2196 return 0; 2197 2198 mon_deliver_fail: 2199 mon_skb = mon_mpdu->head; 2200 while (mon_skb) { 2201 skb_next = mon_skb->next; 2202 dev_kfree_skb_any(mon_skb); 2203 mon_skb = skb_next; 2204 } 2205 return -EINVAL; 2206 } 2207 2208 static int ath12k_dp_pkt_set_pktlen(struct sk_buff *skb, u32 len) 2209 { 2210 if (skb->len > len) { 2211 skb_trim(skb, len); 2212 } else { 2213 if (skb_tailroom(skb) < len - skb->len) { 2214 if ((pskb_expand_head(skb, 0, 2215 len - skb->len - skb_tailroom(skb), 2216 GFP_ATOMIC))) { 2217 return -ENOMEM; 2218 } 2219 } 2220 skb_put(skb, (len - skb->len)); 2221 } 2222 2223 return 0; 2224 } 2225 2226 static void ath12k_dp_mon_parse_rx_msdu_end_err(u32 info, u32 *errmap) 2227 { 2228 if (info & RX_MSDU_END_INFO13_FCS_ERR) 2229 *errmap |= HAL_RX_MPDU_ERR_FCS; 2230 2231 if (info & RX_MSDU_END_INFO13_DECRYPT_ERR) 2232 *errmap |= HAL_RX_MPDU_ERR_DECRYPT; 2233 2234 if (info & RX_MSDU_END_INFO13_TKIP_MIC_ERR) 2235 *errmap |= HAL_RX_MPDU_ERR_TKIP_MIC; 2236 2237 if (info & RX_MSDU_END_INFO13_A_MSDU_ERROR) 2238 *errmap |= HAL_RX_MPDU_ERR_AMSDU_ERR; 2239 2240 if (info & RX_MSDU_END_INFO13_OVERFLOW_ERR) 2241 *errmap |= HAL_RX_MPDU_ERR_OVERFLOW; 2242 2243 if (info & RX_MSDU_END_INFO13_MSDU_LEN_ERR) 2244 *errmap |= HAL_RX_MPDU_ERR_MSDU_LEN; 2245 2246 if (info & RX_MSDU_END_INFO13_MPDU_LEN_ERR) 2247 *errmap |= HAL_RX_MPDU_ERR_MPDU_LEN; 2248 } 2249 2250 static int 2251 ath12k_dp_mon_parse_status_msdu_end(struct ath12k_mon_data *pmon, 2252 const struct hal_rx_msdu_end *msdu_end) 2253 { 2254 struct dp_mon_mpdu *mon_mpdu = pmon->mon_mpdu; 2255 2256 ath12k_dp_mon_parse_rx_msdu_end_err(__le32_to_cpu(msdu_end->info2), 2257 &mon_mpdu->err_bitmap); 2258 2259 mon_mpdu->decap_format = le32_get_bits(msdu_end->info1, 2260 RX_MSDU_END_INFO11_DECAP_FORMAT); 2261 2262 return 0; 2263 } 2264 2265 static int 2266 ath12k_dp_mon_parse_status_buf(struct ath12k *ar, 2267 struct ath12k_mon_data *pmon, 2268 const struct dp_mon_packet_info *packet_info) 2269 { 2270 struct ath12k_base *ab = ar->ab; 2271 struct dp_rxdma_mon_ring *buf_ring = &ab->dp.rxdma_mon_buf_ring; 2272 struct sk_buff *msdu; 2273 int buf_id; 2274 u32 offset; 2275 2276 buf_id = u32_get_bits(packet_info->cookie, DP_RXDMA_BUF_COOKIE_BUF_ID); 2277 2278 spin_lock_bh(&buf_ring->idr_lock); 2279 msdu = idr_remove(&buf_ring->bufs_idr, buf_id); 2280 spin_unlock_bh(&buf_ring->idr_lock); 2281 2282 if (unlikely(!msdu)) { 2283 ath12k_warn(ab, "mon dest desc with inval buf_id %d\n", buf_id); 2284 return 0; 2285 } 2286 2287 dma_unmap_single(ab->dev, ATH12K_SKB_RXCB(msdu)->paddr, 2288 msdu->len + skb_tailroom(msdu), 2289 DMA_FROM_DEVICE); 2290 2291 offset = packet_info->dma_length + ATH12K_MON_RX_DOT11_OFFSET; 2292 if (ath12k_dp_pkt_set_pktlen(msdu, offset)) { 2293 dev_kfree_skb_any(msdu); 2294 goto dest_replenish; 2295 } 2296 2297 if (!pmon->mon_mpdu->head) 2298 pmon->mon_mpdu->head = msdu; 2299 else 2300 pmon->mon_mpdu->tail->next = msdu; 2301 2302 pmon->mon_mpdu->tail = msdu; 2303 2304 dest_replenish: 2305 ath12k_dp_mon_buf_replenish(ab, buf_ring, 1); 2306 2307 return 0; 2308 } 2309 2310 static int 2311 ath12k_dp_mon_parse_rx_dest_tlv(struct ath12k *ar, 2312 struct ath12k_mon_data *pmon, 2313 enum hal_rx_mon_status hal_status, 2314 const void *tlv_data) 2315 { 2316 switch (hal_status) { 2317 case HAL_RX_MON_STATUS_MPDU_START: 2318 if (WARN_ON_ONCE(pmon->mon_mpdu)) 2319 break; 2320 2321 pmon->mon_mpdu = kzalloc(sizeof(*pmon->mon_mpdu), GFP_ATOMIC); 2322 if (!pmon->mon_mpdu) 2323 return -ENOMEM; 2324 break; 2325 case HAL_RX_MON_STATUS_BUF_ADDR: 2326 return ath12k_dp_mon_parse_status_buf(ar, pmon, tlv_data); 2327 case HAL_RX_MON_STATUS_MPDU_END: 2328 /* If no MSDU then free empty MPDU */ 2329 if (pmon->mon_mpdu->tail) { 2330 pmon->mon_mpdu->tail->next = NULL; 2331 list_add_tail(&pmon->mon_mpdu->list, &pmon->dp_rx_mon_mpdu_list); 2332 } else { 2333 kfree(pmon->mon_mpdu); 2334 } 2335 pmon->mon_mpdu = NULL; 2336 break; 2337 case HAL_RX_MON_STATUS_MSDU_END: 2338 return ath12k_dp_mon_parse_status_msdu_end(pmon, tlv_data); 2339 default: 2340 break; 2341 } 2342 2343 return 0; 2344 } 2345 2346 static enum hal_rx_mon_status 2347 ath12k_dp_mon_parse_rx_dest(struct ath12k *ar, struct ath12k_mon_data *pmon, 2348 struct sk_buff *skb) 2349 { 2350 struct hal_tlv_64_hdr *tlv; 2351 struct ath12k_skb_rxcb *rxcb; 2352 enum hal_rx_mon_status hal_status; 2353 u16 tlv_tag, tlv_len; 2354 u8 *ptr = skb->data; 2355 2356 do { 2357 tlv = (struct hal_tlv_64_hdr *)ptr; 2358 tlv_tag = le64_get_bits(tlv->tl, HAL_TLV_64_HDR_TAG); 2359 2360 /* The actual length of PPDU_END is the combined length of many PHY 2361 * TLVs that follow. Skip the TLV header and 2362 * rx_rxpcu_classification_overview that follows the header to get to 2363 * next TLV. 2364 */ 2365 2366 if (tlv_tag == HAL_RX_PPDU_END) 2367 tlv_len = sizeof(struct hal_rx_rxpcu_classification_overview); 2368 else 2369 tlv_len = le64_get_bits(tlv->tl, HAL_TLV_64_HDR_LEN); 2370 2371 hal_status = ath12k_dp_mon_rx_parse_status_tlv(ar, pmon, tlv); 2372 2373 if (ar->monitor_started && 2374 ath12k_dp_mon_parse_rx_dest_tlv(ar, pmon, hal_status, tlv->value)) 2375 return HAL_RX_MON_STATUS_PPDU_DONE; 2376 2377 ptr += sizeof(*tlv) + tlv_len; 2378 ptr = PTR_ALIGN(ptr, HAL_TLV_64_ALIGN); 2379 2380 if ((ptr - skb->data) > skb->len) 2381 break; 2382 2383 } while ((hal_status == HAL_RX_MON_STATUS_PPDU_NOT_DONE) || 2384 (hal_status == HAL_RX_MON_STATUS_BUF_ADDR) || 2385 (hal_status == HAL_RX_MON_STATUS_MPDU_START) || 2386 (hal_status == HAL_RX_MON_STATUS_MPDU_END) || 2387 (hal_status == HAL_RX_MON_STATUS_MSDU_END)); 2388 2389 rxcb = ATH12K_SKB_RXCB(skb); 2390 if (rxcb->is_end_of_ppdu) 2391 hal_status = HAL_RX_MON_STATUS_PPDU_DONE; 2392 2393 return hal_status; 2394 } 2395 2396 enum hal_rx_mon_status 2397 ath12k_dp_mon_rx_parse_mon_status(struct ath12k *ar, 2398 struct ath12k_mon_data *pmon, 2399 struct sk_buff *skb, 2400 struct napi_struct *napi) 2401 { 2402 struct hal_rx_mon_ppdu_info *ppdu_info = &pmon->mon_ppdu_info; 2403 struct dp_mon_mpdu *tmp; 2404 struct dp_mon_mpdu *mon_mpdu = pmon->mon_mpdu; 2405 enum hal_rx_mon_status hal_status; 2406 2407 hal_status = ath12k_dp_mon_parse_rx_dest(ar, pmon, skb); 2408 if (hal_status != HAL_RX_MON_STATUS_PPDU_DONE) 2409 return hal_status; 2410 2411 list_for_each_entry_safe(mon_mpdu, tmp, &pmon->dp_rx_mon_mpdu_list, list) { 2412 list_del(&mon_mpdu->list); 2413 2414 if (mon_mpdu->head && mon_mpdu->tail) 2415 ath12k_dp_mon_rx_deliver(ar, mon_mpdu, ppdu_info, napi); 2416 2417 kfree(mon_mpdu); 2418 } 2419 2420 return hal_status; 2421 } 2422 2423 int ath12k_dp_mon_buf_replenish(struct ath12k_base *ab, 2424 struct dp_rxdma_mon_ring *buf_ring, 2425 int req_entries) 2426 { 2427 struct hal_mon_buf_ring *mon_buf; 2428 struct sk_buff *skb; 2429 struct hal_srng *srng; 2430 dma_addr_t paddr; 2431 u32 cookie; 2432 int buf_id; 2433 2434 srng = &ab->hal.srng_list[buf_ring->refill_buf_ring.ring_id]; 2435 spin_lock_bh(&srng->lock); 2436 ath12k_hal_srng_access_begin(ab, srng); 2437 2438 while (req_entries > 0) { 2439 skb = dev_alloc_skb(DP_RX_BUFFER_SIZE + DP_RX_BUFFER_ALIGN_SIZE); 2440 if (unlikely(!skb)) 2441 goto fail_alloc_skb; 2442 2443 if (!IS_ALIGNED((unsigned long)skb->data, DP_RX_BUFFER_ALIGN_SIZE)) { 2444 skb_pull(skb, 2445 PTR_ALIGN(skb->data, DP_RX_BUFFER_ALIGN_SIZE) - 2446 skb->data); 2447 } 2448 2449 paddr = dma_map_single(ab->dev, skb->data, 2450 skb->len + skb_tailroom(skb), 2451 DMA_FROM_DEVICE); 2452 2453 if (unlikely(dma_mapping_error(ab->dev, paddr))) 2454 goto fail_free_skb; 2455 2456 spin_lock_bh(&buf_ring->idr_lock); 2457 buf_id = idr_alloc(&buf_ring->bufs_idr, skb, 0, 2458 buf_ring->bufs_max * 3, GFP_ATOMIC); 2459 spin_unlock_bh(&buf_ring->idr_lock); 2460 2461 if (unlikely(buf_id < 0)) 2462 goto fail_dma_unmap; 2463 2464 mon_buf = ath12k_hal_srng_src_get_next_entry(ab, srng); 2465 if (unlikely(!mon_buf)) 2466 goto fail_idr_remove; 2467 2468 ATH12K_SKB_RXCB(skb)->paddr = paddr; 2469 2470 cookie = u32_encode_bits(buf_id, DP_RXDMA_BUF_COOKIE_BUF_ID); 2471 2472 mon_buf->paddr_lo = cpu_to_le32(lower_32_bits(paddr)); 2473 mon_buf->paddr_hi = cpu_to_le32(upper_32_bits(paddr)); 2474 mon_buf->cookie = cpu_to_le64(cookie); 2475 2476 req_entries--; 2477 } 2478 2479 ath12k_hal_srng_access_end(ab, srng); 2480 spin_unlock_bh(&srng->lock); 2481 return 0; 2482 2483 fail_idr_remove: 2484 spin_lock_bh(&buf_ring->idr_lock); 2485 idr_remove(&buf_ring->bufs_idr, buf_id); 2486 spin_unlock_bh(&buf_ring->idr_lock); 2487 fail_dma_unmap: 2488 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb), 2489 DMA_FROM_DEVICE); 2490 fail_free_skb: 2491 dev_kfree_skb_any(skb); 2492 fail_alloc_skb: 2493 ath12k_hal_srng_access_end(ab, srng); 2494 spin_unlock_bh(&srng->lock); 2495 return -ENOMEM; 2496 } 2497 2498 static struct dp_mon_tx_ppdu_info * 2499 ath12k_dp_mon_tx_get_ppdu_info(struct ath12k_mon_data *pmon, 2500 unsigned int ppdu_id, 2501 enum dp_mon_tx_ppdu_info_type type) 2502 { 2503 struct dp_mon_tx_ppdu_info *tx_ppdu_info; 2504 2505 if (type == DP_MON_TX_PROT_PPDU_INFO) { 2506 tx_ppdu_info = pmon->tx_prot_ppdu_info; 2507 2508 if (tx_ppdu_info && !tx_ppdu_info->is_used) 2509 return tx_ppdu_info; 2510 kfree(tx_ppdu_info); 2511 } else { 2512 tx_ppdu_info = pmon->tx_data_ppdu_info; 2513 2514 if (tx_ppdu_info && !tx_ppdu_info->is_used) 2515 return tx_ppdu_info; 2516 kfree(tx_ppdu_info); 2517 } 2518 2519 /* allocate new tx_ppdu_info */ 2520 tx_ppdu_info = kzalloc(sizeof(*tx_ppdu_info), GFP_ATOMIC); 2521 if (!tx_ppdu_info) 2522 return NULL; 2523 2524 tx_ppdu_info->is_used = 0; 2525 tx_ppdu_info->ppdu_id = ppdu_id; 2526 2527 if (type == DP_MON_TX_PROT_PPDU_INFO) 2528 pmon->tx_prot_ppdu_info = tx_ppdu_info; 2529 else 2530 pmon->tx_data_ppdu_info = tx_ppdu_info; 2531 2532 return tx_ppdu_info; 2533 } 2534 2535 static struct dp_mon_tx_ppdu_info * 2536 ath12k_dp_mon_hal_tx_ppdu_info(struct ath12k_mon_data *pmon, 2537 u16 tlv_tag) 2538 { 2539 switch (tlv_tag) { 2540 case HAL_TX_FES_SETUP: 2541 case HAL_TX_FLUSH: 2542 case HAL_PCU_PPDU_SETUP_INIT: 2543 case HAL_TX_PEER_ENTRY: 2544 case HAL_TX_QUEUE_EXTENSION: 2545 case HAL_TX_MPDU_START: 2546 case HAL_TX_MSDU_START: 2547 case HAL_TX_DATA: 2548 case HAL_MON_BUF_ADDR: 2549 case HAL_TX_MPDU_END: 2550 case HAL_TX_LAST_MPDU_FETCHED: 2551 case HAL_TX_LAST_MPDU_END: 2552 case HAL_COEX_TX_REQ: 2553 case HAL_TX_RAW_OR_NATIVE_FRAME_SETUP: 2554 case HAL_SCH_CRITICAL_TLV_REFERENCE: 2555 case HAL_TX_FES_SETUP_COMPLETE: 2556 case HAL_TQM_MPDU_GLOBAL_START: 2557 case HAL_SCHEDULER_END: 2558 case HAL_TX_FES_STATUS_USER_PPDU: 2559 break; 2560 case HAL_TX_FES_STATUS_PROT: { 2561 if (!pmon->tx_prot_ppdu_info->is_used) 2562 pmon->tx_prot_ppdu_info->is_used = true; 2563 2564 return pmon->tx_prot_ppdu_info; 2565 } 2566 } 2567 2568 if (!pmon->tx_data_ppdu_info->is_used) 2569 pmon->tx_data_ppdu_info->is_used = true; 2570 2571 return pmon->tx_data_ppdu_info; 2572 } 2573 2574 #define MAX_MONITOR_HEADER 512 2575 #define MAX_DUMMY_FRM_BODY 128 2576 2577 struct sk_buff *ath12k_dp_mon_tx_alloc_skb(void) 2578 { 2579 struct sk_buff *skb; 2580 2581 skb = dev_alloc_skb(MAX_MONITOR_HEADER + MAX_DUMMY_FRM_BODY); 2582 if (!skb) 2583 return NULL; 2584 2585 skb_reserve(skb, MAX_MONITOR_HEADER); 2586 2587 if (!IS_ALIGNED((unsigned long)skb->data, 4)) 2588 skb_pull(skb, PTR_ALIGN(skb->data, 4) - skb->data); 2589 2590 return skb; 2591 } 2592 2593 static int 2594 ath12k_dp_mon_tx_gen_cts2self_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info) 2595 { 2596 struct sk_buff *skb; 2597 struct ieee80211_cts *cts; 2598 2599 skb = ath12k_dp_mon_tx_alloc_skb(); 2600 if (!skb) 2601 return -ENOMEM; 2602 2603 cts = (struct ieee80211_cts *)skb->data; 2604 memset(cts, 0, MAX_DUMMY_FRM_BODY); 2605 cts->frame_control = 2606 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS); 2607 cts->duration = cpu_to_le16(tx_ppdu_info->rx_status.rx_duration); 2608 memcpy(cts->ra, tx_ppdu_info->rx_status.addr1, sizeof(cts->ra)); 2609 2610 skb_put(skb, sizeof(*cts)); 2611 tx_ppdu_info->tx_mon_mpdu->head = skb; 2612 tx_ppdu_info->tx_mon_mpdu->tail = NULL; 2613 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list, 2614 &tx_ppdu_info->dp_tx_mon_mpdu_list); 2615 2616 return 0; 2617 } 2618 2619 static int 2620 ath12k_dp_mon_tx_gen_rts_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info) 2621 { 2622 struct sk_buff *skb; 2623 struct ieee80211_rts *rts; 2624 2625 skb = ath12k_dp_mon_tx_alloc_skb(); 2626 if (!skb) 2627 return -ENOMEM; 2628 2629 rts = (struct ieee80211_rts *)skb->data; 2630 memset(rts, 0, MAX_DUMMY_FRM_BODY); 2631 rts->frame_control = 2632 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS); 2633 rts->duration = cpu_to_le16(tx_ppdu_info->rx_status.rx_duration); 2634 memcpy(rts->ra, tx_ppdu_info->rx_status.addr1, sizeof(rts->ra)); 2635 memcpy(rts->ta, tx_ppdu_info->rx_status.addr2, sizeof(rts->ta)); 2636 2637 skb_put(skb, sizeof(*rts)); 2638 tx_ppdu_info->tx_mon_mpdu->head = skb; 2639 tx_ppdu_info->tx_mon_mpdu->tail = NULL; 2640 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list, 2641 &tx_ppdu_info->dp_tx_mon_mpdu_list); 2642 2643 return 0; 2644 } 2645 2646 static int 2647 ath12k_dp_mon_tx_gen_3addr_qos_null_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info) 2648 { 2649 struct sk_buff *skb; 2650 struct ieee80211_qos_hdr *qhdr; 2651 2652 skb = ath12k_dp_mon_tx_alloc_skb(); 2653 if (!skb) 2654 return -ENOMEM; 2655 2656 qhdr = (struct ieee80211_qos_hdr *)skb->data; 2657 memset(qhdr, 0, MAX_DUMMY_FRM_BODY); 2658 qhdr->frame_control = 2659 cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_QOS_NULLFUNC); 2660 qhdr->duration_id = cpu_to_le16(tx_ppdu_info->rx_status.rx_duration); 2661 memcpy(qhdr->addr1, tx_ppdu_info->rx_status.addr1, ETH_ALEN); 2662 memcpy(qhdr->addr2, tx_ppdu_info->rx_status.addr2, ETH_ALEN); 2663 memcpy(qhdr->addr3, tx_ppdu_info->rx_status.addr3, ETH_ALEN); 2664 2665 skb_put(skb, sizeof(*qhdr)); 2666 tx_ppdu_info->tx_mon_mpdu->head = skb; 2667 tx_ppdu_info->tx_mon_mpdu->tail = NULL; 2668 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list, 2669 &tx_ppdu_info->dp_tx_mon_mpdu_list); 2670 2671 return 0; 2672 } 2673 2674 static int 2675 ath12k_dp_mon_tx_gen_4addr_qos_null_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info) 2676 { 2677 struct sk_buff *skb; 2678 struct dp_mon_qosframe_addr4 *qhdr; 2679 2680 skb = ath12k_dp_mon_tx_alloc_skb(); 2681 if (!skb) 2682 return -ENOMEM; 2683 2684 qhdr = (struct dp_mon_qosframe_addr4 *)skb->data; 2685 memset(qhdr, 0, MAX_DUMMY_FRM_BODY); 2686 qhdr->frame_control = 2687 cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_QOS_NULLFUNC); 2688 qhdr->duration = cpu_to_le16(tx_ppdu_info->rx_status.rx_duration); 2689 memcpy(qhdr->addr1, tx_ppdu_info->rx_status.addr1, ETH_ALEN); 2690 memcpy(qhdr->addr2, tx_ppdu_info->rx_status.addr2, ETH_ALEN); 2691 memcpy(qhdr->addr3, tx_ppdu_info->rx_status.addr3, ETH_ALEN); 2692 memcpy(qhdr->addr4, tx_ppdu_info->rx_status.addr4, ETH_ALEN); 2693 2694 skb_put(skb, sizeof(*qhdr)); 2695 tx_ppdu_info->tx_mon_mpdu->head = skb; 2696 tx_ppdu_info->tx_mon_mpdu->tail = NULL; 2697 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list, 2698 &tx_ppdu_info->dp_tx_mon_mpdu_list); 2699 2700 return 0; 2701 } 2702 2703 static int 2704 ath12k_dp_mon_tx_gen_ack_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info) 2705 { 2706 struct sk_buff *skb; 2707 struct dp_mon_frame_min_one *fbmhdr; 2708 2709 skb = ath12k_dp_mon_tx_alloc_skb(); 2710 if (!skb) 2711 return -ENOMEM; 2712 2713 fbmhdr = (struct dp_mon_frame_min_one *)skb->data; 2714 memset(fbmhdr, 0, MAX_DUMMY_FRM_BODY); 2715 fbmhdr->frame_control = 2716 cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_QOS_CFACK); 2717 memcpy(fbmhdr->addr1, tx_ppdu_info->rx_status.addr1, ETH_ALEN); 2718 2719 /* set duration zero for ack frame */ 2720 fbmhdr->duration = 0; 2721 2722 skb_put(skb, sizeof(*fbmhdr)); 2723 tx_ppdu_info->tx_mon_mpdu->head = skb; 2724 tx_ppdu_info->tx_mon_mpdu->tail = NULL; 2725 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list, 2726 &tx_ppdu_info->dp_tx_mon_mpdu_list); 2727 2728 return 0; 2729 } 2730 2731 static int 2732 ath12k_dp_mon_tx_gen_prot_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info) 2733 { 2734 int ret = 0; 2735 2736 switch (tx_ppdu_info->rx_status.medium_prot_type) { 2737 case DP_MON_TX_MEDIUM_RTS_LEGACY: 2738 case DP_MON_TX_MEDIUM_RTS_11AC_STATIC_BW: 2739 case DP_MON_TX_MEDIUM_RTS_11AC_DYNAMIC_BW: 2740 ret = ath12k_dp_mon_tx_gen_rts_frame(tx_ppdu_info); 2741 break; 2742 case DP_MON_TX_MEDIUM_CTS2SELF: 2743 ret = ath12k_dp_mon_tx_gen_cts2self_frame(tx_ppdu_info); 2744 break; 2745 case DP_MON_TX_MEDIUM_QOS_NULL_NO_ACK_3ADDR: 2746 ret = ath12k_dp_mon_tx_gen_3addr_qos_null_frame(tx_ppdu_info); 2747 break; 2748 case DP_MON_TX_MEDIUM_QOS_NULL_NO_ACK_4ADDR: 2749 ret = ath12k_dp_mon_tx_gen_4addr_qos_null_frame(tx_ppdu_info); 2750 break; 2751 } 2752 2753 return ret; 2754 } 2755 2756 static enum dp_mon_tx_tlv_status 2757 ath12k_dp_mon_tx_parse_status_tlv(struct ath12k_base *ab, 2758 struct ath12k_mon_data *pmon, 2759 u16 tlv_tag, const void *tlv_data, u32 userid) 2760 { 2761 struct dp_mon_tx_ppdu_info *tx_ppdu_info; 2762 enum dp_mon_tx_tlv_status status = DP_MON_TX_STATUS_PPDU_NOT_DONE; 2763 u32 info[7]; 2764 2765 tx_ppdu_info = ath12k_dp_mon_hal_tx_ppdu_info(pmon, tlv_tag); 2766 2767 switch (tlv_tag) { 2768 case HAL_TX_FES_SETUP: { 2769 const struct hal_tx_fes_setup *tx_fes_setup = tlv_data; 2770 2771 info[0] = __le32_to_cpu(tx_fes_setup->info0); 2772 tx_ppdu_info->ppdu_id = __le32_to_cpu(tx_fes_setup->schedule_id); 2773 tx_ppdu_info->num_users = 2774 u32_get_bits(info[0], HAL_TX_FES_SETUP_INFO0_NUM_OF_USERS); 2775 status = DP_MON_TX_FES_SETUP; 2776 break; 2777 } 2778 2779 case HAL_TX_FES_STATUS_END: { 2780 const struct hal_tx_fes_status_end *tx_fes_status_end = tlv_data; 2781 u32 tst_15_0, tst_31_16; 2782 2783 info[0] = __le32_to_cpu(tx_fes_status_end->info0); 2784 tst_15_0 = 2785 u32_get_bits(info[0], 2786 HAL_TX_FES_STATUS_END_INFO0_START_TIMESTAMP_15_0); 2787 tst_31_16 = 2788 u32_get_bits(info[0], 2789 HAL_TX_FES_STATUS_END_INFO0_START_TIMESTAMP_31_16); 2790 2791 tx_ppdu_info->rx_status.ppdu_ts = (tst_15_0 | (tst_31_16 << 16)); 2792 status = DP_MON_TX_FES_STATUS_END; 2793 break; 2794 } 2795 2796 case HAL_RX_RESPONSE_REQUIRED_INFO: { 2797 const struct hal_rx_resp_req_info *rx_resp_req_info = tlv_data; 2798 u32 addr_32; 2799 u16 addr_16; 2800 2801 info[0] = __le32_to_cpu(rx_resp_req_info->info0); 2802 info[1] = __le32_to_cpu(rx_resp_req_info->info1); 2803 info[2] = __le32_to_cpu(rx_resp_req_info->info2); 2804 info[3] = __le32_to_cpu(rx_resp_req_info->info3); 2805 info[4] = __le32_to_cpu(rx_resp_req_info->info4); 2806 info[5] = __le32_to_cpu(rx_resp_req_info->info5); 2807 2808 tx_ppdu_info->rx_status.ppdu_id = 2809 u32_get_bits(info[0], HAL_RX_RESP_REQ_INFO0_PPDU_ID); 2810 tx_ppdu_info->rx_status.reception_type = 2811 u32_get_bits(info[0], HAL_RX_RESP_REQ_INFO0_RECEPTION_TYPE); 2812 tx_ppdu_info->rx_status.rx_duration = 2813 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_DURATION); 2814 tx_ppdu_info->rx_status.mcs = 2815 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_RATE_MCS); 2816 tx_ppdu_info->rx_status.sgi = 2817 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_SGI); 2818 tx_ppdu_info->rx_status.is_stbc = 2819 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_STBC); 2820 tx_ppdu_info->rx_status.ldpc = 2821 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_LDPC); 2822 tx_ppdu_info->rx_status.is_ampdu = 2823 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_IS_AMPDU); 2824 tx_ppdu_info->rx_status.num_users = 2825 u32_get_bits(info[2], HAL_RX_RESP_REQ_INFO2_NUM_USER); 2826 2827 addr_32 = u32_get_bits(info[3], HAL_RX_RESP_REQ_INFO3_ADDR1_31_0); 2828 addr_16 = u32_get_bits(info[3], HAL_RX_RESP_REQ_INFO4_ADDR1_47_32); 2829 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr1); 2830 2831 addr_16 = u32_get_bits(info[4], HAL_RX_RESP_REQ_INFO4_ADDR1_15_0); 2832 addr_32 = u32_get_bits(info[5], HAL_RX_RESP_REQ_INFO5_ADDR1_47_16); 2833 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr2); 2834 2835 if (tx_ppdu_info->rx_status.reception_type == 0) 2836 ath12k_dp_mon_tx_gen_cts2self_frame(tx_ppdu_info); 2837 status = DP_MON_RX_RESPONSE_REQUIRED_INFO; 2838 break; 2839 } 2840 2841 case HAL_PCU_PPDU_SETUP_INIT: { 2842 const struct hal_tx_pcu_ppdu_setup_init *ppdu_setup = tlv_data; 2843 u32 addr_32; 2844 u16 addr_16; 2845 2846 info[0] = __le32_to_cpu(ppdu_setup->info0); 2847 info[1] = __le32_to_cpu(ppdu_setup->info1); 2848 info[2] = __le32_to_cpu(ppdu_setup->info2); 2849 info[3] = __le32_to_cpu(ppdu_setup->info3); 2850 info[4] = __le32_to_cpu(ppdu_setup->info4); 2851 info[5] = __le32_to_cpu(ppdu_setup->info5); 2852 info[6] = __le32_to_cpu(ppdu_setup->info6); 2853 2854 /* protection frame address 1 */ 2855 addr_32 = u32_get_bits(info[1], 2856 HAL_TX_PPDU_SETUP_INFO1_PROT_FRAME_ADDR1_31_0); 2857 addr_16 = u32_get_bits(info[2], 2858 HAL_TX_PPDU_SETUP_INFO2_PROT_FRAME_ADDR1_47_32); 2859 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr1); 2860 2861 /* protection frame address 2 */ 2862 addr_16 = u32_get_bits(info[2], 2863 HAL_TX_PPDU_SETUP_INFO2_PROT_FRAME_ADDR2_15_0); 2864 addr_32 = u32_get_bits(info[3], 2865 HAL_TX_PPDU_SETUP_INFO3_PROT_FRAME_ADDR2_47_16); 2866 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr2); 2867 2868 /* protection frame address 3 */ 2869 addr_32 = u32_get_bits(info[4], 2870 HAL_TX_PPDU_SETUP_INFO4_PROT_FRAME_ADDR3_31_0); 2871 addr_16 = u32_get_bits(info[5], 2872 HAL_TX_PPDU_SETUP_INFO5_PROT_FRAME_ADDR3_47_32); 2873 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr3); 2874 2875 /* protection frame address 4 */ 2876 addr_16 = u32_get_bits(info[5], 2877 HAL_TX_PPDU_SETUP_INFO5_PROT_FRAME_ADDR4_15_0); 2878 addr_32 = u32_get_bits(info[6], 2879 HAL_TX_PPDU_SETUP_INFO6_PROT_FRAME_ADDR4_47_16); 2880 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr4); 2881 2882 status = u32_get_bits(info[0], 2883 HAL_TX_PPDU_SETUP_INFO0_MEDIUM_PROT_TYPE); 2884 break; 2885 } 2886 2887 case HAL_TX_QUEUE_EXTENSION: { 2888 const struct hal_tx_queue_exten *tx_q_exten = tlv_data; 2889 2890 info[0] = __le32_to_cpu(tx_q_exten->info0); 2891 2892 tx_ppdu_info->rx_status.frame_control = 2893 u32_get_bits(info[0], 2894 HAL_TX_Q_EXT_INFO0_FRAME_CTRL); 2895 tx_ppdu_info->rx_status.fc_valid = true; 2896 break; 2897 } 2898 2899 case HAL_TX_FES_STATUS_START: { 2900 const struct hal_tx_fes_status_start *tx_fes_start = tlv_data; 2901 2902 info[0] = __le32_to_cpu(tx_fes_start->info0); 2903 2904 tx_ppdu_info->rx_status.medium_prot_type = 2905 u32_get_bits(info[0], 2906 HAL_TX_FES_STATUS_START_INFO0_MEDIUM_PROT_TYPE); 2907 break; 2908 } 2909 2910 case HAL_TX_FES_STATUS_PROT: { 2911 const struct hal_tx_fes_status_prot *tx_fes_status = tlv_data; 2912 u32 start_timestamp; 2913 u32 end_timestamp; 2914 2915 info[0] = __le32_to_cpu(tx_fes_status->info0); 2916 info[1] = __le32_to_cpu(tx_fes_status->info1); 2917 2918 start_timestamp = 2919 u32_get_bits(info[0], 2920 HAL_TX_FES_STAT_PROT_INFO0_STRT_FRM_TS_15_0); 2921 start_timestamp |= 2922 u32_get_bits(info[0], 2923 HAL_TX_FES_STAT_PROT_INFO0_STRT_FRM_TS_31_16) << 15; 2924 end_timestamp = 2925 u32_get_bits(info[1], 2926 HAL_TX_FES_STAT_PROT_INFO1_END_FRM_TS_15_0); 2927 end_timestamp |= 2928 u32_get_bits(info[1], 2929 HAL_TX_FES_STAT_PROT_INFO1_END_FRM_TS_31_16) << 15; 2930 tx_ppdu_info->rx_status.rx_duration = end_timestamp - start_timestamp; 2931 2932 ath12k_dp_mon_tx_gen_prot_frame(tx_ppdu_info); 2933 break; 2934 } 2935 2936 case HAL_TX_FES_STATUS_START_PPDU: 2937 case HAL_TX_FES_STATUS_START_PROT: { 2938 const struct hal_tx_fes_status_start_prot *tx_fes_stat_start = tlv_data; 2939 u64 ppdu_ts; 2940 2941 info[0] = __le32_to_cpu(tx_fes_stat_start->info0); 2942 2943 tx_ppdu_info->rx_status.ppdu_ts = 2944 u32_get_bits(info[0], 2945 HAL_TX_FES_STAT_STRT_INFO0_PROT_TS_LOWER_32); 2946 ppdu_ts = (u32_get_bits(info[1], 2947 HAL_TX_FES_STAT_STRT_INFO1_PROT_TS_UPPER_32)); 2948 tx_ppdu_info->rx_status.ppdu_ts |= ppdu_ts << 32; 2949 break; 2950 } 2951 2952 case HAL_TX_FES_STATUS_USER_PPDU: { 2953 const struct hal_tx_fes_status_user_ppdu *tx_fes_usr_ppdu = tlv_data; 2954 2955 info[0] = __le32_to_cpu(tx_fes_usr_ppdu->info0); 2956 2957 tx_ppdu_info->rx_status.rx_duration = 2958 u32_get_bits(info[0], 2959 HAL_TX_FES_STAT_USR_PPDU_INFO0_DURATION); 2960 break; 2961 } 2962 2963 case HAL_MACTX_HE_SIG_A_SU: 2964 ath12k_dp_mon_parse_he_sig_su(tlv_data, &tx_ppdu_info->rx_status); 2965 break; 2966 2967 case HAL_MACTX_HE_SIG_A_MU_DL: 2968 ath12k_dp_mon_parse_he_sig_mu(tlv_data, &tx_ppdu_info->rx_status); 2969 break; 2970 2971 case HAL_MACTX_HE_SIG_B1_MU: 2972 ath12k_dp_mon_parse_he_sig_b1_mu(tlv_data, &tx_ppdu_info->rx_status); 2973 break; 2974 2975 case HAL_MACTX_HE_SIG_B2_MU: 2976 ath12k_dp_mon_parse_he_sig_b2_mu(tlv_data, &tx_ppdu_info->rx_status); 2977 break; 2978 2979 case HAL_MACTX_HE_SIG_B2_OFDMA: 2980 ath12k_dp_mon_parse_he_sig_b2_ofdma(tlv_data, &tx_ppdu_info->rx_status); 2981 break; 2982 2983 case HAL_MACTX_VHT_SIG_A: 2984 ath12k_dp_mon_parse_vht_sig_a(tlv_data, &tx_ppdu_info->rx_status); 2985 break; 2986 2987 case HAL_MACTX_L_SIG_A: 2988 ath12k_dp_mon_parse_l_sig_a(tlv_data, &tx_ppdu_info->rx_status); 2989 break; 2990 2991 case HAL_MACTX_L_SIG_B: 2992 ath12k_dp_mon_parse_l_sig_b(tlv_data, &tx_ppdu_info->rx_status); 2993 break; 2994 2995 case HAL_RX_FRAME_BITMAP_ACK: { 2996 const struct hal_rx_frame_bitmap_ack *fbm_ack = tlv_data; 2997 u32 addr_32; 2998 u16 addr_16; 2999 3000 info[0] = __le32_to_cpu(fbm_ack->info0); 3001 info[1] = __le32_to_cpu(fbm_ack->info1); 3002 3003 addr_32 = u32_get_bits(info[0], 3004 HAL_RX_FBM_ACK_INFO0_ADDR1_31_0); 3005 addr_16 = u32_get_bits(info[1], 3006 HAL_RX_FBM_ACK_INFO1_ADDR1_47_32); 3007 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr1); 3008 3009 ath12k_dp_mon_tx_gen_ack_frame(tx_ppdu_info); 3010 break; 3011 } 3012 3013 case HAL_MACTX_PHY_DESC: { 3014 const struct hal_tx_phy_desc *tx_phy_desc = tlv_data; 3015 3016 info[0] = __le32_to_cpu(tx_phy_desc->info0); 3017 info[1] = __le32_to_cpu(tx_phy_desc->info1); 3018 info[2] = __le32_to_cpu(tx_phy_desc->info2); 3019 info[3] = __le32_to_cpu(tx_phy_desc->info3); 3020 3021 tx_ppdu_info->rx_status.beamformed = 3022 u32_get_bits(info[0], 3023 HAL_TX_PHY_DESC_INFO0_BF_TYPE); 3024 tx_ppdu_info->rx_status.preamble_type = 3025 u32_get_bits(info[0], 3026 HAL_TX_PHY_DESC_INFO0_PREAMBLE_11B); 3027 tx_ppdu_info->rx_status.mcs = 3028 u32_get_bits(info[1], 3029 HAL_TX_PHY_DESC_INFO1_MCS); 3030 tx_ppdu_info->rx_status.ltf_size = 3031 u32_get_bits(info[3], 3032 HAL_TX_PHY_DESC_INFO3_LTF_SIZE); 3033 tx_ppdu_info->rx_status.nss = 3034 u32_get_bits(info[2], 3035 HAL_TX_PHY_DESC_INFO2_NSS); 3036 tx_ppdu_info->rx_status.chan_num = 3037 u32_get_bits(info[3], 3038 HAL_TX_PHY_DESC_INFO3_ACTIVE_CHANNEL); 3039 tx_ppdu_info->rx_status.bw = 3040 u32_get_bits(info[0], 3041 HAL_TX_PHY_DESC_INFO0_BANDWIDTH); 3042 break; 3043 } 3044 3045 case HAL_TX_MPDU_START: { 3046 struct dp_mon_mpdu *mon_mpdu = tx_ppdu_info->tx_mon_mpdu; 3047 3048 mon_mpdu = kzalloc(sizeof(*mon_mpdu), GFP_ATOMIC); 3049 if (!mon_mpdu) 3050 return DP_MON_TX_STATUS_PPDU_NOT_DONE; 3051 status = DP_MON_TX_MPDU_START; 3052 break; 3053 } 3054 3055 case HAL_TX_MPDU_END: 3056 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list, 3057 &tx_ppdu_info->dp_tx_mon_mpdu_list); 3058 break; 3059 } 3060 3061 return status; 3062 } 3063 3064 enum dp_mon_tx_tlv_status 3065 ath12k_dp_mon_tx_status_get_num_user(u16 tlv_tag, 3066 struct hal_tlv_hdr *tx_tlv, 3067 u8 *num_users) 3068 { 3069 u32 tlv_status = DP_MON_TX_STATUS_PPDU_NOT_DONE; 3070 u32 info0; 3071 3072 switch (tlv_tag) { 3073 case HAL_TX_FES_SETUP: { 3074 struct hal_tx_fes_setup *tx_fes_setup = 3075 (struct hal_tx_fes_setup *)tx_tlv; 3076 3077 info0 = __le32_to_cpu(tx_fes_setup->info0); 3078 3079 *num_users = u32_get_bits(info0, HAL_TX_FES_SETUP_INFO0_NUM_OF_USERS); 3080 tlv_status = DP_MON_TX_FES_SETUP; 3081 break; 3082 } 3083 3084 case HAL_RX_RESPONSE_REQUIRED_INFO: { 3085 /* TODO: need to update *num_users */ 3086 tlv_status = DP_MON_RX_RESPONSE_REQUIRED_INFO; 3087 break; 3088 } 3089 } 3090 3091 return tlv_status; 3092 } 3093 3094 static void 3095 ath12k_dp_mon_tx_process_ppdu_info(struct ath12k *ar, 3096 struct napi_struct *napi, 3097 struct dp_mon_tx_ppdu_info *tx_ppdu_info) 3098 { 3099 struct dp_mon_mpdu *tmp, *mon_mpdu; 3100 3101 list_for_each_entry_safe(mon_mpdu, tmp, 3102 &tx_ppdu_info->dp_tx_mon_mpdu_list, list) { 3103 list_del(&mon_mpdu->list); 3104 3105 if (mon_mpdu->head) 3106 ath12k_dp_mon_rx_deliver(ar, mon_mpdu, 3107 &tx_ppdu_info->rx_status, napi); 3108 3109 kfree(mon_mpdu); 3110 } 3111 } 3112 3113 enum hal_rx_mon_status 3114 ath12k_dp_mon_tx_parse_mon_status(struct ath12k *ar, 3115 struct ath12k_mon_data *pmon, 3116 struct sk_buff *skb, 3117 struct napi_struct *napi, 3118 u32 ppdu_id) 3119 { 3120 struct ath12k_base *ab = ar->ab; 3121 struct dp_mon_tx_ppdu_info *tx_prot_ppdu_info, *tx_data_ppdu_info; 3122 struct hal_tlv_hdr *tlv; 3123 u8 *ptr = skb->data; 3124 u16 tlv_tag; 3125 u16 tlv_len; 3126 u32 tlv_userid = 0; 3127 u8 num_user; 3128 u32 tlv_status = DP_MON_TX_STATUS_PPDU_NOT_DONE; 3129 3130 tx_prot_ppdu_info = ath12k_dp_mon_tx_get_ppdu_info(pmon, ppdu_id, 3131 DP_MON_TX_PROT_PPDU_INFO); 3132 if (!tx_prot_ppdu_info) 3133 return -ENOMEM; 3134 3135 tlv = (struct hal_tlv_hdr *)ptr; 3136 tlv_tag = le32_get_bits(tlv->tl, HAL_TLV_HDR_TAG); 3137 3138 tlv_status = ath12k_dp_mon_tx_status_get_num_user(tlv_tag, tlv, &num_user); 3139 if (tlv_status == DP_MON_TX_STATUS_PPDU_NOT_DONE || !num_user) 3140 return -EINVAL; 3141 3142 tx_data_ppdu_info = ath12k_dp_mon_tx_get_ppdu_info(pmon, ppdu_id, 3143 DP_MON_TX_DATA_PPDU_INFO); 3144 if (!tx_data_ppdu_info) 3145 return -ENOMEM; 3146 3147 do { 3148 tlv = (struct hal_tlv_hdr *)ptr; 3149 tlv_tag = le32_get_bits(tlv->tl, HAL_TLV_HDR_TAG); 3150 tlv_len = le32_get_bits(tlv->tl, HAL_TLV_HDR_LEN); 3151 tlv_userid = le32_get_bits(tlv->tl, HAL_TLV_USR_ID); 3152 3153 tlv_status = ath12k_dp_mon_tx_parse_status_tlv(ab, pmon, 3154 tlv_tag, ptr, 3155 tlv_userid); 3156 ptr += tlv_len; 3157 ptr = PTR_ALIGN(ptr, HAL_TLV_ALIGN); 3158 if ((ptr - skb->data) >= DP_TX_MONITOR_BUF_SIZE) 3159 break; 3160 } while (tlv_status != DP_MON_TX_FES_STATUS_END); 3161 3162 ath12k_dp_mon_tx_process_ppdu_info(ar, napi, tx_data_ppdu_info); 3163 ath12k_dp_mon_tx_process_ppdu_info(ar, napi, tx_prot_ppdu_info); 3164 3165 return tlv_status; 3166 } 3167 3168 static void 3169 ath12k_dp_mon_rx_update_peer_rate_table_stats(struct ath12k_rx_peer_stats *rx_stats, 3170 struct hal_rx_mon_ppdu_info *ppdu_info, 3171 struct hal_rx_user_status *user_stats, 3172 u32 num_msdu) 3173 { 3174 struct ath12k_rx_peer_rate_stats *stats; 3175 u32 mcs_idx = (user_stats) ? user_stats->mcs : ppdu_info->mcs; 3176 u32 nss_idx = (user_stats) ? user_stats->nss - 1 : ppdu_info->nss - 1; 3177 u32 bw_idx = ppdu_info->bw; 3178 u32 gi_idx = ppdu_info->gi; 3179 u32 len; 3180 3181 if (mcs_idx > HAL_RX_MAX_MCS_HT || nss_idx >= HAL_RX_MAX_NSS || 3182 bw_idx >= HAL_RX_BW_MAX || gi_idx >= HAL_RX_GI_MAX) { 3183 return; 3184 } 3185 3186 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AX || 3187 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11BE) 3188 gi_idx = ath12k_he_gi_to_nl80211_he_gi(ppdu_info->gi); 3189 3190 rx_stats->pkt_stats.rx_rate[bw_idx][gi_idx][nss_idx][mcs_idx] += num_msdu; 3191 stats = &rx_stats->byte_stats; 3192 3193 if (user_stats) 3194 len = user_stats->mpdu_ok_byte_count; 3195 else 3196 len = ppdu_info->mpdu_len; 3197 3198 stats->rx_rate[bw_idx][gi_idx][nss_idx][mcs_idx] += len; 3199 } 3200 3201 static void ath12k_dp_mon_rx_update_peer_su_stats(struct ath12k *ar, 3202 struct ath12k_link_sta *arsta, 3203 struct hal_rx_mon_ppdu_info *ppdu_info) 3204 { 3205 struct ath12k_rx_peer_stats *rx_stats = arsta->rx_stats; 3206 u32 num_msdu; 3207 3208 arsta->rssi_comb = ppdu_info->rssi_comb; 3209 ewma_avg_rssi_add(&arsta->avg_rssi, ppdu_info->rssi_comb); 3210 if (!rx_stats) 3211 return; 3212 3213 num_msdu = ppdu_info->tcp_msdu_count + ppdu_info->tcp_ack_msdu_count + 3214 ppdu_info->udp_msdu_count + ppdu_info->other_msdu_count; 3215 3216 rx_stats->num_msdu += num_msdu; 3217 rx_stats->tcp_msdu_count += ppdu_info->tcp_msdu_count + 3218 ppdu_info->tcp_ack_msdu_count; 3219 rx_stats->udp_msdu_count += ppdu_info->udp_msdu_count; 3220 rx_stats->other_msdu_count += ppdu_info->other_msdu_count; 3221 3222 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A || 3223 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) { 3224 ppdu_info->nss = 1; 3225 ppdu_info->mcs = HAL_RX_MAX_MCS; 3226 ppdu_info->tid = IEEE80211_NUM_TIDS; 3227 } 3228 3229 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX) 3230 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu; 3231 3232 if (ppdu_info->tid <= IEEE80211_NUM_TIDS) 3233 rx_stats->tid_count[ppdu_info->tid] += num_msdu; 3234 3235 if (ppdu_info->preamble_type < HAL_RX_PREAMBLE_MAX) 3236 rx_stats->pream_cnt[ppdu_info->preamble_type] += num_msdu; 3237 3238 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX) 3239 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu; 3240 3241 if (ppdu_info->is_stbc) 3242 rx_stats->stbc_count += num_msdu; 3243 3244 if (ppdu_info->beamformed) 3245 rx_stats->beamformed_count += num_msdu; 3246 3247 if (ppdu_info->num_mpdu_fcs_ok > 1) 3248 rx_stats->ampdu_msdu_count += num_msdu; 3249 else 3250 rx_stats->non_ampdu_msdu_count += num_msdu; 3251 3252 rx_stats->num_mpdu_fcs_ok += ppdu_info->num_mpdu_fcs_ok; 3253 rx_stats->num_mpdu_fcs_err += ppdu_info->num_mpdu_fcs_err; 3254 rx_stats->dcm_count += ppdu_info->dcm; 3255 3256 rx_stats->rx_duration += ppdu_info->rx_duration; 3257 arsta->rx_duration = rx_stats->rx_duration; 3258 3259 if (ppdu_info->nss > 0 && ppdu_info->nss <= HAL_RX_MAX_NSS) { 3260 rx_stats->pkt_stats.nss_count[ppdu_info->nss - 1] += num_msdu; 3261 rx_stats->byte_stats.nss_count[ppdu_info->nss - 1] += ppdu_info->mpdu_len; 3262 } 3263 3264 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11N && 3265 ppdu_info->mcs <= HAL_RX_MAX_MCS_HT) { 3266 rx_stats->pkt_stats.ht_mcs_count[ppdu_info->mcs] += num_msdu; 3267 rx_stats->byte_stats.ht_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len; 3268 /* To fit into rate table for HT packets */ 3269 ppdu_info->mcs = ppdu_info->mcs % 8; 3270 } 3271 3272 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AC && 3273 ppdu_info->mcs <= HAL_RX_MAX_MCS_VHT) { 3274 rx_stats->pkt_stats.vht_mcs_count[ppdu_info->mcs] += num_msdu; 3275 rx_stats->byte_stats.vht_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len; 3276 } 3277 3278 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AX && 3279 ppdu_info->mcs <= HAL_RX_MAX_MCS_HE) { 3280 rx_stats->pkt_stats.he_mcs_count[ppdu_info->mcs] += num_msdu; 3281 rx_stats->byte_stats.he_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len; 3282 } 3283 3284 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11BE && 3285 ppdu_info->mcs <= HAL_RX_MAX_MCS_BE) { 3286 rx_stats->pkt_stats.be_mcs_count[ppdu_info->mcs] += num_msdu; 3287 rx_stats->byte_stats.be_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len; 3288 } 3289 3290 if ((ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A || 3291 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) && 3292 ppdu_info->rate < HAL_RX_LEGACY_RATE_INVALID) { 3293 rx_stats->pkt_stats.legacy_count[ppdu_info->rate] += num_msdu; 3294 rx_stats->byte_stats.legacy_count[ppdu_info->rate] += ppdu_info->mpdu_len; 3295 } 3296 3297 if (ppdu_info->gi < HAL_RX_GI_MAX) { 3298 rx_stats->pkt_stats.gi_count[ppdu_info->gi] += num_msdu; 3299 rx_stats->byte_stats.gi_count[ppdu_info->gi] += ppdu_info->mpdu_len; 3300 } 3301 3302 if (ppdu_info->bw < HAL_RX_BW_MAX) { 3303 rx_stats->pkt_stats.bw_count[ppdu_info->bw] += num_msdu; 3304 rx_stats->byte_stats.bw_count[ppdu_info->bw] += ppdu_info->mpdu_len; 3305 } 3306 3307 ath12k_dp_mon_rx_update_peer_rate_table_stats(rx_stats, ppdu_info, 3308 NULL, num_msdu); 3309 } 3310 3311 void ath12k_dp_mon_rx_process_ulofdma(struct hal_rx_mon_ppdu_info *ppdu_info) 3312 { 3313 struct hal_rx_user_status *rx_user_status; 3314 u32 num_users, i, mu_ul_user_v0_word0, mu_ul_user_v0_word1, ru_size; 3315 3316 if (!(ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_MIMO || 3317 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA || 3318 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO)) 3319 return; 3320 3321 num_users = ppdu_info->num_users; 3322 if (num_users > HAL_MAX_UL_MU_USERS) 3323 num_users = HAL_MAX_UL_MU_USERS; 3324 3325 for (i = 0; i < num_users; i++) { 3326 rx_user_status = &ppdu_info->userstats[i]; 3327 mu_ul_user_v0_word0 = 3328 rx_user_status->ul_ofdma_user_v0_word0; 3329 mu_ul_user_v0_word1 = 3330 rx_user_status->ul_ofdma_user_v0_word1; 3331 3332 if (u32_get_bits(mu_ul_user_v0_word0, 3333 HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VALID) && 3334 !u32_get_bits(mu_ul_user_v0_word0, 3335 HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VER)) { 3336 rx_user_status->mcs = 3337 u32_get_bits(mu_ul_user_v0_word1, 3338 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_MCS); 3339 rx_user_status->nss = 3340 u32_get_bits(mu_ul_user_v0_word1, 3341 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_NSS) + 1; 3342 3343 rx_user_status->ofdma_info_valid = 1; 3344 rx_user_status->ul_ofdma_ru_start_index = 3345 u32_get_bits(mu_ul_user_v0_word1, 3346 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_START); 3347 3348 ru_size = u32_get_bits(mu_ul_user_v0_word1, 3349 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_SIZE); 3350 rx_user_status->ul_ofdma_ru_width = ru_size; 3351 rx_user_status->ul_ofdma_ru_size = ru_size; 3352 } 3353 rx_user_status->ldpc = u32_get_bits(mu_ul_user_v0_word1, 3354 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_LDPC); 3355 } 3356 ppdu_info->ldpc = 1; 3357 } 3358 3359 static void 3360 ath12k_dp_mon_rx_update_user_stats(struct ath12k *ar, 3361 struct hal_rx_mon_ppdu_info *ppdu_info, 3362 u32 uid) 3363 { 3364 struct ath12k_sta *ahsta; 3365 struct ath12k_link_sta *arsta; 3366 struct ath12k_rx_peer_stats *rx_stats = NULL; 3367 struct hal_rx_user_status *user_stats = &ppdu_info->userstats[uid]; 3368 struct ath12k_peer *peer; 3369 u32 num_msdu; 3370 3371 if (user_stats->ast_index == 0 || user_stats->ast_index == 0xFFFF) 3372 return; 3373 3374 peer = ath12k_peer_find_by_ast(ar->ab, user_stats->ast_index); 3375 3376 if (!peer) { 3377 ath12k_warn(ar->ab, "peer ast idx %d can't be found\n", 3378 user_stats->ast_index); 3379 return; 3380 } 3381 3382 ahsta = ath12k_sta_to_ahsta(peer->sta); 3383 arsta = &ahsta->deflink; 3384 arsta->rssi_comb = ppdu_info->rssi_comb; 3385 ewma_avg_rssi_add(&arsta->avg_rssi, ppdu_info->rssi_comb); 3386 rx_stats = arsta->rx_stats; 3387 if (!rx_stats) 3388 return; 3389 3390 num_msdu = user_stats->tcp_msdu_count + user_stats->tcp_ack_msdu_count + 3391 user_stats->udp_msdu_count + user_stats->other_msdu_count; 3392 3393 rx_stats->num_msdu += num_msdu; 3394 rx_stats->tcp_msdu_count += user_stats->tcp_msdu_count + 3395 user_stats->tcp_ack_msdu_count; 3396 rx_stats->udp_msdu_count += user_stats->udp_msdu_count; 3397 rx_stats->other_msdu_count += user_stats->other_msdu_count; 3398 3399 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX) 3400 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu; 3401 3402 if (user_stats->tid <= IEEE80211_NUM_TIDS) 3403 rx_stats->tid_count[user_stats->tid] += num_msdu; 3404 3405 if (user_stats->preamble_type < HAL_RX_PREAMBLE_MAX) 3406 rx_stats->pream_cnt[user_stats->preamble_type] += num_msdu; 3407 3408 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX) 3409 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu; 3410 3411 if (ppdu_info->is_stbc) 3412 rx_stats->stbc_count += num_msdu; 3413 3414 if (ppdu_info->beamformed) 3415 rx_stats->beamformed_count += num_msdu; 3416 3417 if (user_stats->mpdu_cnt_fcs_ok > 1) 3418 rx_stats->ampdu_msdu_count += num_msdu; 3419 else 3420 rx_stats->non_ampdu_msdu_count += num_msdu; 3421 3422 rx_stats->num_mpdu_fcs_ok += user_stats->mpdu_cnt_fcs_ok; 3423 rx_stats->num_mpdu_fcs_err += user_stats->mpdu_cnt_fcs_err; 3424 rx_stats->dcm_count += ppdu_info->dcm; 3425 if (ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA || 3426 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO) 3427 rx_stats->ru_alloc_cnt[user_stats->ul_ofdma_ru_size] += num_msdu; 3428 3429 rx_stats->rx_duration += ppdu_info->rx_duration; 3430 arsta->rx_duration = rx_stats->rx_duration; 3431 3432 if (user_stats->nss > 0 && user_stats->nss <= HAL_RX_MAX_NSS) { 3433 rx_stats->pkt_stats.nss_count[user_stats->nss - 1] += num_msdu; 3434 rx_stats->byte_stats.nss_count[user_stats->nss - 1] += 3435 user_stats->mpdu_ok_byte_count; 3436 } 3437 3438 if (user_stats->preamble_type == HAL_RX_PREAMBLE_11AX && 3439 user_stats->mcs <= HAL_RX_MAX_MCS_HE) { 3440 rx_stats->pkt_stats.he_mcs_count[user_stats->mcs] += num_msdu; 3441 rx_stats->byte_stats.he_mcs_count[user_stats->mcs] += 3442 user_stats->mpdu_ok_byte_count; 3443 } 3444 3445 if (ppdu_info->gi < HAL_RX_GI_MAX) { 3446 rx_stats->pkt_stats.gi_count[ppdu_info->gi] += num_msdu; 3447 rx_stats->byte_stats.gi_count[ppdu_info->gi] += 3448 user_stats->mpdu_ok_byte_count; 3449 } 3450 3451 if (ppdu_info->bw < HAL_RX_BW_MAX) { 3452 rx_stats->pkt_stats.bw_count[ppdu_info->bw] += num_msdu; 3453 rx_stats->byte_stats.bw_count[ppdu_info->bw] += 3454 user_stats->mpdu_ok_byte_count; 3455 } 3456 3457 ath12k_dp_mon_rx_update_peer_rate_table_stats(rx_stats, ppdu_info, 3458 user_stats, num_msdu); 3459 } 3460 3461 static void 3462 ath12k_dp_mon_rx_update_peer_mu_stats(struct ath12k *ar, 3463 struct hal_rx_mon_ppdu_info *ppdu_info) 3464 { 3465 u32 num_users, i; 3466 3467 num_users = ppdu_info->num_users; 3468 if (num_users > HAL_MAX_UL_MU_USERS) 3469 num_users = HAL_MAX_UL_MU_USERS; 3470 3471 for (i = 0; i < num_users; i++) 3472 ath12k_dp_mon_rx_update_user_stats(ar, ppdu_info, i); 3473 } 3474 3475 static void 3476 ath12k_dp_mon_rx_memset_ppdu_info(struct hal_rx_mon_ppdu_info *ppdu_info) 3477 { 3478 memset(ppdu_info, 0, sizeof(*ppdu_info)); 3479 ppdu_info->peer_id = HAL_INVALID_PEERID; 3480 } 3481 3482 int ath12k_dp_mon_srng_process(struct ath12k *ar, int *budget, 3483 struct napi_struct *napi) 3484 { 3485 struct ath12k_base *ab = ar->ab; 3486 struct ath12k_pdev_dp *pdev_dp = &ar->dp; 3487 struct ath12k_mon_data *pmon = (struct ath12k_mon_data *)&pdev_dp->mon_data; 3488 struct hal_rx_mon_ppdu_info *ppdu_info = &pmon->mon_ppdu_info; 3489 struct ath12k_dp *dp = &ab->dp; 3490 struct hal_mon_dest_desc *mon_dst_desc; 3491 struct sk_buff *skb; 3492 struct ath12k_skb_rxcb *rxcb; 3493 struct dp_srng *mon_dst_ring; 3494 struct hal_srng *srng; 3495 struct dp_rxdma_mon_ring *buf_ring; 3496 struct ath12k_sta *ahsta = NULL; 3497 struct ath12k_link_sta *arsta; 3498 struct ath12k_peer *peer; 3499 struct sk_buff_head skb_list; 3500 u64 cookie; 3501 int num_buffs_reaped = 0, srng_id, buf_id; 3502 u32 hal_status, end_offset, info0, end_reason; 3503 u8 pdev_idx = ath12k_hw_mac_id_to_pdev_id(ab->hw_params, ar->pdev_idx); 3504 3505 __skb_queue_head_init(&skb_list); 3506 srng_id = ath12k_hw_mac_id_to_srng_id(ab->hw_params, pdev_idx); 3507 mon_dst_ring = &pdev_dp->rxdma_mon_dst_ring[srng_id]; 3508 buf_ring = &dp->rxdma_mon_buf_ring; 3509 3510 srng = &ab->hal.srng_list[mon_dst_ring->ring_id]; 3511 spin_lock_bh(&srng->lock); 3512 ath12k_hal_srng_access_begin(ab, srng); 3513 3514 while (likely(*budget)) { 3515 *budget -= 1; 3516 mon_dst_desc = ath12k_hal_srng_dst_peek(ab, srng); 3517 if (unlikely(!mon_dst_desc)) 3518 break; 3519 3520 /* In case of empty descriptor, the cookie in the ring descriptor 3521 * is invalid. Therefore, this entry is skipped, and ring processing 3522 * continues. 3523 */ 3524 info0 = le32_to_cpu(mon_dst_desc->info0); 3525 if (u32_get_bits(info0, HAL_MON_DEST_INFO0_EMPTY_DESC)) 3526 goto move_next; 3527 3528 cookie = le32_to_cpu(mon_dst_desc->cookie); 3529 buf_id = u32_get_bits(cookie, DP_RXDMA_BUF_COOKIE_BUF_ID); 3530 3531 spin_lock_bh(&buf_ring->idr_lock); 3532 skb = idr_remove(&buf_ring->bufs_idr, buf_id); 3533 spin_unlock_bh(&buf_ring->idr_lock); 3534 3535 if (unlikely(!skb)) { 3536 ath12k_warn(ab, "monitor destination with invalid buf_id %d\n", 3537 buf_id); 3538 goto move_next; 3539 } 3540 3541 rxcb = ATH12K_SKB_RXCB(skb); 3542 dma_unmap_single(ab->dev, rxcb->paddr, 3543 skb->len + skb_tailroom(skb), 3544 DMA_FROM_DEVICE); 3545 3546 end_reason = u32_get_bits(info0, HAL_MON_DEST_INFO0_END_REASON); 3547 3548 /* HAL_MON_FLUSH_DETECTED implies that an rx flush received at the end of 3549 * rx PPDU and HAL_MON_PPDU_TRUNCATED implies that the PPDU got 3550 * truncated due to a system level error. In both the cases, buffer data 3551 * can be discarded 3552 */ 3553 if ((end_reason == HAL_MON_FLUSH_DETECTED) || 3554 (end_reason == HAL_MON_PPDU_TRUNCATED)) { 3555 ath12k_dbg(ab, ATH12K_DBG_DATA, 3556 "Monitor dest descriptor end reason %d", end_reason); 3557 dev_kfree_skb_any(skb); 3558 goto move_next; 3559 } 3560 3561 /* Calculate the budget when the ring descriptor with the 3562 * HAL_MON_END_OF_PPDU to ensure that one PPDU worth of data is always 3563 * reaped. This helps to efficiently utilize the NAPI budget. 3564 */ 3565 if (end_reason == HAL_MON_END_OF_PPDU) { 3566 *budget -= 1; 3567 rxcb->is_end_of_ppdu = true; 3568 } 3569 3570 end_offset = u32_get_bits(info0, HAL_MON_DEST_INFO0_END_OFFSET); 3571 if (likely(end_offset <= DP_RX_BUFFER_SIZE)) { 3572 skb_put(skb, end_offset); 3573 } else { 3574 ath12k_warn(ab, 3575 "invalid offset on mon stats destination %u\n", 3576 end_offset); 3577 skb_put(skb, DP_RX_BUFFER_SIZE); 3578 } 3579 3580 __skb_queue_tail(&skb_list, skb); 3581 3582 move_next: 3583 ath12k_dp_mon_buf_replenish(ab, buf_ring, 1); 3584 ath12k_hal_srng_dst_get_next_entry(ab, srng); 3585 num_buffs_reaped++; 3586 } 3587 3588 ath12k_hal_srng_access_end(ab, srng); 3589 spin_unlock_bh(&srng->lock); 3590 3591 if (!num_buffs_reaped) 3592 return 0; 3593 3594 /* In some cases, one PPDU worth of data can be spread across multiple NAPI 3595 * schedules, To avoid losing existing parsed ppdu_info information, skip 3596 * the memset of the ppdu_info structure and continue processing it. 3597 */ 3598 if (!ppdu_info->ppdu_continuation) 3599 ath12k_dp_mon_rx_memset_ppdu_info(ppdu_info); 3600 3601 while ((skb = __skb_dequeue(&skb_list))) { 3602 hal_status = ath12k_dp_mon_rx_parse_mon_status(ar, pmon, skb, napi); 3603 if (hal_status != HAL_RX_MON_STATUS_PPDU_DONE) { 3604 ppdu_info->ppdu_continuation = true; 3605 dev_kfree_skb_any(skb); 3606 continue; 3607 } 3608 3609 if (ppdu_info->peer_id == HAL_INVALID_PEERID) 3610 goto free_skb; 3611 3612 rcu_read_lock(); 3613 spin_lock_bh(&ab->base_lock); 3614 peer = ath12k_peer_find_by_id(ab, ppdu_info->peer_id); 3615 if (!peer || !peer->sta) { 3616 ath12k_dbg(ab, ATH12K_DBG_DATA, 3617 "failed to find the peer with monitor peer_id %d\n", 3618 ppdu_info->peer_id); 3619 goto next_skb; 3620 } 3621 3622 if (ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_SU) { 3623 ahsta = ath12k_sta_to_ahsta(peer->sta); 3624 arsta = &ahsta->deflink; 3625 ath12k_dp_mon_rx_update_peer_su_stats(ar, arsta, 3626 ppdu_info); 3627 } else if ((ppdu_info->fc_valid) && 3628 (ppdu_info->ast_index != HAL_AST_IDX_INVALID)) { 3629 ath12k_dp_mon_rx_process_ulofdma(ppdu_info); 3630 ath12k_dp_mon_rx_update_peer_mu_stats(ar, ppdu_info); 3631 } 3632 3633 next_skb: 3634 spin_unlock_bh(&ab->base_lock); 3635 rcu_read_unlock(); 3636 free_skb: 3637 dev_kfree_skb_any(skb); 3638 ath12k_dp_mon_rx_memset_ppdu_info(ppdu_info); 3639 } 3640 3641 return num_buffs_reaped; 3642 } 3643 3644 int ath12k_dp_mon_process_ring(struct ath12k_base *ab, int mac_id, 3645 struct napi_struct *napi, int budget, 3646 enum dp_monitor_mode monitor_mode) 3647 { 3648 struct ath12k *ar = ath12k_ab_to_ar(ab, mac_id); 3649 int num_buffs_reaped = 0; 3650 3651 if (ab->hw_params->rxdma1_enable) { 3652 if (monitor_mode == ATH12K_DP_RX_MONITOR_MODE) 3653 num_buffs_reaped = ath12k_dp_mon_srng_process(ar, &budget, napi); 3654 } 3655 3656 return num_buffs_reaped; 3657 } 3658