1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3 * Copyright (c) 2019-2021 The Linux Foundation. All rights reserved.
4 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
5 */
6
7 #include "dp_mon.h"
8 #include "debug.h"
9 #include "dp_tx.h"
10 #include "peer.h"
11
12 static void
ath12k_dp_mon_fill_rx_stats_info(struct hal_rx_mon_ppdu_info * ppdu_info,struct ieee80211_rx_status * rx_status)13 ath12k_dp_mon_fill_rx_stats_info(struct hal_rx_mon_ppdu_info *ppdu_info,
14 struct ieee80211_rx_status *rx_status)
15 {
16 u32 center_freq = ppdu_info->freq;
17
18 rx_status->freq = center_freq;
19 rx_status->bw = ath12k_mac_bw_to_mac80211_bw(ppdu_info->bw);
20 rx_status->nss = ppdu_info->nss;
21 rx_status->rate_idx = 0;
22 rx_status->encoding = RX_ENC_LEGACY;
23 rx_status->flag |= RX_FLAG_NO_SIGNAL_VAL;
24
25 if (center_freq >= ATH12K_MIN_6GHZ_FREQ &&
26 center_freq <= ATH12K_MAX_6GHZ_FREQ) {
27 rx_status->band = NL80211_BAND_6GHZ;
28 } else if (center_freq >= ATH12K_MIN_2GHZ_FREQ &&
29 center_freq <= ATH12K_MAX_2GHZ_FREQ) {
30 rx_status->band = NL80211_BAND_2GHZ;
31 } else if (center_freq >= ATH12K_MIN_5GHZ_FREQ &&
32 center_freq <= ATH12K_MAX_5GHZ_FREQ) {
33 rx_status->band = NL80211_BAND_5GHZ;
34 } else {
35 rx_status->band = NUM_NL80211_BANDS;
36 }
37 }
38
39 struct sk_buff
ath12k_dp_rx_alloc_mon_status_buf(struct ath12k_base * ab,struct dp_rxdma_mon_ring * rx_ring,int * buf_id)40 *ath12k_dp_rx_alloc_mon_status_buf(struct ath12k_base *ab,
41 struct dp_rxdma_mon_ring *rx_ring,
42 int *buf_id)
43 {
44 struct sk_buff *skb;
45 dma_addr_t paddr;
46
47 skb = dev_alloc_skb(RX_MON_STATUS_BUF_SIZE);
48
49 if (!skb)
50 goto fail_alloc_skb;
51
52 if (!IS_ALIGNED((unsigned long)skb->data,
53 RX_MON_STATUS_BUF_ALIGN)) {
54 skb_pull(skb, PTR_ALIGN(skb->data, RX_MON_STATUS_BUF_ALIGN) -
55 skb->data);
56 }
57
58 paddr = dma_map_single(ab->dev, skb->data,
59 skb->len + skb_tailroom(skb),
60 DMA_FROM_DEVICE);
61 if (unlikely(dma_mapping_error(ab->dev, paddr)))
62 goto fail_free_skb;
63
64 spin_lock_bh(&rx_ring->idr_lock);
65 *buf_id = idr_alloc(&rx_ring->bufs_idr, skb, 0,
66 rx_ring->bufs_max, GFP_ATOMIC);
67 spin_unlock_bh(&rx_ring->idr_lock);
68 if (*buf_id < 0)
69 goto fail_dma_unmap;
70
71 ATH12K_SKB_RXCB(skb)->paddr = paddr;
72 return skb;
73
74 fail_dma_unmap:
75 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
76 DMA_FROM_DEVICE);
77 fail_free_skb:
78 dev_kfree_skb_any(skb);
79 fail_alloc_skb:
80 return NULL;
81 }
82 EXPORT_SYMBOL(ath12k_dp_rx_alloc_mon_status_buf);
83
ath12k_dp_mon_comp_ppduid(u32 msdu_ppdu_id,u32 * ppdu_id)84 u32 ath12k_dp_mon_comp_ppduid(u32 msdu_ppdu_id, u32 *ppdu_id)
85 {
86 u32 ret = 0;
87
88 if ((*ppdu_id < msdu_ppdu_id) &&
89 ((msdu_ppdu_id - *ppdu_id) < DP_NOT_PPDU_ID_WRAP_AROUND)) {
90 /* Hold on mon dest ring, and reap mon status ring. */
91 *ppdu_id = msdu_ppdu_id;
92 ret = msdu_ppdu_id;
93 } else if ((*ppdu_id > msdu_ppdu_id) &&
94 ((*ppdu_id - msdu_ppdu_id) > DP_NOT_PPDU_ID_WRAP_AROUND)) {
95 /* PPDU ID has exceeded the maximum value and will
96 * restart from 0.
97 */
98 *ppdu_id = msdu_ppdu_id;
99 ret = msdu_ppdu_id;
100 }
101 return ret;
102 }
103 EXPORT_SYMBOL(ath12k_dp_mon_comp_ppduid);
104
105 static void
ath12k_dp_mon_fill_rx_rate(struct ath12k_pdev_dp * dp_pdev,struct hal_rx_mon_ppdu_info * ppdu_info,struct ieee80211_rx_status * rx_status)106 ath12k_dp_mon_fill_rx_rate(struct ath12k_pdev_dp *dp_pdev,
107 struct hal_rx_mon_ppdu_info *ppdu_info,
108 struct ieee80211_rx_status *rx_status)
109 {
110 struct ath12k_dp *dp = dp_pdev->dp;
111 struct ath12k_base *ab = dp->ab;
112 struct ieee80211_supported_band *sband;
113 enum rx_msdu_start_pkt_type pkt_type;
114 u8 rate_mcs, nss, sgi;
115 bool is_cck;
116
117 pkt_type = ppdu_info->preamble_type;
118 rate_mcs = ppdu_info->mcs;
119 nss = ppdu_info->nss;
120 sgi = ppdu_info->gi;
121
122 switch (pkt_type) {
123 case RX_MSDU_START_PKT_TYPE_11A:
124 case RX_MSDU_START_PKT_TYPE_11B:
125 rate_mcs = ppdu_info->rate;
126 is_cck = (pkt_type == RX_MSDU_START_PKT_TYPE_11B);
127 if (rx_status->band < NUM_NL80211_BANDS) {
128 struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev);
129
130 sband = &ar->mac.sbands[rx_status->band];
131 rx_status->rate_idx = ath12k_mac_hw_rate_to_idx(sband, rate_mcs,
132 is_cck);
133 }
134 break;
135 case RX_MSDU_START_PKT_TYPE_11N:
136 rx_status->encoding = RX_ENC_HT;
137 if (rate_mcs > ATH12K_HT_MCS_MAX) {
138 ath12k_warn(ab,
139 "Received with invalid mcs in HT mode %d\n",
140 rate_mcs);
141 break;
142 }
143 rx_status->rate_idx = rate_mcs + (8 * (nss - 1));
144 if (sgi)
145 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI;
146 break;
147 case RX_MSDU_START_PKT_TYPE_11AC:
148 rx_status->encoding = RX_ENC_VHT;
149 rx_status->rate_idx = rate_mcs;
150 if (rate_mcs > ATH12K_VHT_MCS_MAX) {
151 ath12k_warn(ab,
152 "Received with invalid mcs in VHT mode %d\n",
153 rate_mcs);
154 break;
155 }
156 if (sgi)
157 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI;
158 break;
159 case RX_MSDU_START_PKT_TYPE_11AX:
160 rx_status->rate_idx = rate_mcs;
161 if (rate_mcs > ATH12K_HE_MCS_MAX) {
162 ath12k_warn(ab,
163 "Received with invalid mcs in HE mode %d\n",
164 rate_mcs);
165 break;
166 }
167 rx_status->encoding = RX_ENC_HE;
168 rx_status->he_gi = ath12k_he_gi_to_nl80211_he_gi(sgi);
169 break;
170 case RX_MSDU_START_PKT_TYPE_11BE:
171 rx_status->rate_idx = rate_mcs;
172 if (rate_mcs > ATH12K_EHT_MCS_MAX) {
173 ath12k_warn(ab,
174 "Received with invalid mcs in EHT mode %d\n",
175 rate_mcs);
176 break;
177 }
178 rx_status->encoding = RX_ENC_EHT;
179 rx_status->he_gi = ath12k_he_gi_to_nl80211_he_gi(sgi);
180 break;
181 default:
182 ath12k_dbg(ab, ATH12K_DBG_DATA,
183 "monitor receives invalid preamble type %d",
184 pkt_type);
185 break;
186 }
187 }
188
ath12k_dp_mon_rx_msdus_set_payload(struct ath12k_base * ab,struct sk_buff * head_msdu,struct sk_buff * tail_msdu)189 static void ath12k_dp_mon_rx_msdus_set_payload(struct ath12k_base *ab,
190 struct sk_buff *head_msdu,
191 struct sk_buff *tail_msdu)
192 {
193 u32 rx_pkt_offset, l2_hdr_offset, total_offset;
194
195 rx_pkt_offset = ab->hal.hal_desc_sz;
196 l2_hdr_offset =
197 ath12k_dp_rx_h_l3pad(ab, (struct hal_rx_desc *)tail_msdu->data);
198
199 if (ab->hw_params->rxdma1_enable)
200 total_offset = ATH12K_MON_RX_PKT_OFFSET;
201 else
202 total_offset = rx_pkt_offset + l2_hdr_offset;
203
204 skb_pull(head_msdu, total_offset);
205 }
206
207 struct sk_buff *
ath12k_dp_mon_rx_merg_msdus(struct ath12k_pdev_dp * dp_pdev,struct dp_mon_mpdu * mon_mpdu,struct hal_rx_mon_ppdu_info * ppdu_info,struct ieee80211_rx_status * rxs)208 ath12k_dp_mon_rx_merg_msdus(struct ath12k_pdev_dp *dp_pdev,
209 struct dp_mon_mpdu *mon_mpdu,
210 struct hal_rx_mon_ppdu_info *ppdu_info,
211 struct ieee80211_rx_status *rxs)
212 {
213 struct ath12k_dp *dp = dp_pdev->dp;
214 struct ath12k_base *ab = dp->ab;
215 struct sk_buff *msdu, *mpdu_buf, *prev_buf, *head_frag_list;
216 struct sk_buff *head_msdu, *tail_msdu;
217 struct hal_rx_desc *rx_desc;
218 u8 *hdr_desc, *dest, decap_format = mon_mpdu->decap_format;
219 struct ieee80211_hdr_3addr *wh;
220 struct ieee80211_channel *channel;
221 u32 frag_list_sum_len = 0;
222 u8 channel_num = ppdu_info->chan_num;
223
224 mpdu_buf = NULL;
225 head_msdu = mon_mpdu->head;
226 tail_msdu = mon_mpdu->tail;
227
228 if (!head_msdu || !tail_msdu)
229 goto err_merge_fail;
230
231 ath12k_dp_mon_fill_rx_stats_info(ppdu_info, rxs);
232
233 if (unlikely(rxs->band == NUM_NL80211_BANDS ||
234 !ath12k_pdev_dp_to_hw(dp_pdev)->wiphy->bands[rxs->band])) {
235 struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev);
236
237 ath12k_dbg(ab, ATH12K_DBG_DATA,
238 "sband is NULL for status band %d channel_num %d center_freq %d pdev_id %d\n",
239 rxs->band, channel_num, ppdu_info->freq, ar->pdev_idx);
240
241 spin_lock_bh(&ar->data_lock);
242 channel = ar->rx_channel;
243 if (channel) {
244 rxs->band = channel->band;
245 channel_num =
246 ieee80211_frequency_to_channel(channel->center_freq);
247 }
248 spin_unlock_bh(&ar->data_lock);
249 }
250
251 if (rxs->band < NUM_NL80211_BANDS)
252 rxs->freq = ieee80211_channel_to_frequency(channel_num,
253 rxs->band);
254
255 ath12k_dp_mon_fill_rx_rate(dp_pdev, ppdu_info, rxs);
256
257 if (decap_format == DP_RX_DECAP_TYPE_RAW) {
258 ath12k_dp_mon_rx_msdus_set_payload(ab, head_msdu, tail_msdu);
259
260 prev_buf = head_msdu;
261 msdu = head_msdu->next;
262 head_frag_list = NULL;
263
264 while (msdu) {
265 ath12k_dp_mon_rx_msdus_set_payload(ab, head_msdu, tail_msdu);
266
267 if (!head_frag_list)
268 head_frag_list = msdu;
269
270 frag_list_sum_len += msdu->len;
271 prev_buf = msdu;
272 msdu = msdu->next;
273 }
274
275 prev_buf->next = NULL;
276
277 skb_trim(prev_buf, prev_buf->len);
278 if (head_frag_list) {
279 skb_shinfo(head_msdu)->frag_list = head_frag_list;
280 head_msdu->data_len = frag_list_sum_len;
281 head_msdu->len += head_msdu->data_len;
282 head_msdu->next = NULL;
283 }
284 } else if (decap_format == DP_RX_DECAP_TYPE_NATIVE_WIFI) {
285 u8 qos_pkt = 0;
286
287 rx_desc = (struct hal_rx_desc *)head_msdu->data;
288 hdr_desc =
289 ab->hal.ops->rx_desc_get_msdu_payload(rx_desc);
290
291 /* Base size */
292 wh = (struct ieee80211_hdr_3addr *)hdr_desc;
293
294 if (ieee80211_is_data_qos(wh->frame_control))
295 qos_pkt = 1;
296
297 msdu = head_msdu;
298
299 while (msdu) {
300 ath12k_dp_mon_rx_msdus_set_payload(ab, head_msdu, tail_msdu);
301 if (qos_pkt) {
302 dest = skb_push(msdu, sizeof(__le16));
303 if (!dest)
304 goto err_merge_fail;
305 memcpy(dest, hdr_desc, sizeof(struct ieee80211_qos_hdr));
306 }
307 prev_buf = msdu;
308 msdu = msdu->next;
309 }
310 dest = skb_put(prev_buf, HAL_RX_FCS_LEN);
311 if (!dest)
312 goto err_merge_fail;
313
314 ath12k_dbg(ab, ATH12K_DBG_DATA,
315 "mpdu_buf %p mpdu_buf->len %u",
316 prev_buf, prev_buf->len);
317 } else {
318 ath12k_dbg(ab, ATH12K_DBG_DATA,
319 "decap format %d is not supported!\n",
320 decap_format);
321 goto err_merge_fail;
322 }
323
324 return head_msdu;
325
326 err_merge_fail:
327 if (mpdu_buf && decap_format != DP_RX_DECAP_TYPE_RAW) {
328 ath12k_dbg(ab, ATH12K_DBG_DATA,
329 "err_merge_fail mpdu_buf %p", mpdu_buf);
330 /* Free the head buffer */
331 dev_kfree_skb_any(mpdu_buf);
332 }
333 return NULL;
334 }
335 EXPORT_SYMBOL(ath12k_dp_mon_rx_merg_msdus);
336
337 static void
ath12k_dp_mon_rx_update_radiotap_he(struct hal_rx_mon_ppdu_info * rx_status,u8 * rtap_buf)338 ath12k_dp_mon_rx_update_radiotap_he(struct hal_rx_mon_ppdu_info *rx_status,
339 u8 *rtap_buf)
340 {
341 u32 rtap_len = 0;
342
343 put_unaligned_le16(rx_status->he_data1, &rtap_buf[rtap_len]);
344 rtap_len += 2;
345
346 put_unaligned_le16(rx_status->he_data2, &rtap_buf[rtap_len]);
347 rtap_len += 2;
348
349 put_unaligned_le16(rx_status->he_data3, &rtap_buf[rtap_len]);
350 rtap_len += 2;
351
352 put_unaligned_le16(rx_status->he_data4, &rtap_buf[rtap_len]);
353 rtap_len += 2;
354
355 put_unaligned_le16(rx_status->he_data5, &rtap_buf[rtap_len]);
356 rtap_len += 2;
357
358 put_unaligned_le16(rx_status->he_data6, &rtap_buf[rtap_len]);
359 }
360
361 static void
ath12k_dp_mon_rx_update_radiotap_he_mu(struct hal_rx_mon_ppdu_info * rx_status,u8 * rtap_buf)362 ath12k_dp_mon_rx_update_radiotap_he_mu(struct hal_rx_mon_ppdu_info *rx_status,
363 u8 *rtap_buf)
364 {
365 u32 rtap_len = 0;
366
367 put_unaligned_le16(rx_status->he_flags1, &rtap_buf[rtap_len]);
368 rtap_len += 2;
369
370 put_unaligned_le16(rx_status->he_flags2, &rtap_buf[rtap_len]);
371 rtap_len += 2;
372
373 rtap_buf[rtap_len] = rx_status->he_RU[0];
374 rtap_len += 1;
375
376 rtap_buf[rtap_len] = rx_status->he_RU[1];
377 rtap_len += 1;
378
379 rtap_buf[rtap_len] = rx_status->he_RU[2];
380 rtap_len += 1;
381
382 rtap_buf[rtap_len] = rx_status->he_RU[3];
383 }
384
ath12k_dp_mon_update_radiotap(struct ath12k_pdev_dp * dp_pdev,struct hal_rx_mon_ppdu_info * ppduinfo,struct sk_buff * mon_skb,struct ieee80211_rx_status * rxs)385 void ath12k_dp_mon_update_radiotap(struct ath12k_pdev_dp *dp_pdev,
386 struct hal_rx_mon_ppdu_info *ppduinfo,
387 struct sk_buff *mon_skb,
388 struct ieee80211_rx_status *rxs)
389 {
390 struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev);
391 struct ieee80211_supported_band *sband;
392 s32 noise_floor;
393 u8 *ptr = NULL;
394
395 spin_lock_bh(&ar->data_lock);
396 noise_floor = ath12k_pdev_get_noise_floor(ar);
397 spin_unlock_bh(&ar->data_lock);
398
399 rxs->flag |= RX_FLAG_MACTIME_START;
400 rxs->nss = ppduinfo->nss;
401 if (test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT,
402 ar->ab->wmi_ab.svc_map))
403 rxs->signal = ppduinfo->rssi_comb;
404 else
405 rxs->signal = ppduinfo->rssi_comb + noise_floor;
406
407 if (ppduinfo->userstats[ppduinfo->userid].ampdu_present) {
408 rxs->flag |= RX_FLAG_AMPDU_DETAILS;
409 rxs->ampdu_reference = ppduinfo->userstats[ppduinfo->userid].ampdu_id;
410 }
411
412 if (ppduinfo->is_eht || ppduinfo->eht_usig) {
413 struct ieee80211_radiotap_tlv *tlv;
414 struct ieee80211_radiotap_eht *eht;
415 struct ieee80211_radiotap_eht_usig *usig;
416 u16 len = 0, i, eht_len, usig_len;
417 u8 user;
418
419 if (ppduinfo->is_eht) {
420 eht_len = struct_size(eht,
421 user_info,
422 ppduinfo->eht_info.num_user_info);
423 len += sizeof(*tlv) + eht_len;
424 }
425
426 if (ppduinfo->eht_usig) {
427 usig_len = sizeof(*usig);
428 len += sizeof(*tlv) + usig_len;
429 }
430
431 rxs->flag |= RX_FLAG_RADIOTAP_TLV_AT_END;
432 rxs->encoding = RX_ENC_EHT;
433
434 skb_reset_mac_header(mon_skb);
435
436 tlv = skb_push(mon_skb, len);
437
438 if (ppduinfo->is_eht) {
439 tlv->type = cpu_to_le16(IEEE80211_RADIOTAP_EHT);
440 tlv->len = cpu_to_le16(eht_len);
441
442 eht = (struct ieee80211_radiotap_eht *)tlv->data;
443 eht->known = ppduinfo->eht_info.eht.known;
444
445 for (i = 0;
446 i < ARRAY_SIZE(eht->data) &&
447 i < ARRAY_SIZE(ppduinfo->eht_info.eht.data);
448 i++)
449 eht->data[i] = ppduinfo->eht_info.eht.data[i];
450
451 for (user = 0; user < ppduinfo->eht_info.num_user_info; user++)
452 put_unaligned_le32(ppduinfo->eht_info.user_info[user],
453 &eht->user_info[user]);
454
455 tlv = (struct ieee80211_radiotap_tlv *)&tlv->data[eht_len];
456 }
457
458 if (ppduinfo->eht_usig) {
459 tlv->type = cpu_to_le16(IEEE80211_RADIOTAP_EHT_USIG);
460 tlv->len = cpu_to_le16(usig_len);
461
462 usig = (struct ieee80211_radiotap_eht_usig *)tlv->data;
463 *usig = ppduinfo->u_sig_info.usig;
464 }
465 } else if (ppduinfo->he_mu_flags) {
466 rxs->flag |= RX_FLAG_RADIOTAP_HE_MU;
467 rxs->encoding = RX_ENC_HE;
468 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he_mu));
469 ath12k_dp_mon_rx_update_radiotap_he_mu(ppduinfo, ptr);
470 } else if (ppduinfo->he_flags) {
471 rxs->flag |= RX_FLAG_RADIOTAP_HE;
472 rxs->encoding = RX_ENC_HE;
473 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he));
474 ath12k_dp_mon_rx_update_radiotap_he(ppduinfo, ptr);
475 } else if (ppduinfo->vht_flags) {
476 rxs->encoding = RX_ENC_VHT;
477 } else if (ppduinfo->ht_flags) {
478 rxs->encoding = RX_ENC_HT;
479 } else {
480 struct ath12k *ar;
481
482 ar = ath12k_pdev_dp_to_ar(dp_pdev);
483 rxs->encoding = RX_ENC_LEGACY;
484 sband = &ar->mac.sbands[rxs->band];
485 rxs->rate_idx = ath12k_mac_hw_rate_to_idx(sband, ppduinfo->rate,
486 ppduinfo->cck_flag);
487 }
488
489 rxs->mactime = ppduinfo->tsft;
490 }
491 EXPORT_SYMBOL(ath12k_dp_mon_update_radiotap);
492
ath12k_dp_mon_rx_deliver_msdu(struct ath12k_pdev_dp * dp_pdev,struct napi_struct * napi,struct sk_buff * msdu,struct ieee80211_rx_status * status)493 void ath12k_dp_mon_rx_deliver_msdu(struct ath12k_pdev_dp *dp_pdev,
494 struct napi_struct *napi,
495 struct sk_buff *msdu,
496 struct ieee80211_rx_status *status)
497 {
498 static const struct ieee80211_radiotap_he known = {
499 .data1 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN |
500 IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN),
501 .data2 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN),
502 };
503 struct ieee80211_rx_status *rx_status;
504 struct ieee80211_radiotap_he *he = NULL;
505
506 status->link_valid = 0;
507
508 if ((status->encoding == RX_ENC_HE) && !(status->flag & RX_FLAG_RADIOTAP_HE) &&
509 !(status->flag & RX_FLAG_SKIP_MONITOR)) {
510 he = skb_push(msdu, sizeof(known));
511 memcpy(he, &known, sizeof(known));
512 status->flag |= RX_FLAG_RADIOTAP_HE;
513 }
514
515 rx_status = IEEE80211_SKB_RXCB(msdu);
516 *rx_status = *status;
517
518 ieee80211_rx_napi(ath12k_pdev_dp_to_hw(dp_pdev), NULL, msdu, napi);
519 }
520 EXPORT_SYMBOL(ath12k_dp_mon_rx_deliver_msdu);
521
ath12k_dp_pkt_set_pktlen(struct sk_buff * skb,u32 len)522 int ath12k_dp_pkt_set_pktlen(struct sk_buff *skb, u32 len)
523 {
524 if (skb->len > len) {
525 skb_trim(skb, len);
526 } else {
527 if (skb_tailroom(skb) < len - skb->len) {
528 if ((pskb_expand_head(skb, 0,
529 len - skb->len - skb_tailroom(skb),
530 GFP_ATOMIC))) {
531 return -ENOMEM;
532 }
533 }
534 skb_put(skb, (len - skb->len));
535 }
536
537 return 0;
538 }
539 EXPORT_SYMBOL(ath12k_dp_pkt_set_pktlen);
540
541 int
ath12k_dp_mon_parse_status_buf(struct ath12k_pdev_dp * dp_pdev,struct ath12k_mon_data * pmon,const struct dp_mon_packet_info * packet_info)542 ath12k_dp_mon_parse_status_buf(struct ath12k_pdev_dp *dp_pdev,
543 struct ath12k_mon_data *pmon,
544 const struct dp_mon_packet_info *packet_info)
545 {
546 struct ath12k_dp *dp = dp_pdev->dp;
547 struct ath12k_base *ab = dp->ab;
548 struct dp_rxdma_mon_ring *buf_ring = &dp->rxdma_mon_buf_ring;
549 struct sk_buff *msdu;
550 int buf_id;
551 u32 offset;
552
553 buf_id = u32_get_bits(packet_info->cookie, DP_RXDMA_BUF_COOKIE_BUF_ID);
554
555 spin_lock_bh(&buf_ring->idr_lock);
556 msdu = idr_remove(&buf_ring->bufs_idr, buf_id);
557 spin_unlock_bh(&buf_ring->idr_lock);
558
559 if (unlikely(!msdu)) {
560 ath12k_warn(ab, "mon dest desc with inval buf_id %d\n", buf_id);
561 return 0;
562 }
563
564 dma_unmap_single(ab->dev, ATH12K_SKB_RXCB(msdu)->paddr,
565 msdu->len + skb_tailroom(msdu),
566 DMA_FROM_DEVICE);
567
568 offset = packet_info->dma_length + ATH12K_MON_RX_DOT11_OFFSET;
569 if (ath12k_dp_pkt_set_pktlen(msdu, offset)) {
570 dev_kfree_skb_any(msdu);
571 goto dest_replenish;
572 }
573
574 if (!pmon->mon_mpdu->head)
575 pmon->mon_mpdu->head = msdu;
576 else
577 pmon->mon_mpdu->tail->next = msdu;
578
579 pmon->mon_mpdu->tail = msdu;
580
581 dest_replenish:
582 ath12k_dp_mon_buf_replenish(ab, buf_ring, 1);
583
584 return 0;
585 }
586 EXPORT_SYMBOL(ath12k_dp_mon_parse_status_buf);
587
ath12k_dp_mon_buf_replenish(struct ath12k_base * ab,struct dp_rxdma_mon_ring * buf_ring,int req_entries)588 int ath12k_dp_mon_buf_replenish(struct ath12k_base *ab,
589 struct dp_rxdma_mon_ring *buf_ring,
590 int req_entries)
591 {
592 struct hal_mon_buf_ring *mon_buf;
593 struct sk_buff *skb;
594 struct hal_srng *srng;
595 dma_addr_t paddr;
596 u32 cookie;
597 int buf_id;
598
599 srng = &ab->hal.srng_list[buf_ring->refill_buf_ring.ring_id];
600 spin_lock_bh(&srng->lock);
601 ath12k_hal_srng_access_begin(ab, srng);
602
603 while (req_entries > 0) {
604 skb = dev_alloc_skb(DP_RX_BUFFER_SIZE + DP_RX_BUFFER_ALIGN_SIZE);
605 if (unlikely(!skb))
606 goto fail_alloc_skb;
607
608 if (!IS_ALIGNED((unsigned long)skb->data, DP_RX_BUFFER_ALIGN_SIZE)) {
609 skb_pull(skb,
610 PTR_ALIGN(skb->data, DP_RX_BUFFER_ALIGN_SIZE) -
611 skb->data);
612 }
613
614 paddr = dma_map_single(ab->dev, skb->data,
615 skb->len + skb_tailroom(skb),
616 DMA_FROM_DEVICE);
617
618 if (unlikely(dma_mapping_error(ab->dev, paddr)))
619 goto fail_free_skb;
620
621 spin_lock_bh(&buf_ring->idr_lock);
622 buf_id = idr_alloc(&buf_ring->bufs_idr, skb, 0,
623 buf_ring->bufs_max * 3, GFP_ATOMIC);
624 spin_unlock_bh(&buf_ring->idr_lock);
625
626 if (unlikely(buf_id < 0))
627 goto fail_dma_unmap;
628
629 mon_buf = ath12k_hal_srng_src_get_next_entry(ab, srng);
630 if (unlikely(!mon_buf))
631 goto fail_idr_remove;
632
633 ATH12K_SKB_RXCB(skb)->paddr = paddr;
634
635 cookie = u32_encode_bits(buf_id, DP_RXDMA_BUF_COOKIE_BUF_ID);
636
637 mon_buf->paddr_lo = cpu_to_le32(lower_32_bits(paddr));
638 mon_buf->paddr_hi = cpu_to_le32(upper_32_bits(paddr));
639 mon_buf->cookie = cpu_to_le64(cookie);
640
641 req_entries--;
642 }
643
644 ath12k_hal_srng_access_end(ab, srng);
645 spin_unlock_bh(&srng->lock);
646 return 0;
647
648 fail_idr_remove:
649 spin_lock_bh(&buf_ring->idr_lock);
650 idr_remove(&buf_ring->bufs_idr, buf_id);
651 spin_unlock_bh(&buf_ring->idr_lock);
652 fail_dma_unmap:
653 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
654 DMA_FROM_DEVICE);
655 fail_free_skb:
656 dev_kfree_skb_any(skb);
657 fail_alloc_skb:
658 ath12k_hal_srng_access_end(ab, srng);
659 spin_unlock_bh(&srng->lock);
660 return -ENOMEM;
661 }
662 EXPORT_SYMBOL(ath12k_dp_mon_buf_replenish);
663
ath12k_dp_mon_status_bufs_replenish(struct ath12k_base * ab,struct dp_rxdma_mon_ring * rx_ring,int req_entries)664 int ath12k_dp_mon_status_bufs_replenish(struct ath12k_base *ab,
665 struct dp_rxdma_mon_ring *rx_ring,
666 int req_entries)
667 {
668 enum hal_rx_buf_return_buf_manager mgr =
669 ab->hal.hal_params->rx_buf_rbm;
670 int num_free, num_remain, buf_id;
671 struct ath12k_buffer_addr *desc;
672 struct hal_srng *srng;
673 struct sk_buff *skb;
674 dma_addr_t paddr;
675 u32 cookie;
676
677 req_entries = min(req_entries, rx_ring->bufs_max);
678
679 srng = &ab->hal.srng_list[rx_ring->refill_buf_ring.ring_id];
680
681 spin_lock_bh(&srng->lock);
682
683 ath12k_hal_srng_access_begin(ab, srng);
684
685 num_free = ath12k_hal_srng_src_num_free(ab, srng, true);
686 if (!req_entries && (num_free > (rx_ring->bufs_max * 3) / 4))
687 req_entries = num_free;
688
689 req_entries = min(num_free, req_entries);
690 num_remain = req_entries;
691
692 while (num_remain > 0) {
693 skb = dev_alloc_skb(RX_MON_STATUS_BUF_SIZE);
694 if (!skb)
695 break;
696
697 if (!IS_ALIGNED((unsigned long)skb->data,
698 RX_MON_STATUS_BUF_ALIGN)) {
699 skb_pull(skb,
700 PTR_ALIGN(skb->data, RX_MON_STATUS_BUF_ALIGN) -
701 skb->data);
702 }
703
704 paddr = dma_map_single(ab->dev, skb->data,
705 skb->len + skb_tailroom(skb),
706 DMA_FROM_DEVICE);
707 if (dma_mapping_error(ab->dev, paddr))
708 goto fail_free_skb;
709
710 spin_lock_bh(&rx_ring->idr_lock);
711 buf_id = idr_alloc(&rx_ring->bufs_idr, skb, 0,
712 rx_ring->bufs_max * 3, GFP_ATOMIC);
713 spin_unlock_bh(&rx_ring->idr_lock);
714 if (buf_id < 0)
715 goto fail_dma_unmap;
716 cookie = u32_encode_bits(buf_id, DP_RXDMA_BUF_COOKIE_BUF_ID);
717
718 desc = ath12k_hal_srng_src_get_next_entry(ab, srng);
719 if (!desc)
720 goto fail_buf_unassign;
721
722 ATH12K_SKB_RXCB(skb)->paddr = paddr;
723
724 num_remain--;
725
726 ath12k_hal_rx_buf_addr_info_set(&ab->hal, desc, paddr, cookie, mgr);
727 }
728
729 ath12k_hal_srng_access_end(ab, srng);
730
731 spin_unlock_bh(&srng->lock);
732
733 return req_entries - num_remain;
734
735 fail_buf_unassign:
736 spin_lock_bh(&rx_ring->idr_lock);
737 idr_remove(&rx_ring->bufs_idr, buf_id);
738 spin_unlock_bh(&rx_ring->idr_lock);
739 fail_dma_unmap:
740 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
741 DMA_FROM_DEVICE);
742 fail_free_skb:
743 dev_kfree_skb_any(skb);
744
745 ath12k_hal_srng_access_end(ab, srng);
746
747 spin_unlock_bh(&srng->lock);
748
749 return req_entries - num_remain;
750 }
751
752 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)753 ath12k_dp_mon_rx_update_peer_rate_table_stats(struct ath12k_rx_peer_stats *rx_stats,
754 struct hal_rx_mon_ppdu_info *ppdu_info,
755 struct hal_rx_user_status *user_stats,
756 u32 num_msdu)
757 {
758 struct ath12k_rx_peer_rate_stats *stats;
759 u32 mcs_idx = (user_stats) ? user_stats->mcs : ppdu_info->mcs;
760 u32 nss_idx = (user_stats) ? user_stats->nss - 1 : ppdu_info->nss - 1;
761 u32 bw_idx = ppdu_info->bw;
762 u32 gi_idx = ppdu_info->gi;
763 u32 len;
764
765 if (!rx_stats)
766 return;
767
768 if (mcs_idx > HAL_RX_MAX_MCS_HT || nss_idx >= HAL_RX_MAX_NSS ||
769 bw_idx >= HAL_RX_BW_MAX || gi_idx >= HAL_RX_GI_MAX) {
770 return;
771 }
772
773 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AX ||
774 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11BE)
775 gi_idx = ath12k_he_gi_to_nl80211_he_gi(ppdu_info->gi);
776
777 rx_stats->pkt_stats.rx_rate[bw_idx][gi_idx][nss_idx][mcs_idx] += num_msdu;
778 stats = &rx_stats->byte_stats;
779
780 if (user_stats)
781 len = user_stats->mpdu_ok_byte_count;
782 else
783 len = ppdu_info->mpdu_len;
784
785 stats->rx_rate[bw_idx][gi_idx][nss_idx][mcs_idx] += len;
786 }
787
ath12k_dp_mon_rx_update_peer_su_stats(struct ath12k_dp_link_peer * peer,struct hal_rx_mon_ppdu_info * ppdu_info)788 void ath12k_dp_mon_rx_update_peer_su_stats(struct ath12k_dp_link_peer *peer,
789 struct hal_rx_mon_ppdu_info *ppdu_info)
790 {
791 struct ath12k_rx_peer_stats *rx_stats = peer->peer_stats.rx_stats;
792 u32 num_msdu;
793
794 peer->rssi_comb = ppdu_info->rssi_comb;
795 ewma_avg_rssi_add(&peer->avg_rssi, ppdu_info->rssi_comb);
796 if (!rx_stats)
797 return;
798
799 num_msdu = ppdu_info->tcp_msdu_count + ppdu_info->tcp_ack_msdu_count +
800 ppdu_info->udp_msdu_count + ppdu_info->other_msdu_count;
801
802 rx_stats->num_msdu += num_msdu;
803 rx_stats->tcp_msdu_count += ppdu_info->tcp_msdu_count +
804 ppdu_info->tcp_ack_msdu_count;
805 rx_stats->udp_msdu_count += ppdu_info->udp_msdu_count;
806 rx_stats->other_msdu_count += ppdu_info->other_msdu_count;
807
808 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A ||
809 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) {
810 ppdu_info->nss = 1;
811 ppdu_info->mcs = HAL_RX_MAX_MCS;
812 ppdu_info->tid = IEEE80211_NUM_TIDS;
813 }
814
815 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX)
816 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu;
817
818 if (ppdu_info->tid <= IEEE80211_NUM_TIDS)
819 rx_stats->tid_count[ppdu_info->tid] += num_msdu;
820
821 if (ppdu_info->preamble_type < HAL_RX_PREAMBLE_MAX)
822 rx_stats->pream_cnt[ppdu_info->preamble_type] += num_msdu;
823
824 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX)
825 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu;
826
827 if (ppdu_info->is_stbc)
828 rx_stats->stbc_count += num_msdu;
829
830 if (ppdu_info->beamformed)
831 rx_stats->beamformed_count += num_msdu;
832
833 if (ppdu_info->num_mpdu_fcs_ok > 1)
834 rx_stats->ampdu_msdu_count += num_msdu;
835 else
836 rx_stats->non_ampdu_msdu_count += num_msdu;
837
838 rx_stats->num_mpdu_fcs_ok += ppdu_info->num_mpdu_fcs_ok;
839 rx_stats->num_mpdu_fcs_err += ppdu_info->num_mpdu_fcs_err;
840 rx_stats->dcm_count += ppdu_info->dcm;
841
842 rx_stats->rx_duration += ppdu_info->rx_duration;
843 peer->rx_duration = rx_stats->rx_duration;
844
845 if (ppdu_info->nss > 0 && ppdu_info->nss <= HAL_RX_MAX_NSS) {
846 rx_stats->pkt_stats.nss_count[ppdu_info->nss - 1] += num_msdu;
847 rx_stats->byte_stats.nss_count[ppdu_info->nss - 1] += ppdu_info->mpdu_len;
848 }
849
850 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11N &&
851 ppdu_info->mcs <= HAL_RX_MAX_MCS_HT) {
852 rx_stats->pkt_stats.ht_mcs_count[ppdu_info->mcs] += num_msdu;
853 rx_stats->byte_stats.ht_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len;
854 /* To fit into rate table for HT packets */
855 ppdu_info->mcs = ppdu_info->mcs % 8;
856 }
857
858 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AC &&
859 ppdu_info->mcs <= HAL_RX_MAX_MCS_VHT) {
860 rx_stats->pkt_stats.vht_mcs_count[ppdu_info->mcs] += num_msdu;
861 rx_stats->byte_stats.vht_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len;
862 }
863
864 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AX &&
865 ppdu_info->mcs <= HAL_RX_MAX_MCS_HE) {
866 rx_stats->pkt_stats.he_mcs_count[ppdu_info->mcs] += num_msdu;
867 rx_stats->byte_stats.he_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len;
868 }
869
870 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11BE &&
871 ppdu_info->mcs <= HAL_RX_MAX_MCS_BE) {
872 rx_stats->pkt_stats.be_mcs_count[ppdu_info->mcs] += num_msdu;
873 rx_stats->byte_stats.be_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len;
874 }
875
876 if ((ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A ||
877 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) &&
878 ppdu_info->rate < HAL_RX_LEGACY_RATE_INVALID) {
879 rx_stats->pkt_stats.legacy_count[ppdu_info->rate] += num_msdu;
880 rx_stats->byte_stats.legacy_count[ppdu_info->rate] += ppdu_info->mpdu_len;
881 }
882
883 if (ppdu_info->gi < HAL_RX_GI_MAX) {
884 rx_stats->pkt_stats.gi_count[ppdu_info->gi] += num_msdu;
885 rx_stats->byte_stats.gi_count[ppdu_info->gi] += ppdu_info->mpdu_len;
886 }
887
888 if (ppdu_info->bw < HAL_RX_BW_MAX) {
889 rx_stats->pkt_stats.bw_count[ppdu_info->bw] += num_msdu;
890 rx_stats->byte_stats.bw_count[ppdu_info->bw] += ppdu_info->mpdu_len;
891 }
892
893 ath12k_dp_mon_rx_update_peer_rate_table_stats(rx_stats, ppdu_info,
894 NULL, num_msdu);
895 }
896 EXPORT_SYMBOL(ath12k_dp_mon_rx_update_peer_su_stats);
897
ath12k_dp_mon_rx_process_ulofdma(struct hal_rx_mon_ppdu_info * ppdu_info)898 void ath12k_dp_mon_rx_process_ulofdma(struct hal_rx_mon_ppdu_info *ppdu_info)
899 {
900 struct hal_rx_user_status *rx_user_status;
901 u32 num_users, i, mu_ul_user_v0_word0, mu_ul_user_v0_word1, ru_size;
902
903 if (!(ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_MIMO ||
904 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA ||
905 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO))
906 return;
907
908 num_users = ppdu_info->num_users;
909 if (num_users > HAL_MAX_UL_MU_USERS)
910 num_users = HAL_MAX_UL_MU_USERS;
911
912 for (i = 0; i < num_users; i++) {
913 rx_user_status = &ppdu_info->userstats[i];
914 mu_ul_user_v0_word0 =
915 rx_user_status->ul_ofdma_user_v0_word0;
916 mu_ul_user_v0_word1 =
917 rx_user_status->ul_ofdma_user_v0_word1;
918
919 if (u32_get_bits(mu_ul_user_v0_word0,
920 HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VALID) &&
921 !u32_get_bits(mu_ul_user_v0_word0,
922 HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VER)) {
923 rx_user_status->mcs =
924 u32_get_bits(mu_ul_user_v0_word1,
925 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_MCS);
926 rx_user_status->nss =
927 u32_get_bits(mu_ul_user_v0_word1,
928 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_NSS) + 1;
929
930 rx_user_status->ofdma_info_valid = 1;
931 rx_user_status->ul_ofdma_ru_start_index =
932 u32_get_bits(mu_ul_user_v0_word1,
933 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_START);
934
935 ru_size = u32_get_bits(mu_ul_user_v0_word1,
936 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_SIZE);
937 rx_user_status->ul_ofdma_ru_width = ru_size;
938 rx_user_status->ul_ofdma_ru_size = ru_size;
939 }
940 rx_user_status->ldpc = u32_get_bits(mu_ul_user_v0_word1,
941 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_LDPC);
942 }
943 ppdu_info->ldpc = 1;
944 }
945 EXPORT_SYMBOL(ath12k_dp_mon_rx_process_ulofdma);
946
947 static void
ath12k_dp_mon_rx_update_user_stats(struct ath12k_base * ab,struct hal_rx_mon_ppdu_info * ppdu_info,u32 uid)948 ath12k_dp_mon_rx_update_user_stats(struct ath12k_base *ab,
949 struct hal_rx_mon_ppdu_info *ppdu_info,
950 u32 uid)
951 {
952 struct ath12k_rx_peer_stats *rx_stats = NULL;
953 struct hal_rx_user_status *user_stats = &ppdu_info->userstats[uid];
954 struct ath12k_dp_link_peer *peer;
955 u32 num_msdu;
956 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
957
958 if (user_stats->ast_index == 0 || user_stats->ast_index == 0xFFFF)
959 return;
960
961 peer = ath12k_dp_link_peer_find_by_ast(dp, user_stats->ast_index);
962
963 if (!peer) {
964 ath12k_warn(ab, "peer ast idx %d can't be found\n",
965 user_stats->ast_index);
966 return;
967 }
968
969 peer->rssi_comb = ppdu_info->rssi_comb;
970 ewma_avg_rssi_add(&peer->avg_rssi, ppdu_info->rssi_comb);
971 rx_stats = peer->peer_stats.rx_stats;
972 if (!rx_stats)
973 return;
974
975 num_msdu = user_stats->tcp_msdu_count + user_stats->tcp_ack_msdu_count +
976 user_stats->udp_msdu_count + user_stats->other_msdu_count;
977
978 rx_stats->num_msdu += num_msdu;
979 rx_stats->tcp_msdu_count += user_stats->tcp_msdu_count +
980 user_stats->tcp_ack_msdu_count;
981 rx_stats->udp_msdu_count += user_stats->udp_msdu_count;
982 rx_stats->other_msdu_count += user_stats->other_msdu_count;
983
984 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX)
985 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu;
986
987 if (user_stats->tid <= IEEE80211_NUM_TIDS)
988 rx_stats->tid_count[user_stats->tid] += num_msdu;
989
990 if (user_stats->preamble_type < HAL_RX_PREAMBLE_MAX)
991 rx_stats->pream_cnt[user_stats->preamble_type] += num_msdu;
992
993 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX)
994 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu;
995
996 if (ppdu_info->is_stbc)
997 rx_stats->stbc_count += num_msdu;
998
999 if (ppdu_info->beamformed)
1000 rx_stats->beamformed_count += num_msdu;
1001
1002 if (user_stats->mpdu_cnt_fcs_ok > 1)
1003 rx_stats->ampdu_msdu_count += num_msdu;
1004 else
1005 rx_stats->non_ampdu_msdu_count += num_msdu;
1006
1007 rx_stats->num_mpdu_fcs_ok += user_stats->mpdu_cnt_fcs_ok;
1008 rx_stats->num_mpdu_fcs_err += user_stats->mpdu_cnt_fcs_err;
1009 rx_stats->dcm_count += ppdu_info->dcm;
1010 if (ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA ||
1011 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO)
1012 rx_stats->ru_alloc_cnt[user_stats->ul_ofdma_ru_size] += num_msdu;
1013
1014 rx_stats->rx_duration += ppdu_info->rx_duration;
1015 peer->rx_duration = rx_stats->rx_duration;
1016
1017 if (user_stats->nss > 0 && user_stats->nss <= HAL_RX_MAX_NSS) {
1018 rx_stats->pkt_stats.nss_count[user_stats->nss - 1] += num_msdu;
1019 rx_stats->byte_stats.nss_count[user_stats->nss - 1] +=
1020 user_stats->mpdu_ok_byte_count;
1021 }
1022
1023 if (user_stats->preamble_type == HAL_RX_PREAMBLE_11AX &&
1024 user_stats->mcs <= HAL_RX_MAX_MCS_HE) {
1025 rx_stats->pkt_stats.he_mcs_count[user_stats->mcs] += num_msdu;
1026 rx_stats->byte_stats.he_mcs_count[user_stats->mcs] +=
1027 user_stats->mpdu_ok_byte_count;
1028 }
1029
1030 if (ppdu_info->gi < HAL_RX_GI_MAX) {
1031 rx_stats->pkt_stats.gi_count[ppdu_info->gi] += num_msdu;
1032 rx_stats->byte_stats.gi_count[ppdu_info->gi] +=
1033 user_stats->mpdu_ok_byte_count;
1034 }
1035
1036 if (ppdu_info->bw < HAL_RX_BW_MAX) {
1037 rx_stats->pkt_stats.bw_count[ppdu_info->bw] += num_msdu;
1038 rx_stats->byte_stats.bw_count[ppdu_info->bw] +=
1039 user_stats->mpdu_ok_byte_count;
1040 }
1041
1042 ath12k_dp_mon_rx_update_peer_rate_table_stats(rx_stats, ppdu_info,
1043 user_stats, num_msdu);
1044 }
1045
1046 void
ath12k_dp_mon_rx_update_peer_mu_stats(struct ath12k_base * ab,struct hal_rx_mon_ppdu_info * ppdu_info)1047 ath12k_dp_mon_rx_update_peer_mu_stats(struct ath12k_base *ab,
1048 struct hal_rx_mon_ppdu_info *ppdu_info)
1049 {
1050 u32 num_users, i;
1051
1052 num_users = ppdu_info->num_users;
1053 if (num_users > HAL_MAX_UL_MU_USERS)
1054 num_users = HAL_MAX_UL_MU_USERS;
1055
1056 for (i = 0; i < num_users; i++)
1057 ath12k_dp_mon_rx_update_user_stats(ab, ppdu_info, i);
1058 }
1059 EXPORT_SYMBOL(ath12k_dp_mon_rx_update_peer_mu_stats);
1060