1 /*
2 * Copyright (c) 2021, The Linux Foundation. All rights reserved.
3 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 #include <dp_types.h>
19 #include "dp_rx.h"
20 #include "dp_peer.h"
21 #include <dp_htt.h>
22 #include <dp_mon_filter.h>
23 #include <dp_mon.h>
24 #include <dp_rx_mon.h>
25 #include <dp_rx_mon_2.0.h>
26 #include <dp_mon_2.0.h>
27 #include <dp_mon_filter_2.0.h>
28 #include <dp_tx_mon_2.0.h>
29 #include <hal_be_api_mon.h>
30 #include <dp_be.h>
31 #include <htt_ppdu_stats.h>
32 #ifdef QCA_SUPPORT_LITE_MONITOR
33 #include "dp_lite_mon.h"
34 #endif
35
36 #if !defined(DISABLE_MON_CONFIG)
37 /*
38 * dp_mon_add_desc_list_to_free_list() - append unused desc_list back to
39 * freelist.
40 *
41 * @soc: core txrx main context
42 * @local_desc_list: local desc list provided by the caller
43 * @tail: attach the point to last desc of local desc list
44 * @mon_desc_pool: monitor descriptor pool pointer
45 */
46 void
dp_mon_add_desc_list_to_free_list(struct dp_soc * soc,union dp_mon_desc_list_elem_t ** local_desc_list,union dp_mon_desc_list_elem_t ** tail,struct dp_mon_desc_pool * mon_desc_pool)47 dp_mon_add_desc_list_to_free_list(struct dp_soc *soc,
48 union dp_mon_desc_list_elem_t **local_desc_list,
49 union dp_mon_desc_list_elem_t **tail,
50 struct dp_mon_desc_pool *mon_desc_pool)
51 {
52 union dp_mon_desc_list_elem_t *temp_list = NULL;
53
54 qdf_spin_lock_bh(&mon_desc_pool->lock);
55
56 temp_list = mon_desc_pool->freelist;
57 mon_desc_pool->freelist = *local_desc_list;
58 (*tail)->next = temp_list;
59 *tail = NULL;
60 *local_desc_list = NULL;
61
62 qdf_spin_unlock_bh(&mon_desc_pool->lock);
63 }
64
65 /*
66 * dp_mon_get_free_desc_list() - provide a list of descriptors from
67 * the free mon desc pool.
68 *
69 * @soc: core txrx main context
70 * @mon_desc_pool: monitor descriptor pool pointer
71 * @num_descs: number of descs requested from freelist
72 * @desc_list: attach the descs to this list (output parameter)
73 * @tail: attach the point to last desc of free list (output parameter)
74 *
75 * Return: number of descs allocated from free list.
76 */
77 static uint16_t
dp_mon_get_free_desc_list(struct dp_soc * soc,struct dp_mon_desc_pool * mon_desc_pool,uint16_t num_descs,union dp_mon_desc_list_elem_t ** desc_list,union dp_mon_desc_list_elem_t ** tail)78 dp_mon_get_free_desc_list(struct dp_soc *soc,
79 struct dp_mon_desc_pool *mon_desc_pool,
80 uint16_t num_descs,
81 union dp_mon_desc_list_elem_t **desc_list,
82 union dp_mon_desc_list_elem_t **tail)
83 {
84 uint16_t count;
85
86 qdf_spin_lock_bh(&mon_desc_pool->lock);
87
88 *desc_list = *tail = mon_desc_pool->freelist;
89
90 for (count = 0; count < num_descs; count++) {
91 if (qdf_unlikely(!mon_desc_pool->freelist)) {
92 qdf_spin_unlock_bh(&mon_desc_pool->lock);
93 return count;
94 }
95 *tail = mon_desc_pool->freelist;
96 mon_desc_pool->freelist = mon_desc_pool->freelist->next;
97 }
98 (*tail)->next = NULL;
99 qdf_spin_unlock_bh(&mon_desc_pool->lock);
100 return count;
101 }
102
103 static inline QDF_STATUS
dp_mon_frag_alloc_and_map(struct dp_soc * dp_soc,struct dp_mon_desc * mon_desc,struct dp_mon_desc_pool * mon_desc_pool)104 dp_mon_frag_alloc_and_map(struct dp_soc *dp_soc,
105 struct dp_mon_desc *mon_desc,
106 struct dp_mon_desc_pool *mon_desc_pool)
107 {
108 QDF_STATUS ret = QDF_STATUS_E_FAILURE;
109
110 mon_desc->buf_addr = qdf_frag_alloc(&mon_desc_pool->pf_cache,
111 mon_desc_pool->buf_size);
112
113 if (!mon_desc->buf_addr) {
114 dp_mon_err("Frag alloc failed");
115 return QDF_STATUS_E_NOMEM;
116 }
117
118 ret = qdf_mem_map_page(dp_soc->osdev,
119 mon_desc->buf_addr,
120 QDF_DMA_FROM_DEVICE,
121 mon_desc_pool->buf_size,
122 &mon_desc->paddr);
123
124 if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
125 qdf_frag_free(mon_desc->buf_addr);
126 dp_mon_err("Frag map failed");
127 return QDF_STATUS_E_FAULT;
128 }
129
130 return QDF_STATUS_SUCCESS;
131 }
132
133 QDF_STATUS
dp_mon_desc_pool_init(struct dp_mon_desc_pool * mon_desc_pool,uint32_t pool_size)134 dp_mon_desc_pool_init(struct dp_mon_desc_pool *mon_desc_pool,
135 uint32_t pool_size)
136 {
137 int desc_id;
138 /* Initialize monitor desc lock */
139 qdf_spinlock_create(&mon_desc_pool->lock);
140
141 qdf_spin_lock_bh(&mon_desc_pool->lock);
142
143 mon_desc_pool->buf_size = DP_MON_DATA_BUFFER_SIZE;
144 /* link SW descs into a freelist */
145 mon_desc_pool->freelist = &mon_desc_pool->array[0];
146 mon_desc_pool->pool_size = pool_size - 1;
147 qdf_mem_zero(mon_desc_pool->freelist,
148 mon_desc_pool->pool_size *
149 sizeof(union dp_mon_desc_list_elem_t));
150
151 for (desc_id = 0; desc_id < mon_desc_pool->pool_size; desc_id++) {
152 if (desc_id == mon_desc_pool->pool_size - 1)
153 mon_desc_pool->array[desc_id].next = NULL;
154 else
155 mon_desc_pool->array[desc_id].next =
156 &mon_desc_pool->array[desc_id + 1];
157 mon_desc_pool->array[desc_id].mon_desc.in_use = 0;
158 mon_desc_pool->array[desc_id].mon_desc.cookie = desc_id;
159 }
160 qdf_spin_unlock_bh(&mon_desc_pool->lock);
161
162 return QDF_STATUS_SUCCESS;
163 }
164
dp_mon_desc_pool_deinit(struct dp_mon_desc_pool * mon_desc_pool)165 void dp_mon_desc_pool_deinit(struct dp_mon_desc_pool *mon_desc_pool)
166 {
167 qdf_spin_lock_bh(&mon_desc_pool->lock);
168
169 mon_desc_pool->freelist = NULL;
170 mon_desc_pool->pool_size = 0;
171
172 qdf_spin_unlock_bh(&mon_desc_pool->lock);
173 qdf_spinlock_destroy(&mon_desc_pool->lock);
174 }
175
dp_mon_desc_pool_free(struct dp_soc * soc,struct dp_mon_desc_pool * mon_desc_pool,enum dp_ctxt_type ctx_type)176 void dp_mon_desc_pool_free(struct dp_soc *soc,
177 struct dp_mon_desc_pool *mon_desc_pool,
178 enum dp_ctxt_type ctx_type)
179 {
180 dp_context_free_mem(soc, ctx_type, mon_desc_pool->array);
181 }
182
dp_vdev_set_monitor_mode_buf_rings_rx_2_0(struct dp_pdev * pdev)183 QDF_STATUS dp_vdev_set_monitor_mode_buf_rings_rx_2_0(struct dp_pdev *pdev)
184 {
185 int rx_mon_max_entries;
186 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx;
187 struct dp_soc *soc = pdev->soc;
188 struct dp_mon_soc *mon_soc = soc->monitor_soc;
189 struct dp_mon_soc_be *mon_soc_be = dp_get_be_mon_soc_from_dp_mon_soc(mon_soc);
190 QDF_STATUS status;
191
192 if (!mon_soc_be) {
193 dp_mon_err("DP MON SOC is NULL");
194 return QDF_STATUS_E_FAILURE;
195 }
196
197 soc_cfg_ctx = soc->wlan_cfg_ctx;
198 rx_mon_max_entries = wlan_cfg_get_dp_soc_rx_mon_buf_ring_size(soc_cfg_ctx);
199
200 hal_set_low_threshold(soc->rxdma_mon_buf_ring[0].hal_srng,
201 MON_BUF_MIN_ENTRIES << 2);
202 status = htt_srng_setup(soc->htt_handle, 0,
203 soc->rxdma_mon_buf_ring[0].hal_srng,
204 RXDMA_MONITOR_BUF);
205
206 if (status != QDF_STATUS_SUCCESS) {
207 dp_mon_err("Failed to send htt srng setup message for Rx mon buf ring");
208 return status;
209 }
210
211 if (mon_soc_be->rx_mon_ring_fill_level < rx_mon_max_entries) {
212 status = dp_rx_mon_buffers_alloc(soc,
213 (rx_mon_max_entries -
214 mon_soc_be->rx_mon_ring_fill_level));
215 if (status != QDF_STATUS_SUCCESS) {
216 dp_mon_err("%pK: Rx mon buffers allocation failed", soc);
217 return status;
218 }
219 mon_soc_be->rx_mon_ring_fill_level +=
220 (rx_mon_max_entries -
221 mon_soc_be->rx_mon_ring_fill_level);
222 }
223
224 return QDF_STATUS_SUCCESS;
225 }
226
227 static
dp_vdev_set_monitor_mode_buf_rings_2_0(struct dp_pdev * pdev)228 QDF_STATUS dp_vdev_set_monitor_mode_buf_rings_2_0(struct dp_pdev *pdev)
229 {
230 int status;
231 struct dp_soc *soc = pdev->soc;
232
233 status = dp_vdev_set_monitor_mode_buf_rings_rx_2_0(pdev);
234 if (status != QDF_STATUS_SUCCESS) {
235 dp_mon_err("%pK: Rx monitor extra buffer allocation failed",
236 soc);
237 return status;
238 }
239
240 return QDF_STATUS_SUCCESS;
241 }
242
243 static
dp_vdev_set_monitor_mode_rings_2_0(struct dp_pdev * pdev,uint8_t delayed_replenish)244 QDF_STATUS dp_vdev_set_monitor_mode_rings_2_0(struct dp_pdev *pdev,
245 uint8_t delayed_replenish)
246 {
247 return QDF_STATUS_SUCCESS;
248 }
249
250 #ifdef QCA_ENHANCED_STATS_SUPPORT
251 /**
252 * dp_mon_tx_enable_enhanced_stats_2_0() - Send HTT cmd to FW to enable stats
253 * @pdev: Datapath pdev handle
254 *
255 * Return: none
256 */
dp_mon_tx_enable_enhanced_stats_2_0(struct dp_pdev * pdev)257 static void dp_mon_tx_enable_enhanced_stats_2_0(struct dp_pdev *pdev)
258 {
259 dp_h2t_cfg_stats_msg_send(pdev, DP_PPDU_STATS_CFG_ENH_STATS,
260 pdev->pdev_id);
261 }
262
263 /**
264 * dp_mon_tx_disable_enhanced_stats_2_0() - Send HTT cmd to FW to disable stats
265 * @pdev: Datapath pdev handle
266 *
267 * Return: none
268 */
dp_mon_tx_disable_enhanced_stats_2_0(struct dp_pdev * pdev)269 static void dp_mon_tx_disable_enhanced_stats_2_0(struct dp_pdev *pdev)
270 {
271 dp_h2t_cfg_stats_msg_send(pdev, 0, pdev->pdev_id);
272 }
273 #endif
274
275 #if defined(QCA_ENHANCED_STATS_SUPPORT) && defined(WLAN_FEATURE_11BE)
276 void
dp_mon_tx_stats_update_2_0(struct dp_mon_peer * mon_peer,struct cdp_tx_completion_ppdu_user * ppdu)277 dp_mon_tx_stats_update_2_0(struct dp_mon_peer *mon_peer,
278 struct cdp_tx_completion_ppdu_user *ppdu)
279 {
280 uint8_t preamble, mcs, punc_mode, res_mcs;
281
282 preamble = ppdu->preamble;
283 mcs = ppdu->mcs;
284
285 punc_mode = dp_mon_get_puncture_type(ppdu->punc_pattern_bitmap,
286 ppdu->bw);
287 ppdu->punc_mode = punc_mode;
288
289 DP_STATS_INC(mon_peer, tx.punc_bw[punc_mode], ppdu->num_msdu);
290
291 if (preamble == DOT11_BE) {
292 res_mcs = (mcs < MAX_MCS_11BE) ? mcs : (MAX_MCS - 1);
293
294 DP_STATS_INC(mon_peer,
295 tx.pkt_type[preamble].mcs_count[res_mcs],
296 ppdu->num_msdu);
297 DP_STATS_INCC(mon_peer,
298 tx.su_be_ppdu_cnt.mcs_count[res_mcs], 1,
299 (ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_SU));
300 DP_STATS_INCC(mon_peer,
301 tx.mu_be_ppdu_cnt[TXRX_TYPE_MU_OFDMA].mcs_count[res_mcs],
302 1, (ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_OFDMA));
303 DP_STATS_INCC(mon_peer,
304 tx.mu_be_ppdu_cnt[TXRX_TYPE_MU_MIMO].mcs_count[res_mcs],
305 1, (ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_MIMO));
306 }
307 }
308
309 enum cdp_punctured_modes
dp_mon_get_puncture_type(uint16_t puncture_pattern,uint8_t bw)310 dp_mon_get_puncture_type(uint16_t puncture_pattern, uint8_t bw)
311 {
312 uint16_t mask;
313 uint8_t punctured_bits;
314
315 if (!puncture_pattern)
316 return NO_PUNCTURE;
317
318 switch (bw) {
319 case CMN_BW_80MHZ:
320 mask = PUNCTURE_80MHZ_MASK;
321 break;
322 case CMN_BW_160MHZ:
323 mask = PUNCTURE_160MHZ_MASK;
324 break;
325 case CMN_BW_320MHZ:
326 mask = PUNCTURE_320MHZ_MASK;
327 break;
328 default:
329 return NO_PUNCTURE;
330 }
331
332 /* 0s in puncture pattern received in TLV indicates punctured 20Mhz,
333 * after complement, 1s will indicate punctured 20Mhz
334 */
335 puncture_pattern = ~puncture_pattern;
336 puncture_pattern &= mask;
337
338 if (puncture_pattern) {
339 punctured_bits = 0;
340 while (puncture_pattern != 0) {
341 punctured_bits++;
342 puncture_pattern &= (puncture_pattern - 1);
343 }
344
345 if (bw == CMN_BW_80MHZ) {
346 if (punctured_bits == IEEE80211_PUNC_MINUS20MHZ)
347 return PUNCTURED_20MHZ;
348 else
349 return NO_PUNCTURE;
350 } else if (bw == CMN_BW_160MHZ) {
351 if (punctured_bits == IEEE80211_PUNC_MINUS20MHZ)
352 return PUNCTURED_20MHZ;
353 else if (punctured_bits == IEEE80211_PUNC_MINUS40MHZ)
354 return PUNCTURED_40MHZ;
355 else
356 return NO_PUNCTURE;
357 } else if (bw == CMN_BW_320MHZ) {
358 if (punctured_bits == IEEE80211_PUNC_MINUS40MHZ)
359 return PUNCTURED_40MHZ;
360 else if (punctured_bits == IEEE80211_PUNC_MINUS80MHZ)
361 return PUNCTURED_80MHZ;
362 else if (punctured_bits == IEEE80211_PUNC_MINUS120MHZ)
363 return PUNCTURED_120MHZ;
364 else
365 return NO_PUNCTURE;
366 }
367 }
368 return NO_PUNCTURE;
369 }
370 #endif
371
372 #if defined(QCA_ENHANCED_STATS_SUPPORT) && !defined(WLAN_FEATURE_11BE)
373 void
dp_mon_tx_stats_update_2_0(struct dp_mon_peer * mon_peer,struct cdp_tx_completion_ppdu_user * ppdu)374 dp_mon_tx_stats_update_2_0(struct dp_mon_peer *mon_peer,
375 struct cdp_tx_completion_ppdu_user *ppdu)
376 {
377 ppdu->punc_mode = NO_PUNCTURE;
378 }
379
380 enum cdp_punctured_modes
dp_mon_get_puncture_type(uint16_t puncture_pattern,uint8_t bw)381 dp_mon_get_puncture_type(uint16_t puncture_pattern, uint8_t bw)
382 {
383 return NO_PUNCTURE;
384 }
385 #endif /* QCA_ENHANCED_STATS_SUPPORT && WLAN_FEATURE_11BE */
386
387 #ifdef QCA_SUPPORT_BPR
388 static QDF_STATUS
dp_set_bpr_enable_2_0(struct dp_pdev * pdev,int val)389 dp_set_bpr_enable_2_0(struct dp_pdev *pdev, int val)
390 {
391 return QDF_STATUS_SUCCESS;
392 }
393 #endif /* QCA_SUPPORT_BPR */
394
395 #ifdef QCA_ENHANCED_STATS_SUPPORT
396 #ifdef WDI_EVENT_ENABLE
397 /**
398 * dp_ppdu_desc_notify_2_0 - Notify upper layer for PPDU indication via WDI
399 *
400 * @pdev: Datapath pdev handle
401 * @nbuf: Buffer to be shipped
402 *
403 * Return: void
404 */
dp_ppdu_desc_notify_2_0(struct dp_pdev * pdev,qdf_nbuf_t nbuf)405 static void dp_ppdu_desc_notify_2_0(struct dp_pdev *pdev, qdf_nbuf_t nbuf)
406 {
407 struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
408
409 ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(nbuf);
410
411 if (ppdu_desc->num_mpdu != 0 && ppdu_desc->num_users != 0 &&
412 ppdu_desc->frame_ctrl & HTT_FRAMECTRL_DATATYPE) {
413 dp_wdi_event_handler(WDI_EVENT_TX_PPDU_DESC,
414 pdev->soc,
415 nbuf, HTT_INVALID_PEER,
416 WDI_NO_VAL,
417 pdev->pdev_id);
418 } else {
419 qdf_nbuf_free(nbuf);
420 }
421 }
422 #endif
423
424 /**
425 * dp_ppdu_stats_feat_enable_check_2_0 - Check if feature(s) is enabled to
426 * consume ppdu stats from FW
427 *
428 * @pdev: Datapath pdev handle
429 *
430 * Return: true if enabled, else return false
431 */
dp_ppdu_stats_feat_enable_check_2_0(struct dp_pdev * pdev)432 static bool dp_ppdu_stats_feat_enable_check_2_0(struct dp_pdev *pdev)
433 {
434 return pdev->monitor_pdev->enhanced_stats_en;
435 }
436 #endif
437
dp_mon_soc_htt_srng_setup_2_0(struct dp_soc * soc)438 QDF_STATUS dp_mon_soc_htt_srng_setup_2_0(struct dp_soc *soc)
439 {
440 QDF_STATUS status;
441
442 status = dp_rx_mon_soc_htt_srng_setup_2_0(soc, 0);
443 if (status != QDF_STATUS_SUCCESS) {
444 dp_err("Failed to send htt srng setup message for Rx mon buf ring");
445 return status;
446 }
447
448 status = dp_tx_mon_soc_htt_srng_setup_2_0(soc, 0);
449 if (status != QDF_STATUS_SUCCESS) {
450 dp_err("Failed to send htt srng setup message for Tx mon buf ring");
451 return status;
452 }
453
454 return status;
455 }
456
457 #if defined(DP_CON_MON)
dp_mon_pdev_htt_srng_setup_2_0(struct dp_soc * soc,struct dp_pdev * pdev,int mac_id,int mac_for_pdev)458 QDF_STATUS dp_mon_pdev_htt_srng_setup_2_0(struct dp_soc *soc,
459 struct dp_pdev *pdev,
460 int mac_id,
461 int mac_for_pdev)
462 {
463 struct dp_mon_soc *mon_soc = soc->monitor_soc;
464 struct dp_mon_soc_be *mon_soc_be = dp_get_be_mon_soc_from_dp_mon_soc(mon_soc);
465 QDF_STATUS status;
466
467 if (!mon_soc_be->tx_mon_dst_ring[mac_id].hal_srng)
468 return QDF_STATUS_SUCCESS;
469
470 status = dp_tx_mon_pdev_htt_srng_setup_2_0(soc, pdev, mac_id,
471 mac_for_pdev);
472 if (status != QDF_STATUS_SUCCESS) {
473 dp_mon_err("Failed to send htt srng message for Tx mon dst ring");
474 return status;
475 }
476
477 return status;
478 }
479 #else
480 /* This is for WIN case */
dp_mon_pdev_htt_srng_setup_2_0(struct dp_soc * soc,struct dp_pdev * pdev,int mac_id,int mac_for_pdev)481 QDF_STATUS dp_mon_pdev_htt_srng_setup_2_0(struct dp_soc *soc,
482 struct dp_pdev *pdev,
483 int mac_id,
484 int mac_for_pdev)
485 {
486 struct dp_mon_soc *mon_soc = soc->monitor_soc;
487 struct dp_mon_soc_be *mon_soc_be = dp_get_be_mon_soc_from_dp_mon_soc(mon_soc);
488 QDF_STATUS status;
489
490 if (!soc->rxdma_mon_dst_ring[mac_id].hal_srng)
491 return QDF_STATUS_SUCCESS;
492
493 status = dp_rx_mon_pdev_htt_srng_setup_2_0(soc, pdev, mac_id,
494 mac_for_pdev);
495 if (status != QDF_STATUS_SUCCESS) {
496 dp_mon_err("Failed to send htt srng setup message for Rxdma dst ring");
497 return status;
498 }
499
500 if (!mon_soc_be->tx_mon_dst_ring[mac_id].hal_srng)
501 return QDF_STATUS_SUCCESS;
502
503 status = dp_tx_mon_pdev_htt_srng_setup_2_0(soc, pdev, mac_id,
504 mac_for_pdev);
505 if (status != QDF_STATUS_SUCCESS) {
506 dp_mon_err("Failed to send htt srng message for Tx mon dst ring");
507 return status;
508 }
509
510 return status;
511 }
512 #endif
513
514 static
dp_rx_mon_refill_buf_ring_2_0(struct dp_intr * int_ctx)515 QDF_STATUS dp_rx_mon_refill_buf_ring_2_0(struct dp_intr *int_ctx)
516 {
517 struct dp_soc *soc = int_ctx->soc;
518 struct dp_mon_soc *mon_soc = soc->monitor_soc;
519 union dp_mon_desc_list_elem_t *desc_list = NULL;
520 union dp_mon_desc_list_elem_t *tail = NULL;
521 struct dp_srng *rx_mon_buf_ring;
522 struct dp_intr_stats *intr_stats = &int_ctx->intr_stats;
523 struct dp_mon_soc_be *mon_soc_be = dp_get_be_mon_soc_from_dp_mon_soc(mon_soc);
524 uint32_t num_entries_avail, num_entries, num_entries_in_ring;
525 int sync_hw_ptr = 1, hp = 0, tp = 0;
526 void *hal_srng;
527
528 rx_mon_buf_ring = &soc->rxdma_mon_buf_ring[0];
529 hal_srng = rx_mon_buf_ring->hal_srng;
530
531 intr_stats->num_host2rxdma_ring_masks++;
532 mon_soc_be->rx_low_thresh_intrs++;
533 hal_srng_access_start(soc->hal_soc, hal_srng);
534 num_entries_avail = hal_srng_src_num_avail(soc->hal_soc,
535 hal_srng,
536 sync_hw_ptr);
537 num_entries_in_ring = rx_mon_buf_ring->num_entries - num_entries_avail;
538 hal_get_sw_hptp(soc->hal_soc, (hal_ring_handle_t)hal_srng, &tp, &hp);
539 hal_srng_access_end(soc->hal_soc, hal_srng);
540
541 if (num_entries_avail) {
542 if (num_entries_in_ring < mon_soc_be->rx_mon_ring_fill_level)
543 num_entries = mon_soc_be->rx_mon_ring_fill_level
544 - num_entries_in_ring;
545 else
546 return QDF_STATUS_SUCCESS;
547
548 dp_mon_buffers_replenish(soc, rx_mon_buf_ring,
549 &mon_soc_be->rx_desc_mon,
550 num_entries, &desc_list, &tail,
551 NULL);
552 }
553
554 return QDF_STATUS_SUCCESS;
555 }
556
dp_mon_soc_detach_2_0(struct dp_soc * soc)557 QDF_STATUS dp_mon_soc_detach_2_0(struct dp_soc *soc)
558 {
559 dp_rx_mon_soc_detach_2_0(soc, 0);
560 dp_tx_mon_soc_detach_2_0(soc, 0);
561 return QDF_STATUS_SUCCESS;
562 }
563
dp_mon_soc_deinit_2_0(struct dp_soc * soc)564 void dp_mon_soc_deinit_2_0(struct dp_soc *soc)
565 {
566 struct dp_mon_soc *mon_soc = soc->monitor_soc;
567 struct dp_mon_soc_be *mon_soc_be =
568 dp_get_be_mon_soc_from_dp_mon_soc(mon_soc);
569
570 if (!mon_soc_be->is_dp_mon_soc_initialized)
571 return;
572
573 dp_rx_mon_soc_deinit_2_0(soc, 0);
574 dp_tx_mon_soc_deinit_2_0(soc, 0);
575
576 mon_soc_be->is_dp_mon_soc_initialized = false;
577 }
578
dp_mon_soc_init_2_0(struct dp_soc * soc)579 QDF_STATUS dp_mon_soc_init_2_0(struct dp_soc *soc)
580 {
581 struct dp_mon_soc *mon_soc = soc->monitor_soc;
582 struct dp_mon_soc_be *mon_soc_be =
583 dp_get_be_mon_soc_from_dp_mon_soc(mon_soc);
584
585 if (soc->rxdma_mon_buf_ring[0].hal_srng) {
586 dp_mon_info("%pK: mon soc init is done", soc);
587 return QDF_STATUS_SUCCESS;
588 }
589
590 if (dp_rx_mon_soc_init_2_0(soc)) {
591 dp_mon_err("%pK: " RNG_ERR "tx_mon_buf_ring", soc);
592 goto fail;
593 }
594
595 if (dp_tx_mon_soc_init_2_0(soc)) {
596 dp_mon_err("%pK: " RNG_ERR "tx_mon_buf_ring", soc);
597 goto fail;
598 }
599
600 mon_soc_be->tx_mon_ring_fill_level = 0;
601 if (soc->rxdma_mon_buf_ring[0].num_entries < DP_MON_RING_FILL_LEVEL_DEFAULT)
602 mon_soc_be->rx_mon_ring_fill_level = soc->rxdma_mon_buf_ring[0].num_entries;
603 else
604 mon_soc_be->rx_mon_ring_fill_level = DP_MON_RING_FILL_LEVEL_DEFAULT;
605
606 mon_soc_be->is_dp_mon_soc_initialized = true;
607 return QDF_STATUS_SUCCESS;
608 fail:
609 dp_mon_soc_deinit_2_0(soc);
610 return QDF_STATUS_E_FAILURE;
611 }
612
dp_mon_soc_attach_2_0(struct dp_soc * soc)613 QDF_STATUS dp_mon_soc_attach_2_0(struct dp_soc *soc)
614 {
615 struct dp_mon_soc *mon_soc = soc->monitor_soc;
616 struct dp_mon_soc_be *mon_soc_be =
617 dp_get_be_mon_soc_from_dp_mon_soc(mon_soc);
618 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx;
619
620 soc_cfg_ctx = soc->wlan_cfg_ctx;
621 if (!mon_soc_be) {
622 dp_mon_err("DP MON SOC is NULL");
623 return QDF_STATUS_E_FAILURE;
624 }
625
626 if (dp_rx_mon_soc_attach_2_0(soc, 0)) {
627 dp_mon_err("%pK: " RNG_ERR "rx_mon_buf_ring", soc);
628 goto fail;
629 }
630
631 if (dp_tx_mon_soc_attach_2_0(soc, 0)) {
632 dp_mon_err("%pK: " RNG_ERR "tx_mon_buf_ring", soc);
633 goto fail;
634 }
635
636 /* allocate sw desc pool */
637 if (dp_rx_mon_buf_desc_pool_alloc(soc)) {
638 dp_mon_err("%pK: Rx mon desc pool allocation failed", soc);
639 goto fail;
640 }
641
642 if (dp_tx_mon_buf_desc_pool_alloc(soc)) {
643 dp_mon_err("%pK: Tx mon desc pool allocation failed", soc);
644 goto fail;
645 }
646
647 return QDF_STATUS_SUCCESS;
648 fail:
649 dp_mon_soc_detach_2_0(soc);
650 return QDF_STATUS_E_NOMEM;
651 }
652
653 static
dp_mon_pdev_free_2_0(struct dp_pdev * pdev)654 void dp_mon_pdev_free_2_0(struct dp_pdev *pdev)
655 {
656 }
657
658 static
dp_mon_pdev_alloc_2_0(struct dp_pdev * pdev)659 QDF_STATUS dp_mon_pdev_alloc_2_0(struct dp_pdev *pdev)
660 {
661 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
662 struct dp_mon_pdev_be *mon_pdev_be =
663 dp_get_be_mon_pdev_from_dp_mon_pdev(mon_pdev);
664
665 if (!mon_pdev_be) {
666 dp_mon_err("DP MON PDEV is NULL");
667 return QDF_STATUS_E_FAILURE;
668 }
669
670 return QDF_STATUS_SUCCESS;
671 }
672
673 #else
674 static inline
dp_mon_htt_srng_setup_2_0(struct dp_soc * soc,struct dp_pdev * pdev,int mac_id,int mac_for_pdev)675 QDF_STATUS dp_mon_htt_srng_setup_2_0(struct dp_soc *soc,
676 struct dp_pdev *pdev,
677 int mac_id,
678 int mac_for_pdev)
679 {
680 return QDF_STATUS_SUCCESS;
681 }
682
683 static uint32_t
dp_tx_mon_process_2_0(struct dp_soc * soc,struct dp_intr * int_ctx,uint32_t mac_id,uint32_t quota)684 dp_tx_mon_process_2_0(struct dp_soc *soc, struct dp_intr *int_ctx,
685 uint32_t mac_id, uint32_t quota)
686 {
687 return 0;
688 }
689
690 static inline
dp_mon_soc_attach_2_0(struct dp_soc * soc)691 QDF_STATUS dp_mon_soc_attach_2_0(struct dp_soc *soc)
692 {
693 return status;
694 }
695
696 static inline
dp_mon_soc_detach_2_0(struct dp_soc * soc)697 QDF_STATUS dp_mon_soc_detach_2_0(struct dp_soc *soc)
698 {
699 return status;
700 }
701
702 static inline
dp_pdev_mon_rings_deinit_2_0(struct dp_pdev * pdev)703 void dp_pdev_mon_rings_deinit_2_0(struct dp_pdev *pdev)
704 {
705 }
706
707 static inline
dp_pdev_mon_rings_init_2_0(struct dp_soc * soc,struct dp_pdev * pdev)708 QDF_STATUS dp_pdev_mon_rings_init_2_0(struct dp_soc *soc, struct dp_pdev *pdev)
709 {
710 return QDF_STATUS_SUCCESS;
711 }
712
713 static inline
dp_pdev_mon_rings_free_2_0(struct dp_pdev * pdev)714 void dp_pdev_mon_rings_free_2_0(struct dp_pdev *pdev)
715 {
716 }
717
718 static inline
dp_pdev_mon_rings_alloc_2_0(struct dp_soc * soc,struct dp_pdev * pdev)719 QDF_STATUS dp_pdev_mon_rings_alloc_2_0(struct dp_soc *soc, struct dp_pdev *pdev)
720 {
721 return QDF_STATUS_SUCCESS;
722 }
723
724 static inline
dp_mon_pdev_free_2_0(struct dp_pdev * pdev)725 void dp_mon_pdev_free_2_0(struct dp_pdev *pdev)
726 {
727 }
728
729 static inline
dp_mon_pdev_alloc_2_0(struct dp_pdev * pdev)730 QDF_STATUS dp_mon_pdev_alloc_2_0(struct dp_pdev *pdev)
731 {
732 return QDF_STATUS_SUCCESS;
733 }
734
735 static inline
dp_vdev_set_monitor_mode_buf_rings_2_0(struct dp_pdev * pdev)736 void dp_vdev_set_monitor_mode_buf_rings_2_0(struct dp_pdev *pdev)
737 {
738 }
739
740 static inline
dp_vdev_set_monitor_mode_rings_2_0(struct dp_pdev * pdev,uint8_t delayed_replenish)741 QDF_STATUS dp_vdev_set_monitor_mode_rings_2_0(struct dp_pdev *pdev,
742 uint8_t delayed_replenish)
743 {
744 return QDF_STATUS_SUCCESS;
745 }
746 #endif
747
dp_pdev_mon_rings_deinit_2_0(struct dp_pdev * pdev)748 void dp_pdev_mon_rings_deinit_2_0(struct dp_pdev *pdev)
749 {
750 int mac_id = 0;
751 struct dp_soc *soc = pdev->soc;
752
753 for (mac_id = 0; mac_id < DP_NUM_MACS_PER_PDEV; mac_id++) {
754 int lmac_id = dp_get_lmac_id_for_pdev_id(soc, mac_id,
755 pdev->pdev_id);
756
757 dp_rx_mon_pdev_rings_deinit_2_0(pdev, lmac_id);
758 dp_tx_mon_pdev_rings_deinit_2_0(pdev, lmac_id);
759 }
760 }
761
dp_pdev_mon_rings_init_2_0(struct dp_pdev * pdev)762 QDF_STATUS dp_pdev_mon_rings_init_2_0(struct dp_pdev *pdev)
763 {
764 struct dp_soc *soc = pdev->soc;
765 int mac_id = 0;
766 QDF_STATUS status = QDF_STATUS_SUCCESS;
767
768 for (mac_id = 0; mac_id < DP_NUM_MACS_PER_PDEV; mac_id++) {
769 int lmac_id = dp_get_lmac_id_for_pdev_id(soc, mac_id,
770 pdev->pdev_id);
771
772 status = dp_rx_mon_pdev_rings_init_2_0(pdev, lmac_id);
773 if (QDF_IS_STATUS_ERROR(status)) {
774 dp_mon_err("%pK: " RNG_ERR "rxdma_mon_dst_ring", soc);
775 goto fail;
776 }
777
778 status = dp_tx_mon_pdev_rings_init_2_0(pdev, lmac_id);
779 if (QDF_IS_STATUS_ERROR(status)) {
780 dp_mon_err("%pK: " RNG_ERR "tx_mon_dst_ring", soc);
781 goto fail;
782 }
783 }
784 return status;
785
786 fail:
787 dp_pdev_mon_rings_deinit_2_0(pdev);
788 return status;
789 }
790
dp_pdev_mon_rings_free_2_0(struct dp_pdev * pdev)791 void dp_pdev_mon_rings_free_2_0(struct dp_pdev *pdev)
792 {
793 int mac_id = 0;
794 struct dp_soc *soc = pdev->soc;
795
796 for (mac_id = 0; mac_id < DP_NUM_MACS_PER_PDEV; mac_id++) {
797 int lmac_id = dp_get_lmac_id_for_pdev_id(soc, mac_id,
798 pdev->pdev_id);
799
800 dp_rx_mon_pdev_rings_free_2_0(pdev, lmac_id);
801 dp_tx_mon_pdev_rings_free_2_0(pdev, lmac_id);
802 }
803 }
804
dp_pdev_mon_rings_alloc_2_0(struct dp_pdev * pdev)805 QDF_STATUS dp_pdev_mon_rings_alloc_2_0(struct dp_pdev *pdev)
806 {
807 struct dp_soc *soc = pdev->soc;
808 int mac_id = 0;
809 QDF_STATUS status = QDF_STATUS_SUCCESS;
810
811 for (mac_id = 0; mac_id < DP_NUM_MACS_PER_PDEV; mac_id++) {
812 int lmac_id =
813 dp_get_lmac_id_for_pdev_id(soc, mac_id, pdev->pdev_id);
814
815 status = dp_rx_mon_pdev_rings_alloc_2_0(pdev, lmac_id);
816 if (QDF_IS_STATUS_ERROR(status)) {
817 dp_err("%pK: " RNG_ERR "rxdma_mon_dst_ring", pdev);
818 goto fail;
819 }
820
821 status = dp_tx_mon_pdev_rings_alloc_2_0(pdev, lmac_id);
822 if (QDF_IS_STATUS_ERROR(status)) {
823 dp_err("%pK: " RNG_ERR "tx_mon_dst_ring", pdev);
824 goto fail;
825 }
826 }
827 return status;
828
829 fail:
830 dp_pdev_mon_rings_free_2_0(pdev);
831 return status;
832 }
833
dp_mon_pool_frag_unmap_and_free(struct dp_soc * soc,struct dp_mon_desc_pool * mon_desc_pool)834 void dp_mon_pool_frag_unmap_and_free(struct dp_soc *soc,
835 struct dp_mon_desc_pool *mon_desc_pool)
836 {
837 int desc_id;
838 qdf_frag_t vaddr;
839 qdf_dma_addr_t paddr;
840
841 qdf_spin_lock_bh(&mon_desc_pool->lock);
842 for (desc_id = 0; desc_id < mon_desc_pool->pool_size; desc_id++) {
843 if (mon_desc_pool->array[desc_id].mon_desc.in_use) {
844 vaddr = mon_desc_pool->array[desc_id].mon_desc.buf_addr;
845 paddr = mon_desc_pool->array[desc_id].mon_desc.paddr;
846
847 if (!(mon_desc_pool->array[desc_id].mon_desc.unmapped)) {
848 qdf_mem_unmap_page(soc->osdev, paddr,
849 mon_desc_pool->buf_size,
850 QDF_DMA_FROM_DEVICE);
851 mon_desc_pool->array[desc_id].mon_desc.unmapped = 1;
852 mon_desc_pool->array[desc_id].mon_desc.cookie = desc_id;
853 }
854 qdf_frag_free(vaddr);
855 }
856 }
857 qdf_spin_unlock_bh(&mon_desc_pool->lock);
858 }
859
860 QDF_STATUS
dp_mon_buffers_replenish(struct dp_soc * dp_soc,struct dp_srng * dp_mon_srng,struct dp_mon_desc_pool * mon_desc_pool,uint32_t num_req_buffers,union dp_mon_desc_list_elem_t ** desc_list,union dp_mon_desc_list_elem_t ** tail,uint32_t * replenish_cnt_ref)861 dp_mon_buffers_replenish(struct dp_soc *dp_soc,
862 struct dp_srng *dp_mon_srng,
863 struct dp_mon_desc_pool *mon_desc_pool,
864 uint32_t num_req_buffers,
865 union dp_mon_desc_list_elem_t **desc_list,
866 union dp_mon_desc_list_elem_t **tail,
867 uint32_t *replenish_cnt_ref)
868 {
869 uint32_t num_alloc_desc;
870 uint32_t num_entries_avail;
871 uint32_t count = 0;
872 int sync_hw_ptr = 1;
873 struct dp_mon_desc mon_desc = {0};
874 void *mon_ring_entry;
875 union dp_mon_desc_list_elem_t *next;
876 void *mon_srng;
877 unsigned long long desc;
878 QDF_STATUS ret = QDF_STATUS_E_FAILURE;
879 struct dp_mon_soc *mon_soc = dp_soc->monitor_soc;
880
881 if (!num_req_buffers) {
882 dp_mon_debug("%pK: Received request for 0 buffers replenish",
883 dp_soc);
884 ret = QDF_STATUS_E_INVAL;
885 goto free_desc;
886 }
887
888 mon_srng = dp_mon_srng->hal_srng;
889
890 hal_srng_access_start(dp_soc->hal_soc, mon_srng);
891
892 num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc,
893 mon_srng, sync_hw_ptr);
894
895 if (!num_entries_avail) {
896 hal_srng_access_end(dp_soc->hal_soc, mon_srng);
897 goto free_desc;
898 }
899 if (num_entries_avail < num_req_buffers)
900 num_req_buffers = num_entries_avail;
901
902 /*
903 * if desc_list is NULL, allocate the descs from freelist
904 */
905 if (!(*desc_list)) {
906 num_alloc_desc = dp_mon_get_free_desc_list(dp_soc,
907 mon_desc_pool,
908 num_req_buffers,
909 desc_list,
910 tail);
911
912 if (!num_alloc_desc) {
913 dp_mon_debug("%pK: no free rx_descs in freelist", dp_soc);
914 hal_srng_access_end(dp_soc->hal_soc, mon_srng);
915 return QDF_STATUS_E_NOMEM;
916 }
917
918 dp_mon_info("%pK: %d rx desc allocated",
919 dp_soc, num_alloc_desc);
920
921 num_req_buffers = num_alloc_desc;
922 }
923
924 while (count <= num_req_buffers - 1) {
925 ret = dp_mon_frag_alloc_and_map(dp_soc,
926 &mon_desc,
927 mon_desc_pool);
928
929 if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
930 if (qdf_unlikely(ret == QDF_STATUS_E_FAULT))
931 continue;
932 break;
933 }
934
935 count++;
936 next = (*desc_list)->next;
937 mon_ring_entry = hal_srng_src_get_next(
938 dp_soc->hal_soc,
939 mon_srng);
940
941 if (!mon_ring_entry)
942 break;
943
944 qdf_assert_always((*desc_list)->mon_desc.in_use == 0);
945
946 (*desc_list)->mon_desc.in_use = 1;
947 (*desc_list)->mon_desc.unmapped = 0;
948 (*desc_list)->mon_desc.buf_addr = mon_desc.buf_addr;
949 (*desc_list)->mon_desc.paddr = mon_desc.paddr;
950 (*desc_list)->mon_desc.magic = DP_MON_DESC_MAGIC;
951 (*desc_list)->mon_desc.cookie_2++;
952
953 mon_soc->stats.frag_alloc++;
954
955 /* populate lower 40 bit mon_desc address in desc
956 * and cookie_2 in upper 24 bits
957 */
958 desc = dp_mon_get_debug_desc_addr(desc_list);
959 hal_mon_buff_addr_info_set(dp_soc->hal_soc,
960 mon_ring_entry,
961 desc,
962 mon_desc.paddr);
963
964 *desc_list = next;
965 }
966
967 hal_srng_access_end(dp_soc->hal_soc, mon_srng);
968 if (replenish_cnt_ref)
969 *replenish_cnt_ref += count;
970
971 free_desc:
972 /*
973 * add any available free desc back to the free list
974 */
975 if (*desc_list) {
976 dp_mon_add_desc_list_to_free_list(dp_soc, desc_list, tail,
977 mon_desc_pool);
978 }
979
980 return ret;
981 }
982
dp_mon_desc_pool_alloc(struct dp_soc * soc,enum dp_ctxt_type ctx_type,uint32_t pool_size,struct dp_mon_desc_pool * mon_desc_pool)983 QDF_STATUS dp_mon_desc_pool_alloc(struct dp_soc *soc,
984 enum dp_ctxt_type ctx_type,
985 uint32_t pool_size,
986 struct dp_mon_desc_pool *mon_desc_pool)
987 {
988 size_t mem_size;
989
990 mon_desc_pool->pool_size = pool_size - 1;
991 mem_size = mon_desc_pool->pool_size *
992 sizeof(union dp_mon_desc_list_elem_t);
993 mon_desc_pool->array = dp_context_alloc_mem(soc, ctx_type, mem_size);
994
995 return QDF_STATUS_SUCCESS;
996 }
997
dp_vdev_set_monitor_mode_buf_rings_tx_2_0(struct dp_pdev * pdev,uint16_t num_of_buffers)998 QDF_STATUS dp_vdev_set_monitor_mode_buf_rings_tx_2_0(struct dp_pdev *pdev,
999 uint16_t num_of_buffers)
1000 {
1001 int tx_mon_max_entries;
1002 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx;
1003 struct dp_soc *soc = pdev->soc;
1004 struct dp_mon_soc *mon_soc = soc->monitor_soc;
1005 struct dp_mon_soc_be *mon_soc_be =
1006 dp_get_be_mon_soc_from_dp_mon_soc(mon_soc);
1007 QDF_STATUS status;
1008
1009 if (!mon_soc_be) {
1010 dp_mon_err("DP MON SOC is NULL");
1011 return QDF_STATUS_E_FAILURE;
1012 }
1013
1014 soc_cfg_ctx = soc->wlan_cfg_ctx;
1015 tx_mon_max_entries =
1016 wlan_cfg_get_dp_soc_tx_mon_buf_ring_size(soc_cfg_ctx);
1017
1018 hal_set_low_threshold(mon_soc_be->tx_mon_buf_ring.hal_srng,
1019 tx_mon_max_entries >> 2);
1020 status = htt_srng_setup(soc->htt_handle, 0,
1021 mon_soc_be->tx_mon_buf_ring.hal_srng,
1022 TX_MONITOR_BUF);
1023
1024 if (status != QDF_STATUS_SUCCESS) {
1025 dp_mon_err("Failed to send htt srng setup message for Tx mon buf ring");
1026 return status;
1027 }
1028
1029 if (mon_soc_be->tx_mon_ring_fill_level < num_of_buffers) {
1030 if (dp_tx_mon_buffers_alloc(soc,
1031 (num_of_buffers -
1032 mon_soc_be->tx_mon_ring_fill_level))) {
1033 dp_mon_err("%pK: Tx mon buffers allocation failed",
1034 soc);
1035 return QDF_STATUS_E_FAILURE;
1036 }
1037 mon_soc_be->tx_mon_ring_fill_level +=
1038 (num_of_buffers -
1039 mon_soc_be->tx_mon_ring_fill_level);
1040 }
1041
1042 return QDF_STATUS_SUCCESS;
1043 }
1044
1045 #if defined(WDI_EVENT_ENABLE) &&\
1046 (defined(QCA_ENHANCED_STATS_SUPPORT) || !defined(REMOVE_PKT_LOG) ||\
1047 defined(WLAN_FEATURE_PKT_CAPTURE_V2))
1048 static inline
dp_mon_ppdu_stats_handler_register(struct dp_mon_soc * mon_soc)1049 void dp_mon_ppdu_stats_handler_register(struct dp_mon_soc *mon_soc)
1050 {
1051 mon_soc->mon_ops->mon_ppdu_stats_ind_handler =
1052 dp_ppdu_stats_ind_handler;
1053 }
1054 #else
1055 static inline
dp_mon_ppdu_stats_handler_register(struct dp_mon_soc * mon_soc)1056 void dp_mon_ppdu_stats_handler_register(struct dp_mon_soc *mon_soc)
1057 {
1058 }
1059 #endif
1060
dp_mon_register_intr_ops_2_0(struct dp_soc * soc)1061 static void dp_mon_register_intr_ops_2_0(struct dp_soc *soc)
1062 {
1063 struct dp_mon_soc *mon_soc = soc->monitor_soc;
1064
1065 mon_soc->mon_ops->rx_mon_refill_buf_ring =
1066 dp_rx_mon_refill_buf_ring_2_0,
1067 mon_soc->mon_ops->tx_mon_refill_buf_ring =
1068 NULL,
1069 mon_soc->mon_rx_process = dp_rx_mon_process_2_0;
1070 dp_mon_ppdu_stats_handler_register(mon_soc);
1071 }
1072
1073 #ifdef MONITOR_TLV_RECORDING_ENABLE
1074 /**
1075 * dp_mon_pdev_initialize_tlv_logger() - initialize dp_mon_tlv_logger for
1076 * Rx and Tx
1077 *
1078 * @tlv_logger : double pointer to dp_mon_tlv_logger
1079 * @direction: Rx/Tx
1080 * Return: QDF_STATUS
1081 */
1082 static QDF_STATUS
dp_mon_pdev_initialize_tlv_logger(struct dp_mon_tlv_logger ** tlv_logger,uint8_t direction)1083 dp_mon_pdev_initialize_tlv_logger(struct dp_mon_tlv_logger **tlv_logger,
1084 uint8_t direction)
1085 {
1086 struct dp_mon_tlv_logger *tlv_log = NULL;
1087
1088 tlv_log = qdf_mem_malloc(sizeof(struct dp_mon_tlv_logger));
1089 if (!tlv_log) {
1090 dp_mon_err("Memory allocation failed");
1091 return QDF_STATUS_E_NOMEM;
1092 }
1093
1094 if (direction == MONITOR_TLV_RECORDING_RX)
1095 tlv_log->buff = qdf_mem_malloc(MAX_TLV_LOGGING_SIZE *
1096 sizeof(struct dp_mon_tlv_info));
1097 else if (direction == MONITOR_TLV_RECORDING_TX)
1098 tlv_log->buff = qdf_mem_malloc(MAX_TLV_LOGGING_SIZE *
1099 sizeof(struct dp_tx_mon_tlv_info));
1100
1101 if (!tlv_log->buff) {
1102 dp_mon_err("Memory allocation failed");
1103 qdf_mem_free(tlv_log);
1104 tlv_log = NULL;
1105 return QDF_STATUS_E_NOMEM;
1106 }
1107
1108 tlv_log->curr_ppdu_pos = 0;
1109 tlv_log->wrap_flag = 0;
1110 tlv_log->ppdu_start_idx = 0;
1111 tlv_log->mpdu_idx = MAX_PPDU_START_TLV_NUM;
1112 tlv_log->ppdu_end_idx = MAX_PPDU_START_TLV_NUM + MAX_MPDU_TLV_NUM;
1113 tlv_log->max_ppdu_start_idx = MAX_PPDU_START_TLV_NUM - 1;
1114 tlv_log->max_mpdu_idx = MAX_PPDU_START_TLV_NUM + MAX_MPDU_TLV_NUM - 1;
1115 tlv_log->max_ppdu_end_idx = MAX_TLVS_PER_PPDU - 1;
1116
1117 tlv_log->tlv_logging_enable = 1;
1118 *tlv_logger = tlv_log;
1119
1120 return QDF_STATUS_SUCCESS;
1121 }
1122
1123 /*
1124 * dp_mon_pdev_tlv_logger_init() - initializes struct dp_mon_tlv_logger
1125 *
1126 * @pdev: pointer to dp_pdev
1127 *
1128 * Return: QDF_STATUS
1129 */
1130 static
dp_mon_pdev_tlv_logger_init(struct dp_pdev * pdev)1131 QDF_STATUS dp_mon_pdev_tlv_logger_init(struct dp_pdev *pdev)
1132 {
1133 struct dp_mon_pdev *mon_pdev = NULL;
1134 struct dp_mon_pdev_be *mon_pdev_be = NULL;
1135 struct dp_soc *soc = NULL;
1136
1137 if (!pdev)
1138 return QDF_STATUS_E_INVAL;
1139
1140 soc = pdev->soc;
1141 mon_pdev = pdev->monitor_pdev;
1142 if (!mon_pdev)
1143 return QDF_STATUS_E_INVAL;
1144
1145 mon_pdev_be = dp_get_be_mon_pdev_from_dp_mon_pdev(mon_pdev);
1146
1147 if (dp_mon_pdev_initialize_tlv_logger(&mon_pdev_be->rx_tlv_log,
1148 MONITOR_TLV_RECORDING_RX))
1149 return QDF_STATUS_E_FAILURE;
1150
1151 if (dp_mon_pdev_initialize_tlv_logger(&mon_pdev_be->tx_tlv_log,
1152 MONITOR_TLV_RECORDING_TX))
1153 return QDF_STATUS_E_FAILURE;
1154
1155 return QDF_STATUS_SUCCESS;
1156 }
1157
1158 /**
1159 * dp_mon_pdev_deinitialize_tlv_logger() - deinitialize dp_mon_tlv_logger for
1160 * Rx and Tx
1161 *
1162 * @tlv_logger : double pointer to dp_mon_tlv_logger
1163 *
1164 * Return: QDF_STATUS
1165 */
1166 static QDF_STATUS
dp_mon_pdev_deinitialize_tlv_logger(struct dp_mon_tlv_logger ** tlv_logger)1167 dp_mon_pdev_deinitialize_tlv_logger(struct dp_mon_tlv_logger **tlv_logger)
1168 {
1169 struct dp_mon_tlv_logger *tlv_log = *tlv_logger;
1170
1171 if (!tlv_log)
1172 return QDF_STATUS_SUCCESS;
1173 if (!(tlv_log->buff))
1174 return QDF_STATUS_E_INVAL;
1175
1176 tlv_log->tlv_logging_enable = 0;
1177 qdf_mem_free(tlv_log->buff);
1178 tlv_log->buff = NULL;
1179 qdf_mem_free(tlv_log);
1180 tlv_log = NULL;
1181 *tlv_logger = NULL;
1182
1183 return QDF_STATUS_SUCCESS;
1184 }
1185
1186 /*
1187 * dp_mon_pdev_tlv_logger_deinit() - deinitializes struct dp_mon_tlv_logger
1188 *
1189 * @pdev: pointer to dp_pdev
1190 *
1191 * Return: QDF_STATUS
1192 */
1193 static
dp_mon_pdev_tlv_logger_deinit(struct dp_pdev * pdev)1194 QDF_STATUS dp_mon_pdev_tlv_logger_deinit(struct dp_pdev *pdev)
1195 {
1196 struct dp_mon_pdev *mon_pdev = NULL;
1197 struct dp_mon_pdev_be *mon_pdev_be = NULL;
1198
1199 if (!pdev)
1200 return QDF_STATUS_E_INVAL;
1201
1202 mon_pdev = pdev->monitor_pdev;
1203 if (!mon_pdev)
1204 return QDF_STATUS_E_INVAL;
1205
1206 mon_pdev_be = dp_get_be_mon_pdev_from_dp_mon_pdev(mon_pdev);
1207
1208 if (dp_mon_pdev_deinitialize_tlv_logger(&mon_pdev_be->rx_tlv_log))
1209 return QDF_STATUS_E_FAILURE;
1210 if (dp_mon_pdev_deinitialize_tlv_logger(&mon_pdev_be->tx_tlv_log))
1211 return QDF_STATUS_E_FAILURE;
1212
1213 return QDF_STATUS_SUCCESS;
1214 }
1215
1216 #else
1217
1218 static inline
dp_mon_pdev_tlv_logger_init(struct dp_pdev * pdev)1219 QDF_STATUS dp_mon_pdev_tlv_logger_init(struct dp_pdev *pdev)
1220 {
1221 return QDF_STATUS_SUCCESS;
1222 }
1223
1224 static inline
dp_mon_pdev_tlv_logger_deinit(struct dp_pdev * pdev)1225 QDF_STATUS dp_mon_pdev_tlv_logger_deinit(struct dp_pdev *pdev)
1226 {
1227 return QDF_STATUS_SUCCESS;
1228 }
1229
1230 #endif
1231
1232 /**
1233 * dp_mon_register_feature_ops_2_0() - register feature ops
1234 *
1235 * @soc: dp soc context
1236 *
1237 * @return: void
1238 */
1239 static void
dp_mon_register_feature_ops_2_0(struct dp_soc * soc)1240 dp_mon_register_feature_ops_2_0(struct dp_soc *soc)
1241 {
1242 struct dp_mon_ops *mon_ops = dp_mon_ops_get(soc);
1243
1244 if (!mon_ops) {
1245 dp_err("mon_ops is NULL, feature ops registration failed");
1246 return;
1247 }
1248
1249 mon_ops->mon_config_debug_sniffer = dp_config_debug_sniffer;
1250 mon_ops->mon_peer_tx_init = NULL;
1251 mon_ops->mon_peer_tx_cleanup = NULL;
1252 mon_ops->mon_htt_ppdu_stats_attach = dp_htt_ppdu_stats_attach;
1253 mon_ops->mon_htt_ppdu_stats_detach = dp_htt_ppdu_stats_detach;
1254 mon_ops->mon_print_pdev_rx_mon_stats = dp_print_pdev_rx_mon_stats;
1255 mon_ops->mon_set_bsscolor = dp_mon_set_bsscolor;
1256 mon_ops->mon_pdev_get_filter_ucast_data =
1257 dp_lite_mon_get_filter_ucast_data;
1258 mon_ops->mon_pdev_get_filter_mcast_data =
1259 dp_lite_mon_get_filter_mcast_data;
1260 mon_ops->mon_pdev_get_filter_non_data =
1261 dp_lite_mon_get_filter_non_data;
1262 mon_ops->mon_neighbour_peer_add_ast = NULL;
1263 #ifdef WLAN_TX_PKT_CAPTURE_ENH_BE
1264 mon_ops->mon_peer_tid_peer_id_update = NULL;
1265 mon_ops->mon_tx_capture_debugfs_init = NULL;
1266 mon_ops->mon_tx_add_to_comp_queue = NULL;
1267 mon_ops->mon_print_pdev_tx_capture_stats =
1268 dp_print_pdev_tx_monitor_stats_2_0;
1269 mon_ops->mon_config_enh_tx_capture = dp_config_enh_tx_monitor_2_0;
1270 mon_ops->mon_tx_peer_filter = dp_peer_set_tx_capture_enabled_2_0;
1271 #endif
1272 #if (defined(WIFI_MONITOR_SUPPORT) && defined(WLAN_TX_MON_CORE_DEBUG))
1273 mon_ops->mon_peer_tid_peer_id_update = NULL;
1274 mon_ops->mon_tx_capture_debugfs_init = NULL;
1275 mon_ops->mon_tx_add_to_comp_queue = NULL;
1276 mon_ops->mon_print_pdev_tx_capture_stats = NULL;
1277 mon_ops->mon_config_enh_tx_capture = dp_config_enh_tx_core_monitor_2_0;
1278 mon_ops->mon_tx_peer_filter = NULL;
1279 #endif
1280 #ifdef WLAN_RX_PKT_CAPTURE_ENH
1281 mon_ops->mon_config_enh_rx_capture = NULL;
1282 #endif
1283 #ifdef QCA_SUPPORT_BPR
1284 mon_ops->mon_set_bpr_enable = dp_set_bpr_enable_2_0;
1285 #endif
1286 #ifdef ATH_SUPPORT_NAC
1287 mon_ops->mon_set_filter_neigh_peers = NULL;
1288 #endif
1289 #ifdef WLAN_ATF_ENABLE
1290 mon_ops->mon_set_atf_stats_enable = dp_set_atf_stats_enable;
1291 #endif
1292 #ifdef FEATURE_NAC_RSSI
1293 mon_ops->mon_filter_neighbour_peer = NULL;
1294 #endif
1295 #ifdef QCA_MCOPY_SUPPORT
1296 mon_ops->mon_filter_setup_mcopy_mode = NULL;
1297 mon_ops->mon_filter_reset_mcopy_mode = NULL;
1298 mon_ops->mon_mcopy_check_deliver = NULL;
1299 #endif
1300 #ifdef QCA_ENHANCED_STATS_SUPPORT
1301 mon_ops->mon_filter_setup_enhanced_stats =
1302 dp_mon_filter_setup_enhanced_stats_2_0;
1303 mon_ops->mon_filter_reset_enhanced_stats =
1304 dp_mon_filter_reset_enhanced_stats_2_0;
1305 mon_ops->mon_tx_enable_enhanced_stats =
1306 dp_mon_tx_enable_enhanced_stats_2_0;
1307 mon_ops->mon_tx_disable_enhanced_stats =
1308 dp_mon_tx_disable_enhanced_stats_2_0;
1309 mon_ops->mon_ppdu_stats_feat_enable_check =
1310 dp_ppdu_stats_feat_enable_check_2_0;
1311 mon_ops->mon_tx_stats_update = dp_mon_tx_stats_update_2_0;
1312 mon_ops->mon_ppdu_desc_deliver = dp_ppdu_desc_deliver;
1313 #ifdef WDI_EVENT_ENABLE
1314 mon_ops->mon_ppdu_desc_notify = dp_ppdu_desc_notify_2_0;
1315 #endif
1316 #endif
1317 #ifdef WLAN_RX_PKT_CAPTURE_ENH
1318 mon_ops->mon_filter_setup_rx_enh_capture = NULL;
1319 #endif
1320 #ifdef WDI_EVENT_ENABLE
1321 mon_ops->mon_set_pktlog_wifi3 = dp_set_pktlog_wifi3;
1322 mon_ops->mon_filter_setup_rx_pkt_log_full =
1323 dp_mon_filter_setup_rx_pkt_log_full_2_0;
1324 mon_ops->mon_filter_reset_rx_pkt_log_full =
1325 dp_mon_filter_reset_rx_pkt_log_full_2_0;
1326 mon_ops->mon_filter_setup_rx_pkt_log_lite =
1327 dp_mon_filter_setup_rx_pkt_log_lite_2_0;
1328 mon_ops->mon_filter_reset_rx_pkt_log_lite =
1329 dp_mon_filter_reset_rx_pkt_log_lite_2_0;
1330 mon_ops->mon_filter_setup_rx_pkt_log_cbf =
1331 dp_mon_filter_setup_rx_pkt_log_cbf_2_0;
1332 mon_ops->mon_filter_reset_rx_pkt_log_cbf =
1333 dp_mon_filter_reset_rx_pktlog_cbf_2_0;
1334 #if defined(BE_PKTLOG_SUPPORT) && defined(WLAN_PKT_CAPTURE_TX_2_0)
1335 mon_ops->mon_filter_setup_pktlog_hybrid =
1336 dp_mon_filter_setup_pktlog_hybrid_2_0;
1337 mon_ops->mon_filter_reset_pktlog_hybrid =
1338 dp_mon_filter_reset_pktlog_hybrid_2_0;
1339 #endif
1340 #endif
1341 #if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
1342 mon_ops->mon_pktlogmod_exit = dp_pktlogmod_exit;
1343 #endif
1344 mon_ops->rx_hdr_length_set = dp_rx_mon_hdr_length_set;
1345 mon_ops->rx_packet_length_set = dp_rx_mon_packet_length_set;
1346 mon_ops->rx_mon_enable = dp_rx_mon_enable_set;
1347 mon_ops->rx_wmask_subscribe = dp_rx_mon_word_mask_subscribe;
1348 mon_ops->rx_pkt_tlv_offset = dp_rx_mon_pkt_tlv_offset_subscribe;
1349 mon_ops->rx_enable_mpdu_logging = dp_rx_mon_enable_mpdu_logging;
1350 mon_ops->mon_neighbour_peers_detach = NULL;
1351 mon_ops->mon_vdev_set_monitor_mode_buf_rings =
1352 dp_vdev_set_monitor_mode_buf_rings_2_0;
1353 mon_ops->mon_vdev_set_monitor_mode_rings =
1354 dp_vdev_set_monitor_mode_rings_2_0;
1355 #ifdef QCA_ENHANCED_STATS_SUPPORT
1356 mon_ops->mon_rx_stats_update = dp_rx_mon_stats_update_2_0;
1357 mon_ops->mon_rx_populate_ppdu_usr_info =
1358 dp_rx_mon_populate_ppdu_usr_info_2_0;
1359 mon_ops->mon_rx_populate_ppdu_info = dp_rx_mon_populate_ppdu_info_2_0;
1360 #endif
1361 #ifdef QCA_UNDECODED_METADATA_SUPPORT
1362 mon_ops->mon_config_undecoded_metadata_capture =
1363 dp_mon_config_undecoded_metadata_capture;
1364 mon_ops->mon_filter_setup_undecoded_metadata_capture =
1365 dp_mon_filter_setup_undecoded_metadata_capture_2_0;
1366 mon_ops->mon_filter_reset_undecoded_metadata_capture =
1367 dp_mon_filter_reset_undecoded_metadata_capture_2_0;
1368 #endif
1369 mon_ops->rx_enable_fpmo = dp_rx_mon_enable_fpmo;
1370 mon_ops->mon_rx_print_advanced_stats =
1371 dp_mon_rx_print_advanced_stats_2_0;
1372 mon_ops->mon_mac_filter_set = NULL;
1373 }
1374
1375 struct dp_mon_ops monitor_ops_2_0 = {
1376 .mon_soc_cfg_init = dp_mon_soc_cfg_init,
1377 .mon_soc_attach[0] = NULL,
1378 .mon_soc_attach[1] = dp_mon_soc_attach_2_0,
1379 .mon_soc_detach[0] = NULL,
1380 .mon_soc_detach[1] = dp_mon_soc_detach_2_0,
1381 .mon_soc_init[0] = NULL,
1382 .mon_soc_init[1] = dp_mon_soc_init_2_0,
1383 .mon_soc_deinit[0] = NULL,
1384 .mon_soc_deinit[1] = dp_mon_soc_deinit_2_0,
1385 .mon_pdev_alloc = dp_mon_pdev_alloc_2_0,
1386 .mon_pdev_free = dp_mon_pdev_free_2_0,
1387 .mon_pdev_attach = dp_mon_pdev_attach,
1388 .mon_pdev_detach = dp_mon_pdev_detach,
1389 .mon_pdev_init = dp_mon_pdev_init,
1390 .mon_pdev_deinit = dp_mon_pdev_deinit,
1391 .mon_vdev_attach = dp_mon_vdev_attach,
1392 .mon_vdev_detach = dp_mon_vdev_detach,
1393 .mon_peer_attach = dp_mon_peer_attach,
1394 .mon_peer_detach = dp_mon_peer_detach,
1395 .mon_peer_get_peerstats_ctx = dp_mon_peer_get_peerstats_ctx,
1396 .mon_peer_reset_stats = dp_mon_peer_reset_stats,
1397 .mon_peer_get_stats = dp_mon_peer_get_stats,
1398 .mon_invalid_peer_update_pdev_stats =
1399 dp_mon_invalid_peer_update_pdev_stats,
1400 .mon_peer_get_stats_param = dp_mon_peer_get_stats_param,
1401 .mon_flush_rings = NULL,
1402 #if !defined(DISABLE_MON_CONFIG)
1403 .mon_pdev_htt_srng_setup[0] = NULL,
1404 .mon_pdev_htt_srng_setup[1] = dp_mon_pdev_htt_srng_setup_2_0,
1405 .mon_soc_htt_srng_setup = dp_mon_soc_htt_srng_setup_2_0,
1406 #endif
1407 #if defined(DP_CON_MON)
1408 .mon_service_rings = NULL,
1409 #endif
1410 #ifndef DISABLE_MON_CONFIG
1411 .mon_rx_process = NULL,
1412 #endif
1413 #if !defined(DISABLE_MON_CONFIG) && defined(MON_ENABLE_DROP_FOR_MAC)
1414 .mon_drop_packets_for_mac = NULL,
1415 #endif
1416 .mon_vdev_timer_init = NULL,
1417 .mon_vdev_timer_start = NULL,
1418 .mon_vdev_timer_stop = NULL,
1419 .mon_vdev_timer_deinit = NULL,
1420 .mon_reap_timer_init = NULL,
1421 .mon_reap_timer_start = NULL,
1422 .mon_reap_timer_stop = NULL,
1423 .mon_reap_timer_deinit = NULL,
1424 .mon_filter_setup_tx_mon_mode = dp_mon_filter_setup_tx_mon_mode_2_0,
1425 .mon_filter_reset_tx_mon_mode = dp_mon_filter_reset_tx_mon_mode_2_0,
1426 .mon_rings_alloc[0] = NULL,
1427 .mon_rings_free[0] = NULL,
1428 .mon_rings_init[0] = NULL,
1429 .mon_rings_deinit[0] = NULL,
1430 .mon_rings_alloc[1] = dp_pdev_mon_rings_alloc_2_0,
1431 .mon_rings_free[1] = dp_pdev_mon_rings_free_2_0,
1432 .mon_rings_init[1] = dp_pdev_mon_rings_init_2_0,
1433 .mon_rings_deinit[1] = dp_pdev_mon_rings_deinit_2_0,
1434 .rx_mon_desc_pool_init = NULL,
1435 .rx_mon_desc_pool_deinit = NULL,
1436 .rx_mon_desc_pool_alloc = NULL,
1437 .rx_mon_desc_pool_free = NULL,
1438 .rx_mon_buffers_alloc = NULL,
1439 .rx_mon_buffers_free = NULL,
1440 .tx_mon_desc_pool_init = NULL,
1441 .tx_mon_desc_pool_deinit = NULL,
1442 .tx_mon_desc_pool_alloc = NULL,
1443 .tx_mon_desc_pool_free = NULL,
1444 #ifndef DISABLE_MON_CONFIG
1445 .mon_register_intr_ops = dp_mon_register_intr_ops_2_0,
1446 #endif
1447 .mon_register_feature_ops = dp_mon_register_feature_ops_2_0,
1448 #ifdef WLAN_TX_PKT_CAPTURE_ENH_BE
1449 .mon_tx_ppdu_stats_attach = dp_tx_ppdu_stats_attach_2_0,
1450 .mon_tx_ppdu_stats_detach = dp_tx_ppdu_stats_detach_2_0,
1451 .mon_peer_tx_capture_filter_check = NULL,
1452 #endif
1453 #if (defined(WIFI_MONITOR_SUPPORT) && defined(WLAN_TX_MON_CORE_DEBUG))
1454 .mon_tx_ppdu_stats_attach = NULL,
1455 .mon_tx_ppdu_stats_detach = NULL,
1456 .mon_peer_tx_capture_filter_check = NULL,
1457 #endif
1458 .mon_pdev_ext_init = dp_mon_pdev_ext_init_2_0,
1459 .mon_pdev_ext_deinit = dp_mon_pdev_ext_deinit_2_0,
1460 .mon_lite_mon_alloc = dp_lite_mon_alloc,
1461 .mon_lite_mon_dealloc = dp_lite_mon_dealloc,
1462 .mon_lite_mon_vdev_delete = dp_lite_mon_vdev_delete,
1463 .mon_lite_mon_disable_rx = dp_lite_mon_disable_rx,
1464 .mon_lite_mon_is_rx_adv_filter_enable = dp_lite_mon_is_rx_adv_filter_enable,
1465 #ifdef QCA_KMEM_CACHE_SUPPORT
1466 .mon_rx_ppdu_info_cache_create = dp_rx_mon_ppdu_info_cache_create,
1467 .mon_rx_ppdu_info_cache_destroy = dp_rx_mon_ppdu_info_cache_destroy,
1468 #endif
1469 .mon_rx_pdev_tlv_logger_init = dp_mon_pdev_tlv_logger_init,
1470 .mon_rx_pdev_tlv_logger_deinit = dp_mon_pdev_tlv_logger_deinit,
1471 };
1472
1473 struct cdp_mon_ops dp_ops_mon_2_0 = {
1474 .txrx_reset_monitor_mode = dp_reset_monitor_mode,
1475 /* Added support for HK advance filter */
1476 .txrx_set_advance_monitor_filter = NULL,
1477 .txrx_deliver_tx_mgmt = dp_deliver_tx_mgmt,
1478 .config_full_mon_mode = NULL,
1479 .soc_config_full_mon_mode = NULL,
1480 .get_mon_pdev_rx_stats = dp_pdev_get_rx_mon_stats,
1481 .txrx_enable_mon_reap_timer = NULL,
1482 #ifdef QCA_ENHANCED_STATS_SUPPORT
1483 .txrx_enable_enhanced_stats = dp_enable_enhanced_stats,
1484 .txrx_disable_enhanced_stats = dp_disable_enhanced_stats,
1485 #endif /* QCA_ENHANCED_STATS_SUPPORT */
1486 #if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
1487 .txrx_update_filter_neighbour_peers = dp_lite_mon_config_nac_peer,
1488 #endif
1489 #ifdef ATH_SUPPORT_NAC_RSSI
1490 .txrx_vdev_config_for_nac_rssi = dp_lite_mon_config_nac_rssi_peer,
1491 .txrx_vdev_get_neighbour_rssi = dp_lite_mon_get_nac_peer_rssi,
1492 #endif
1493 #ifdef QCA_SUPPORT_LITE_MONITOR
1494 .txrx_set_lite_mon_config = dp_lite_mon_set_config,
1495 .txrx_get_lite_mon_config = dp_lite_mon_get_config,
1496 .txrx_set_lite_mon_peer_config = dp_lite_mon_set_peer_config,
1497 .txrx_get_lite_mon_peer_config = dp_lite_mon_get_peer_config,
1498 .txrx_is_lite_mon_enabled = dp_lite_mon_is_enabled,
1499 .txrx_get_lite_mon_legacy_feature_enabled =
1500 dp_lite_mon_get_legacy_feature_enabled,
1501 #endif
1502 .txrx_set_mon_pdev_params_rssi_dbm_conv =
1503 dp_mon_pdev_params_rssi_dbm_conv,
1504 #ifdef WLAN_CONFIG_TELEMETRY_AGENT
1505 .txrx_update_pdev_mon_telemetry_airtime_stats =
1506 dp_pdev_update_telemetry_airtime_stats,
1507 #endif
1508 .txrx_update_mon_mac_filter = NULL,
1509 #ifdef WLAN_FEATURE_LOCAL_PKT_CAPTURE
1510 .start_local_pkt_capture = NULL,
1511 .stop_local_pkt_capture = NULL,
1512 .is_local_pkt_capture_running = NULL,
1513 #endif /* WLAN_FEATURE_LOCAL_PKT_CAPTURE */
1514 };
1515
1516 #if defined(WLAN_PKT_CAPTURE_TX_2_0) || \
1517 defined(WLAN_PKT_CAPTURE_RX_2_0)
dp_mon_ops_register_cmn_2_0(struct dp_mon_soc * mon_soc)1518 void dp_mon_ops_register_cmn_2_0(struct dp_mon_soc *mon_soc)
1519 {
1520 struct dp_mon_ops *mon_ops = mon_soc->mon_ops;
1521
1522 if (!mon_ops) {
1523 dp_err("tx 2.0 ops registration failed");
1524 return;
1525 }
1526 mon_ops->tx_mon_filter_alloc = dp_mon_filter_alloc_2_0;
1527 mon_ops->tx_mon_filter_dealloc = dp_mon_filter_dealloc_2_0;
1528 }
1529 #endif
1530
1531 #ifdef WLAN_PKT_CAPTURE_TX_2_0
dp_mon_ops_register_tx_2_0(struct dp_mon_soc * mon_soc)1532 void dp_mon_ops_register_tx_2_0(struct dp_mon_soc *mon_soc)
1533 {
1534 struct dp_mon_ops *mon_ops = mon_soc->mon_ops;
1535
1536 if (!mon_ops) {
1537 dp_err("tx 2.0 ops registration failed");
1538 return;
1539 }
1540 mon_ops->tx_mon_filter_update = dp_tx_mon_filter_update_2_0;
1541 #ifndef DISABLE_MON_CONFIG
1542 mon_ops->mon_tx_process = dp_tx_mon_process_2_0;
1543 mon_ops->print_txmon_ring_stat = dp_tx_mon_print_ring_stat_2_0;
1544 #endif
1545 }
1546 #endif
1547
1548 #ifdef WLAN_PKT_CAPTURE_RX_2_0
dp_mon_ops_register_rx_2_0(struct dp_mon_soc * mon_soc)1549 void dp_mon_ops_register_rx_2_0(struct dp_mon_soc *mon_soc)
1550 {
1551 struct dp_mon_ops *mon_ops = mon_soc->mon_ops;
1552
1553 if (!mon_ops) {
1554 dp_err("rx 2.0 ops registration failed");
1555 return;
1556 }
1557 mon_ops->mon_filter_setup_rx_mon_mode =
1558 dp_mon_filter_setup_rx_mon_mode_2_0;
1559 mon_ops->mon_filter_reset_rx_mon_mode =
1560 dp_mon_filter_reset_rx_mon_mode_2_0;
1561 mon_ops->rx_mon_filter_update = dp_rx_mon_filter_update_2_0;
1562 }
1563 #endif
1564
1565 #ifdef QCA_MONITOR_OPS_PER_SOC_SUPPORT
dp_mon_ops_register_2_0(struct dp_mon_soc * mon_soc)1566 void dp_mon_ops_register_2_0(struct dp_mon_soc *mon_soc)
1567 {
1568 struct dp_mon_ops *mon_ops = NULL;
1569
1570 if (mon_soc->mon_ops) {
1571 dp_mon_err("monitor ops is allocated");
1572 return;
1573 }
1574
1575 mon_ops = qdf_mem_malloc(sizeof(struct dp_mon_ops));
1576 if (!mon_ops) {
1577 dp_mon_err("Failed to allocate memory for mon ops");
1578 return;
1579 }
1580
1581 qdf_mem_copy(mon_ops, &monitor_ops_2_0, sizeof(struct dp_mon_ops));
1582 mon_soc->mon_ops = mon_ops;
1583 dp_mon_ops_register_tx_2_0(mon_soc);
1584 dp_mon_ops_register_rx_2_0(mon_soc);
1585 dp_mon_ops_register_cmn_2_0(mon_soc);
1586 }
1587
dp_mon_cdp_ops_register_2_0(struct cdp_ops * ops)1588 void dp_mon_cdp_ops_register_2_0(struct cdp_ops *ops)
1589 {
1590 struct cdp_mon_ops *mon_ops = NULL;
1591
1592 if (ops->mon_ops) {
1593 dp_mon_err("cdp monitor ops is allocated");
1594 return;
1595 }
1596
1597 mon_ops = qdf_mem_malloc(sizeof(struct cdp_mon_ops));
1598 if (!mon_ops) {
1599 dp_mon_err("Failed to allocate memory for mon ops");
1600 return;
1601 }
1602
1603 qdf_mem_copy(mon_ops, &dp_ops_mon_2_0, sizeof(struct cdp_mon_ops));
1604 ops->mon_ops = mon_ops;
1605 }
1606 #else
dp_mon_ops_register_2_0(struct dp_mon_soc * mon_soc)1607 void dp_mon_ops_register_2_0(struct dp_mon_soc *mon_soc)
1608 {
1609 mon_soc->mon_ops = &monitor_ops_2_0;
1610 }
1611
dp_mon_cdp_ops_register_2_0(struct cdp_ops * ops)1612 void dp_mon_cdp_ops_register_2_0(struct cdp_ops *ops)
1613 {
1614 ops->mon_ops = &dp_ops_mon_2_0;
1615 }
1616 #endif
1617
1618 #ifdef QCA_ENHANCED_STATS_SUPPORT
1619 static void
dp_enable_enhanced_stats_for_each_pdev(struct dp_soc * soc,void * arg,int chip_id)1620 dp_enable_enhanced_stats_for_each_pdev(struct dp_soc *soc, void *arg,
1621 int chip_id) {
1622 uint8_t i = 0;
1623
1624 for (i = 0; i < MAX_PDEV_CNT; i++)
1625 dp_enable_enhanced_stats(dp_soc_to_cdp_soc_t(soc), i);
1626 }
1627
1628 QDF_STATUS
dp_enable_enhanced_stats_2_0(struct cdp_soc_t * soc,uint8_t pdev_id)1629 dp_enable_enhanced_stats_2_0(struct cdp_soc_t *soc, uint8_t pdev_id)
1630 {
1631 struct dp_soc *dp_soc = cdp_soc_t_to_dp_soc(soc);
1632 struct dp_soc_be *be_soc = NULL;
1633
1634 be_soc = dp_get_be_soc_from_dp_soc(dp_soc);
1635
1636 /* enable only on one soc if MLD is disabled */
1637 if (!be_soc->mlo_enabled || !be_soc->ml_ctxt) {
1638 dp_enable_enhanced_stats(soc, pdev_id);
1639 return QDF_STATUS_SUCCESS;
1640 }
1641
1642 dp_mlo_iter_ptnr_soc(be_soc,
1643 dp_enable_enhanced_stats_for_each_pdev,
1644 NULL);
1645 return QDF_STATUS_SUCCESS;
1646 }
1647
1648 static void
dp_disable_enhanced_stats_for_each_pdev(struct dp_soc * soc,void * arg,int chip_id)1649 dp_disable_enhanced_stats_for_each_pdev(struct dp_soc *soc, void *arg,
1650 int chip_id) {
1651 uint8_t i = 0;
1652
1653 for (i = 0; i < MAX_PDEV_CNT; i++)
1654 dp_disable_enhanced_stats(dp_soc_to_cdp_soc_t(soc), i);
1655 }
1656
1657 QDF_STATUS
dp_disable_enhanced_stats_2_0(struct cdp_soc_t * soc,uint8_t pdev_id)1658 dp_disable_enhanced_stats_2_0(struct cdp_soc_t *soc, uint8_t pdev_id)
1659 {
1660 struct dp_soc *dp_soc = cdp_soc_t_to_dp_soc(soc);
1661 struct dp_soc_be *be_soc = NULL;
1662
1663 be_soc = dp_get_be_soc_from_dp_soc(dp_soc);
1664
1665 /* enable only on one soc if MLD is disabled */
1666 if (!be_soc->mlo_enabled || !be_soc->ml_ctxt) {
1667 dp_disable_enhanced_stats(soc, pdev_id);
1668 return QDF_STATUS_SUCCESS;
1669 }
1670
1671 dp_mlo_iter_ptnr_soc(be_soc,
1672 dp_disable_enhanced_stats_for_each_pdev,
1673 NULL);
1674 return QDF_STATUS_SUCCESS;
1675 }
1676 #endif
1677
1678 #ifdef WLAN_FEATURE_LOCAL_PKT_CAPTURE
dp_local_pkt_capture_tx_config(struct dp_pdev * pdev)1679 QDF_STATUS dp_local_pkt_capture_tx_config(struct dp_pdev *pdev)
1680 {
1681 struct dp_soc *soc = pdev->soc;
1682 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx;
1683 uint16_t num_buffers;
1684 QDF_STATUS status;
1685
1686 soc_cfg_ctx = soc->wlan_cfg_ctx;
1687 num_buffers = wlan_cfg_get_dp_soc_tx_mon_buf_ring_size(soc_cfg_ctx);
1688
1689 status = dp_vdev_set_monitor_mode_buf_rings_tx_2_0(pdev, num_buffers);
1690
1691 if (QDF_IS_STATUS_ERROR(status))
1692 dp_mon_err("Tx monitor buffer allocation failed");
1693
1694 return status;
1695 }
1696 #endif
1697