1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3 * Copyright (c) 2019-2021 The Linux Foundation. All rights reserved.
4 * Copyright (c) 2021-2022 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
ath12k_dp_mon_rx_handle_ofdma_info(void * rx_tlv,struct hal_rx_user_status * rx_user_status)13 static void ath12k_dp_mon_rx_handle_ofdma_info(void *rx_tlv,
14 struct hal_rx_user_status *rx_user_status)
15 {
16 struct hal_rx_ppdu_end_user_stats *ppdu_end_user =
17 (struct hal_rx_ppdu_end_user_stats *)rx_tlv;
18
19 rx_user_status->ul_ofdma_user_v0_word0 =
20 __le32_to_cpu(ppdu_end_user->usr_resp_ref);
21 rx_user_status->ul_ofdma_user_v0_word1 =
22 __le32_to_cpu(ppdu_end_user->usr_resp_ref_ext);
23 }
24
25 static void
ath12k_dp_mon_rx_populate_byte_count(void * rx_tlv,void * ppduinfo,struct hal_rx_user_status * rx_user_status)26 ath12k_dp_mon_rx_populate_byte_count(void *rx_tlv, void *ppduinfo,
27 struct hal_rx_user_status *rx_user_status)
28 {
29 struct hal_rx_ppdu_end_user_stats *ppdu_end_user =
30 (struct hal_rx_ppdu_end_user_stats *)rx_tlv;
31 u32 mpdu_ok_byte_count = __le32_to_cpu(ppdu_end_user->mpdu_ok_cnt);
32 u32 mpdu_err_byte_count = __le32_to_cpu(ppdu_end_user->mpdu_err_cnt);
33
34 rx_user_status->mpdu_ok_byte_count =
35 u32_get_bits(mpdu_ok_byte_count,
36 HAL_RX_PPDU_END_USER_STATS_MPDU_DELIM_OK_BYTE_COUNT);
37 rx_user_status->mpdu_err_byte_count =
38 u32_get_bits(mpdu_err_byte_count,
39 HAL_RX_PPDU_END_USER_STATS_MPDU_DELIM_ERR_BYTE_COUNT);
40 }
41
42 static void
ath12k_dp_mon_rx_populate_mu_user_info(void * rx_tlv,struct hal_rx_mon_ppdu_info * ppdu_info,struct hal_rx_user_status * rx_user_status)43 ath12k_dp_mon_rx_populate_mu_user_info(void *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
ath12k_dp_mon_parse_vht_sig_a(u8 * tlv_data,struct hal_rx_mon_ppdu_info * ppdu_info)81 static void ath12k_dp_mon_parse_vht_sig_a(u8 *tlv_data,
82 struct hal_rx_mon_ppdu_info *ppdu_info)
83 {
84 struct hal_rx_vht_sig_a_info *vht_sig =
85 (struct hal_rx_vht_sig_a_info *)tlv_data;
86 u32 nsts, group_id, info0, info1;
87 u8 gi_setting;
88
89 info0 = __le32_to_cpu(vht_sig->info0);
90 info1 = __le32_to_cpu(vht_sig->info1);
91
92 ppdu_info->ldpc = u32_get_bits(info1, HAL_RX_VHT_SIG_A_INFO_INFO1_SU_MU_CODING);
93 ppdu_info->mcs = u32_get_bits(info1, HAL_RX_VHT_SIG_A_INFO_INFO1_MCS);
94 gi_setting = u32_get_bits(info1, HAL_RX_VHT_SIG_A_INFO_INFO1_GI_SETTING);
95 switch (gi_setting) {
96 case HAL_RX_VHT_SIG_A_NORMAL_GI:
97 ppdu_info->gi = HAL_RX_GI_0_8_US;
98 break;
99 case HAL_RX_VHT_SIG_A_SHORT_GI:
100 case HAL_RX_VHT_SIG_A_SHORT_GI_AMBIGUITY:
101 ppdu_info->gi = HAL_RX_GI_0_4_US;
102 break;
103 }
104
105 ppdu_info->is_stbc = u32_get_bits(info0, HAL_RX_VHT_SIG_A_INFO_INFO0_STBC);
106 nsts = u32_get_bits(info0, HAL_RX_VHT_SIG_A_INFO_INFO0_NSTS);
107 if (ppdu_info->is_stbc && nsts > 0)
108 nsts = ((nsts + 1) >> 1) - 1;
109
110 ppdu_info->nss = u32_get_bits(nsts, VHT_SIG_SU_NSS_MASK);
111 ppdu_info->bw = u32_get_bits(info0, HAL_RX_VHT_SIG_A_INFO_INFO0_BW);
112 ppdu_info->beamformed = u32_get_bits(info1,
113 HAL_RX_VHT_SIG_A_INFO_INFO1_BEAMFORMED);
114 group_id = u32_get_bits(info0, HAL_RX_VHT_SIG_A_INFO_INFO0_GROUP_ID);
115 if (group_id == 0 || group_id == 63)
116 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_SU;
117 else
118 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_MU_MIMO;
119 ppdu_info->vht_flag_values5 = group_id;
120 ppdu_info->vht_flag_values3[0] = (((ppdu_info->mcs) << 4) |
121 ppdu_info->nss);
122 ppdu_info->vht_flag_values2 = ppdu_info->bw;
123 ppdu_info->vht_flag_values4 =
124 u32_get_bits(info1, HAL_RX_VHT_SIG_A_INFO_INFO1_SU_MU_CODING);
125 }
126
ath12k_dp_mon_parse_ht_sig(u8 * tlv_data,struct hal_rx_mon_ppdu_info * ppdu_info)127 static void ath12k_dp_mon_parse_ht_sig(u8 *tlv_data,
128 struct hal_rx_mon_ppdu_info *ppdu_info)
129 {
130 struct hal_rx_ht_sig_info *ht_sig =
131 (struct hal_rx_ht_sig_info *)tlv_data;
132 u32 info0 = __le32_to_cpu(ht_sig->info0);
133 u32 info1 = __le32_to_cpu(ht_sig->info1);
134
135 ppdu_info->mcs = u32_get_bits(info0, HAL_RX_HT_SIG_INFO_INFO0_MCS);
136 ppdu_info->bw = u32_get_bits(info0, HAL_RX_HT_SIG_INFO_INFO0_BW);
137 ppdu_info->is_stbc = u32_get_bits(info1, HAL_RX_HT_SIG_INFO_INFO1_STBC);
138 ppdu_info->ldpc = u32_get_bits(info1, HAL_RX_HT_SIG_INFO_INFO1_FEC_CODING);
139 ppdu_info->gi = u32_get_bits(info1, HAL_RX_HT_SIG_INFO_INFO1_GI);
140 ppdu_info->nss = (ppdu_info->mcs >> 3);
141 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_SU;
142 }
143
ath12k_dp_mon_parse_l_sig_b(u8 * tlv_data,struct hal_rx_mon_ppdu_info * ppdu_info)144 static void ath12k_dp_mon_parse_l_sig_b(u8 *tlv_data,
145 struct hal_rx_mon_ppdu_info *ppdu_info)
146 {
147 struct hal_rx_lsig_b_info *lsigb =
148 (struct hal_rx_lsig_b_info *)tlv_data;
149 u32 info0 = __le32_to_cpu(lsigb->info0);
150 u8 rate;
151
152 rate = u32_get_bits(info0, HAL_RX_LSIG_B_INFO_INFO0_RATE);
153 switch (rate) {
154 case 1:
155 rate = HAL_RX_LEGACY_RATE_1_MBPS;
156 break;
157 case 2:
158 case 5:
159 rate = HAL_RX_LEGACY_RATE_2_MBPS;
160 break;
161 case 3:
162 case 6:
163 rate = HAL_RX_LEGACY_RATE_5_5_MBPS;
164 break;
165 case 4:
166 case 7:
167 rate = HAL_RX_LEGACY_RATE_11_MBPS;
168 break;
169 default:
170 rate = HAL_RX_LEGACY_RATE_INVALID;
171 }
172
173 ppdu_info->rate = rate;
174 ppdu_info->cck_flag = 1;
175 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_SU;
176 }
177
ath12k_dp_mon_parse_l_sig_a(u8 * tlv_data,struct hal_rx_mon_ppdu_info * ppdu_info)178 static void ath12k_dp_mon_parse_l_sig_a(u8 *tlv_data,
179 struct hal_rx_mon_ppdu_info *ppdu_info)
180 {
181 struct hal_rx_lsig_a_info *lsiga =
182 (struct hal_rx_lsig_a_info *)tlv_data;
183 u32 info0 = __le32_to_cpu(lsiga->info0);
184 u8 rate;
185
186 rate = u32_get_bits(info0, HAL_RX_LSIG_A_INFO_INFO0_RATE);
187 switch (rate) {
188 case 8:
189 rate = HAL_RX_LEGACY_RATE_48_MBPS;
190 break;
191 case 9:
192 rate = HAL_RX_LEGACY_RATE_24_MBPS;
193 break;
194 case 10:
195 rate = HAL_RX_LEGACY_RATE_12_MBPS;
196 break;
197 case 11:
198 rate = HAL_RX_LEGACY_RATE_6_MBPS;
199 break;
200 case 12:
201 rate = HAL_RX_LEGACY_RATE_54_MBPS;
202 break;
203 case 13:
204 rate = HAL_RX_LEGACY_RATE_36_MBPS;
205 break;
206 case 14:
207 rate = HAL_RX_LEGACY_RATE_18_MBPS;
208 break;
209 case 15:
210 rate = HAL_RX_LEGACY_RATE_9_MBPS;
211 break;
212 default:
213 rate = HAL_RX_LEGACY_RATE_INVALID;
214 }
215
216 ppdu_info->rate = rate;
217 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_SU;
218 }
219
ath12k_dp_mon_parse_he_sig_b2_ofdma(u8 * tlv_data,struct hal_rx_mon_ppdu_info * ppdu_info)220 static void ath12k_dp_mon_parse_he_sig_b2_ofdma(u8 *tlv_data,
221 struct hal_rx_mon_ppdu_info *ppdu_info)
222 {
223 struct hal_rx_he_sig_b2_ofdma_info *he_sig_b2_ofdma =
224 (struct hal_rx_he_sig_b2_ofdma_info *)tlv_data;
225 u32 info0, value;
226
227 info0 = __le32_to_cpu(he_sig_b2_ofdma->info0);
228
229 ppdu_info->he_data1 |= HE_MCS_KNOWN | HE_DCM_KNOWN | HE_CODING_KNOWN;
230
231 /* HE-data2 */
232 ppdu_info->he_data2 |= HE_TXBF_KNOWN;
233
234 ppdu_info->mcs = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_MCS);
235 value = ppdu_info->mcs << HE_TRANSMIT_MCS_SHIFT;
236 ppdu_info->he_data3 |= value;
237
238 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_DCM);
239 value = value << HE_DCM_SHIFT;
240 ppdu_info->he_data3 |= value;
241
242 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_CODING);
243 ppdu_info->ldpc = value;
244 value = value << HE_CODING_SHIFT;
245 ppdu_info->he_data3 |= value;
246
247 /* HE-data4 */
248 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_ID);
249 value = value << HE_STA_ID_SHIFT;
250 ppdu_info->he_data4 |= value;
251
252 ppdu_info->nss = u32_get_bits(info0, HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_NSTS);
253 ppdu_info->beamformed = u32_get_bits(info0,
254 HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_TXBF);
255 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_MU_OFDMA;
256 }
257
ath12k_dp_mon_parse_he_sig_b2_mu(u8 * tlv_data,struct hal_rx_mon_ppdu_info * ppdu_info)258 static void ath12k_dp_mon_parse_he_sig_b2_mu(u8 *tlv_data,
259 struct hal_rx_mon_ppdu_info *ppdu_info)
260 {
261 struct hal_rx_he_sig_b2_mu_info *he_sig_b2_mu =
262 (struct hal_rx_he_sig_b2_mu_info *)tlv_data;
263 u32 info0, value;
264
265 info0 = __le32_to_cpu(he_sig_b2_mu->info0);
266
267 ppdu_info->he_data1 |= HE_MCS_KNOWN | HE_CODING_KNOWN;
268
269 ppdu_info->mcs = u32_get_bits(info0, HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_MCS);
270 value = ppdu_info->mcs << HE_TRANSMIT_MCS_SHIFT;
271 ppdu_info->he_data3 |= value;
272
273 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_CODING);
274 ppdu_info->ldpc = value;
275 value = value << HE_CODING_SHIFT;
276 ppdu_info->he_data3 |= value;
277
278 value = u32_get_bits(info0, HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_ID);
279 value = value << HE_STA_ID_SHIFT;
280 ppdu_info->he_data4 |= value;
281
282 ppdu_info->nss = u32_get_bits(info0, HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_NSTS);
283 }
284
ath12k_dp_mon_parse_he_sig_b1_mu(u8 * tlv_data,struct hal_rx_mon_ppdu_info * ppdu_info)285 static void ath12k_dp_mon_parse_he_sig_b1_mu(u8 *tlv_data,
286 struct hal_rx_mon_ppdu_info *ppdu_info)
287 {
288 struct hal_rx_he_sig_b1_mu_info *he_sig_b1_mu =
289 (struct hal_rx_he_sig_b1_mu_info *)tlv_data;
290 u32 info0 = __le32_to_cpu(he_sig_b1_mu->info0);
291 u16 ru_tones;
292
293 ru_tones = u32_get_bits(info0,
294 HAL_RX_HE_SIG_B1_MU_INFO_INFO0_RU_ALLOCATION);
295 ppdu_info->ru_alloc = ath12k_he_ru_tones_to_nl80211_he_ru_alloc(ru_tones);
296 ppdu_info->he_RU[0] = ru_tones;
297 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_MU_MIMO;
298 }
299
ath12k_dp_mon_parse_he_sig_mu(u8 * tlv_data,struct hal_rx_mon_ppdu_info * ppdu_info)300 static void ath12k_dp_mon_parse_he_sig_mu(u8 *tlv_data,
301 struct hal_rx_mon_ppdu_info *ppdu_info)
302 {
303 struct hal_rx_he_sig_a_mu_dl_info *he_sig_a_mu_dl =
304 (struct hal_rx_he_sig_a_mu_dl_info *)tlv_data;
305 u32 info0, info1, value;
306 u16 he_gi = 0, he_ltf = 0;
307
308 info0 = __le32_to_cpu(he_sig_a_mu_dl->info0);
309 info1 = __le32_to_cpu(he_sig_a_mu_dl->info1);
310
311 ppdu_info->he_mu_flags = 1;
312
313 ppdu_info->he_data1 = HE_MU_FORMAT_TYPE;
314 ppdu_info->he_data1 |=
315 HE_BSS_COLOR_KNOWN |
316 HE_DL_UL_KNOWN |
317 HE_LDPC_EXTRA_SYMBOL_KNOWN |
318 HE_STBC_KNOWN |
319 HE_DATA_BW_RU_KNOWN |
320 HE_DOPPLER_KNOWN;
321
322 ppdu_info->he_data2 =
323 HE_GI_KNOWN |
324 HE_LTF_SYMBOLS_KNOWN |
325 HE_PRE_FEC_PADDING_KNOWN |
326 HE_PE_DISAMBIGUITY_KNOWN |
327 HE_TXOP_KNOWN |
328 HE_MIDABLE_PERIODICITY_KNOWN;
329
330 /* data3 */
331 ppdu_info->he_data3 = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_BSS_COLOR);
332 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_UL_FLAG);
333 value = value << HE_DL_UL_SHIFT;
334 ppdu_info->he_data3 |= value;
335
336 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_LDPC_EXTRA);
337 value = value << HE_LDPC_EXTRA_SYMBOL_SHIFT;
338 ppdu_info->he_data3 |= value;
339
340 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_STBC);
341 value = value << HE_STBC_SHIFT;
342 ppdu_info->he_data3 |= value;
343
344 /* data4 */
345 ppdu_info->he_data4 = u32_get_bits(info0,
346 HAL_RX_HE_SIG_A_MU_DL_INFO0_SPATIAL_REUSE);
347 ppdu_info->he_data4 = value;
348
349 /* data5 */
350 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_TRANSMIT_BW);
351 ppdu_info->he_data5 = value;
352 ppdu_info->bw = value;
353
354 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_CP_LTF_SIZE);
355 switch (value) {
356 case 0:
357 he_gi = HE_GI_0_8;
358 he_ltf = HE_LTF_4_X;
359 break;
360 case 1:
361 he_gi = HE_GI_0_8;
362 he_ltf = HE_LTF_2_X;
363 break;
364 case 2:
365 he_gi = HE_GI_1_6;
366 he_ltf = HE_LTF_2_X;
367 break;
368 case 3:
369 he_gi = HE_GI_3_2;
370 he_ltf = HE_LTF_4_X;
371 break;
372 }
373
374 ppdu_info->gi = he_gi;
375 value = he_gi << HE_GI_SHIFT;
376 ppdu_info->he_data5 |= value;
377
378 value = he_ltf << HE_LTF_SIZE_SHIFT;
379 ppdu_info->he_data5 |= value;
380
381 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_NUM_LTF_SYMB);
382 value = (value << HE_LTF_SYM_SHIFT);
383 ppdu_info->he_data5 |= value;
384
385 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_PKT_EXT_FACTOR);
386 value = value << HE_PRE_FEC_PAD_SHIFT;
387 ppdu_info->he_data5 |= value;
388
389 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_PKT_EXT_PE_DISAM);
390 value = value << HE_PE_DISAMBIGUITY_SHIFT;
391 ppdu_info->he_data5 |= value;
392
393 /*data6*/
394 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_DOPPLER_INDICATION);
395 value = value << HE_DOPPLER_SHIFT;
396 ppdu_info->he_data6 |= value;
397
398 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_MU_DL_INFO1_TXOP_DURATION);
399 value = value << HE_TXOP_SHIFT;
400 ppdu_info->he_data6 |= value;
401
402 /* HE-MU Flags */
403 /* HE-MU-flags1 */
404 ppdu_info->he_flags1 =
405 HE_SIG_B_MCS_KNOWN |
406 HE_SIG_B_DCM_KNOWN |
407 HE_SIG_B_COMPRESSION_FLAG_1_KNOWN |
408 HE_SIG_B_SYM_NUM_KNOWN |
409 HE_RU_0_KNOWN;
410
411 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_MCS_OF_SIGB);
412 ppdu_info->he_flags1 |= value;
413 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_DCM_OF_SIGB);
414 value = value << HE_DCM_FLAG_1_SHIFT;
415 ppdu_info->he_flags1 |= value;
416
417 /* HE-MU-flags2 */
418 ppdu_info->he_flags2 = HE_BW_KNOWN;
419
420 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_TRANSMIT_BW);
421 ppdu_info->he_flags2 |= value;
422 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_COMP_MODE_SIGB);
423 value = value << HE_SIG_B_COMPRESSION_FLAG_2_SHIFT;
424 ppdu_info->he_flags2 |= value;
425 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_MU_DL_INFO0_NUM_SIGB_SYMB);
426 value = value - 1;
427 value = value << HE_NUM_SIG_B_SYMBOLS_SHIFT;
428 ppdu_info->he_flags2 |= value;
429
430 ppdu_info->is_stbc = info1 &
431 HAL_RX_HE_SIG_A_MU_DL_INFO1_STBC;
432 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_MU_MIMO;
433 }
434
ath12k_dp_mon_parse_he_sig_su(u8 * tlv_data,struct hal_rx_mon_ppdu_info * ppdu_info)435 static void ath12k_dp_mon_parse_he_sig_su(u8 *tlv_data,
436 struct hal_rx_mon_ppdu_info *ppdu_info)
437 {
438 struct hal_rx_he_sig_a_su_info *he_sig_a =
439 (struct hal_rx_he_sig_a_su_info *)tlv_data;
440 u32 info0, info1, value;
441 u32 dcm;
442 u8 he_dcm = 0, he_stbc = 0;
443 u16 he_gi = 0, he_ltf = 0;
444
445 ppdu_info->he_flags = 1;
446
447 info0 = __le32_to_cpu(he_sig_a->info0);
448 info1 = __le32_to_cpu(he_sig_a->info1);
449
450 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_FORMAT_IND);
451 if (value == 0)
452 ppdu_info->he_data1 = HE_TRIG_FORMAT_TYPE;
453 else
454 ppdu_info->he_data1 = HE_SU_FORMAT_TYPE;
455
456 ppdu_info->he_data1 |=
457 HE_BSS_COLOR_KNOWN |
458 HE_BEAM_CHANGE_KNOWN |
459 HE_DL_UL_KNOWN |
460 HE_MCS_KNOWN |
461 HE_DCM_KNOWN |
462 HE_CODING_KNOWN |
463 HE_LDPC_EXTRA_SYMBOL_KNOWN |
464 HE_STBC_KNOWN |
465 HE_DATA_BW_RU_KNOWN |
466 HE_DOPPLER_KNOWN;
467
468 ppdu_info->he_data2 |=
469 HE_GI_KNOWN |
470 HE_TXBF_KNOWN |
471 HE_PE_DISAMBIGUITY_KNOWN |
472 HE_TXOP_KNOWN |
473 HE_LTF_SYMBOLS_KNOWN |
474 HE_PRE_FEC_PADDING_KNOWN |
475 HE_MIDABLE_PERIODICITY_KNOWN;
476
477 ppdu_info->he_data3 = u32_get_bits(info0,
478 HAL_RX_HE_SIG_A_SU_INFO_INFO0_BSS_COLOR);
479 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_BEAM_CHANGE);
480 value = value << HE_BEAM_CHANGE_SHIFT;
481 ppdu_info->he_data3 |= value;
482 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_DL_UL_FLAG);
483 value = value << HE_DL_UL_SHIFT;
484 ppdu_info->he_data3 |= value;
485
486 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_MCS);
487 ppdu_info->mcs = value;
488 value = value << HE_TRANSMIT_MCS_SHIFT;
489 ppdu_info->he_data3 |= value;
490
491 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_DCM);
492 he_dcm = value;
493 value = value << HE_DCM_SHIFT;
494 ppdu_info->he_data3 |= value;
495 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_CODING);
496 value = value << HE_CODING_SHIFT;
497 ppdu_info->he_data3 |= value;
498 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_LDPC_EXTRA);
499 value = value << HE_LDPC_EXTRA_SYMBOL_SHIFT;
500 ppdu_info->he_data3 |= value;
501 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_STBC);
502 he_stbc = value;
503 value = value << HE_STBC_SHIFT;
504 ppdu_info->he_data3 |= value;
505
506 /* data4 */
507 ppdu_info->he_data4 = u32_get_bits(info0,
508 HAL_RX_HE_SIG_A_SU_INFO_INFO0_SPATIAL_REUSE);
509
510 /* data5 */
511 value = u32_get_bits(info0,
512 HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_BW);
513 ppdu_info->he_data5 = value;
514 ppdu_info->bw = value;
515 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_CP_LTF_SIZE);
516 switch (value) {
517 case 0:
518 he_gi = HE_GI_0_8;
519 he_ltf = HE_LTF_1_X;
520 break;
521 case 1:
522 he_gi = HE_GI_0_8;
523 he_ltf = HE_LTF_2_X;
524 break;
525 case 2:
526 he_gi = HE_GI_1_6;
527 he_ltf = HE_LTF_2_X;
528 break;
529 case 3:
530 if (he_dcm && he_stbc) {
531 he_gi = HE_GI_0_8;
532 he_ltf = HE_LTF_4_X;
533 } else {
534 he_gi = HE_GI_3_2;
535 he_ltf = HE_LTF_4_X;
536 }
537 break;
538 }
539 ppdu_info->gi = he_gi;
540 value = he_gi << HE_GI_SHIFT;
541 ppdu_info->he_data5 |= value;
542 value = he_ltf << HE_LTF_SIZE_SHIFT;
543 ppdu_info->ltf_size = he_ltf;
544 ppdu_info->he_data5 |= value;
545
546 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_NSTS);
547 value = (value << HE_LTF_SYM_SHIFT);
548 ppdu_info->he_data5 |= value;
549
550 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_PKT_EXT_FACTOR);
551 value = value << HE_PRE_FEC_PAD_SHIFT;
552 ppdu_info->he_data5 |= value;
553
554 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_TXBF);
555 value = value << HE_TXBF_SHIFT;
556 ppdu_info->he_data5 |= value;
557 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_PKT_EXT_PE_DISAM);
558 value = value << HE_PE_DISAMBIGUITY_SHIFT;
559 ppdu_info->he_data5 |= value;
560
561 /* data6 */
562 value = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_NSTS);
563 value++;
564 ppdu_info->he_data6 = value;
565 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_DOPPLER_IND);
566 value = value << HE_DOPPLER_SHIFT;
567 ppdu_info->he_data6 |= value;
568 value = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_TXOP_DURATION);
569 value = value << HE_TXOP_SHIFT;
570 ppdu_info->he_data6 |= value;
571
572 ppdu_info->mcs =
573 u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_MCS);
574 ppdu_info->bw =
575 u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_BW);
576 ppdu_info->ldpc = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_CODING);
577 ppdu_info->is_stbc = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_STBC);
578 ppdu_info->beamformed = u32_get_bits(info1, HAL_RX_HE_SIG_A_SU_INFO_INFO1_TXBF);
579 dcm = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_DCM);
580 ppdu_info->nss = u32_get_bits(info0, HAL_RX_HE_SIG_A_SU_INFO_INFO0_NSTS);
581 ppdu_info->dcm = dcm;
582 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_SU;
583 }
584
585 static enum hal_rx_mon_status
ath12k_dp_mon_rx_parse_status_tlv(struct ath12k_base * ab,struct ath12k_mon_data * pmon,u32 tlv_tag,u8 * tlv_data,u32 userid)586 ath12k_dp_mon_rx_parse_status_tlv(struct ath12k_base *ab,
587 struct ath12k_mon_data *pmon,
588 u32 tlv_tag, u8 *tlv_data, u32 userid)
589 {
590 struct hal_rx_mon_ppdu_info *ppdu_info = &pmon->mon_ppdu_info;
591 u32 info[7];
592
593 switch (tlv_tag) {
594 case HAL_RX_PPDU_START: {
595 struct hal_rx_ppdu_start *ppdu_start =
596 (struct hal_rx_ppdu_start *)tlv_data;
597
598 info[0] = __le32_to_cpu(ppdu_start->info0);
599
600 ppdu_info->ppdu_id =
601 u32_get_bits(info[0], HAL_RX_PPDU_START_INFO0_PPDU_ID);
602 ppdu_info->chan_num = __le32_to_cpu(ppdu_start->chan_num);
603 ppdu_info->ppdu_ts = __le32_to_cpu(ppdu_start->ppdu_start_ts);
604
605 if (ppdu_info->ppdu_id != ppdu_info->last_ppdu_id) {
606 ppdu_info->last_ppdu_id = ppdu_info->ppdu_id;
607 ppdu_info->num_users = 0;
608 memset(&ppdu_info->mpdu_fcs_ok_bitmap, 0,
609 HAL_RX_NUM_WORDS_PER_PPDU_BITMAP *
610 sizeof(ppdu_info->mpdu_fcs_ok_bitmap[0]));
611 }
612 break;
613 }
614 case HAL_RX_PPDU_END_USER_STATS: {
615 struct hal_rx_ppdu_end_user_stats *eu_stats =
616 (struct hal_rx_ppdu_end_user_stats *)tlv_data;
617
618 info[0] = __le32_to_cpu(eu_stats->info0);
619 info[1] = __le32_to_cpu(eu_stats->info1);
620 info[2] = __le32_to_cpu(eu_stats->info2);
621 info[4] = __le32_to_cpu(eu_stats->info4);
622 info[5] = __le32_to_cpu(eu_stats->info5);
623 info[6] = __le32_to_cpu(eu_stats->info6);
624
625 ppdu_info->ast_index =
626 u32_get_bits(info[2], HAL_RX_PPDU_END_USER_STATS_INFO2_AST_INDEX);
627 ppdu_info->fc_valid =
628 u32_get_bits(info[1], HAL_RX_PPDU_END_USER_STATS_INFO1_FC_VALID);
629 ppdu_info->tid =
630 ffs(u32_get_bits(info[6],
631 HAL_RX_PPDU_END_USER_STATS_INFO6_TID_BITMAP)
632 - 1);
633 ppdu_info->tcp_msdu_count =
634 u32_get_bits(info[4],
635 HAL_RX_PPDU_END_USER_STATS_INFO4_TCP_MSDU_CNT);
636 ppdu_info->udp_msdu_count =
637 u32_get_bits(info[4],
638 HAL_RX_PPDU_END_USER_STATS_INFO4_UDP_MSDU_CNT);
639 ppdu_info->other_msdu_count =
640 u32_get_bits(info[5],
641 HAL_RX_PPDU_END_USER_STATS_INFO5_OTHER_MSDU_CNT);
642 ppdu_info->tcp_ack_msdu_count =
643 u32_get_bits(info[5],
644 HAL_RX_PPDU_END_USER_STATS_INFO5_TCP_ACK_MSDU_CNT);
645 ppdu_info->preamble_type =
646 u32_get_bits(info[1],
647 HAL_RX_PPDU_END_USER_STATS_INFO1_PKT_TYPE);
648 ppdu_info->num_mpdu_fcs_ok =
649 u32_get_bits(info[1],
650 HAL_RX_PPDU_END_USER_STATS_INFO1_MPDU_CNT_FCS_OK);
651 ppdu_info->num_mpdu_fcs_err =
652 u32_get_bits(info[0],
653 HAL_RX_PPDU_END_USER_STATS_INFO0_MPDU_CNT_FCS_ERR);
654 switch (ppdu_info->preamble_type) {
655 case HAL_RX_PREAMBLE_11N:
656 ppdu_info->ht_flags = 1;
657 break;
658 case HAL_RX_PREAMBLE_11AC:
659 ppdu_info->vht_flags = 1;
660 break;
661 case HAL_RX_PREAMBLE_11AX:
662 ppdu_info->he_flags = 1;
663 break;
664 default:
665 break;
666 }
667
668 if (userid < HAL_MAX_UL_MU_USERS) {
669 struct hal_rx_user_status *rxuser_stats =
670 &ppdu_info->userstats[userid];
671 ppdu_info->num_users += 1;
672
673 ath12k_dp_mon_rx_handle_ofdma_info(tlv_data, rxuser_stats);
674 ath12k_dp_mon_rx_populate_mu_user_info(tlv_data, ppdu_info,
675 rxuser_stats);
676 }
677 ppdu_info->mpdu_fcs_ok_bitmap[0] = __le32_to_cpu(eu_stats->rsvd1[0]);
678 ppdu_info->mpdu_fcs_ok_bitmap[1] = __le32_to_cpu(eu_stats->rsvd1[1]);
679 break;
680 }
681 case HAL_RX_PPDU_END_USER_STATS_EXT: {
682 struct hal_rx_ppdu_end_user_stats_ext *eu_stats =
683 (struct hal_rx_ppdu_end_user_stats_ext *)tlv_data;
684 ppdu_info->mpdu_fcs_ok_bitmap[2] = __le32_to_cpu(eu_stats->info1);
685 ppdu_info->mpdu_fcs_ok_bitmap[3] = __le32_to_cpu(eu_stats->info2);
686 ppdu_info->mpdu_fcs_ok_bitmap[4] = __le32_to_cpu(eu_stats->info3);
687 ppdu_info->mpdu_fcs_ok_bitmap[5] = __le32_to_cpu(eu_stats->info4);
688 ppdu_info->mpdu_fcs_ok_bitmap[6] = __le32_to_cpu(eu_stats->info5);
689 ppdu_info->mpdu_fcs_ok_bitmap[7] = __le32_to_cpu(eu_stats->info6);
690 break;
691 }
692 case HAL_PHYRX_HT_SIG:
693 ath12k_dp_mon_parse_ht_sig(tlv_data, ppdu_info);
694 break;
695
696 case HAL_PHYRX_L_SIG_B:
697 ath12k_dp_mon_parse_l_sig_b(tlv_data, ppdu_info);
698 break;
699
700 case HAL_PHYRX_L_SIG_A:
701 ath12k_dp_mon_parse_l_sig_a(tlv_data, ppdu_info);
702 break;
703
704 case HAL_PHYRX_VHT_SIG_A:
705 ath12k_dp_mon_parse_vht_sig_a(tlv_data, ppdu_info);
706 break;
707
708 case HAL_PHYRX_HE_SIG_A_SU:
709 ath12k_dp_mon_parse_he_sig_su(tlv_data, ppdu_info);
710 break;
711
712 case HAL_PHYRX_HE_SIG_A_MU_DL:
713 ath12k_dp_mon_parse_he_sig_mu(tlv_data, ppdu_info);
714 break;
715
716 case HAL_PHYRX_HE_SIG_B1_MU:
717 ath12k_dp_mon_parse_he_sig_b1_mu(tlv_data, ppdu_info);
718 break;
719
720 case HAL_PHYRX_HE_SIG_B2_MU:
721 ath12k_dp_mon_parse_he_sig_b2_mu(tlv_data, ppdu_info);
722 break;
723
724 case HAL_PHYRX_HE_SIG_B2_OFDMA:
725 ath12k_dp_mon_parse_he_sig_b2_ofdma(tlv_data, ppdu_info);
726 break;
727
728 case HAL_PHYRX_RSSI_LEGACY: {
729 struct hal_rx_phyrx_rssi_legacy_info *rssi =
730 (struct hal_rx_phyrx_rssi_legacy_info *)tlv_data;
731 u32 reception_type = 0;
732 u32 rssi_legacy_info = __le32_to_cpu(rssi->rsvd[0]);
733
734 info[0] = __le32_to_cpu(rssi->info0);
735
736 /* TODO: Please note that the combined rssi will not be accurate
737 * in MU case. Rssi in MU needs to be retrieved from
738 * PHYRX_OTHER_RECEIVE_INFO TLV.
739 */
740 ppdu_info->rssi_comb =
741 u32_get_bits(info[0],
742 HAL_RX_PHYRX_RSSI_LEGACY_INFO_INFO0_RSSI_COMB);
743 reception_type =
744 u32_get_bits(rssi_legacy_info,
745 HAL_RX_PHYRX_RSSI_LEGACY_INFO_RSVD1_RECEPTION);
746
747 switch (reception_type) {
748 case HAL_RECEPTION_TYPE_ULOFMDA:
749 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_MU_OFDMA;
750 break;
751 case HAL_RECEPTION_TYPE_ULMIMO:
752 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_MU_MIMO;
753 break;
754 default:
755 ppdu_info->reception_type = HAL_RX_RECEPTION_TYPE_SU;
756 break;
757 }
758 break;
759 }
760 case HAL_RXPCU_PPDU_END_INFO: {
761 struct hal_rx_ppdu_end_duration *ppdu_rx_duration =
762 (struct hal_rx_ppdu_end_duration *)tlv_data;
763
764 info[0] = __le32_to_cpu(ppdu_rx_duration->info0);
765 ppdu_info->rx_duration =
766 u32_get_bits(info[0], HAL_RX_PPDU_END_DURATION);
767 ppdu_info->tsft = __le32_to_cpu(ppdu_rx_duration->rsvd0[1]);
768 ppdu_info->tsft = (ppdu_info->tsft << 32) |
769 __le32_to_cpu(ppdu_rx_duration->rsvd0[0]);
770 break;
771 }
772 case HAL_RX_MPDU_START: {
773 struct hal_rx_mpdu_start *mpdu_start =
774 (struct hal_rx_mpdu_start *)tlv_data;
775 struct dp_mon_mpdu *mon_mpdu = pmon->mon_mpdu;
776 u16 peer_id;
777
778 info[1] = __le32_to_cpu(mpdu_start->info1);
779 peer_id = u32_get_bits(info[1], HAL_RX_MPDU_START_INFO1_PEERID);
780 if (peer_id)
781 ppdu_info->peer_id = peer_id;
782
783 ppdu_info->mpdu_len += u32_get_bits(info[1],
784 HAL_RX_MPDU_START_INFO2_MPDU_LEN);
785 if (userid < HAL_MAX_UL_MU_USERS) {
786 info[0] = __le32_to_cpu(mpdu_start->info0);
787 ppdu_info->userid = userid;
788 ppdu_info->ampdu_id[userid] =
789 u32_get_bits(info[0], HAL_RX_MPDU_START_INFO1_PEERID);
790 }
791
792 mon_mpdu = kzalloc(sizeof(*mon_mpdu), GFP_ATOMIC);
793 if (!mon_mpdu)
794 return HAL_RX_MON_STATUS_PPDU_NOT_DONE;
795
796 break;
797 }
798 case HAL_RX_MSDU_START:
799 /* TODO: add msdu start parsing logic */
800 break;
801 case HAL_MON_BUF_ADDR: {
802 struct dp_rxdma_ring *buf_ring = &ab->dp.rxdma_mon_buf_ring;
803 struct dp_mon_packet_info *packet_info =
804 (struct dp_mon_packet_info *)tlv_data;
805 int buf_id = u32_get_bits(packet_info->cookie,
806 DP_RXDMA_BUF_COOKIE_BUF_ID);
807 struct sk_buff *msdu;
808 struct dp_mon_mpdu *mon_mpdu = pmon->mon_mpdu;
809 struct ath12k_skb_rxcb *rxcb;
810
811 spin_lock_bh(&buf_ring->idr_lock);
812 msdu = idr_remove(&buf_ring->bufs_idr, buf_id);
813 spin_unlock_bh(&buf_ring->idr_lock);
814
815 if (unlikely(!msdu)) {
816 ath12k_warn(ab, "monitor destination with invalid buf_id %d\n",
817 buf_id);
818 return HAL_RX_MON_STATUS_PPDU_NOT_DONE;
819 }
820
821 rxcb = ATH12K_SKB_RXCB(msdu);
822 dma_unmap_single(ab->dev, rxcb->paddr,
823 msdu->len + skb_tailroom(msdu),
824 DMA_FROM_DEVICE);
825
826 if (mon_mpdu->tail)
827 mon_mpdu->tail->next = msdu;
828 else
829 mon_mpdu->tail = msdu;
830
831 ath12k_dp_mon_buf_replenish(ab, buf_ring, 1);
832
833 break;
834 }
835 case HAL_RX_MSDU_END: {
836 struct rx_msdu_end_qcn9274 *msdu_end =
837 (struct rx_msdu_end_qcn9274 *)tlv_data;
838 bool is_first_msdu_in_mpdu;
839 u16 msdu_end_info;
840
841 msdu_end_info = __le16_to_cpu(msdu_end->info5);
842 is_first_msdu_in_mpdu = u32_get_bits(msdu_end_info,
843 RX_MSDU_END_INFO5_FIRST_MSDU);
844 if (is_first_msdu_in_mpdu) {
845 pmon->mon_mpdu->head = pmon->mon_mpdu->tail;
846 pmon->mon_mpdu->tail = NULL;
847 }
848 break;
849 }
850 case HAL_RX_MPDU_END:
851 list_add_tail(&pmon->mon_mpdu->list, &pmon->dp_rx_mon_mpdu_list);
852 break;
853 case HAL_DUMMY:
854 return HAL_RX_MON_STATUS_BUF_DONE;
855 case HAL_RX_PPDU_END_STATUS_DONE:
856 case 0:
857 return HAL_RX_MON_STATUS_PPDU_DONE;
858 default:
859 break;
860 }
861
862 return HAL_RX_MON_STATUS_PPDU_NOT_DONE;
863 }
864
ath12k_dp_mon_rx_msdus_set_payload(struct ath12k * ar,struct sk_buff * msdu)865 static void ath12k_dp_mon_rx_msdus_set_payload(struct ath12k *ar, struct sk_buff *msdu)
866 {
867 u32 rx_pkt_offset, l2_hdr_offset;
868
869 rx_pkt_offset = ar->ab->hw_params->hal_desc_sz;
870 l2_hdr_offset = ath12k_dp_rx_h_l3pad(ar->ab,
871 (struct hal_rx_desc *)msdu->data);
872 skb_pull(msdu, rx_pkt_offset + l2_hdr_offset);
873 }
874
875 static struct sk_buff *
ath12k_dp_mon_rx_merg_msdus(struct ath12k * ar,u32 mac_id,struct sk_buff * head_msdu,struct ieee80211_rx_status * rxs,bool * fcs_err)876 ath12k_dp_mon_rx_merg_msdus(struct ath12k *ar,
877 u32 mac_id, struct sk_buff *head_msdu,
878 struct ieee80211_rx_status *rxs, bool *fcs_err)
879 {
880 struct ath12k_base *ab = ar->ab;
881 struct sk_buff *msdu, *mpdu_buf, *prev_buf;
882 struct hal_rx_desc *rx_desc;
883 u8 *hdr_desc, *dest, decap_format;
884 struct ieee80211_hdr_3addr *wh;
885 u32 err_bitmap;
886
887 mpdu_buf = NULL;
888
889 if (!head_msdu)
890 goto err_merge_fail;
891
892 rx_desc = (struct hal_rx_desc *)head_msdu->data;
893 err_bitmap = ath12k_dp_rx_h_mpdu_err(ab, rx_desc);
894
895 if (err_bitmap & HAL_RX_MPDU_ERR_FCS)
896 *fcs_err = true;
897
898 decap_format = ath12k_dp_rx_h_decap_type(ab, rx_desc);
899
900 ath12k_dp_rx_h_ppdu(ar, rx_desc, rxs);
901
902 if (decap_format == DP_RX_DECAP_TYPE_RAW) {
903 ath12k_dp_mon_rx_msdus_set_payload(ar, head_msdu);
904
905 prev_buf = head_msdu;
906 msdu = head_msdu->next;
907
908 while (msdu) {
909 ath12k_dp_mon_rx_msdus_set_payload(ar, msdu);
910
911 prev_buf = msdu;
912 msdu = msdu->next;
913 }
914
915 prev_buf->next = NULL;
916
917 skb_trim(prev_buf, prev_buf->len - HAL_RX_FCS_LEN);
918 } else if (decap_format == DP_RX_DECAP_TYPE_NATIVE_WIFI) {
919 u8 qos_pkt = 0;
920
921 rx_desc = (struct hal_rx_desc *)head_msdu->data;
922 hdr_desc = ab->hw_params->hal_ops->rx_desc_get_msdu_payload(rx_desc);
923
924 /* Base size */
925 wh = (struct ieee80211_hdr_3addr *)hdr_desc;
926
927 if (ieee80211_is_data_qos(wh->frame_control))
928 qos_pkt = 1;
929
930 msdu = head_msdu;
931
932 while (msdu) {
933 ath12k_dp_mon_rx_msdus_set_payload(ar, msdu);
934 if (qos_pkt) {
935 dest = skb_push(msdu, sizeof(__le16));
936 if (!dest)
937 goto err_merge_fail;
938 memcpy(dest, hdr_desc, sizeof(struct ieee80211_qos_hdr));
939 }
940 prev_buf = msdu;
941 msdu = msdu->next;
942 }
943 dest = skb_put(prev_buf, HAL_RX_FCS_LEN);
944 if (!dest)
945 goto err_merge_fail;
946
947 ath12k_dbg(ab, ATH12K_DBG_DATA,
948 "mpdu_buf %pK mpdu_buf->len %u",
949 prev_buf, prev_buf->len);
950 } else {
951 ath12k_dbg(ab, ATH12K_DBG_DATA,
952 "decap format %d is not supported!\n",
953 decap_format);
954 goto err_merge_fail;
955 }
956
957 return head_msdu;
958
959 err_merge_fail:
960 if (mpdu_buf && decap_format != DP_RX_DECAP_TYPE_RAW) {
961 ath12k_dbg(ab, ATH12K_DBG_DATA,
962 "err_merge_fail mpdu_buf %pK", mpdu_buf);
963 /* Free the head buffer */
964 dev_kfree_skb_any(mpdu_buf);
965 }
966 return NULL;
967 }
968
969 static void
ath12k_dp_mon_rx_update_radiotap_he(struct hal_rx_mon_ppdu_info * rx_status,u8 * rtap_buf)970 ath12k_dp_mon_rx_update_radiotap_he(struct hal_rx_mon_ppdu_info *rx_status,
971 u8 *rtap_buf)
972 {
973 u32 rtap_len = 0;
974
975 put_unaligned_le16(rx_status->he_data1, &rtap_buf[rtap_len]);
976 rtap_len += 2;
977
978 put_unaligned_le16(rx_status->he_data2, &rtap_buf[rtap_len]);
979 rtap_len += 2;
980
981 put_unaligned_le16(rx_status->he_data3, &rtap_buf[rtap_len]);
982 rtap_len += 2;
983
984 put_unaligned_le16(rx_status->he_data4, &rtap_buf[rtap_len]);
985 rtap_len += 2;
986
987 put_unaligned_le16(rx_status->he_data5, &rtap_buf[rtap_len]);
988 rtap_len += 2;
989
990 put_unaligned_le16(rx_status->he_data6, &rtap_buf[rtap_len]);
991 }
992
993 static void
ath12k_dp_mon_rx_update_radiotap_he_mu(struct hal_rx_mon_ppdu_info * rx_status,u8 * rtap_buf)994 ath12k_dp_mon_rx_update_radiotap_he_mu(struct hal_rx_mon_ppdu_info *rx_status,
995 u8 *rtap_buf)
996 {
997 u32 rtap_len = 0;
998
999 put_unaligned_le16(rx_status->he_flags1, &rtap_buf[rtap_len]);
1000 rtap_len += 2;
1001
1002 put_unaligned_le16(rx_status->he_flags2, &rtap_buf[rtap_len]);
1003 rtap_len += 2;
1004
1005 rtap_buf[rtap_len] = rx_status->he_RU[0];
1006 rtap_len += 1;
1007
1008 rtap_buf[rtap_len] = rx_status->he_RU[1];
1009 rtap_len += 1;
1010
1011 rtap_buf[rtap_len] = rx_status->he_RU[2];
1012 rtap_len += 1;
1013
1014 rtap_buf[rtap_len] = rx_status->he_RU[3];
1015 }
1016
ath12k_dp_mon_update_radiotap(struct ath12k * ar,struct hal_rx_mon_ppdu_info * ppduinfo,struct sk_buff * mon_skb,struct ieee80211_rx_status * rxs)1017 static void ath12k_dp_mon_update_radiotap(struct ath12k *ar,
1018 struct hal_rx_mon_ppdu_info *ppduinfo,
1019 struct sk_buff *mon_skb,
1020 struct ieee80211_rx_status *rxs)
1021 {
1022 struct ieee80211_supported_band *sband;
1023 u8 *ptr = NULL;
1024 u16 ampdu_id = ppduinfo->ampdu_id[ppduinfo->userid];
1025
1026 rxs->flag |= RX_FLAG_MACTIME_START;
1027 rxs->signal = ppduinfo->rssi_comb + ATH12K_DEFAULT_NOISE_FLOOR;
1028 rxs->nss = ppduinfo->nss + 1;
1029
1030 if (ampdu_id) {
1031 rxs->flag |= RX_FLAG_AMPDU_DETAILS;
1032 rxs->ampdu_reference = ampdu_id;
1033 }
1034
1035 if (ppduinfo->he_mu_flags) {
1036 rxs->flag |= RX_FLAG_RADIOTAP_HE_MU;
1037 rxs->encoding = RX_ENC_HE;
1038 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he_mu));
1039 ath12k_dp_mon_rx_update_radiotap_he_mu(ppduinfo, ptr);
1040 } else if (ppduinfo->he_flags) {
1041 rxs->flag |= RX_FLAG_RADIOTAP_HE;
1042 rxs->encoding = RX_ENC_HE;
1043 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he));
1044 ath12k_dp_mon_rx_update_radiotap_he(ppduinfo, ptr);
1045 rxs->rate_idx = ppduinfo->rate;
1046 } else if (ppduinfo->vht_flags) {
1047 rxs->encoding = RX_ENC_VHT;
1048 rxs->rate_idx = ppduinfo->rate;
1049 } else if (ppduinfo->ht_flags) {
1050 rxs->encoding = RX_ENC_HT;
1051 rxs->rate_idx = ppduinfo->rate;
1052 } else {
1053 rxs->encoding = RX_ENC_LEGACY;
1054 sband = &ar->mac.sbands[rxs->band];
1055 rxs->rate_idx = ath12k_mac_hw_rate_to_idx(sband, ppduinfo->rate,
1056 ppduinfo->cck_flag);
1057 }
1058
1059 rxs->mactime = ppduinfo->tsft;
1060 }
1061
ath12k_dp_mon_rx_deliver_msdu(struct ath12k * ar,struct napi_struct * napi,struct sk_buff * msdu,struct ieee80211_rx_status * status)1062 static void ath12k_dp_mon_rx_deliver_msdu(struct ath12k *ar, struct napi_struct *napi,
1063 struct sk_buff *msdu,
1064 struct ieee80211_rx_status *status)
1065 {
1066 static const struct ieee80211_radiotap_he known = {
1067 .data1 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN |
1068 IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN),
1069 .data2 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN),
1070 };
1071 struct ieee80211_rx_status *rx_status;
1072 struct ieee80211_radiotap_he *he = NULL;
1073 struct ieee80211_sta *pubsta = NULL;
1074 struct ath12k_peer *peer;
1075 struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu);
1076 u8 decap = DP_RX_DECAP_TYPE_RAW;
1077 bool is_mcbc = rxcb->is_mcbc;
1078 bool is_eapol_tkip = rxcb->is_eapol;
1079
1080 status->link_valid = 0;
1081
1082 if ((status->encoding == RX_ENC_HE) && !(status->flag & RX_FLAG_RADIOTAP_HE) &&
1083 !(status->flag & RX_FLAG_SKIP_MONITOR)) {
1084 he = skb_push(msdu, sizeof(known));
1085 memcpy(he, &known, sizeof(known));
1086 status->flag |= RX_FLAG_RADIOTAP_HE;
1087 }
1088
1089 if (!(status->flag & RX_FLAG_ONLY_MONITOR))
1090 decap = ath12k_dp_rx_h_decap_type(ar->ab, rxcb->rx_desc);
1091 spin_lock_bh(&ar->ab->base_lock);
1092 peer = ath12k_dp_rx_h_find_peer(ar->ab, msdu);
1093 if (peer && peer->sta)
1094 pubsta = peer->sta;
1095 spin_unlock_bh(&ar->ab->base_lock);
1096
1097 ath12k_dbg(ar->ab, ATH12K_DBG_DATA,
1098 "rx skb %pK len %u peer %pM %u %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",
1099 msdu,
1100 msdu->len,
1101 peer ? peer->addr : NULL,
1102 rxcb->tid,
1103 (is_mcbc) ? "mcast" : "ucast",
1104 (status->encoding == RX_ENC_LEGACY) ? "legacy" : "",
1105 (status->encoding == RX_ENC_HT) ? "ht" : "",
1106 (status->encoding == RX_ENC_VHT) ? "vht" : "",
1107 (status->encoding == RX_ENC_HE) ? "he" : "",
1108 (status->bw == RATE_INFO_BW_40) ? "40" : "",
1109 (status->bw == RATE_INFO_BW_80) ? "80" : "",
1110 (status->bw == RATE_INFO_BW_160) ? "160" : "",
1111 status->enc_flags & RX_ENC_FLAG_SHORT_GI ? "sgi " : "",
1112 status->rate_idx,
1113 status->nss,
1114 status->freq,
1115 status->band, status->flag,
1116 !!(status->flag & RX_FLAG_FAILED_FCS_CRC),
1117 !!(status->flag & RX_FLAG_MMIC_ERROR),
1118 !!(status->flag & RX_FLAG_AMSDU_MORE));
1119
1120 ath12k_dbg_dump(ar->ab, ATH12K_DBG_DP_RX, NULL, "dp rx msdu: ",
1121 msdu->data, msdu->len);
1122 rx_status = IEEE80211_SKB_RXCB(msdu);
1123 *rx_status = *status;
1124
1125 /* TODO: trace rx packet */
1126
1127 /* PN for multicast packets are not validate in HW,
1128 * so skip 802.3 rx path
1129 * Also, fast_rx expects the STA to be authorized, hence
1130 * eapol packets are sent in slow path.
1131 */
1132 if (decap == DP_RX_DECAP_TYPE_ETHERNET2_DIX && !is_eapol_tkip &&
1133 !(is_mcbc && rx_status->flag & RX_FLAG_DECRYPTED))
1134 rx_status->flag |= RX_FLAG_8023;
1135
1136 ieee80211_rx_napi(ar->hw, pubsta, msdu, napi);
1137 }
1138
ath12k_dp_mon_rx_deliver(struct ath12k * ar,u32 mac_id,struct sk_buff * head_msdu,struct hal_rx_mon_ppdu_info * ppduinfo,struct napi_struct * napi)1139 static int ath12k_dp_mon_rx_deliver(struct ath12k *ar, u32 mac_id,
1140 struct sk_buff *head_msdu,
1141 struct hal_rx_mon_ppdu_info *ppduinfo,
1142 struct napi_struct *napi)
1143 {
1144 struct ath12k_pdev_dp *dp = &ar->dp;
1145 struct sk_buff *mon_skb, *skb_next, *header;
1146 struct ieee80211_rx_status *rxs = &dp->rx_status;
1147 bool fcs_err = false;
1148
1149 mon_skb = ath12k_dp_mon_rx_merg_msdus(ar, mac_id, head_msdu,
1150 rxs, &fcs_err);
1151 if (!mon_skb)
1152 goto mon_deliver_fail;
1153
1154 header = mon_skb;
1155 rxs->flag = 0;
1156
1157 if (fcs_err)
1158 rxs->flag = RX_FLAG_FAILED_FCS_CRC;
1159
1160 do {
1161 skb_next = mon_skb->next;
1162 if (!skb_next)
1163 rxs->flag &= ~RX_FLAG_AMSDU_MORE;
1164 else
1165 rxs->flag |= RX_FLAG_AMSDU_MORE;
1166
1167 if (mon_skb == header) {
1168 header = NULL;
1169 rxs->flag &= ~RX_FLAG_ALLOW_SAME_PN;
1170 } else {
1171 rxs->flag |= RX_FLAG_ALLOW_SAME_PN;
1172 }
1173 rxs->flag |= RX_FLAG_ONLY_MONITOR;
1174 ath12k_dp_mon_update_radiotap(ar, ppduinfo, mon_skb, rxs);
1175 ath12k_dp_mon_rx_deliver_msdu(ar, napi, mon_skb, rxs);
1176 mon_skb = skb_next;
1177 } while (mon_skb);
1178 rxs->flag = 0;
1179
1180 return 0;
1181
1182 mon_deliver_fail:
1183 mon_skb = head_msdu;
1184 while (mon_skb) {
1185 skb_next = mon_skb->next;
1186 dev_kfree_skb_any(mon_skb);
1187 mon_skb = skb_next;
1188 }
1189 return -EINVAL;
1190 }
1191
1192 static enum hal_rx_mon_status
ath12k_dp_mon_parse_rx_dest(struct ath12k_base * ab,struct ath12k_mon_data * pmon,struct sk_buff * skb)1193 ath12k_dp_mon_parse_rx_dest(struct ath12k_base *ab, struct ath12k_mon_data *pmon,
1194 struct sk_buff *skb)
1195 {
1196 struct hal_rx_mon_ppdu_info *ppdu_info = &pmon->mon_ppdu_info;
1197 struct hal_tlv_hdr *tlv;
1198 enum hal_rx_mon_status hal_status;
1199 u32 tlv_userid = 0;
1200 u16 tlv_tag, tlv_len;
1201 u8 *ptr = skb->data;
1202
1203 memset(ppdu_info, 0, sizeof(struct hal_rx_mon_ppdu_info));
1204
1205 do {
1206 tlv = (struct hal_tlv_hdr *)ptr;
1207 tlv_tag = le32_get_bits(tlv->tl, HAL_TLV_HDR_TAG);
1208 tlv_len = le32_get_bits(tlv->tl, HAL_TLV_HDR_LEN);
1209 tlv_userid = le32_get_bits(tlv->tl, HAL_TLV_USR_ID);
1210 ptr += sizeof(*tlv);
1211
1212 /* The actual length of PPDU_END is the combined length of many PHY
1213 * TLVs that follow. Skip the TLV header and
1214 * rx_rxpcu_classification_overview that follows the header to get to
1215 * next TLV.
1216 */
1217
1218 if (tlv_tag == HAL_RX_PPDU_END)
1219 tlv_len = sizeof(struct hal_rx_rxpcu_classification_overview);
1220
1221 hal_status = ath12k_dp_mon_rx_parse_status_tlv(ab, pmon,
1222 tlv_tag, ptr, tlv_userid);
1223 ptr += tlv_len;
1224 ptr = PTR_ALIGN(ptr, HAL_TLV_ALIGN);
1225
1226 if ((ptr - skb->data) >= DP_RX_BUFFER_SIZE)
1227 break;
1228
1229 } while (hal_status == HAL_RX_MON_STATUS_PPDU_NOT_DONE);
1230
1231 return hal_status;
1232 }
1233
1234 enum hal_rx_mon_status
ath12k_dp_mon_rx_parse_mon_status(struct ath12k * ar,struct ath12k_mon_data * pmon,int mac_id,struct sk_buff * skb,struct napi_struct * napi)1235 ath12k_dp_mon_rx_parse_mon_status(struct ath12k *ar,
1236 struct ath12k_mon_data *pmon,
1237 int mac_id,
1238 struct sk_buff *skb,
1239 struct napi_struct *napi)
1240 {
1241 struct ath12k_base *ab = ar->ab;
1242 struct hal_rx_mon_ppdu_info *ppdu_info = &pmon->mon_ppdu_info;
1243 struct dp_mon_mpdu *tmp;
1244 struct dp_mon_mpdu *mon_mpdu = pmon->mon_mpdu;
1245 struct sk_buff *head_msdu, *tail_msdu;
1246 enum hal_rx_mon_status hal_status = HAL_RX_MON_STATUS_BUF_DONE;
1247
1248 ath12k_dp_mon_parse_rx_dest(ab, pmon, skb);
1249
1250 list_for_each_entry_safe(mon_mpdu, tmp, &pmon->dp_rx_mon_mpdu_list, list) {
1251 list_del(&mon_mpdu->list);
1252 head_msdu = mon_mpdu->head;
1253 tail_msdu = mon_mpdu->tail;
1254
1255 if (head_msdu && tail_msdu) {
1256 ath12k_dp_mon_rx_deliver(ar, mac_id, head_msdu,
1257 ppdu_info, napi);
1258 }
1259
1260 kfree(mon_mpdu);
1261 }
1262 return hal_status;
1263 }
1264
ath12k_dp_mon_buf_replenish(struct ath12k_base * ab,struct dp_rxdma_ring * buf_ring,int req_entries)1265 int ath12k_dp_mon_buf_replenish(struct ath12k_base *ab,
1266 struct dp_rxdma_ring *buf_ring,
1267 int req_entries)
1268 {
1269 struct hal_mon_buf_ring *mon_buf;
1270 struct sk_buff *skb;
1271 struct hal_srng *srng;
1272 dma_addr_t paddr;
1273 u32 cookie;
1274 int buf_id;
1275
1276 srng = &ab->hal.srng_list[buf_ring->refill_buf_ring.ring_id];
1277 spin_lock_bh(&srng->lock);
1278 ath12k_hal_srng_access_begin(ab, srng);
1279
1280 while (req_entries > 0) {
1281 skb = dev_alloc_skb(DP_RX_BUFFER_SIZE + DP_RX_BUFFER_ALIGN_SIZE);
1282 if (unlikely(!skb))
1283 goto fail_alloc_skb;
1284
1285 if (!IS_ALIGNED((unsigned long)skb->data, DP_RX_BUFFER_ALIGN_SIZE)) {
1286 skb_pull(skb,
1287 PTR_ALIGN(skb->data, DP_RX_BUFFER_ALIGN_SIZE) -
1288 skb->data);
1289 }
1290
1291 paddr = dma_map_single(ab->dev, skb->data,
1292 skb->len + skb_tailroom(skb),
1293 DMA_FROM_DEVICE);
1294
1295 if (unlikely(dma_mapping_error(ab->dev, paddr)))
1296 goto fail_free_skb;
1297
1298 spin_lock_bh(&buf_ring->idr_lock);
1299 buf_id = idr_alloc(&buf_ring->bufs_idr, skb, 0,
1300 buf_ring->bufs_max * 3, GFP_ATOMIC);
1301 spin_unlock_bh(&buf_ring->idr_lock);
1302
1303 if (unlikely(buf_id < 0))
1304 goto fail_dma_unmap;
1305
1306 mon_buf = ath12k_hal_srng_src_get_next_entry(ab, srng);
1307 if (unlikely(!mon_buf))
1308 goto fail_idr_remove;
1309
1310 ATH12K_SKB_RXCB(skb)->paddr = paddr;
1311
1312 cookie = u32_encode_bits(buf_id, DP_RXDMA_BUF_COOKIE_BUF_ID);
1313
1314 mon_buf->paddr_lo = cpu_to_le32(lower_32_bits(paddr));
1315 mon_buf->paddr_hi = cpu_to_le32(upper_32_bits(paddr));
1316 mon_buf->cookie = cpu_to_le64(cookie);
1317
1318 req_entries--;
1319 }
1320
1321 ath12k_hal_srng_access_end(ab, srng);
1322 spin_unlock_bh(&srng->lock);
1323 return 0;
1324
1325 fail_idr_remove:
1326 spin_lock_bh(&buf_ring->idr_lock);
1327 idr_remove(&buf_ring->bufs_idr, buf_id);
1328 spin_unlock_bh(&buf_ring->idr_lock);
1329 fail_dma_unmap:
1330 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
1331 DMA_FROM_DEVICE);
1332 fail_free_skb:
1333 dev_kfree_skb_any(skb);
1334 fail_alloc_skb:
1335 ath12k_hal_srng_access_end(ab, srng);
1336 spin_unlock_bh(&srng->lock);
1337 return -ENOMEM;
1338 }
1339
1340 static struct dp_mon_tx_ppdu_info *
ath12k_dp_mon_tx_get_ppdu_info(struct ath12k_mon_data * pmon,unsigned int ppdu_id,enum dp_mon_tx_ppdu_info_type type)1341 ath12k_dp_mon_tx_get_ppdu_info(struct ath12k_mon_data *pmon,
1342 unsigned int ppdu_id,
1343 enum dp_mon_tx_ppdu_info_type type)
1344 {
1345 struct dp_mon_tx_ppdu_info *tx_ppdu_info;
1346
1347 if (type == DP_MON_TX_PROT_PPDU_INFO) {
1348 tx_ppdu_info = pmon->tx_prot_ppdu_info;
1349
1350 if (tx_ppdu_info && !tx_ppdu_info->is_used)
1351 return tx_ppdu_info;
1352 kfree(tx_ppdu_info);
1353 } else {
1354 tx_ppdu_info = pmon->tx_data_ppdu_info;
1355
1356 if (tx_ppdu_info && !tx_ppdu_info->is_used)
1357 return tx_ppdu_info;
1358 kfree(tx_ppdu_info);
1359 }
1360
1361 /* allocate new tx_ppdu_info */
1362 tx_ppdu_info = kzalloc(sizeof(*tx_ppdu_info), GFP_ATOMIC);
1363 if (!tx_ppdu_info)
1364 return NULL;
1365
1366 tx_ppdu_info->is_used = 0;
1367 tx_ppdu_info->ppdu_id = ppdu_id;
1368
1369 if (type == DP_MON_TX_PROT_PPDU_INFO)
1370 pmon->tx_prot_ppdu_info = tx_ppdu_info;
1371 else
1372 pmon->tx_data_ppdu_info = tx_ppdu_info;
1373
1374 return tx_ppdu_info;
1375 }
1376
1377 static struct dp_mon_tx_ppdu_info *
ath12k_dp_mon_hal_tx_ppdu_info(struct ath12k_mon_data * pmon,u16 tlv_tag)1378 ath12k_dp_mon_hal_tx_ppdu_info(struct ath12k_mon_data *pmon,
1379 u16 tlv_tag)
1380 {
1381 switch (tlv_tag) {
1382 case HAL_TX_FES_SETUP:
1383 case HAL_TX_FLUSH:
1384 case HAL_PCU_PPDU_SETUP_INIT:
1385 case HAL_TX_PEER_ENTRY:
1386 case HAL_TX_QUEUE_EXTENSION:
1387 case HAL_TX_MPDU_START:
1388 case HAL_TX_MSDU_START:
1389 case HAL_TX_DATA:
1390 case HAL_MON_BUF_ADDR:
1391 case HAL_TX_MPDU_END:
1392 case HAL_TX_LAST_MPDU_FETCHED:
1393 case HAL_TX_LAST_MPDU_END:
1394 case HAL_COEX_TX_REQ:
1395 case HAL_TX_RAW_OR_NATIVE_FRAME_SETUP:
1396 case HAL_SCH_CRITICAL_TLV_REFERENCE:
1397 case HAL_TX_FES_SETUP_COMPLETE:
1398 case HAL_TQM_MPDU_GLOBAL_START:
1399 case HAL_SCHEDULER_END:
1400 case HAL_TX_FES_STATUS_USER_PPDU:
1401 break;
1402 case HAL_TX_FES_STATUS_PROT: {
1403 if (!pmon->tx_prot_ppdu_info->is_used)
1404 pmon->tx_prot_ppdu_info->is_used = true;
1405
1406 return pmon->tx_prot_ppdu_info;
1407 }
1408 }
1409
1410 if (!pmon->tx_data_ppdu_info->is_used)
1411 pmon->tx_data_ppdu_info->is_used = true;
1412
1413 return pmon->tx_data_ppdu_info;
1414 }
1415
1416 #define MAX_MONITOR_HEADER 512
1417 #define MAX_DUMMY_FRM_BODY 128
1418
ath12k_dp_mon_tx_alloc_skb(void)1419 struct sk_buff *ath12k_dp_mon_tx_alloc_skb(void)
1420 {
1421 struct sk_buff *skb;
1422
1423 skb = dev_alloc_skb(MAX_MONITOR_HEADER + MAX_DUMMY_FRM_BODY);
1424 if (!skb)
1425 return NULL;
1426
1427 skb_reserve(skb, MAX_MONITOR_HEADER);
1428
1429 if (!IS_ALIGNED((unsigned long)skb->data, 4))
1430 skb_pull(skb, PTR_ALIGN(skb->data, 4) - skb->data);
1431
1432 return skb;
1433 }
1434
1435 static int
ath12k_dp_mon_tx_gen_cts2self_frame(struct dp_mon_tx_ppdu_info * tx_ppdu_info)1436 ath12k_dp_mon_tx_gen_cts2self_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info)
1437 {
1438 struct sk_buff *skb;
1439 struct ieee80211_cts *cts;
1440
1441 skb = ath12k_dp_mon_tx_alloc_skb();
1442 if (!skb)
1443 return -ENOMEM;
1444
1445 cts = (struct ieee80211_cts *)skb->data;
1446 memset(cts, 0, MAX_DUMMY_FRM_BODY);
1447 cts->frame_control =
1448 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS);
1449 cts->duration = cpu_to_le16(tx_ppdu_info->rx_status.rx_duration);
1450 memcpy(cts->ra, tx_ppdu_info->rx_status.addr1, sizeof(cts->ra));
1451
1452 skb_put(skb, sizeof(*cts));
1453 tx_ppdu_info->tx_mon_mpdu->head = skb;
1454 tx_ppdu_info->tx_mon_mpdu->tail = NULL;
1455 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list,
1456 &tx_ppdu_info->dp_tx_mon_mpdu_list);
1457
1458 return 0;
1459 }
1460
1461 static int
ath12k_dp_mon_tx_gen_rts_frame(struct dp_mon_tx_ppdu_info * tx_ppdu_info)1462 ath12k_dp_mon_tx_gen_rts_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info)
1463 {
1464 struct sk_buff *skb;
1465 struct ieee80211_rts *rts;
1466
1467 skb = ath12k_dp_mon_tx_alloc_skb();
1468 if (!skb)
1469 return -ENOMEM;
1470
1471 rts = (struct ieee80211_rts *)skb->data;
1472 memset(rts, 0, MAX_DUMMY_FRM_BODY);
1473 rts->frame_control =
1474 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
1475 rts->duration = cpu_to_le16(tx_ppdu_info->rx_status.rx_duration);
1476 memcpy(rts->ra, tx_ppdu_info->rx_status.addr1, sizeof(rts->ra));
1477 memcpy(rts->ta, tx_ppdu_info->rx_status.addr2, sizeof(rts->ta));
1478
1479 skb_put(skb, sizeof(*rts));
1480 tx_ppdu_info->tx_mon_mpdu->head = skb;
1481 tx_ppdu_info->tx_mon_mpdu->tail = NULL;
1482 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list,
1483 &tx_ppdu_info->dp_tx_mon_mpdu_list);
1484
1485 return 0;
1486 }
1487
1488 static int
ath12k_dp_mon_tx_gen_3addr_qos_null_frame(struct dp_mon_tx_ppdu_info * tx_ppdu_info)1489 ath12k_dp_mon_tx_gen_3addr_qos_null_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info)
1490 {
1491 struct sk_buff *skb;
1492 struct ieee80211_qos_hdr *qhdr;
1493
1494 skb = ath12k_dp_mon_tx_alloc_skb();
1495 if (!skb)
1496 return -ENOMEM;
1497
1498 qhdr = (struct ieee80211_qos_hdr *)skb->data;
1499 memset(qhdr, 0, MAX_DUMMY_FRM_BODY);
1500 qhdr->frame_control =
1501 cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_QOS_NULLFUNC);
1502 qhdr->duration_id = cpu_to_le16(tx_ppdu_info->rx_status.rx_duration);
1503 memcpy(qhdr->addr1, tx_ppdu_info->rx_status.addr1, ETH_ALEN);
1504 memcpy(qhdr->addr2, tx_ppdu_info->rx_status.addr2, ETH_ALEN);
1505 memcpy(qhdr->addr3, tx_ppdu_info->rx_status.addr3, ETH_ALEN);
1506
1507 skb_put(skb, sizeof(*qhdr));
1508 tx_ppdu_info->tx_mon_mpdu->head = skb;
1509 tx_ppdu_info->tx_mon_mpdu->tail = NULL;
1510 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list,
1511 &tx_ppdu_info->dp_tx_mon_mpdu_list);
1512
1513 return 0;
1514 }
1515
1516 static int
ath12k_dp_mon_tx_gen_4addr_qos_null_frame(struct dp_mon_tx_ppdu_info * tx_ppdu_info)1517 ath12k_dp_mon_tx_gen_4addr_qos_null_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info)
1518 {
1519 struct sk_buff *skb;
1520 struct dp_mon_qosframe_addr4 *qhdr;
1521
1522 skb = ath12k_dp_mon_tx_alloc_skb();
1523 if (!skb)
1524 return -ENOMEM;
1525
1526 qhdr = (struct dp_mon_qosframe_addr4 *)skb->data;
1527 memset(qhdr, 0, MAX_DUMMY_FRM_BODY);
1528 qhdr->frame_control =
1529 cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_QOS_NULLFUNC);
1530 qhdr->duration = cpu_to_le16(tx_ppdu_info->rx_status.rx_duration);
1531 memcpy(qhdr->addr1, tx_ppdu_info->rx_status.addr1, ETH_ALEN);
1532 memcpy(qhdr->addr2, tx_ppdu_info->rx_status.addr2, ETH_ALEN);
1533 memcpy(qhdr->addr3, tx_ppdu_info->rx_status.addr3, ETH_ALEN);
1534 memcpy(qhdr->addr4, tx_ppdu_info->rx_status.addr4, ETH_ALEN);
1535
1536 skb_put(skb, sizeof(*qhdr));
1537 tx_ppdu_info->tx_mon_mpdu->head = skb;
1538 tx_ppdu_info->tx_mon_mpdu->tail = NULL;
1539 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list,
1540 &tx_ppdu_info->dp_tx_mon_mpdu_list);
1541
1542 return 0;
1543 }
1544
1545 static int
ath12k_dp_mon_tx_gen_ack_frame(struct dp_mon_tx_ppdu_info * tx_ppdu_info)1546 ath12k_dp_mon_tx_gen_ack_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info)
1547 {
1548 struct sk_buff *skb;
1549 struct dp_mon_frame_min_one *fbmhdr;
1550
1551 skb = ath12k_dp_mon_tx_alloc_skb();
1552 if (!skb)
1553 return -ENOMEM;
1554
1555 fbmhdr = (struct dp_mon_frame_min_one *)skb->data;
1556 memset(fbmhdr, 0, MAX_DUMMY_FRM_BODY);
1557 fbmhdr->frame_control =
1558 cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_QOS_CFACK);
1559 memcpy(fbmhdr->addr1, tx_ppdu_info->rx_status.addr1, ETH_ALEN);
1560
1561 /* set duration zero for ack frame */
1562 fbmhdr->duration = 0;
1563
1564 skb_put(skb, sizeof(*fbmhdr));
1565 tx_ppdu_info->tx_mon_mpdu->head = skb;
1566 tx_ppdu_info->tx_mon_mpdu->tail = NULL;
1567 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list,
1568 &tx_ppdu_info->dp_tx_mon_mpdu_list);
1569
1570 return 0;
1571 }
1572
1573 static int
ath12k_dp_mon_tx_gen_prot_frame(struct dp_mon_tx_ppdu_info * tx_ppdu_info)1574 ath12k_dp_mon_tx_gen_prot_frame(struct dp_mon_tx_ppdu_info *tx_ppdu_info)
1575 {
1576 int ret = 0;
1577
1578 switch (tx_ppdu_info->rx_status.medium_prot_type) {
1579 case DP_MON_TX_MEDIUM_RTS_LEGACY:
1580 case DP_MON_TX_MEDIUM_RTS_11AC_STATIC_BW:
1581 case DP_MON_TX_MEDIUM_RTS_11AC_DYNAMIC_BW:
1582 ret = ath12k_dp_mon_tx_gen_rts_frame(tx_ppdu_info);
1583 break;
1584 case DP_MON_TX_MEDIUM_CTS2SELF:
1585 ret = ath12k_dp_mon_tx_gen_cts2self_frame(tx_ppdu_info);
1586 break;
1587 case DP_MON_TX_MEDIUM_QOS_NULL_NO_ACK_3ADDR:
1588 ret = ath12k_dp_mon_tx_gen_3addr_qos_null_frame(tx_ppdu_info);
1589 break;
1590 case DP_MON_TX_MEDIUM_QOS_NULL_NO_ACK_4ADDR:
1591 ret = ath12k_dp_mon_tx_gen_4addr_qos_null_frame(tx_ppdu_info);
1592 break;
1593 }
1594
1595 return ret;
1596 }
1597
1598 static enum dp_mon_tx_tlv_status
ath12k_dp_mon_tx_parse_status_tlv(struct ath12k_base * ab,struct ath12k_mon_data * pmon,u16 tlv_tag,u8 * tlv_data,u32 userid)1599 ath12k_dp_mon_tx_parse_status_tlv(struct ath12k_base *ab,
1600 struct ath12k_mon_data *pmon,
1601 u16 tlv_tag, u8 *tlv_data, u32 userid)
1602 {
1603 struct dp_mon_tx_ppdu_info *tx_ppdu_info;
1604 enum dp_mon_tx_tlv_status status = DP_MON_TX_STATUS_PPDU_NOT_DONE;
1605 u32 info[7];
1606
1607 tx_ppdu_info = ath12k_dp_mon_hal_tx_ppdu_info(pmon, tlv_tag);
1608
1609 switch (tlv_tag) {
1610 case HAL_TX_FES_SETUP: {
1611 struct hal_tx_fes_setup *tx_fes_setup =
1612 (struct hal_tx_fes_setup *)tlv_data;
1613
1614 info[0] = __le32_to_cpu(tx_fes_setup->info0);
1615 tx_ppdu_info->ppdu_id = __le32_to_cpu(tx_fes_setup->schedule_id);
1616 tx_ppdu_info->num_users =
1617 u32_get_bits(info[0], HAL_TX_FES_SETUP_INFO0_NUM_OF_USERS);
1618 status = DP_MON_TX_FES_SETUP;
1619 break;
1620 }
1621
1622 case HAL_TX_FES_STATUS_END: {
1623 struct hal_tx_fes_status_end *tx_fes_status_end =
1624 (struct hal_tx_fes_status_end *)tlv_data;
1625 u32 tst_15_0, tst_31_16;
1626
1627 info[0] = __le32_to_cpu(tx_fes_status_end->info0);
1628 tst_15_0 =
1629 u32_get_bits(info[0],
1630 HAL_TX_FES_STATUS_END_INFO0_START_TIMESTAMP_15_0);
1631 tst_31_16 =
1632 u32_get_bits(info[0],
1633 HAL_TX_FES_STATUS_END_INFO0_START_TIMESTAMP_31_16);
1634
1635 tx_ppdu_info->rx_status.ppdu_ts = (tst_15_0 | (tst_31_16 << 16));
1636 status = DP_MON_TX_FES_STATUS_END;
1637 break;
1638 }
1639
1640 case HAL_RX_RESPONSE_REQUIRED_INFO: {
1641 struct hal_rx_resp_req_info *rx_resp_req_info =
1642 (struct hal_rx_resp_req_info *)tlv_data;
1643 u32 addr_32;
1644 u16 addr_16;
1645
1646 info[0] = __le32_to_cpu(rx_resp_req_info->info0);
1647 info[1] = __le32_to_cpu(rx_resp_req_info->info1);
1648 info[2] = __le32_to_cpu(rx_resp_req_info->info2);
1649 info[3] = __le32_to_cpu(rx_resp_req_info->info3);
1650 info[4] = __le32_to_cpu(rx_resp_req_info->info4);
1651 info[5] = __le32_to_cpu(rx_resp_req_info->info5);
1652
1653 tx_ppdu_info->rx_status.ppdu_id =
1654 u32_get_bits(info[0], HAL_RX_RESP_REQ_INFO0_PPDU_ID);
1655 tx_ppdu_info->rx_status.reception_type =
1656 u32_get_bits(info[0], HAL_RX_RESP_REQ_INFO0_RECEPTION_TYPE);
1657 tx_ppdu_info->rx_status.rx_duration =
1658 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_DURATION);
1659 tx_ppdu_info->rx_status.mcs =
1660 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_RATE_MCS);
1661 tx_ppdu_info->rx_status.sgi =
1662 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_SGI);
1663 tx_ppdu_info->rx_status.is_stbc =
1664 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_STBC);
1665 tx_ppdu_info->rx_status.ldpc =
1666 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_LDPC);
1667 tx_ppdu_info->rx_status.is_ampdu =
1668 u32_get_bits(info[1], HAL_RX_RESP_REQ_INFO1_IS_AMPDU);
1669 tx_ppdu_info->rx_status.num_users =
1670 u32_get_bits(info[2], HAL_RX_RESP_REQ_INFO2_NUM_USER);
1671
1672 addr_32 = u32_get_bits(info[3], HAL_RX_RESP_REQ_INFO3_ADDR1_31_0);
1673 addr_16 = u32_get_bits(info[3], HAL_RX_RESP_REQ_INFO4_ADDR1_47_32);
1674 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr1);
1675
1676 addr_16 = u32_get_bits(info[4], HAL_RX_RESP_REQ_INFO4_ADDR1_15_0);
1677 addr_32 = u32_get_bits(info[5], HAL_RX_RESP_REQ_INFO5_ADDR1_47_16);
1678 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr2);
1679
1680 if (tx_ppdu_info->rx_status.reception_type == 0)
1681 ath12k_dp_mon_tx_gen_cts2self_frame(tx_ppdu_info);
1682 status = DP_MON_RX_RESPONSE_REQUIRED_INFO;
1683 break;
1684 }
1685
1686 case HAL_PCU_PPDU_SETUP_INIT: {
1687 struct hal_tx_pcu_ppdu_setup_init *ppdu_setup =
1688 (struct hal_tx_pcu_ppdu_setup_init *)tlv_data;
1689 u32 addr_32;
1690 u16 addr_16;
1691
1692 info[0] = __le32_to_cpu(ppdu_setup->info0);
1693 info[1] = __le32_to_cpu(ppdu_setup->info1);
1694 info[2] = __le32_to_cpu(ppdu_setup->info2);
1695 info[3] = __le32_to_cpu(ppdu_setup->info3);
1696 info[4] = __le32_to_cpu(ppdu_setup->info4);
1697 info[5] = __le32_to_cpu(ppdu_setup->info5);
1698 info[6] = __le32_to_cpu(ppdu_setup->info6);
1699
1700 /* protection frame address 1 */
1701 addr_32 = u32_get_bits(info[1],
1702 HAL_TX_PPDU_SETUP_INFO1_PROT_FRAME_ADDR1_31_0);
1703 addr_16 = u32_get_bits(info[2],
1704 HAL_TX_PPDU_SETUP_INFO2_PROT_FRAME_ADDR1_47_32);
1705 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr1);
1706
1707 /* protection frame address 2 */
1708 addr_16 = u32_get_bits(info[2],
1709 HAL_TX_PPDU_SETUP_INFO2_PROT_FRAME_ADDR2_15_0);
1710 addr_32 = u32_get_bits(info[3],
1711 HAL_TX_PPDU_SETUP_INFO3_PROT_FRAME_ADDR2_47_16);
1712 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr2);
1713
1714 /* protection frame address 3 */
1715 addr_32 = u32_get_bits(info[4],
1716 HAL_TX_PPDU_SETUP_INFO4_PROT_FRAME_ADDR3_31_0);
1717 addr_16 = u32_get_bits(info[5],
1718 HAL_TX_PPDU_SETUP_INFO5_PROT_FRAME_ADDR3_47_32);
1719 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr3);
1720
1721 /* protection frame address 4 */
1722 addr_16 = u32_get_bits(info[5],
1723 HAL_TX_PPDU_SETUP_INFO5_PROT_FRAME_ADDR4_15_0);
1724 addr_32 = u32_get_bits(info[6],
1725 HAL_TX_PPDU_SETUP_INFO6_PROT_FRAME_ADDR4_47_16);
1726 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr4);
1727
1728 status = u32_get_bits(info[0],
1729 HAL_TX_PPDU_SETUP_INFO0_MEDIUM_PROT_TYPE);
1730 break;
1731 }
1732
1733 case HAL_TX_QUEUE_EXTENSION: {
1734 struct hal_tx_queue_exten *tx_q_exten =
1735 (struct hal_tx_queue_exten *)tlv_data;
1736
1737 info[0] = __le32_to_cpu(tx_q_exten->info0);
1738
1739 tx_ppdu_info->rx_status.frame_control =
1740 u32_get_bits(info[0],
1741 HAL_TX_Q_EXT_INFO0_FRAME_CTRL);
1742 tx_ppdu_info->rx_status.fc_valid = true;
1743 break;
1744 }
1745
1746 case HAL_TX_FES_STATUS_START: {
1747 struct hal_tx_fes_status_start *tx_fes_start =
1748 (struct hal_tx_fes_status_start *)tlv_data;
1749
1750 info[0] = __le32_to_cpu(tx_fes_start->info0);
1751
1752 tx_ppdu_info->rx_status.medium_prot_type =
1753 u32_get_bits(info[0],
1754 HAL_TX_FES_STATUS_START_INFO0_MEDIUM_PROT_TYPE);
1755 break;
1756 }
1757
1758 case HAL_TX_FES_STATUS_PROT: {
1759 struct hal_tx_fes_status_prot *tx_fes_status =
1760 (struct hal_tx_fes_status_prot *)tlv_data;
1761 u32 start_timestamp;
1762 u32 end_timestamp;
1763
1764 info[0] = __le32_to_cpu(tx_fes_status->info0);
1765 info[1] = __le32_to_cpu(tx_fes_status->info1);
1766
1767 start_timestamp =
1768 u32_get_bits(info[0],
1769 HAL_TX_FES_STAT_PROT_INFO0_STRT_FRM_TS_15_0);
1770 start_timestamp |=
1771 u32_get_bits(info[0],
1772 HAL_TX_FES_STAT_PROT_INFO0_STRT_FRM_TS_31_16) << 15;
1773 end_timestamp =
1774 u32_get_bits(info[1],
1775 HAL_TX_FES_STAT_PROT_INFO1_END_FRM_TS_15_0);
1776 end_timestamp |=
1777 u32_get_bits(info[1],
1778 HAL_TX_FES_STAT_PROT_INFO1_END_FRM_TS_31_16) << 15;
1779 tx_ppdu_info->rx_status.rx_duration = end_timestamp - start_timestamp;
1780
1781 ath12k_dp_mon_tx_gen_prot_frame(tx_ppdu_info);
1782 break;
1783 }
1784
1785 case HAL_TX_FES_STATUS_START_PPDU:
1786 case HAL_TX_FES_STATUS_START_PROT: {
1787 struct hal_tx_fes_status_start_prot *tx_fes_stat_start =
1788 (struct hal_tx_fes_status_start_prot *)tlv_data;
1789 u64 ppdu_ts;
1790
1791 info[0] = __le32_to_cpu(tx_fes_stat_start->info0);
1792
1793 tx_ppdu_info->rx_status.ppdu_ts =
1794 u32_get_bits(info[0],
1795 HAL_TX_FES_STAT_STRT_INFO0_PROT_TS_LOWER_32);
1796 ppdu_ts = (u32_get_bits(info[1],
1797 HAL_TX_FES_STAT_STRT_INFO1_PROT_TS_UPPER_32));
1798 tx_ppdu_info->rx_status.ppdu_ts |= ppdu_ts << 32;
1799 break;
1800 }
1801
1802 case HAL_TX_FES_STATUS_USER_PPDU: {
1803 struct hal_tx_fes_status_user_ppdu *tx_fes_usr_ppdu =
1804 (struct hal_tx_fes_status_user_ppdu *)tlv_data;
1805
1806 info[0] = __le32_to_cpu(tx_fes_usr_ppdu->info0);
1807
1808 tx_ppdu_info->rx_status.rx_duration =
1809 u32_get_bits(info[0],
1810 HAL_TX_FES_STAT_USR_PPDU_INFO0_DURATION);
1811 break;
1812 }
1813
1814 case HAL_MACTX_HE_SIG_A_SU:
1815 ath12k_dp_mon_parse_he_sig_su(tlv_data, &tx_ppdu_info->rx_status);
1816 break;
1817
1818 case HAL_MACTX_HE_SIG_A_MU_DL:
1819 ath12k_dp_mon_parse_he_sig_mu(tlv_data, &tx_ppdu_info->rx_status);
1820 break;
1821
1822 case HAL_MACTX_HE_SIG_B1_MU:
1823 ath12k_dp_mon_parse_he_sig_b1_mu(tlv_data, &tx_ppdu_info->rx_status);
1824 break;
1825
1826 case HAL_MACTX_HE_SIG_B2_MU:
1827 ath12k_dp_mon_parse_he_sig_b2_mu(tlv_data, &tx_ppdu_info->rx_status);
1828 break;
1829
1830 case HAL_MACTX_HE_SIG_B2_OFDMA:
1831 ath12k_dp_mon_parse_he_sig_b2_ofdma(tlv_data, &tx_ppdu_info->rx_status);
1832 break;
1833
1834 case HAL_MACTX_VHT_SIG_A:
1835 ath12k_dp_mon_parse_vht_sig_a(tlv_data, &tx_ppdu_info->rx_status);
1836 break;
1837
1838 case HAL_MACTX_L_SIG_A:
1839 ath12k_dp_mon_parse_l_sig_a(tlv_data, &tx_ppdu_info->rx_status);
1840 break;
1841
1842 case HAL_MACTX_L_SIG_B:
1843 ath12k_dp_mon_parse_l_sig_b(tlv_data, &tx_ppdu_info->rx_status);
1844 break;
1845
1846 case HAL_RX_FRAME_BITMAP_ACK: {
1847 struct hal_rx_frame_bitmap_ack *fbm_ack =
1848 (struct hal_rx_frame_bitmap_ack *)tlv_data;
1849 u32 addr_32;
1850 u16 addr_16;
1851
1852 info[0] = __le32_to_cpu(fbm_ack->info0);
1853 info[1] = __le32_to_cpu(fbm_ack->info1);
1854
1855 addr_32 = u32_get_bits(info[0],
1856 HAL_RX_FBM_ACK_INFO0_ADDR1_31_0);
1857 addr_16 = u32_get_bits(info[1],
1858 HAL_RX_FBM_ACK_INFO1_ADDR1_47_32);
1859 ath12k_dp_get_mac_addr(addr_32, addr_16, tx_ppdu_info->rx_status.addr1);
1860
1861 ath12k_dp_mon_tx_gen_ack_frame(tx_ppdu_info);
1862 break;
1863 }
1864
1865 case HAL_MACTX_PHY_DESC: {
1866 struct hal_tx_phy_desc *tx_phy_desc =
1867 (struct hal_tx_phy_desc *)tlv_data;
1868
1869 info[0] = __le32_to_cpu(tx_phy_desc->info0);
1870 info[1] = __le32_to_cpu(tx_phy_desc->info1);
1871 info[2] = __le32_to_cpu(tx_phy_desc->info2);
1872 info[3] = __le32_to_cpu(tx_phy_desc->info3);
1873
1874 tx_ppdu_info->rx_status.beamformed =
1875 u32_get_bits(info[0],
1876 HAL_TX_PHY_DESC_INFO0_BF_TYPE);
1877 tx_ppdu_info->rx_status.preamble_type =
1878 u32_get_bits(info[0],
1879 HAL_TX_PHY_DESC_INFO0_PREAMBLE_11B);
1880 tx_ppdu_info->rx_status.mcs =
1881 u32_get_bits(info[1],
1882 HAL_TX_PHY_DESC_INFO1_MCS);
1883 tx_ppdu_info->rx_status.ltf_size =
1884 u32_get_bits(info[3],
1885 HAL_TX_PHY_DESC_INFO3_LTF_SIZE);
1886 tx_ppdu_info->rx_status.nss =
1887 u32_get_bits(info[2],
1888 HAL_TX_PHY_DESC_INFO2_NSS);
1889 tx_ppdu_info->rx_status.chan_num =
1890 u32_get_bits(info[3],
1891 HAL_TX_PHY_DESC_INFO3_ACTIVE_CHANNEL);
1892 tx_ppdu_info->rx_status.bw =
1893 u32_get_bits(info[0],
1894 HAL_TX_PHY_DESC_INFO0_BANDWIDTH);
1895 break;
1896 }
1897
1898 case HAL_TX_MPDU_START: {
1899 struct dp_mon_mpdu *mon_mpdu = tx_ppdu_info->tx_mon_mpdu;
1900
1901 mon_mpdu = kzalloc(sizeof(*mon_mpdu), GFP_ATOMIC);
1902 if (!mon_mpdu)
1903 return DP_MON_TX_STATUS_PPDU_NOT_DONE;
1904 status = DP_MON_TX_MPDU_START;
1905 break;
1906 }
1907
1908 case HAL_MON_BUF_ADDR: {
1909 struct dp_rxdma_ring *buf_ring = &ab->dp.tx_mon_buf_ring;
1910 struct dp_mon_packet_info *packet_info =
1911 (struct dp_mon_packet_info *)tlv_data;
1912 int buf_id = u32_get_bits(packet_info->cookie,
1913 DP_RXDMA_BUF_COOKIE_BUF_ID);
1914 struct sk_buff *msdu;
1915 struct dp_mon_mpdu *mon_mpdu = tx_ppdu_info->tx_mon_mpdu;
1916 struct ath12k_skb_rxcb *rxcb;
1917
1918 spin_lock_bh(&buf_ring->idr_lock);
1919 msdu = idr_remove(&buf_ring->bufs_idr, buf_id);
1920 spin_unlock_bh(&buf_ring->idr_lock);
1921
1922 if (unlikely(!msdu)) {
1923 ath12k_warn(ab, "monitor destination with invalid buf_id %d\n",
1924 buf_id);
1925 return DP_MON_TX_STATUS_PPDU_NOT_DONE;
1926 }
1927
1928 rxcb = ATH12K_SKB_RXCB(msdu);
1929 dma_unmap_single(ab->dev, rxcb->paddr,
1930 msdu->len + skb_tailroom(msdu),
1931 DMA_FROM_DEVICE);
1932
1933 if (!mon_mpdu->head)
1934 mon_mpdu->head = msdu;
1935 else if (mon_mpdu->tail)
1936 mon_mpdu->tail->next = msdu;
1937
1938 mon_mpdu->tail = msdu;
1939
1940 ath12k_dp_mon_buf_replenish(ab, buf_ring, 1);
1941 status = DP_MON_TX_BUFFER_ADDR;
1942 break;
1943 }
1944
1945 case HAL_TX_MPDU_END:
1946 list_add_tail(&tx_ppdu_info->tx_mon_mpdu->list,
1947 &tx_ppdu_info->dp_tx_mon_mpdu_list);
1948 break;
1949 }
1950
1951 return status;
1952 }
1953
1954 enum dp_mon_tx_tlv_status
ath12k_dp_mon_tx_status_get_num_user(u16 tlv_tag,struct hal_tlv_hdr * tx_tlv,u8 * num_users)1955 ath12k_dp_mon_tx_status_get_num_user(u16 tlv_tag,
1956 struct hal_tlv_hdr *tx_tlv,
1957 u8 *num_users)
1958 {
1959 u32 tlv_status = DP_MON_TX_STATUS_PPDU_NOT_DONE;
1960 u32 info0;
1961
1962 switch (tlv_tag) {
1963 case HAL_TX_FES_SETUP: {
1964 struct hal_tx_fes_setup *tx_fes_setup =
1965 (struct hal_tx_fes_setup *)tx_tlv;
1966
1967 info0 = __le32_to_cpu(tx_fes_setup->info0);
1968
1969 *num_users = u32_get_bits(info0, HAL_TX_FES_SETUP_INFO0_NUM_OF_USERS);
1970 tlv_status = DP_MON_TX_FES_SETUP;
1971 break;
1972 }
1973
1974 case HAL_RX_RESPONSE_REQUIRED_INFO: {
1975 /* TODO: need to update *num_users */
1976 tlv_status = DP_MON_RX_RESPONSE_REQUIRED_INFO;
1977 break;
1978 }
1979 }
1980
1981 return tlv_status;
1982 }
1983
1984 static void
ath12k_dp_mon_tx_process_ppdu_info(struct ath12k * ar,int mac_id,struct napi_struct * napi,struct dp_mon_tx_ppdu_info * tx_ppdu_info)1985 ath12k_dp_mon_tx_process_ppdu_info(struct ath12k *ar, int mac_id,
1986 struct napi_struct *napi,
1987 struct dp_mon_tx_ppdu_info *tx_ppdu_info)
1988 {
1989 struct dp_mon_mpdu *tmp, *mon_mpdu;
1990 struct sk_buff *head_msdu;
1991
1992 list_for_each_entry_safe(mon_mpdu, tmp,
1993 &tx_ppdu_info->dp_tx_mon_mpdu_list, list) {
1994 list_del(&mon_mpdu->list);
1995 head_msdu = mon_mpdu->head;
1996
1997 if (head_msdu)
1998 ath12k_dp_mon_rx_deliver(ar, mac_id, head_msdu,
1999 &tx_ppdu_info->rx_status, napi);
2000
2001 kfree(mon_mpdu);
2002 }
2003 }
2004
2005 enum hal_rx_mon_status
ath12k_dp_mon_tx_parse_mon_status(struct ath12k * ar,struct ath12k_mon_data * pmon,int mac_id,struct sk_buff * skb,struct napi_struct * napi,u32 ppdu_id)2006 ath12k_dp_mon_tx_parse_mon_status(struct ath12k *ar,
2007 struct ath12k_mon_data *pmon,
2008 int mac_id,
2009 struct sk_buff *skb,
2010 struct napi_struct *napi,
2011 u32 ppdu_id)
2012 {
2013 struct ath12k_base *ab = ar->ab;
2014 struct dp_mon_tx_ppdu_info *tx_prot_ppdu_info, *tx_data_ppdu_info;
2015 struct hal_tlv_hdr *tlv;
2016 u8 *ptr = skb->data;
2017 u16 tlv_tag;
2018 u16 tlv_len;
2019 u32 tlv_userid = 0;
2020 u8 num_user;
2021 u32 tlv_status = DP_MON_TX_STATUS_PPDU_NOT_DONE;
2022
2023 tx_prot_ppdu_info = ath12k_dp_mon_tx_get_ppdu_info(pmon, ppdu_id,
2024 DP_MON_TX_PROT_PPDU_INFO);
2025 if (!tx_prot_ppdu_info)
2026 return -ENOMEM;
2027
2028 tlv = (struct hal_tlv_hdr *)ptr;
2029 tlv_tag = le32_get_bits(tlv->tl, HAL_TLV_HDR_TAG);
2030
2031 tlv_status = ath12k_dp_mon_tx_status_get_num_user(tlv_tag, tlv, &num_user);
2032 if (tlv_status == DP_MON_TX_STATUS_PPDU_NOT_DONE || !num_user)
2033 return -EINVAL;
2034
2035 tx_data_ppdu_info = ath12k_dp_mon_tx_get_ppdu_info(pmon, ppdu_id,
2036 DP_MON_TX_DATA_PPDU_INFO);
2037 if (!tx_data_ppdu_info)
2038 return -ENOMEM;
2039
2040 do {
2041 tlv = (struct hal_tlv_hdr *)ptr;
2042 tlv_tag = le32_get_bits(tlv->tl, HAL_TLV_HDR_TAG);
2043 tlv_len = le32_get_bits(tlv->tl, HAL_TLV_HDR_LEN);
2044 tlv_userid = le32_get_bits(tlv->tl, HAL_TLV_USR_ID);
2045
2046 tlv_status = ath12k_dp_mon_tx_parse_status_tlv(ab, pmon,
2047 tlv_tag, ptr,
2048 tlv_userid);
2049 ptr += tlv_len;
2050 ptr = PTR_ALIGN(ptr, HAL_TLV_ALIGN);
2051 if ((ptr - skb->data) >= DP_TX_MONITOR_BUF_SIZE)
2052 break;
2053 } while (tlv_status != DP_MON_TX_FES_STATUS_END);
2054
2055 ath12k_dp_mon_tx_process_ppdu_info(ar, mac_id, napi, tx_data_ppdu_info);
2056 ath12k_dp_mon_tx_process_ppdu_info(ar, mac_id, napi, tx_prot_ppdu_info);
2057
2058 return tlv_status;
2059 }
2060
ath12k_dp_mon_srng_process(struct ath12k * ar,int mac_id,int * budget,enum dp_monitor_mode monitor_mode,struct napi_struct * napi)2061 int ath12k_dp_mon_srng_process(struct ath12k *ar, int mac_id, int *budget,
2062 enum dp_monitor_mode monitor_mode,
2063 struct napi_struct *napi)
2064 {
2065 struct hal_mon_dest_desc *mon_dst_desc;
2066 struct ath12k_pdev_dp *pdev_dp = &ar->dp;
2067 struct ath12k_mon_data *pmon = (struct ath12k_mon_data *)&pdev_dp->mon_data;
2068 struct ath12k_base *ab = ar->ab;
2069 struct ath12k_dp *dp = &ab->dp;
2070 struct sk_buff *skb;
2071 struct ath12k_skb_rxcb *rxcb;
2072 struct dp_srng *mon_dst_ring;
2073 struct hal_srng *srng;
2074 struct dp_rxdma_ring *buf_ring;
2075 u64 cookie;
2076 u32 ppdu_id;
2077 int num_buffs_reaped = 0, srng_id, buf_id;
2078 u8 dest_idx = 0, i;
2079 bool end_of_ppdu;
2080 struct hal_rx_mon_ppdu_info *ppdu_info;
2081 struct ath12k_peer *peer = NULL;
2082
2083 ppdu_info = &pmon->mon_ppdu_info;
2084 memset(ppdu_info, 0, sizeof(*ppdu_info));
2085 ppdu_info->peer_id = HAL_INVALID_PEERID;
2086
2087 srng_id = ath12k_hw_mac_id_to_srng_id(ab->hw_params, mac_id);
2088
2089 if (monitor_mode == ATH12K_DP_RX_MONITOR_MODE) {
2090 mon_dst_ring = &pdev_dp->rxdma_mon_dst_ring[srng_id];
2091 buf_ring = &dp->rxdma_mon_buf_ring;
2092 } else {
2093 mon_dst_ring = &pdev_dp->tx_mon_dst_ring[srng_id];
2094 buf_ring = &dp->tx_mon_buf_ring;
2095 }
2096
2097 srng = &ab->hal.srng_list[mon_dst_ring->ring_id];
2098
2099 spin_lock_bh(&srng->lock);
2100 ath12k_hal_srng_access_begin(ab, srng);
2101
2102 while (likely(*budget)) {
2103 *budget -= 1;
2104 mon_dst_desc = ath12k_hal_srng_dst_peek(ab, srng);
2105 if (unlikely(!mon_dst_desc))
2106 break;
2107
2108 cookie = le32_to_cpu(mon_dst_desc->cookie);
2109 buf_id = u32_get_bits(cookie, DP_RXDMA_BUF_COOKIE_BUF_ID);
2110
2111 spin_lock_bh(&buf_ring->idr_lock);
2112 skb = idr_remove(&buf_ring->bufs_idr, buf_id);
2113 spin_unlock_bh(&buf_ring->idr_lock);
2114
2115 if (unlikely(!skb)) {
2116 ath12k_warn(ab, "monitor destination with invalid buf_id %d\n",
2117 buf_id);
2118 goto move_next;
2119 }
2120
2121 rxcb = ATH12K_SKB_RXCB(skb);
2122 dma_unmap_single(ab->dev, rxcb->paddr,
2123 skb->len + skb_tailroom(skb),
2124 DMA_FROM_DEVICE);
2125
2126 pmon->dest_skb_q[dest_idx] = skb;
2127 dest_idx++;
2128 ppdu_id = le32_to_cpu(mon_dst_desc->ppdu_id);
2129 end_of_ppdu = le32_get_bits(mon_dst_desc->info0,
2130 HAL_MON_DEST_INFO0_END_OF_PPDU);
2131 if (!end_of_ppdu)
2132 continue;
2133
2134 for (i = 0; i < dest_idx; i++) {
2135 skb = pmon->dest_skb_q[i];
2136
2137 if (monitor_mode == ATH12K_DP_RX_MONITOR_MODE)
2138 ath12k_dp_mon_rx_parse_mon_status(ar, pmon, mac_id,
2139 skb, napi);
2140 else
2141 ath12k_dp_mon_tx_parse_mon_status(ar, pmon, mac_id,
2142 skb, napi, ppdu_id);
2143
2144 peer = ath12k_peer_find_by_id(ab, ppdu_info->peer_id);
2145
2146 if (!peer || !peer->sta) {
2147 ath12k_dbg(ab, ATH12K_DBG_DATA,
2148 "failed to find the peer with peer_id %d\n",
2149 ppdu_info->peer_id);
2150 dev_kfree_skb_any(skb);
2151 continue;
2152 }
2153
2154 dev_kfree_skb_any(skb);
2155 pmon->dest_skb_q[i] = NULL;
2156 }
2157
2158 dest_idx = 0;
2159 move_next:
2160 ath12k_dp_mon_buf_replenish(ab, buf_ring, 1);
2161 ath12k_hal_srng_src_get_next_entry(ab, srng);
2162 num_buffs_reaped++;
2163 }
2164
2165 ath12k_hal_srng_access_end(ab, srng);
2166 spin_unlock_bh(&srng->lock);
2167
2168 return num_buffs_reaped;
2169 }
2170
2171 static void
ath12k_dp_mon_rx_update_peer_rate_table_stats(struct ath12k_rx_peer_stats * rx_stats,struct hal_rx_mon_ppdu_info * ppdu_info,struct hal_rx_user_status * user_stats,u32 num_msdu)2172 ath12k_dp_mon_rx_update_peer_rate_table_stats(struct ath12k_rx_peer_stats *rx_stats,
2173 struct hal_rx_mon_ppdu_info *ppdu_info,
2174 struct hal_rx_user_status *user_stats,
2175 u32 num_msdu)
2176 {
2177 u32 rate_idx = 0;
2178 u32 mcs_idx = (user_stats) ? user_stats->mcs : ppdu_info->mcs;
2179 u32 nss_idx = (user_stats) ? user_stats->nss - 1 : ppdu_info->nss - 1;
2180 u32 bw_idx = ppdu_info->bw;
2181 u32 gi_idx = ppdu_info->gi;
2182
2183 if ((mcs_idx > HAL_RX_MAX_MCS_HE) || (nss_idx >= HAL_RX_MAX_NSS) ||
2184 (bw_idx >= HAL_RX_BW_MAX) || (gi_idx >= HAL_RX_GI_MAX)) {
2185 return;
2186 }
2187
2188 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11N ||
2189 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AC) {
2190 rate_idx = mcs_idx * 8 + 8 * 10 * nss_idx;
2191 rate_idx += bw_idx * 2 + gi_idx;
2192 } else if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AX) {
2193 gi_idx = ath12k_he_gi_to_nl80211_he_gi(ppdu_info->gi);
2194 rate_idx = mcs_idx * 12 + 12 * 12 * nss_idx;
2195 rate_idx += bw_idx * 3 + gi_idx;
2196 } else {
2197 return;
2198 }
2199
2200 rx_stats->pkt_stats.rx_rate[rate_idx] += num_msdu;
2201 if (user_stats)
2202 rx_stats->byte_stats.rx_rate[rate_idx] += user_stats->mpdu_ok_byte_count;
2203 else
2204 rx_stats->byte_stats.rx_rate[rate_idx] += ppdu_info->mpdu_len;
2205 }
2206
ath12k_dp_mon_rx_update_peer_su_stats(struct ath12k * ar,struct ath12k_sta * arsta,struct hal_rx_mon_ppdu_info * ppdu_info)2207 static void ath12k_dp_mon_rx_update_peer_su_stats(struct ath12k *ar,
2208 struct ath12k_sta *arsta,
2209 struct hal_rx_mon_ppdu_info *ppdu_info)
2210 {
2211 struct ath12k_rx_peer_stats *rx_stats = arsta->rx_stats;
2212 u32 num_msdu;
2213
2214 if (!rx_stats)
2215 return;
2216
2217 arsta->rssi_comb = ppdu_info->rssi_comb;
2218
2219 num_msdu = ppdu_info->tcp_msdu_count + ppdu_info->tcp_ack_msdu_count +
2220 ppdu_info->udp_msdu_count + ppdu_info->other_msdu_count;
2221
2222 rx_stats->num_msdu += num_msdu;
2223 rx_stats->tcp_msdu_count += ppdu_info->tcp_msdu_count +
2224 ppdu_info->tcp_ack_msdu_count;
2225 rx_stats->udp_msdu_count += ppdu_info->udp_msdu_count;
2226 rx_stats->other_msdu_count += ppdu_info->other_msdu_count;
2227
2228 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A ||
2229 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) {
2230 ppdu_info->nss = 1;
2231 ppdu_info->mcs = HAL_RX_MAX_MCS;
2232 ppdu_info->tid = IEEE80211_NUM_TIDS;
2233 }
2234
2235 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX)
2236 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu;
2237
2238 if (ppdu_info->tid <= IEEE80211_NUM_TIDS)
2239 rx_stats->tid_count[ppdu_info->tid] += num_msdu;
2240
2241 if (ppdu_info->preamble_type < HAL_RX_PREAMBLE_MAX)
2242 rx_stats->pream_cnt[ppdu_info->preamble_type] += num_msdu;
2243
2244 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX)
2245 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu;
2246
2247 if (ppdu_info->is_stbc)
2248 rx_stats->stbc_count += num_msdu;
2249
2250 if (ppdu_info->beamformed)
2251 rx_stats->beamformed_count += num_msdu;
2252
2253 if (ppdu_info->num_mpdu_fcs_ok > 1)
2254 rx_stats->ampdu_msdu_count += num_msdu;
2255 else
2256 rx_stats->non_ampdu_msdu_count += num_msdu;
2257
2258 rx_stats->num_mpdu_fcs_ok += ppdu_info->num_mpdu_fcs_ok;
2259 rx_stats->num_mpdu_fcs_err += ppdu_info->num_mpdu_fcs_err;
2260 rx_stats->dcm_count += ppdu_info->dcm;
2261
2262 rx_stats->rx_duration += ppdu_info->rx_duration;
2263 arsta->rx_duration = rx_stats->rx_duration;
2264
2265 if (ppdu_info->nss > 0 && ppdu_info->nss <= HAL_RX_MAX_NSS) {
2266 rx_stats->pkt_stats.nss_count[ppdu_info->nss - 1] += num_msdu;
2267 rx_stats->byte_stats.nss_count[ppdu_info->nss - 1] += ppdu_info->mpdu_len;
2268 }
2269
2270 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11N &&
2271 ppdu_info->mcs <= HAL_RX_MAX_MCS_HT) {
2272 rx_stats->pkt_stats.ht_mcs_count[ppdu_info->mcs] += num_msdu;
2273 rx_stats->byte_stats.ht_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len;
2274 /* To fit into rate table for HT packets */
2275 ppdu_info->mcs = ppdu_info->mcs % 8;
2276 }
2277
2278 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AC &&
2279 ppdu_info->mcs <= HAL_RX_MAX_MCS_VHT) {
2280 rx_stats->pkt_stats.vht_mcs_count[ppdu_info->mcs] += num_msdu;
2281 rx_stats->byte_stats.vht_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len;
2282 }
2283
2284 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AX &&
2285 ppdu_info->mcs <= HAL_RX_MAX_MCS_HE) {
2286 rx_stats->pkt_stats.he_mcs_count[ppdu_info->mcs] += num_msdu;
2287 rx_stats->byte_stats.he_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len;
2288 }
2289
2290 if ((ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A ||
2291 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) &&
2292 ppdu_info->rate < HAL_RX_LEGACY_RATE_INVALID) {
2293 rx_stats->pkt_stats.legacy_count[ppdu_info->rate] += num_msdu;
2294 rx_stats->byte_stats.legacy_count[ppdu_info->rate] += ppdu_info->mpdu_len;
2295 }
2296
2297 if (ppdu_info->gi < HAL_RX_GI_MAX) {
2298 rx_stats->pkt_stats.gi_count[ppdu_info->gi] += num_msdu;
2299 rx_stats->byte_stats.gi_count[ppdu_info->gi] += ppdu_info->mpdu_len;
2300 }
2301
2302 if (ppdu_info->bw < HAL_RX_BW_MAX) {
2303 rx_stats->pkt_stats.bw_count[ppdu_info->bw] += num_msdu;
2304 rx_stats->byte_stats.bw_count[ppdu_info->bw] += ppdu_info->mpdu_len;
2305 }
2306
2307 ath12k_dp_mon_rx_update_peer_rate_table_stats(rx_stats, ppdu_info,
2308 NULL, num_msdu);
2309 }
2310
ath12k_dp_mon_rx_process_ulofdma(struct hal_rx_mon_ppdu_info * ppdu_info)2311 void ath12k_dp_mon_rx_process_ulofdma(struct hal_rx_mon_ppdu_info *ppdu_info)
2312 {
2313 struct hal_rx_user_status *rx_user_status;
2314 u32 num_users, i, mu_ul_user_v0_word0, mu_ul_user_v0_word1, ru_size;
2315
2316 if (!(ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_MIMO ||
2317 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA ||
2318 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO))
2319 return;
2320
2321 num_users = ppdu_info->num_users;
2322 if (num_users > HAL_MAX_UL_MU_USERS)
2323 num_users = HAL_MAX_UL_MU_USERS;
2324
2325 for (i = 0; i < num_users; i++) {
2326 rx_user_status = &ppdu_info->userstats[i];
2327 mu_ul_user_v0_word0 =
2328 rx_user_status->ul_ofdma_user_v0_word0;
2329 mu_ul_user_v0_word1 =
2330 rx_user_status->ul_ofdma_user_v0_word1;
2331
2332 if (u32_get_bits(mu_ul_user_v0_word0,
2333 HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VALID) &&
2334 !u32_get_bits(mu_ul_user_v0_word0,
2335 HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VER)) {
2336 rx_user_status->mcs =
2337 u32_get_bits(mu_ul_user_v0_word1,
2338 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_MCS);
2339 rx_user_status->nss =
2340 u32_get_bits(mu_ul_user_v0_word1,
2341 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_NSS) + 1;
2342
2343 rx_user_status->ofdma_info_valid = 1;
2344 rx_user_status->ul_ofdma_ru_start_index =
2345 u32_get_bits(mu_ul_user_v0_word1,
2346 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_START);
2347
2348 ru_size = u32_get_bits(mu_ul_user_v0_word1,
2349 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_SIZE);
2350 rx_user_status->ul_ofdma_ru_width = ru_size;
2351 rx_user_status->ul_ofdma_ru_size = ru_size;
2352 }
2353 rx_user_status->ldpc = u32_get_bits(mu_ul_user_v0_word1,
2354 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_LDPC);
2355 }
2356 ppdu_info->ldpc = 1;
2357 }
2358
2359 static void
ath12k_dp_mon_rx_update_user_stats(struct ath12k * ar,struct hal_rx_mon_ppdu_info * ppdu_info,u32 uid)2360 ath12k_dp_mon_rx_update_user_stats(struct ath12k *ar,
2361 struct hal_rx_mon_ppdu_info *ppdu_info,
2362 u32 uid)
2363 {
2364 struct ath12k_sta *arsta = NULL;
2365 struct ath12k_rx_peer_stats *rx_stats = NULL;
2366 struct hal_rx_user_status *user_stats = &ppdu_info->userstats[uid];
2367 struct ath12k_peer *peer;
2368 u32 num_msdu;
2369
2370 if (user_stats->ast_index == 0 || user_stats->ast_index == 0xFFFF)
2371 return;
2372
2373 peer = ath12k_peer_find_by_ast(ar->ab, user_stats->ast_index);
2374
2375 if (!peer) {
2376 ath12k_warn(ar->ab, "peer ast idx %d can't be found\n",
2377 user_stats->ast_index);
2378 return;
2379 }
2380
2381 arsta = (struct ath12k_sta *)peer->sta->drv_priv;
2382 rx_stats = arsta->rx_stats;
2383
2384 if (!rx_stats)
2385 return;
2386
2387 arsta->rssi_comb = ppdu_info->rssi_comb;
2388
2389 num_msdu = user_stats->tcp_msdu_count + user_stats->tcp_ack_msdu_count +
2390 user_stats->udp_msdu_count + user_stats->other_msdu_count;
2391
2392 rx_stats->num_msdu += num_msdu;
2393 rx_stats->tcp_msdu_count += user_stats->tcp_msdu_count +
2394 user_stats->tcp_ack_msdu_count;
2395 rx_stats->udp_msdu_count += user_stats->udp_msdu_count;
2396 rx_stats->other_msdu_count += user_stats->other_msdu_count;
2397
2398 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX)
2399 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu;
2400
2401 if (user_stats->tid <= IEEE80211_NUM_TIDS)
2402 rx_stats->tid_count[user_stats->tid] += num_msdu;
2403
2404 if (user_stats->preamble_type < HAL_RX_PREAMBLE_MAX)
2405 rx_stats->pream_cnt[user_stats->preamble_type] += num_msdu;
2406
2407 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX)
2408 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu;
2409
2410 if (ppdu_info->is_stbc)
2411 rx_stats->stbc_count += num_msdu;
2412
2413 if (ppdu_info->beamformed)
2414 rx_stats->beamformed_count += num_msdu;
2415
2416 if (user_stats->mpdu_cnt_fcs_ok > 1)
2417 rx_stats->ampdu_msdu_count += num_msdu;
2418 else
2419 rx_stats->non_ampdu_msdu_count += num_msdu;
2420
2421 rx_stats->num_mpdu_fcs_ok += user_stats->mpdu_cnt_fcs_ok;
2422 rx_stats->num_mpdu_fcs_err += user_stats->mpdu_cnt_fcs_err;
2423 rx_stats->dcm_count += ppdu_info->dcm;
2424 if (ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA ||
2425 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO)
2426 rx_stats->ru_alloc_cnt[user_stats->ul_ofdma_ru_size] += num_msdu;
2427
2428 rx_stats->rx_duration += ppdu_info->rx_duration;
2429 arsta->rx_duration = rx_stats->rx_duration;
2430
2431 if (user_stats->nss > 0 && user_stats->nss <= HAL_RX_MAX_NSS) {
2432 rx_stats->pkt_stats.nss_count[user_stats->nss - 1] += num_msdu;
2433 rx_stats->byte_stats.nss_count[user_stats->nss - 1] +=
2434 user_stats->mpdu_ok_byte_count;
2435 }
2436
2437 if (user_stats->preamble_type == HAL_RX_PREAMBLE_11AX &&
2438 user_stats->mcs <= HAL_RX_MAX_MCS_HE) {
2439 rx_stats->pkt_stats.he_mcs_count[user_stats->mcs] += num_msdu;
2440 rx_stats->byte_stats.he_mcs_count[user_stats->mcs] +=
2441 user_stats->mpdu_ok_byte_count;
2442 }
2443
2444 if (ppdu_info->gi < HAL_RX_GI_MAX) {
2445 rx_stats->pkt_stats.gi_count[ppdu_info->gi] += num_msdu;
2446 rx_stats->byte_stats.gi_count[ppdu_info->gi] +=
2447 user_stats->mpdu_ok_byte_count;
2448 }
2449
2450 if (ppdu_info->bw < HAL_RX_BW_MAX) {
2451 rx_stats->pkt_stats.bw_count[ppdu_info->bw] += num_msdu;
2452 rx_stats->byte_stats.bw_count[ppdu_info->bw] +=
2453 user_stats->mpdu_ok_byte_count;
2454 }
2455
2456 ath12k_dp_mon_rx_update_peer_rate_table_stats(rx_stats, ppdu_info,
2457 user_stats, num_msdu);
2458 }
2459
2460 static void
ath12k_dp_mon_rx_update_peer_mu_stats(struct ath12k * ar,struct hal_rx_mon_ppdu_info * ppdu_info)2461 ath12k_dp_mon_rx_update_peer_mu_stats(struct ath12k *ar,
2462 struct hal_rx_mon_ppdu_info *ppdu_info)
2463 {
2464 u32 num_users, i;
2465
2466 num_users = ppdu_info->num_users;
2467 if (num_users > HAL_MAX_UL_MU_USERS)
2468 num_users = HAL_MAX_UL_MU_USERS;
2469
2470 for (i = 0; i < num_users; i++)
2471 ath12k_dp_mon_rx_update_user_stats(ar, ppdu_info, i);
2472 }
2473
ath12k_dp_mon_rx_process_stats(struct ath12k * ar,int mac_id,struct napi_struct * napi,int * budget)2474 int ath12k_dp_mon_rx_process_stats(struct ath12k *ar, int mac_id,
2475 struct napi_struct *napi, int *budget)
2476 {
2477 struct ath12k_base *ab = ar->ab;
2478 struct ath12k_pdev_dp *pdev_dp = &ar->dp;
2479 struct ath12k_mon_data *pmon = (struct ath12k_mon_data *)&pdev_dp->mon_data;
2480 struct hal_rx_mon_ppdu_info *ppdu_info = &pmon->mon_ppdu_info;
2481 struct ath12k_dp *dp = &ab->dp;
2482 struct hal_mon_dest_desc *mon_dst_desc;
2483 struct sk_buff *skb;
2484 struct ath12k_skb_rxcb *rxcb;
2485 struct dp_srng *mon_dst_ring;
2486 struct hal_srng *srng;
2487 struct dp_rxdma_ring *buf_ring;
2488 struct ath12k_sta *arsta = NULL;
2489 struct ath12k_peer *peer;
2490 u64 cookie;
2491 int num_buffs_reaped = 0, srng_id, buf_id;
2492 u8 dest_idx = 0, i;
2493 bool end_of_ppdu;
2494 u32 hal_status;
2495
2496 srng_id = ath12k_hw_mac_id_to_srng_id(ab->hw_params, mac_id);
2497 mon_dst_ring = &pdev_dp->rxdma_mon_dst_ring[srng_id];
2498 buf_ring = &dp->rxdma_mon_buf_ring;
2499
2500 srng = &ab->hal.srng_list[mon_dst_ring->ring_id];
2501 spin_lock_bh(&srng->lock);
2502 ath12k_hal_srng_access_begin(ab, srng);
2503
2504 while (likely(*budget)) {
2505 *budget -= 1;
2506 mon_dst_desc = ath12k_hal_srng_dst_peek(ab, srng);
2507 if (unlikely(!mon_dst_desc))
2508 break;
2509 cookie = le32_to_cpu(mon_dst_desc->cookie);
2510 buf_id = u32_get_bits(cookie, DP_RXDMA_BUF_COOKIE_BUF_ID);
2511
2512 spin_lock_bh(&buf_ring->idr_lock);
2513 skb = idr_remove(&buf_ring->bufs_idr, buf_id);
2514 spin_unlock_bh(&buf_ring->idr_lock);
2515
2516 if (unlikely(!skb)) {
2517 ath12k_warn(ab, "monitor destination with invalid buf_id %d\n",
2518 buf_id);
2519 goto move_next;
2520 }
2521
2522 rxcb = ATH12K_SKB_RXCB(skb);
2523 dma_unmap_single(ab->dev, rxcb->paddr,
2524 skb->len + skb_tailroom(skb),
2525 DMA_FROM_DEVICE);
2526 pmon->dest_skb_q[dest_idx] = skb;
2527 dest_idx++;
2528 end_of_ppdu = le32_get_bits(mon_dst_desc->info0,
2529 HAL_MON_DEST_INFO0_END_OF_PPDU);
2530 if (!end_of_ppdu)
2531 continue;
2532
2533 for (i = 0; i < dest_idx; i++) {
2534 skb = pmon->dest_skb_q[i];
2535 hal_status = ath12k_dp_mon_parse_rx_dest(ab, pmon, skb);
2536
2537 if (ppdu_info->peer_id == HAL_INVALID_PEERID ||
2538 hal_status != HAL_RX_MON_STATUS_PPDU_DONE) {
2539 dev_kfree_skb_any(skb);
2540 continue;
2541 }
2542
2543 rcu_read_lock();
2544 spin_lock_bh(&ab->base_lock);
2545 peer = ath12k_peer_find_by_id(ab, ppdu_info->peer_id);
2546 if (!peer || !peer->sta) {
2547 ath12k_dbg(ab, ATH12K_DBG_DATA,
2548 "failed to find the peer with peer_id %d\n",
2549 ppdu_info->peer_id);
2550 spin_unlock_bh(&ab->base_lock);
2551 rcu_read_unlock();
2552 dev_kfree_skb_any(skb);
2553 continue;
2554 }
2555
2556 if (ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_SU) {
2557 arsta = (struct ath12k_sta *)peer->sta->drv_priv;
2558 ath12k_dp_mon_rx_update_peer_su_stats(ar, arsta,
2559 ppdu_info);
2560 } else if ((ppdu_info->fc_valid) &&
2561 (ppdu_info->ast_index != HAL_AST_IDX_INVALID)) {
2562 ath12k_dp_mon_rx_process_ulofdma(ppdu_info);
2563 ath12k_dp_mon_rx_update_peer_mu_stats(ar, ppdu_info);
2564 }
2565
2566 spin_unlock_bh(&ab->base_lock);
2567 rcu_read_unlock();
2568 dev_kfree_skb_any(skb);
2569 memset(ppdu_info, 0, sizeof(*ppdu_info));
2570 ppdu_info->peer_id = HAL_INVALID_PEERID;
2571 }
2572
2573 dest_idx = 0;
2574 move_next:
2575 ath12k_dp_mon_buf_replenish(ab, buf_ring, 1);
2576 ath12k_hal_srng_dst_get_next_entry(ab, srng);
2577 num_buffs_reaped++;
2578 }
2579
2580 ath12k_hal_srng_access_end(ab, srng);
2581 spin_unlock_bh(&srng->lock);
2582 return num_buffs_reaped;
2583 }
2584
ath12k_dp_mon_process_ring(struct ath12k_base * ab,int mac_id,struct napi_struct * napi,int budget,enum dp_monitor_mode monitor_mode)2585 int ath12k_dp_mon_process_ring(struct ath12k_base *ab, int mac_id,
2586 struct napi_struct *napi, int budget,
2587 enum dp_monitor_mode monitor_mode)
2588 {
2589 struct ath12k *ar = ath12k_ab_to_ar(ab, mac_id);
2590 int num_buffs_reaped = 0;
2591
2592 if (!ar->monitor_started)
2593 ath12k_dp_mon_rx_process_stats(ar, mac_id, napi, &budget);
2594 else
2595 num_buffs_reaped = ath12k_dp_mon_srng_process(ar, mac_id, &budget,
2596 monitor_mode, napi);
2597
2598 return num_buffs_reaped;
2599 }
2600