xref: /wlan-driver/qca-wifi-host-cmn/dp/wifi3.0/monitor/dp_mon.h (revision 5113495b16420b49004c444715d2daae2066e7dc)
1 /*
2  * Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
3  * Copyright (c) 2021-2024 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 #ifndef _DP_MON_H_
19 #define _DP_MON_H_
20 
21 #include "qdf_trace.h"
22 #include "dp_internal.h"
23 #include "dp_types.h"
24 #include "dp_htt.h"
25 #include "dp_rx_mon.h"
26 
27 #include <dp_mon_filter.h>
28 #ifdef WLAN_TX_PKT_CAPTURE_ENH
29 #include "dp_tx_capture.h"
30 #endif
31 
32 #ifdef QCA_SUPPORT_LITE_MONITOR
33 #include "dp_lite_mon.h"
34 #endif
35 
36 #define DP_INTR_POLL_TIMER_MS	5
37 #define DP_HIST_TRACK_SIZE 50
38 
39 #define MON_VDEV_TIMER_INIT 0x1
40 #define MON_VDEV_TIMER_RUNNING 0x2
41 
42 /* Budget to reap monitor status ring */
43 #define DP_MON_REAP_BUDGET 1024
44 #define MON_BUF_MIN_ENTRIES 64
45 
46 /* 40MHZ BW 2 20MHZ sub bands */
47 #define SUB40BW 2
48 /* 80MHZ BW 4 20MHZ sub bands */
49 #define SUB80BW 4
50 /* 160MHZ BW 8 20MHZ sub bands */
51 #define SUB160BW 8
52 /* 320MHZ BW 16 20MHZ sub bands */
53 #define SUB320BW 16
54 
55 #define RNG_ERR		"SRNG setup failed for"
56 #define dp_mon_info(params...) \
57 	__QDF_TRACE_FL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_MON, ## params)
58 #define dp_mon_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_MON, params)
59 #define dp_mon_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_MON, params)
60 #define dp_mon_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_MON, params)
61 
62 #define dp_mon_warn_rl(params...) QDF_TRACE_WARN_RL(QDF_MODULE_ID_MON, params)
63 #define dp_mon_debug_rl(params...) QDF_TRACE_DEBUG_RL(QDF_MODULE_ID_MON, params)
64 #define dp_mon_info_rl(params...) \
65 	__QDF_TRACE_RL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_MON, ## params)
66 
67 #ifdef WLAN_FEATURE_LOCAL_PKT_CAPTURE
68 #define IS_LOCAL_PKT_CAPTURE_RUNNING(var, field) ((var)->field)
69 #else
70 #define IS_LOCAL_PKT_CAPTURE_RUNNING(var, field) 0
71 #endif
72 
73 #ifdef QCA_ENHANCED_STATS_SUPPORT
74 typedef struct dp_peer_extd_tx_stats dp_mon_peer_tx_stats;
75 typedef struct dp_peer_extd_rx_stats dp_mon_peer_rx_stats;
76 
77 #define DP_UPDATE_MON_STATS(_tgtobj, _srcobj) \
78 	DP_UPDATE_EXTD_STATS(_tgtobj, _srcobj)
79 #endif
80 
81 #ifndef WLAN_TX_PKT_CAPTURE_ENH
82 struct dp_pdev_tx_capture {
83 };
84 
85 struct dp_peer_tx_capture {
86 };
87 #endif
88 
89 /**
90  * struct ieee80211_ctlframe_addr2 - control frame addr
91  * @i_fc: frame control
92  * @i_aidordur: aid or duration
93  * @i_addr1: address 1
94  * @i_addr2: address 2
95  */
96 struct ieee80211_ctlframe_addr2 {
97 	uint8_t i_fc[2];
98 	uint8_t i_aidordur[2];
99 	uint8_t i_addr1[QDF_NET_MAC_ADDR_MAX_LEN];
100 	uint8_t i_addr2[QDF_NET_MAC_ADDR_MAX_LEN];
101 } __packed;
102 
103 #ifndef WLAN_TX_PKT_CAPTURE_ENH
104 static inline void
dp_process_ppdu_stats_update_failed_bitmap(struct dp_pdev * pdev,void * data,uint32_t ppdu_id,uint32_t size)105 dp_process_ppdu_stats_update_failed_bitmap(struct dp_pdev *pdev,
106 					   void *data,
107 					   uint32_t ppdu_id,
108 					   uint32_t size)
109 {
110 }
111 #endif
112 
113 #ifdef DP_CON_MON_MSI_ENABLED
dp_is_monitor_mode_using_poll(struct dp_soc * soc)114 static inline bool dp_is_monitor_mode_using_poll(struct dp_soc *soc)
115 {
116 	return false;
117 }
118 #else
dp_is_monitor_mode_using_poll(struct dp_soc * soc)119 static inline bool dp_is_monitor_mode_using_poll(struct dp_soc *soc)
120 {
121 	return true;
122 }
123 #endif
124 
125 /**
126  * dp_mon_soc_attach() - DP monitor soc attach
127  * @soc: Datapath SOC handle
128  *
129  * Return: QDF_STATUS_SUCCESS: Success
130  *         QDF_STATUS_E_NOMEM: Error
131  */
132 QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc);
133 
134 /**
135  * dp_mon_soc_detach() - DP monitor soc detach
136  * @soc: Datapath SOC handle
137  *
138  * Return: QDF_STATUS_SUCCESS: Success
139  *         QDF_STATUS_E_FAILURE: Error
140  */
141 QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc);
142 
143 /**
144  * dp_mon_soc_cfg_init() - DP monitor soc config init
145  * @soc: Datapath SOC handle
146  *
147  * Return: QDF_STATUS_SUCCESS: Success
148  *         QDF_STATUS_E_FAILURE: Error
149  */
150 QDF_STATUS dp_mon_soc_cfg_init(struct dp_soc *soc);
151 
152 /**
153  * dp_mon_pdev_attach() - DP monitor pdev attach
154  * @pdev: Datapath pdev handle
155  *
156  * Return: QDF_STATUS_SUCCESS: Success
157  *         QDF_STATUS_E_NOMEM: Error
158  */
159 QDF_STATUS dp_mon_pdev_attach(struct dp_pdev *pdev);
160 
161 /**
162  * dp_mon_pdev_detach() - DP monitor pdev detach
163  * @pdev: Datapath pdev handle
164  *
165  * Return: QDF_STATUS_SUCCESS: Success
166  *         QDF_STATUS_E_FAILURE: Error
167  */
168 QDF_STATUS dp_mon_pdev_detach(struct dp_pdev *pdev);
169 
170 /**
171  * dp_mon_pdev_init() - DP monitor pdev init
172  * @pdev: Datapath pdev handle
173  *
174  * Return: QDF_STATUS_SUCCESS: Success
175  *         QDF_STATUS_E_FAILURE: Error
176  */
177 QDF_STATUS dp_mon_pdev_init(struct dp_pdev *pdev);
178 
179 /**
180  * dp_mon_pdev_deinit() - DP monitor pdev deinit
181  * @pdev: Datapath pdev handle
182  *
183  * Return: QDF_STATUS_SUCCESS: Success
184  *         QDF_STATUS_E_FAILURE: Error
185  */
186 QDF_STATUS dp_mon_pdev_deinit(struct dp_pdev *pdev);
187 
188 /**
189  * dp_mon_vdev_attach() - DP monitor vdev attach
190  * @vdev: Datapath vdev handle
191  *
192  * Return: QDF_STATUS_SUCCESS: Success
193  *         QDF_STATUS_E_NOMEM: Error
194  */
195 QDF_STATUS dp_mon_vdev_attach(struct dp_vdev *vdev);
196 
197 /**
198  * dp_mon_vdev_detach() - DP monitor vdev detach
199  * @vdev: Datapath vdev handle
200  *
201  * Return: QDF_STATUS_SUCCESS: Success
202  *         QDF_STATUS_E_FAILURE: Error
203  */
204 QDF_STATUS dp_mon_vdev_detach(struct dp_vdev *vdev);
205 
206 /**
207  * dp_mon_peer_attach() - DP monitor peer attach
208  * @peer: Datapath peer handle
209  *
210  * Return: QDF_STATUS_SUCCESS: Success
211  *         QDF_STATUS_E_NOMEM: Error
212  */
213 #if defined(WLAN_TX_PKT_CAPTURE_ENH) || defined(FEATURE_PERPKT_INFO)
214 QDF_STATUS dp_mon_peer_attach(struct dp_peer *peer);
215 #else
216 static inline
dp_mon_peer_attach(struct dp_peer * peer)217 QDF_STATUS dp_mon_peer_attach(struct dp_peer *peer)
218 {
219 	return QDF_STATUS_SUCCESS;
220 }
221 #endif
222 
223 /**
224  * dp_mon_peer_detach() - DP monitor peer detach
225  * @peer: Datapath peer handle
226  *
227  * Return: QDF_STATUS_SUCCESS: Success
228  *         QDF_STATUS_E_FAILURE: Error
229  */
230 QDF_STATUS dp_mon_peer_detach(struct dp_peer *peer);
231 
232 /**
233  * dp_mon_peer_get_peerstats_ctx() - Get peer stats context from monitor peer
234  * @peer: Datapath peer handle
235  *
236  * Return: peerstats_ctx
237  */
238 struct cdp_peer_rate_stats_ctx *dp_mon_peer_get_peerstats_ctx(struct
239 							      dp_peer *peer);
240 
241 #ifdef QCA_ENHANCED_STATS_SUPPORT
242 /**
243  * dp_mon_peer_reset_stats() - Reset monitor peer stats
244  * @peer: Datapath peer handle
245  *
246  * Return: none
247  */
248 void dp_mon_peer_reset_stats(struct dp_peer *peer);
249 
250 /**
251  * dp_mon_peer_get_stats() - Get monitor peer stats
252  *
253  * @peer: Datapath peer handle
254  * @arg: Pointer to stats struct
255  * @type: Update type
256  *
257  * Return: none
258  */
259 void dp_mon_peer_get_stats(struct dp_peer *peer, void *arg,
260 			   enum cdp_stat_update_type type);
261 
262 /**
263  * dp_mon_invalid_peer_update_pdev_stats() - Update pdev stats from
264  *					invalid monitor peer
265  * @pdev: Datapath pdev handle
266  *
267  * Return: none
268  */
269 void dp_mon_invalid_peer_update_pdev_stats(struct dp_pdev *pdev);
270 
271 /**
272  * dp_mon_peer_get_stats_param() - Get stats param value from monitor peer
273  * @peer: Datapath peer handle
274  * @type: Stats type requested
275  * @buf: Pointer to buffer for stats param
276  *
277  * Return: QDF_STATUS
278  */
279 QDF_STATUS dp_mon_peer_get_stats_param(struct dp_peer *peer,
280 				       enum cdp_peer_stats_type type,
281 				       cdp_peer_stats_param_t *buf);
282 #else
dp_mon_peer_reset_stats(struct dp_peer * peer)283 static inline void dp_mon_peer_reset_stats(struct dp_peer *peer)
284 {
285 }
286 
287 static inline
dp_mon_peer_get_stats(struct dp_peer * peer,void * arg,enum cdp_stat_update_type type)288 void dp_mon_peer_get_stats(struct dp_peer *peer, void *arg,
289 			   enum cdp_stat_update_type type)
290 {
291 }
292 
dp_mon_invalid_peer_update_pdev_stats(struct dp_pdev * pdev)293 static inline void dp_mon_invalid_peer_update_pdev_stats(struct dp_pdev *pdev)
294 {
295 }
296 
297 static inline
dp_mon_peer_get_stats_param(struct dp_peer * peer,enum cdp_peer_stats_type type,cdp_peer_stats_param_t * buf)298 QDF_STATUS dp_mon_peer_get_stats_param(struct dp_peer *peer,
299 				       enum cdp_peer_stats_type type,
300 				       cdp_peer_stats_param_t *buf)
301 {
302 	return QDF_STATUS_E_FAILURE;
303 }
304 #endif
305 
306 /**
307  * dp_mon_cdp_ops_register() - Register monitor cdp ops
308  * @soc: Datapath soc handle
309  *
310  */
311 void dp_mon_cdp_ops_register(struct dp_soc *soc);
312 
313 /**
314  * dp_mon_cdp_ops_deregister() - deregister monitor cdp ops
315  * @soc: Datapath soc handle
316  *
317  */
318 void dp_mon_cdp_ops_deregister(struct dp_soc *soc);
319 
320 /**
321  * dp_mon_intr_ops_deregister() - deregister monitor interrupt ops
322  * @soc: Datapath soc handle
323  *
324  */
325 void dp_mon_intr_ops_deregister(struct dp_soc *soc);
326 
327 /**
328  * dp_mon_feature_ops_deregister() - deregister monitor feature ops
329  * @soc: Datapath soc handle
330  *
331  */
332 void dp_mon_feature_ops_deregister(struct dp_soc *soc);
333 
334 /**
335  * dp_mon_ops_free() - free monitor ops
336  * @soc: Datapath soc handle
337  *
338  */
339 void dp_mon_ops_free(struct dp_soc *soc);
340 
341 /**
342  * dp_mon_ops_register() - Register monitor ops
343  * @soc: Datapath soc handle
344  *
345  */
346 void dp_mon_ops_register(struct dp_soc *soc);
347 
348 #ifndef DISABLE_MON_CONFIG
349 void dp_mon_register_intr_ops(struct dp_soc *soc);
350 #else
dp_mon_register_intr_ops(struct dp_soc * soc)351 static inline void dp_mon_register_intr_ops(struct dp_soc *soc)
352 {}
353 #endif
354 
355 /**
356  * dp_mon_htt_srng_setup() - DP mon htt srng setup
357  * @soc: Datapath soc handle
358  * @pdev: Datapath pdev handle
359  * @mac_id: mac id
360  * @mac_for_pdev: mac id mapped pdev
361  *
362  * Return: QDF_STATUS_SUCCESS: Success
363  *         QDF_STATUS_E_FAILURE: Error
364  */
365 QDF_STATUS dp_mon_htt_srng_setup(struct dp_soc *soc,
366 				 struct dp_pdev *pdev,
367 				 int mac_id,
368 				 int mac_for_pdev);
369 
370 /**
371  * dp_config_debug_sniffer()- API to enable/disable debug sniffer
372  * @pdev: DP_PDEV handle
373  * @val: user provided value
374  *
375  * Return: 0 for success. nonzero for failure.
376  */
377 #if defined(QCA_MCOPY_SUPPORT) || defined(QCA_TX_CAPTURE_SUPPORT)
378 QDF_STATUS
379 dp_config_debug_sniffer(struct dp_pdev *pdev, int val);
380 #else
381 static inline QDF_STATUS
dp_config_debug_sniffer(struct dp_pdev * pdev,int val)382 dp_config_debug_sniffer(struct dp_pdev *pdev, int val) {
383 	return QDF_STATUS_E_INVAL;
384 }
385 #endif /* QCA_MCOPY_SUPPORT || QCA_TX_CAPTURE_SUPPORT */
386 
387 /**
388  * dp_mon_config_undecoded_metadata_capture()- API to enable/disable undecoded
389  *                                             metadata capture
390  * @pdev: DP_PDEV handle
391  * @val: user provided value
392  *
393  * Return: 0 for success. nonzero for failure.
394  */
395 #ifdef QCA_UNDECODED_METADATA_SUPPORT
396 QDF_STATUS
397 dp_mon_config_undecoded_metadata_capture(struct dp_pdev *pdev, int val);
398 #else
399 static inline QDF_STATUS
dp_mon_config_undecoded_metadata_capture(struct dp_pdev * pdev,int val)400 dp_mon_config_undecoded_metadata_capture(struct dp_pdev *pdev, int val) {
401 	return QDF_STATUS_E_INVAL;
402 }
403 #endif /* QCA_UNDECODED_METADATA_SUPPORT */
404 
405 /**
406  * dp_htt_ppdu_stats_attach() - attach resources for HTT PPDU stats processing
407  * @pdev: Datapath PDEV handle
408  *
409  * Return: QDF_STATUS_SUCCESS: Success
410  *         QDF_STATUS_E_NOMEM: Error
411  */
412 QDF_STATUS dp_htt_ppdu_stats_attach(struct dp_pdev *pdev);
413 
414 /**
415  * dp_htt_ppdu_stats_detach() - detach stats resources
416  * @pdev: Datapath PDEV handle
417  *
418  * Return: void
419  */
420 void dp_htt_ppdu_stats_detach(struct dp_pdev *pdev);
421 
422 /**
423  * dp_set_bpr_enable() - API to enable/disable bpr feature
424  * @pdev: DP_PDEV handle.
425  * @val: Provided value.
426  *
427  * Return: 0 for success. nonzero for failure.
428  */
429 #ifdef QCA_SUPPORT_BPR
430 QDF_STATUS
431 dp_set_bpr_enable(struct dp_pdev *pdev, int val);
432 #endif
433 
434 #ifdef ATH_SUPPORT_NAC
435 int dp_set_filter_neigh_peers(struct dp_pdev *pdev,
436 				     bool val);
437 #endif /* ATH_SUPPORT_NAC */
438 
439 #ifdef WLAN_ATF_ENABLE
440 void dp_set_atf_stats_enable(struct dp_pdev *pdev, bool value);
441 #endif
442 
443 /**
444  * dp_mon_set_bsscolor() - sets bsscolor for tx capture
445  * @pdev: Datapath PDEV handle
446  * @bsscolor: new bsscolor
447  */
448 void
449 dp_mon_set_bsscolor(struct dp_pdev *pdev, uint8_t bsscolor);
450 
451 /**
452  * dp_pdev_get_filter_ucast_data() - get DP PDEV monitor ucast filter
453  * @pdev_handle: Datapath PDEV handle
454  *
455  * Return: true on ucast filter flag set
456  */
457 bool dp_pdev_get_filter_ucast_data(struct cdp_pdev *pdev_handle);
458 
459 /**
460  * dp_pdev_get_filter_mcast_data() - get DP PDEV monitor mcast filter
461  * @pdev_handle: Datapath PDEV handle
462  *
463  * Return: true on mcast filter flag set
464  */
465 bool dp_pdev_get_filter_mcast_data(struct cdp_pdev *pdev_handle);
466 
467 /**
468  * dp_pdev_get_filter_non_data() - get DP PDEV monitor non_data filter
469  * @pdev_handle: Datapath PDEV handle
470  *
471  * Return: true on non data filter flag set
472  */
473 bool dp_pdev_get_filter_non_data(struct cdp_pdev *pdev_handle);
474 
475 /**
476  * dp_set_pktlog_wifi3() - attach txrx vdev
477  * @pdev: Datapath PDEV handle
478  * @event: which event's notifications are being subscribed to
479  * @enable: WDI event subscribe or not. (True or False)
480  *
481  * Return: Success, NULL on failure
482  */
483 #ifdef WDI_EVENT_ENABLE
484 int dp_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event,
485 			bool enable);
486 #endif
487 
488 /* MCL specific functions */
489 #if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
490 /**
491  * dp_pktlogmod_exit() - API to cleanup pktlog info
492  * @pdev: Pdev handle
493  *
494  * Return: none
495  */
496 void dp_pktlogmod_exit(struct dp_pdev *pdev);
497 #else
498 static inline
dp_pktlogmod_exit(struct dp_pdev * handle)499 void dp_pktlogmod_exit(struct dp_pdev *handle)
500 {
501 }
502 #endif
503 
504 #ifdef QCA_MONITOR_PKT_SUPPORT
505 /**
506  * dp_vdev_set_monitor_mode_buf_rings() - set monitor mode buf rings
507  * @pdev: DP pdev object
508  *
509  * Allocate SW descriptor pool, buffers, link descriptor memory
510  * Initialize monitor related SRNGs
511  *
512  * Return: QDF_STATUS
513  */
514 QDF_STATUS dp_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev);
515 
516 /**
517  * dp_vdev_set_monitor_mode_rings() - set monitor mode rings
518  * @pdev: DP pdev object
519  * @delayed_replenish:
520  *
521  * Allocate SW descriptor pool, buffers, link descriptor memory
522  * Initialize monitor related SRNGs
523  *
524  * Return: QDF_STATUS
525  */
526 QDF_STATUS dp_vdev_set_monitor_mode_rings(struct dp_pdev *pdev,
527 					  uint8_t delayed_replenish);
528 
529 #else
530 static inline QDF_STATUS
dp_vdev_set_monitor_mode_buf_rings(struct dp_pdev * pdev)531 dp_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev)
532 {
533 	return QDF_STATUS_SUCCESS;
534 }
535 
536 static inline QDF_STATUS
dp_vdev_set_monitor_mode_rings(struct dp_pdev * pdev,uint8_t delayed_replenish)537 dp_vdev_set_monitor_mode_rings(struct dp_pdev *pdev,
538 			       uint8_t delayed_replenish)
539 {
540 	return QDF_STATUS_SUCCESS;
541 }
542 #endif
543 
544 #if defined(WDI_EVENT_ENABLE) &&\
545 	(defined(QCA_ENHANCED_STATS_SUPPORT) || !defined(REMOVE_PKT_LOG) ||\
546 	 defined(WLAN_FEATURE_PKT_CAPTURE_V2))
547 /**
548  * dp_ppdu_stats_ind_handler() - PPDU stats msg handler
549  * @soc:	 HTT SOC handle
550  * @msg_word:    Pointer to payload
551  * @htt_t2h_msg: HTT msg nbuf
552  *
553  * Return: True if buffer should be freed by caller.
554  */
555 bool dp_ppdu_stats_ind_handler(struct htt_soc *soc,
556 			       uint32_t *msg_word,
557 			       qdf_nbuf_t htt_t2h_msg);
558 #endif
559 
560 #if defined(QCA_ENHANCED_STATS_SUPPORT) || \
561 	(!defined(WLAN_TX_PKT_CAPTURE_ENH) || defined(WLAN_PKT_CAPTURE_TX_2_0))
562 /**
563  * dp_ppdu_desc_deliver(): Function to deliver Tx PPDU status descriptor
564  * to upper layer
565  * @pdev: DP pdev handle
566  * @ppdu_info: per PPDU TLV descriptor
567  *
568  * return: void
569  */
570 void dp_ppdu_desc_deliver(struct dp_pdev *pdev, struct ppdu_info *ppdu_info);
571 #endif
572 
573 #ifdef QCA_RSSI_DB2DBM
574 /**
575  * dp_mon_pdev_params_rssi_dbm_conv() --> to set rssi in dbm conversion
576  *						params into monitor pdev.
577  * @cdp_soc: dp soc handle.
578  * @params: cdp_rssi_db2dbm_param_dp structure value.
579  *
580  * Return: QDF_STATUS_SUCCESS if value set successfully
581  *         QDF_STATUS_E_INVAL false if error
582  */
583 QDF_STATUS
584 dp_mon_pdev_params_rssi_dbm_conv(struct cdp_soc_t *cdp_soc,
585 				 struct cdp_rssi_db2dbm_param_dp *params);
586 #else
587 static inline QDF_STATUS
dp_mon_pdev_params_rssi_dbm_conv(struct cdp_soc_t * cdp_soc,struct cdp_rssi_db2dbm_param_dp * params)588 dp_mon_pdev_params_rssi_dbm_conv(struct cdp_soc_t *cdp_soc,
589 				 struct cdp_rssi_db2dbm_param_dp *params)
590 {
591 	return QDF_STATUS_E_INVAL;
592 }
593 #endif /* QCA_RSSI_DB2DBM */
594 
595 #if !defined(DISABLE_MON_CONFIG)
596 typedef	QDF_STATUS (*mon_pdev_htt_srng_setup_fp)(struct dp_soc *soc,
597 						 struct dp_pdev *pdev,
598 						 int mac_id,
599 						 int mac_for_pdev);
600 #endif
601 typedef	QDF_STATUS (*mon_rings_alloc_fp)(struct dp_pdev *pdev);
602 typedef	void (*mon_rings_free_fp)(struct dp_pdev *pdev);
603 typedef	QDF_STATUS (*mon_rings_init_fp)(struct dp_pdev *pdev);
604 typedef	void (*mon_rings_deinit_fp)(struct dp_pdev *pdev);
605 typedef	QDF_STATUS (*mon_soc_attach_fp)(struct dp_soc *soc);
606 typedef	QDF_STATUS (*mon_soc_detach_fp)(struct dp_soc *soc);
607 typedef	QDF_STATUS (*mon_soc_init_fp)(struct dp_soc *soc);
608 typedef	void (*mon_soc_deinit_fp)(struct dp_soc *soc);
609 
610 struct dp_mon_ops {
611 	QDF_STATUS (*mon_soc_cfg_init)(struct dp_soc *soc);
612 	mon_soc_attach_fp mon_soc_attach[2];
613 	mon_soc_detach_fp mon_soc_detach[2];
614 	mon_soc_init_fp mon_soc_init[2];
615 	mon_soc_deinit_fp mon_soc_deinit[2];
616 	QDF_STATUS (*mon_pdev_alloc)(struct dp_pdev *pdev);
617 	void (*mon_pdev_free)(struct dp_pdev *pdev);
618 	QDF_STATUS (*mon_pdev_attach)(struct dp_pdev *pdev);
619 	QDF_STATUS (*mon_pdev_detach)(struct dp_pdev *pdev);
620 	QDF_STATUS (*mon_pdev_init)(struct dp_pdev *pdev);
621 	QDF_STATUS (*mon_pdev_deinit)(struct dp_pdev *pdev);
622 	QDF_STATUS (*mon_vdev_attach)(struct dp_vdev *vdev);
623 	QDF_STATUS (*mon_vdev_detach)(struct dp_vdev *vdev);
624 	QDF_STATUS (*mon_peer_attach)(struct dp_peer *peer);
625 	QDF_STATUS (*mon_peer_detach)(struct dp_peer *peer);
626 	struct cdp_peer_rate_stats_ctx *(*mon_peer_get_peerstats_ctx)(struct
627 								dp_peer *peer);
628 	void (*mon_peer_reset_stats)(struct dp_peer *peer);
629 	void (*mon_peer_get_stats)(struct dp_peer *peer, void *arg,
630 				   enum cdp_stat_update_type type);
631 	void (*mon_invalid_peer_update_pdev_stats)(struct dp_pdev *pdev);
632 	QDF_STATUS (*mon_peer_get_stats_param)(struct dp_peer *peer,
633 					       enum cdp_peer_stats_type type,
634 					       cdp_peer_stats_param_t *buf);
635 	QDF_STATUS (*mon_config_debug_sniffer)(struct dp_pdev *pdev, int val);
636 	void (*mon_flush_rings)(struct dp_soc *soc);
637 #if !defined(DISABLE_MON_CONFIG)
638 	mon_pdev_htt_srng_setup_fp mon_pdev_htt_srng_setup[2];
639 	QDF_STATUS (*mon_soc_htt_srng_setup)(struct dp_soc *soc);
640 #endif
641 #if !defined(DISABLE_MON_CONFIG) && defined(MON_ENABLE_DROP_FOR_MAC)
642 	uint32_t (*mon_drop_packets_for_mac)(struct dp_pdev *pdev,
643 					     uint32_t mac_id,
644 					     uint32_t quota,
645 					     bool force_flush);
646 #endif
647 #if defined(DP_CON_MON)
648 	void (*mon_service_rings)(struct  dp_soc *soc, uint32_t quota);
649 #endif
650 #ifndef DISABLE_MON_CONFIG
651 	uint32_t (*mon_rx_process)(struct dp_soc *soc,
652 				   struct dp_intr *int_ctx,
653 				   uint32_t mac_id,
654 				   uint32_t quota);
655 	uint32_t (*mon_tx_process)(struct dp_soc *soc,
656 				   struct dp_intr *int_ctx,
657 				   uint32_t mac_id,
658 				   uint32_t quota);
659 	void (*print_txmon_ring_stat)(struct dp_pdev *pdev);
660 #endif
661 	void (*mon_peer_tx_init)(struct dp_pdev *pdev, struct dp_peer *peer);
662 	void (*mon_peer_tx_cleanup)(struct dp_vdev *vdev,
663 				    struct dp_peer *peer);
664 #ifdef WIFI_MONITOR_SUPPORT
665 	void (*mon_peer_tid_peer_id_update)(struct dp_peer *peer,
666 					    uint16_t peer_id);
667 	void (*mon_tx_ppdu_stats_attach)(struct dp_pdev *pdev);
668 	void (*mon_tx_ppdu_stats_detach)(struct dp_pdev *pdev);
669 	QDF_STATUS (*mon_tx_capture_debugfs_init)(struct dp_pdev *pdev);
670 	void (*mon_peer_tx_capture_filter_check)(struct dp_pdev *pdev,
671 						 struct dp_peer *peer);
672 	QDF_STATUS (*mon_tx_add_to_comp_queue)(struct dp_soc *soc,
673 					       struct dp_tx_desc_s *desc,
674 					       struct hal_tx_completion_status *ts,
675 					       uint16_t peer_id);
676 	QDF_STATUS (*mon_update_msdu_to_list)(struct dp_soc *soc,
677 					      struct dp_pdev *pdev,
678 					      struct dp_peer *peer,
679 					      struct hal_tx_completion_status *ts,
680 					      qdf_nbuf_t netbuf);
681 	QDF_STATUS
682 	(*mon_peer_tx_capture_get_stats)(struct dp_peer *peer,
683 					 struct cdp_peer_tx_capture_stats *sts);
684 	QDF_STATUS
685 	(*mon_pdev_tx_capture_get_stats)(struct dp_pdev *pdev,
686 					 struct cdp_pdev_tx_capture_stats *sts);
687 #endif
688 #if defined(WDI_EVENT_ENABLE) &&\
689 	(defined(QCA_ENHANCED_STATS_SUPPORT) || !defined(REMOVE_PKT_LOG) ||\
690 	 defined(WLAN_FEATURE_PKT_CAPTURE_V2))
691 	bool (*mon_ppdu_stats_ind_handler)(struct htt_soc *soc,
692 					   uint32_t *msg_word,
693 					   qdf_nbuf_t htt_t2h_msg);
694 #endif
695 	QDF_STATUS (*mon_htt_ppdu_stats_attach)(struct dp_pdev *pdev);
696 	void (*mon_htt_ppdu_stats_detach)(struct dp_pdev *pdev);
697 	void (*mon_print_pdev_rx_mon_stats)(struct dp_pdev *pdev);
698 
699 #ifdef WIFI_MONITOR_SUPPORT
700 	void (*mon_print_pdev_tx_capture_stats)(struct dp_pdev *pdev);
701 	QDF_STATUS (*mon_config_enh_tx_capture)(struct dp_pdev *pdev,
702 						uint8_t val);
703 	QDF_STATUS (*mon_tx_peer_filter)(struct dp_pdev *pdev_handle,
704 					 struct dp_peer *peer_handle,
705 					 uint8_t is_tx_pkt_cap_enable,
706 					 uint8_t *peer_mac);
707 #endif
708 #ifdef WLAN_RX_PKT_CAPTURE_ENH
709 	QDF_STATUS (*mon_config_enh_rx_capture)(struct dp_pdev *pdev,
710 						uint8_t val);
711 #endif
712 #ifdef QCA_SUPPORT_BPR
713 	QDF_STATUS (*mon_set_bpr_enable)(struct dp_pdev *pdev, int val);
714 #endif
715 #ifdef ATH_SUPPORT_NAC
716 	int (*mon_set_filter_neigh_peers)(struct dp_pdev *pdev, bool val);
717 #endif
718 #ifdef WLAN_ATF_ENABLE
719 	void (*mon_set_atf_stats_enable)(struct dp_pdev *pdev, bool value);
720 #endif
721 	void (*mon_set_bsscolor)(struct dp_pdev *pdev, uint8_t bsscolor);
722 	bool (*mon_pdev_get_filter_ucast_data)(struct cdp_pdev *pdev_handle);
723 	bool (*mon_pdev_get_filter_non_data)(struct cdp_pdev *pdev_handle);
724 	bool (*mon_pdev_get_filter_mcast_data)(struct cdp_pdev *pdev_handle);
725 #ifdef WDI_EVENT_ENABLE
726 	int (*mon_set_pktlog_wifi3)(struct dp_pdev *pdev, uint32_t event,
727 				    bool enable);
728 #endif
729 #if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
730 	void (*mon_pktlogmod_exit)(struct dp_pdev *pdev);
731 #endif
732 	QDF_STATUS (*mon_vdev_set_monitor_mode_buf_rings)(struct dp_pdev *pdev);
733 	QDF_STATUS (*mon_vdev_set_monitor_mode_rings)(struct dp_pdev *pdev,
734 						      uint8_t delayed_replenish);
735 	void (*mon_neighbour_peers_detach)(struct dp_pdev *pdev);
736 #ifdef FEATURE_NAC_RSSI
737 	QDF_STATUS (*mon_filter_neighbour_peer)(struct dp_pdev *pdev,
738 						uint8_t *rx_pkt_hdr);
739 #endif
740 	void (*mon_vdev_timer_init)(struct dp_soc *soc);
741 	void (*mon_vdev_timer_start)(struct dp_soc *soc);
742 	bool (*mon_vdev_timer_stop)(struct dp_soc *soc);
743 	void (*mon_vdev_timer_deinit)(struct dp_soc *soc);
744 	void (*mon_reap_timer_init)(struct dp_soc *soc);
745 	bool (*mon_reap_timer_start)(struct dp_soc *soc,
746 				     enum cdp_mon_reap_source source);
747 	bool (*mon_reap_timer_stop)(struct dp_soc *soc,
748 				    enum cdp_mon_reap_source source);
749 	void (*mon_reap_timer_deinit)(struct dp_soc *soc);
750 #ifdef QCA_MCOPY_SUPPORT
751 	QDF_STATUS (*mon_mcopy_check_deliver)(struct dp_pdev *pdev,
752 					      uint16_t peer_id,
753 					      uint32_t ppdu_id,
754 					      uint8_t first_msdu);
755 #endif
756 	void (*mon_neighbour_peer_add_ast)(struct dp_pdev *pdev,
757 					   struct dp_peer *ta_peer,
758 					   uint8_t *mac_addr,
759 					   qdf_nbuf_t nbuf,
760 					   uint32_t flags);
761 #ifdef QCA_ENHANCED_STATS_SUPPORT
762 	void (*mon_filter_setup_enhanced_stats)(struct dp_pdev *pdev);
763 	void (*mon_filter_reset_enhanced_stats)(struct dp_pdev *pdev);
764 	void (*mon_tx_stats_update)(struct dp_mon_peer *mon_peer,
765 				    struct cdp_tx_completion_ppdu_user *ppdu);
766 	void (*mon_tx_enable_enhanced_stats)(struct dp_pdev *pdev);
767 	void (*mon_tx_disable_enhanced_stats)(struct dp_pdev *pdev);
768 	void (*mon_ppdu_desc_deliver)(struct dp_pdev *pdev,
769 				      struct ppdu_info *ppdu_info);
770 	bool (*mon_ppdu_stats_feat_enable_check)(struct dp_pdev *pdev);
771 	void (*mon_ppdu_desc_notify)(struct dp_pdev *pdev, qdf_nbuf_t nbuf);
772 #endif
773 #ifdef QCA_MCOPY_SUPPORT
774 	void (*mon_filter_setup_mcopy_mode)(struct dp_pdev *pdev);
775 	void (*mon_filter_reset_mcopy_mode)(struct dp_pdev *pdev);
776 #endif
777 #if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
778 	void (*mon_filter_setup_smart_monitor)(struct dp_pdev *pdev);
779 	void (*mon_filter_reset_smart_monitor)(struct dp_pdev *pdev);
780 #endif
781 	void (*mon_filter_set_reset_mon_mac_filter)(struct dp_pdev *pdev,
782 						    bool val);
783 #ifdef WLAN_RX_PKT_CAPTURE_ENH
784 	void (*mon_filter_setup_rx_enh_capture)(struct dp_pdev *pdev);
785 	void (*mon_filter_reset_rx_enh_capture)(struct dp_pdev *pdev);
786 #endif
787 	void (*mon_filter_setup_rx_mon_mode)(struct dp_pdev *pdev);
788 	void (*mon_filter_reset_rx_mon_mode)(struct dp_pdev *pdev);
789 	void (*mon_filter_setup_tx_mon_mode)(struct dp_pdev *pdev);
790 	void (*mon_filter_reset_tx_mon_mode)(struct dp_pdev *pdev);
791 #ifdef WDI_EVENT_ENABLE
792 	void (*mon_filter_setup_rx_pkt_log_full)(struct dp_pdev *pdev);
793 	void (*mon_filter_reset_rx_pkt_log_full)(struct dp_pdev *pdev);
794 	void (*mon_filter_setup_rx_pkt_log_lite)(struct dp_pdev *pdev);
795 	void (*mon_filter_reset_rx_pkt_log_lite)(struct dp_pdev *pdev);
796 	void (*mon_filter_setup_rx_pkt_log_cbf)(struct dp_pdev *pdev);
797 	void (*mon_filter_reset_rx_pkt_log_cbf)(struct dp_pdev *pdev);
798 #ifdef BE_PKTLOG_SUPPORT
799 	void (*mon_filter_setup_pktlog_hybrid)(struct dp_pdev *pdev);
800 	void (*mon_filter_reset_pktlog_hybrid)(struct dp_pdev *pdev);
801 #endif
802 #endif
803 	QDF_STATUS (*rx_mon_filter_update)(struct dp_pdev *pdev);
804 	QDF_STATUS (*tx_mon_filter_update)(struct dp_pdev *pdev);
805 	QDF_STATUS (*set_mon_mode_buf_rings_tx)(struct dp_pdev *pdev,
806 						uint16_t num_buf);
807 
808 	QDF_STATUS (*tx_mon_filter_alloc)(struct dp_pdev *pdev);
809 	void (*tx_mon_filter_dealloc)(struct dp_pdev *pdev);
810 	mon_rings_alloc_fp mon_rings_alloc[2];
811 	mon_rings_free_fp mon_rings_free[2];
812 	mon_rings_init_fp mon_rings_init[2];
813 	mon_rings_deinit_fp mon_rings_deinit[2];
814 
815 	QDF_STATUS (*rx_mon_buffers_alloc)(struct dp_pdev *pdev);
816 	void (*rx_mon_buffers_free)(struct dp_pdev *pdev);
817 	void (*rx_mon_desc_pool_init)(struct dp_pdev *pdev);
818 	void (*rx_mon_desc_pool_deinit)(struct dp_pdev *pdev);
819 	QDF_STATUS (*rx_mon_desc_pool_alloc)(struct dp_pdev *pdev);
820 	void (*rx_mon_desc_pool_free)(struct dp_pdev *pdev);
821 	void (*tx_mon_desc_pool_init)(struct dp_pdev *pdev);
822 	void (*tx_mon_desc_pool_deinit)(struct dp_pdev *pdev);
823 	QDF_STATUS (*tx_mon_desc_pool_alloc)(struct dp_pdev *pdev);
824 	void (*tx_mon_desc_pool_free)(struct dp_pdev *pdev);
825 	void (*rx_mon_enable)(uint32_t *msg_word,
826 			      struct htt_rx_ring_tlv_filter *tlv_filter);
827 	void (*rx_hdr_length_set)(uint32_t *msg_word,
828 				  struct htt_rx_ring_tlv_filter *tlv_filter);
829 	void (*rx_packet_length_set)(uint32_t *msg_word,
830 				     struct htt_rx_ring_tlv_filter *tlv_filter);
831 	void (*rx_wmask_subscribe)(struct dp_soc *soc,
832 				   uint32_t *msg_word, int pdev_id,
833 				   struct htt_rx_ring_tlv_filter *tlv_filter);
834 	void (*rx_pkt_tlv_offset)(uint32_t *msg_word,
835 				  struct htt_rx_ring_tlv_filter *tlv_filter);
836 	void (*rx_enable_mpdu_logging)(uint32_t *msg_word,
837 				       struct htt_rx_ring_tlv_filter *tlv_filter);
838 	void (*rx_enable_fpmo)(uint32_t *msg_word,
839 			       struct htt_rx_ring_tlv_filter *tlv_filter);
840 #ifndef DISABLE_MON_CONFIG
841 	void (*mon_register_intr_ops)(struct dp_soc *soc);
842 #endif
843 	void (*mon_register_feature_ops)(struct dp_soc *soc);
844 #ifdef QCA_ENHANCED_STATS_SUPPORT
845 	void (*mon_rx_stats_update)(struct dp_mon_peer *mon_peer,
846 				    struct cdp_rx_indication_ppdu *ppdu,
847 				    struct cdp_rx_stats_ppdu_user *ppdu_user);
848 	void (*mon_rx_populate_ppdu_usr_info)(struct mon_rx_user_status *rx_user_status,
849 					      struct cdp_rx_stats_ppdu_user *ppdu_user);
850 	void (*mon_rx_populate_ppdu_info)(struct hal_rx_ppdu_info *hal_ppdu_info,
851 					  struct cdp_rx_indication_ppdu *ppdu);
852 #endif
853 	QDF_STATUS (*rx_mon_refill_buf_ring)(struct dp_intr *int_ctx);
854 	QDF_STATUS (*tx_mon_refill_buf_ring)(struct dp_intr *int_ctx);
855 #ifdef QCA_UNDECODED_METADATA_SUPPORT
856 	QDF_STATUS (*mon_config_undecoded_metadata_capture)
857 	    (struct dp_pdev *pdev, int val);
858 	void (*mon_filter_setup_undecoded_metadata_capture)
859 	    (struct dp_pdev *pdev);
860 	void (*mon_filter_reset_undecoded_metadata_capture)
861 	    (struct dp_pdev *pdev);
862 #endif
863 	QDF_STATUS (*mon_pdev_ext_init)(struct dp_pdev *pdev);
864 	QDF_STATUS (*mon_pdev_ext_deinit)(struct dp_pdev *pdev);
865 	QDF_STATUS (*mon_rx_pdev_tlv_logger_init)(struct dp_pdev *pdev);
866 	QDF_STATUS (*mon_rx_pdev_tlv_logger_deinit)(struct dp_pdev *pdev);
867 	QDF_STATUS (*mon_lite_mon_alloc)(struct dp_pdev *pdev);
868 	void (*mon_lite_mon_dealloc)(struct dp_pdev *pdev);
869 	void (*mon_lite_mon_vdev_delete)(struct dp_pdev *pdev,
870 					 struct dp_vdev *vdev);
871 	void (*mon_lite_mon_disable_rx)(struct dp_pdev *pdev);
872 	bool (*mon_lite_mon_is_rx_adv_filter_enable)(struct dp_pdev *pdev);
873 	/* Print advanced monitor stats */
874 	void (*mon_rx_print_advanced_stats)
875 		(struct dp_soc *soc, struct dp_pdev *pdev);
876 	QDF_STATUS (*mon_rx_ppdu_info_cache_create)(struct dp_pdev *pdev);
877 	void (*mon_rx_ppdu_info_cache_destroy)(struct dp_pdev *pdev);
878 	void (*mon_mac_filter_set)(uint32_t *msg_word,
879 				   struct htt_rx_ring_tlv_filter *tlv_filter);
880 #ifdef WLAN_FEATURE_LOCAL_PKT_CAPTURE
881 	QDF_STATUS (*start_local_pkt_capture)(struct dp_pdev *pdev);
882 	QDF_STATUS (*stop_local_pkt_capture)(struct dp_pdev *pdev);
883 	bool (*is_local_pkt_capture_running)(struct dp_pdev *pdev);
884 #endif /* WLAN_FEATURE_LOCAL_PKT_CAPTURE */
885 };
886 
887 /**
888  * struct dp_mon_soc_stats - monitor stats
889  * @frag_alloc: Number of frags allocated
890  * @frag_free: Number of frags freed
891  * @empty_queue: Number of frags freed due to empty queue
892  */
893 struct dp_mon_soc_stats {
894 	uint32_t frag_alloc;
895 	uint32_t frag_free;
896 	uint32_t empty_queue;
897 };
898 
899 struct dp_mon_soc {
900 	/* Holds all monitor related fields extracted from dp_soc */
901 	/* Holds pointer to monitor ops */
902 	/* monitor link descriptor pages */
903 	struct qdf_mem_multi_page_t mon_link_desc_pages[MAX_NUM_LMAC_HW];
904 
905 	/* total link descriptors for monitor mode for each radio */
906 	uint32_t total_mon_link_descs[MAX_NUM_LMAC_HW];
907 
908 	 /* Monitor Link descriptor memory banks */
909 	struct link_desc_bank
910 		mon_link_desc_banks[MAX_NUM_LMAC_HW][MAX_MON_LINK_DESC_BANKS];
911 	uint32_t num_mon_link_desc_banks[MAX_NUM_LMAC_HW];
912 	/* Smart monitor capability for HKv2 */
913 	uint8_t hw_nac_monitor_support;
914 
915 	/* Full monitor mode support */
916 	bool full_mon_mode;
917 
918 	/*interrupt timer*/
919 	qdf_timer_t mon_reap_timer;
920 	uint8_t reap_timer_init;
921 
922 	qdf_spinlock_t reap_timer_lock;
923 
924 	/* Bitmap to record trigger sources of the reap timer */
925 	qdf_bitmap(mon_reap_src_bitmap, CDP_MON_REAP_SOURCE_NUM);
926 
927 	qdf_timer_t mon_vdev_timer;
928 	uint8_t mon_vdev_timer_state;
929 
930 	struct dp_mon_ops *mon_ops;
931 	bool monitor_mode_v2;
932 #ifndef DISABLE_MON_CONFIG
933 	uint32_t (*mon_rx_process)(struct dp_soc *soc,
934 				   struct dp_intr *int_ctx,
935 				   uint32_t mac_id,
936 				   uint32_t quota);
937 #endif
938 
939 #ifdef WLAN_TX_PKT_CAPTURE_ENH
940 	struct dp_soc_tx_capture dp_soc_tx_capt;
941 #endif
942 	/* monitor stats */
943 	struct dp_mon_soc_stats stats;
944 };
945 
946 #ifdef WLAN_CONFIG_TELEMETRY_AGENT
947 struct dp_mon_peer_airtime_consumption {
948 	uint32_t consumption;
949 	uint16_t avg_consumption_per_sec;
950 };
951 
952 /**
953  * struct dp_mon_peer_airtime_stats - Monitor peer airtime stats
954  * @tx_airtime_consumption: tx artime consumption of peer
955  * @rx_airtime_consumption: rx airtime consumption of peer
956  * @last_update_time: Time when last avergae of airtime is done
957  */
958 struct dp_mon_peer_airtime_stats {
959 	struct dp_mon_peer_airtime_consumption tx_airtime_consumption[WME_AC_MAX];
960 	struct dp_mon_peer_airtime_consumption rx_airtime_consumption[WME_AC_MAX];
961 	uint64_t last_update_time;
962 };
963 
964 /**
965  * struct dp_mon_peer_deterministic - Monitor peer deterministic stats
966  * @deter: Deterministic stats per data tid
967  * @avg_tx_rate: Avg TX rate
968  */
969 struct dp_mon_peer_deterministic {
970 	struct cdp_peer_deter_stats deter[CDP_DATA_TID_MAX];
971 	uint64_t avg_tx_rate;
972 };
973 #endif
974 
975 /**
976  * struct dp_mon_peer_stats - Monitor peer stats
977  * @tx: tx stats
978  * @rx: rx stats
979  * @airtime_stats: mon peer airtime stats
980  * @deter_stats: Deterministic stats
981  */
982 struct dp_mon_peer_stats {
983 #ifdef QCA_ENHANCED_STATS_SUPPORT
984 	dp_mon_peer_tx_stats tx;
985 	dp_mon_peer_rx_stats rx;
986 #ifdef WLAN_CONFIG_TELEMETRY_AGENT
987 	struct dp_mon_peer_airtime_stats airtime_stats;
988 	struct dp_mon_peer_deterministic deter_stats;
989 #endif
990 #endif
991 };
992 
993 struct dp_mon_peer {
994 #ifdef WLAN_TX_PKT_CAPTURE_ENH
995 	struct dp_peer_tx_capture tx_capture;
996 #endif
997 #ifdef FEATURE_PERPKT_INFO
998 	/* delayed ba ppdu stats handling */
999 	struct cdp_delayed_tx_completion_ppdu_user delayed_ba_ppdu_stats;
1000 	/* delayed ba flag */
1001 	bool last_delayed_ba;
1002 	/* delayed ba ppdu id */
1003 	uint32_t last_delayed_ba_ppduid;
1004 #endif
1005 	uint8_t tx_cap_enabled:1, /* Peer's tx-capture is enabled */
1006 		rx_cap_enabled:1; /* Peer's rx-capture is enabled */
1007 
1008 	/* Peer level flag to check peer based pktlog enabled or
1009 	 * disabled
1010 	 */
1011 	uint8_t peer_based_pktlog_filter;
1012 
1013 	/* Monitor peer stats */
1014 	struct dp_mon_peer_stats stats;
1015 
1016 	/* peer extended statistics context */
1017 	struct cdp_peer_rate_stats_ctx *peerstats_ctx;
1018 };
1019 
1020 struct dp_rx_mon_rssi_offset {
1021 	/* Temperature based rssi offset */
1022 	int32_t rssi_temp_offset;
1023 	/* Low noise amplifier bypass offset */
1024 	int32_t xlna_bypass_offset;
1025 	/* Low noise amplifier bypass threshold */
1026 	int32_t xlna_bypass_threshold;
1027 	/* 3 Bytes of xbar_config are used for RF to BB mapping */
1028 	uint32_t xbar_config;
1029 	/* min noise floor in active chains per channel */
1030 	int8_t min_nf_dbm;
1031 	/* this value is sum of temp_oofset + min_nf*/
1032 	int32_t rssi_offset;
1033 };
1034 
1035 struct dp_ring_ppdu_id_tracker {
1036 	uint64_t time_ppdu_id_mon_dest;
1037 	uint32_t ppdu_id_mon_dest;
1038 	uint64_t time_ppdu_id_mon_status;
1039 	uint32_t ppdu_id_mon_status;
1040 	uint32_t dest_hp;
1041 	uint32_t dest_tp;
1042 	int32_t dest_hw_hp;
1043 	int32_t dest_hw_tp;
1044 	uint32_t status_hp;
1045 	uint32_t status_tp;
1046 	int32_t status_hw_hp;
1047 	int32_t status_hw_tp;
1048 };
1049 
1050 struct  dp_mon_pdev {
1051 	/* monitor */
1052 	bool monitor_configured;
1053 	uint32_t mon_vdev_id;
1054 
1055 	struct dp_mon_filter **filter;	/* Monitor Filter pointer */
1056 
1057 	/* advance filter mode and type*/
1058 	uint8_t mon_filter_mode;
1059 	uint16_t fp_mgmt_filter;
1060 	uint16_t fp_ctrl_filter;
1061 	uint16_t fp_data_filter;
1062 	uint16_t mo_mgmt_filter;
1063 	uint16_t mo_ctrl_filter;
1064 	uint16_t mo_data_filter;
1065 	uint16_t md_data_filter;
1066 
1067 #ifdef WLAN_TX_PKT_CAPTURE_ENH
1068 	struct dp_pdev_tx_capture tx_capture;
1069 	bool stop_tx_capture_work_q_timer;
1070 #endif
1071 
1072 	/* tx packet capture enhancement */
1073 	enum cdp_tx_enh_capture_mode tx_capture_enabled;
1074 	/* Stuck count on monitor destination ring MPDU process */
1075 	uint32_t mon_dest_ring_stuck_cnt;
1076 	/* monitor mode lock */
1077 	qdf_spinlock_t mon_lock;
1078 
1079 	/* Monitor mode operation channel */
1080 	int mon_chan_num;
1081 
1082 	/* Monitor mode operation frequency */
1083 	qdf_freq_t mon_chan_freq;
1084 
1085 	/* Monitor mode band */
1086 	enum reg_wifi_band mon_chan_band;
1087 
1088 	uint32_t mon_ppdu_status;
1089 	/* monitor mode status/destination ring PPDU and MPDU count */
1090 	struct cdp_pdev_mon_stats rx_mon_stats;
1091 	/* Monitor mode interface and status storage */
1092 	struct dp_vdev *mvdev;
1093 	struct cdp_mon_status rx_mon_recv_status;
1094 	/* to track duplicate link descriptor indications by HW for a WAR */
1095 	uint64_t mon_last_linkdesc_paddr;
1096 	/* to track duplicate buffer indications by HW for a WAR */
1097 	uint32_t mon_last_buf_cookie;
1098 
1099 #ifdef QCA_SUPPORT_FULL_MON
1100 	/* List to maintain all MPDUs for a PPDU in monitor mode */
1101 	TAILQ_HEAD(, dp_mon_mpdu) mon_mpdu_q;
1102 
1103 	/* TODO: define per-user mpdu list
1104 	 * struct dp_mon_mpdu_list mpdu_list[MAX_MU_USERS];
1105 	 */
1106 	struct hal_rx_mon_desc_info *mon_desc;
1107 	struct dp_ring_ppdu_id_tracker hist_ppdu_id_mon_d[DP_HIST_TRACK_SIZE];
1108 	struct dp_ring_ppdu_id_tracker hist_ppdu_id_mon_s[DP_HIST_TRACK_SIZE];
1109 	uint8_t hist_mon_dest_idx;
1110 	uint8_t hist_mon_status_idx;
1111 #endif
1112 	bool set_reset_mon;
1113 	bool is_bkpressure;
1114 	/* Flag to hold on to monitor destination ring */
1115 	bool hold_mon_dest_ring;
1116 	uint64_t reap_status[DP_MON_STATUS_MAX];
1117 	uint64_t prev_status[DP_MON_STATUS_MAX];
1118 	uint64_t status_match[DP_MON_STATUS_MAX];
1119 
1120 	/* Flag to indicate monitor rings are initialized */
1121 	uint8_t pdev_mon_init;
1122 #ifndef REMOVE_PKT_LOG
1123 	bool pkt_log_init;
1124 	struct pktlog_dev_t *pl_dev; /* Pktlog pdev */
1125 #endif /* #ifndef REMOVE_PKT_LOG */
1126 
1127 	/* Smart Mesh */
1128 	bool filter_neighbour_peers;
1129 
1130 	/*flag to indicate neighbour_peers_list not empty */
1131 	bool neighbour_peers_added;
1132 	/* smart mesh mutex */
1133 	qdf_spinlock_t neighbour_peer_mutex;
1134 	/* Neighnour peer list */
1135 	TAILQ_HEAD(, dp_neighbour_peer) neighbour_peers_list;
1136 	/* Enhanced Stats is enabled */
1137 	uint8_t enhanced_stats_en;
1138 	qdf_nbuf_queue_t rx_status_q;
1139 
1140 	/* 128 bytes mpdu header queue per user for ppdu */
1141 	qdf_nbuf_queue_t mpdu_q[MAX_MU_USERS];
1142 
1143 	/* is this a mpdu header TLV and not msdu header TLV */
1144 	bool is_mpdu_hdr[MAX_MU_USERS];
1145 
1146 	/* per user 128 bytes msdu header list for MPDU */
1147 	struct msdu_list msdu_list[MAX_MU_USERS];
1148 
1149 	/* RX enhanced capture mode */
1150 	uint8_t rx_enh_capture_mode;
1151 	/* Rx per peer enhanced capture mode */
1152 	bool rx_enh_capture_peer;
1153 	struct dp_vdev *rx_enh_monitor_vdev;
1154 	/* RX enhanced capture trailer enable/disable flag */
1155 	bool is_rx_enh_capture_trailer_enabled;
1156 #ifdef WLAN_RX_PKT_CAPTURE_ENH
1157 	/* RX per MPDU/PPDU information */
1158 	struct cdp_rx_indication_mpdu mpdu_ind;
1159 #endif
1160 
1161 	/* Packet log mode */
1162 	uint8_t rx_pktlog_mode;
1163 	/* Enable pktlog logging cbf */
1164 	bool rx_pktlog_cbf;
1165 
1166 #ifdef BE_PKTLOG_SUPPORT
1167 	/* Enable pktlog logging hybrid */
1168 	bool pktlog_hybrid_mode;
1169 #endif
1170 	bool tx_sniffer_enable;
1171 	/* mirror copy mode */
1172 	enum m_copy_mode mcopy_mode;
1173 	bool bpr_enable;
1174 	/* Pdev level flag to check peer based pktlog enabled or
1175 	 * disabled
1176 	 */
1177 	uint8_t dp_peer_based_pktlog;
1178 
1179 #ifdef WLAN_ATF_ENABLE
1180 	/* ATF stats enable */
1181 	bool dp_atf_stats_enable;
1182 #endif
1183 
1184 	/* Maintains first status buffer's paddr of a PPDU */
1185 	uint64_t status_buf_addr;
1186 	struct hal_rx_ppdu_info ppdu_info;
1187 
1188 	/* ppdu_id of last received HTT TX stats */
1189 	uint32_t last_ppdu_id;
1190 	struct {
1191 		uint8_t last_user;
1192 		qdf_nbuf_t buf;
1193 	} tx_ppdu_info;
1194 
1195 	struct {
1196 		uint32_t tx_ppdu_id;
1197 		uint16_t tx_peer_id;
1198 		uint32_t rx_ppdu_id;
1199 	} m_copy_id;
1200 
1201 	/* To check if PPDU Tx stats are enabled for Pktlog */
1202 	bool pktlog_ppdu_stats;
1203 
1204 #ifdef ATH_SUPPORT_NAC_RSSI
1205 	bool nac_rssi_filtering;
1206 #endif
1207 
1208 	/* ppdu_stats lock for queue concurrency between cores*/
1209 	qdf_spinlock_t ppdu_stats_lock;
1210 
1211 	/* list of ppdu tlvs */
1212 	TAILQ_HEAD(, ppdu_info) ppdu_info_list;
1213 	TAILQ_HEAD(, ppdu_info) sched_comp_ppdu_list;
1214 
1215 	uint32_t sched_comp_list_depth;
1216 	uint16_t delivered_sched_cmdid;
1217 	uint16_t last_sched_cmdid;
1218 	uint32_t tlv_count;
1219 	uint32_t list_depth;
1220 
1221 	struct {
1222 		qdf_nbuf_t last_nbuf; /*Ptr to mgmt last buf */
1223 		uint8_t *mgmt_buf; /* Ptr to mgmt. payload in HTT ppdu stats */
1224 		uint32_t mgmt_buf_len; /* Len of mgmt. payload in ppdu stats */
1225 		uint32_t ppdu_id;
1226 	} mgmtctrl_frm_info;
1227 	/* Context of cal client timer */
1228 	struct cdp_cal_client *cal_client_ctx;
1229 	uint32_t *ppdu_tlv_buf; /* Buffer to hold HTT ppdu stats TLVs*/
1230 
1231 	qdf_nbuf_t mcopy_status_nbuf;
1232 	bool is_dp_mon_pdev_initialized;
1233 	/* indicates if spcl vap is configured */
1234 	bool scan_spcl_vap_configured;
1235 	bool undecoded_metadata_capture;
1236 #ifdef QCA_UNDECODED_METADATA_SUPPORT
1237 	uint32_t phyrx_error_mask;
1238 	uint32_t phyrx_error_mask_cont;
1239 #endif
1240 #ifdef QCA_SUPPORT_SCAN_SPCL_VAP_STATS
1241 	/* enable spcl vap stats reset on ch change */
1242 	bool reset_scan_spcl_vap_stats_enable;
1243 #endif
1244 	bool is_tlv_hdr_64_bit;
1245 	/* TLV header size*/
1246 	uint8_t tlv_hdr_size;
1247 
1248 	/* Invalid monitor peer to account for stats in mcopy mode */
1249 	struct dp_mon_peer *invalid_mon_peer;
1250 
1251 	bool rssi_dbm_conv_support;
1252 	struct dp_rx_mon_rssi_offset rssi_offsets;
1253 	uint8_t phy_ppdu_id_size;
1254 #ifdef WLAN_FEATURE_LOCAL_PKT_CAPTURE
1255 	bool is_local_pkt_capture_running;
1256 	/* Maintain MSDU list on PPDU */
1257 	qdf_nbuf_queue_t msdu_queue;
1258 	/* Maintain MPDU list of PPDU */
1259 	qdf_nbuf_queue_t mpdu_queue;
1260 	/* To  check if 1st MPDU of PPDU */
1261 	bool first_mpdu;
1262 	/* LPC lock */
1263 	qdf_spinlock_t lpc_lock;
1264 #endif
1265 };
1266 
1267 struct  dp_mon_vdev {
1268 	/* callback to hand rx monitor 802.11 MPDU to the OS shim */
1269 	ol_txrx_rx_mon_fp osif_rx_mon;
1270 #ifdef QCA_SUPPORT_SCAN_SPCL_VAP_STATS
1271 	struct cdp_scan_spcl_vap_stats *scan_spcl_vap_stats;
1272 #endif
1273 };
1274 
1275 #if defined(QCA_TX_CAPTURE_SUPPORT) || defined(QCA_ENHANCED_STATS_SUPPORT)
1276 void dp_deliver_mgmt_frm(struct dp_pdev *pdev, qdf_nbuf_t nbuf);
1277 #else
1278 static inline
dp_deliver_mgmt_frm(struct dp_pdev * pdev,qdf_nbuf_t nbuf)1279 void dp_deliver_mgmt_frm(struct dp_pdev *pdev, qdf_nbuf_t nbuf)
1280 {
1281 }
1282 #endif
1283 
1284 #if defined(WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG) ||\
1285 	defined(WLAN_SUPPORT_RX_FLOW_TAG)
1286 /**
1287  * dp_rx_mon_update_protocol_flow_tag() - Performs necessary checks for monitor
1288  *                                       mode and then tags appropriate packets
1289  * @soc: core txrx main context
1290  * @dp_pdev: pdev on which packet is received
1291  * @msdu: QDF packet buffer on which the protocol tag should be set
1292  * @rx_desc: base address where the RX TLVs start
1293  *
1294  * Return: void
1295  */
1296 void dp_rx_mon_update_protocol_flow_tag(struct dp_soc *soc,
1297 					struct dp_pdev *dp_pdev,
1298 					qdf_nbuf_t msdu, void *rx_desc);
1299 #endif /* WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG || WLAN_SUPPORT_RX_FLOW_TAG */
1300 
1301 #if !defined(WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG) &&\
1302 	!defined(WLAN_SUPPORT_RX_FLOW_TAG)
1303 /**
1304  * dp_rx_mon_update_protocol_flow_tag() - Performs necessary checks for monitor
1305  *                                       mode and then tags appropriate packets
1306  * @soc: core txrx main context
1307  * @dp_pdev: pdev on which packet is received
1308  * @msdu: QDF packet buffer on which the protocol tag should be set
1309  * @rx_desc: base address where the RX TLVs start
1310  *
1311  * Return: void
1312  */
1313 static inline
dp_rx_mon_update_protocol_flow_tag(struct dp_soc * soc,struct dp_pdev * dp_pdev,qdf_nbuf_t msdu,void * rx_desc)1314 void dp_rx_mon_update_protocol_flow_tag(struct dp_soc *soc,
1315 					struct dp_pdev *dp_pdev,
1316 					qdf_nbuf_t msdu, void *rx_desc)
1317 {
1318 }
1319 #endif /* WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG || WLAN_SUPPORT_RX_FLOW_TAG */
1320 
1321 #ifndef WLAN_TX_PKT_CAPTURE_ENH
1322 /**
1323  * dp_peer_tid_queue_init() - Initialize ppdu stats queue per TID
1324  * @peer: Datapath peer
1325  *
1326  */
dp_peer_tid_queue_init(struct dp_peer * peer)1327 static inline void dp_peer_tid_queue_init(struct dp_peer *peer)
1328 {
1329 }
1330 
1331 /**
1332  * dp_peer_tid_queue_cleanup() - remove ppdu stats queue per TID
1333  * @peer: Datapath peer
1334  *
1335  */
dp_peer_tid_queue_cleanup(struct dp_peer * peer)1336 static inline void dp_peer_tid_queue_cleanup(struct dp_peer *peer)
1337 {
1338 }
1339 
1340 /**
1341  * dp_peer_update_80211_hdr() - dp peer update 80211 hdr
1342  * @vdev: Datapath vdev
1343  * @peer: Datapath peer
1344  *
1345  */
1346 static inline void
dp_peer_update_80211_hdr(struct dp_vdev * vdev,struct dp_peer * peer)1347 dp_peer_update_80211_hdr(struct dp_vdev *vdev, struct dp_peer *peer)
1348 {
1349 }
1350 
1351 /**
1352  * dp_get_peer_tx_capture_stats() - to get peer tx capture stats
1353  * @peer: DP PEER handle
1354  * @stats: pointor to peer tx capture stats
1355  *
1356  * return: QDF_STATUS
1357  */
1358 static inline QDF_STATUS
dp_get_peer_tx_capture_stats(struct dp_peer * peer,struct cdp_peer_tx_capture_stats * stats)1359 dp_get_peer_tx_capture_stats(struct dp_peer *peer,
1360 			     struct cdp_peer_tx_capture_stats *stats)
1361 {
1362 	return QDF_STATUS_E_FAILURE;
1363 }
1364 
1365 /**
1366  * dp_get_pdev_tx_capture_stats() - to get pdev tx capture stats
1367  * @pdev: DP PDEV handle
1368  * @stats: pointor to pdev tx capture stats
1369  *
1370  * return: QDF_STATUS
1371  */
1372 static inline QDF_STATUS
dp_get_pdev_tx_capture_stats(struct dp_pdev * pdev,struct cdp_pdev_tx_capture_stats * stats)1373 dp_get_pdev_tx_capture_stats(struct dp_pdev *pdev,
1374 			     struct cdp_pdev_tx_capture_stats *stats)
1375 {
1376 	return QDF_STATUS_E_FAILURE;
1377 }
1378 #endif
1379 
1380 #ifdef WLAN_TX_PKT_CAPTURE_ENH
1381 extern uint8_t
1382 dp_cpu_ring_map[DP_NSS_CPU_RING_MAP_MAX][WLAN_CFG_INT_NUM_CONTEXTS_MAX];
1383 #endif
1384 
1385 /**
1386  * dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap() - Get ppdu stats tlv
1387  * bitmap for sniffer mode
1388  * @bitmap: received bitmap
1389  *
1390  * Return: expected bitmap value, returns zero if doesn't match with
1391  * either 64-bit Tx window or 256-bit window tlv bitmap
1392  */
1393 int
1394 dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap(uint32_t bitmap);
1395 
1396 #if (defined(DP_CON_MON) || defined(WDI_EVENT_ENABLE)) &&\
1397 	(!defined(REMOVE_PKT_LOG))
1398 /**
1399  * dp_pkt_log_init() - API to initialize packet log
1400  * @soc_hdl: Datapath soc handle
1401  * @pdev_id: id of data path pdev handle
1402  * @scn: HIF context
1403  *
1404  * Return: none
1405  */
1406 void dp_pkt_log_init(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, void *scn);
1407 #else
1408 static inline void
dp_pkt_log_init(struct cdp_soc_t * soc_hdl,uint8_t pdev_id,void * scn)1409 dp_pkt_log_init(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, void *scn)
1410 {
1411 }
1412 #endif
1413 
1414 #if defined(WDI_EVENT_ENABLE) && defined(QCA_ENHANCED_STATS_SUPPORT)
1415 QDF_STATUS dp_peer_stats_notify(struct dp_pdev *pdev, struct dp_peer *peer);
1416 #else
dp_peer_stats_notify(struct dp_pdev * pdev,struct dp_peer * peer)1417 static inline QDF_STATUS dp_peer_stats_notify(struct dp_pdev *pdev,
1418 					      struct dp_peer *peer)
1419 {
1420 	return QDF_STATUS_SUCCESS;
1421 }
1422 #endif
1423 
1424 #if defined(FEATURE_PERPKT_INFO) && defined(WDI_EVENT_ENABLE)
1425 void dp_send_stats_event(struct dp_pdev *pdev, struct dp_peer *peer,
1426 			 uint16_t peer_id);
1427 #else
1428 static inline
dp_send_stats_event(struct dp_pdev * pdev,struct dp_peer * peer,uint16_t peer_id)1429 void dp_send_stats_event(struct dp_pdev *pdev, struct dp_peer *peer,
1430 			 uint16_t peer_id)
1431 {
1432 }
1433 #endif
1434 
1435 #ifndef WLAN_TX_PKT_CAPTURE_ENH
1436 /**
1437  * dp_tx_ppdu_stats_process - Deferred PPDU stats handler
1438  * @context: Opaque work context (PDEV)
1439  *
1440  * Return: none
1441  */
dp_tx_ppdu_stats_process(void * context)1442 static  inline void dp_tx_ppdu_stats_process(void *context)
1443 {
1444 }
1445 
1446 /**
1447  * dp_tx_capture_htt_frame_counter: increment counter for htt_frame_type
1448  * @pdev: DP pdev handle
1449  * @htt_frame_type: htt frame type received from fw
1450  *
1451  * return: void
1452  */
1453 static inline
dp_tx_capture_htt_frame_counter(struct dp_pdev * pdev,uint32_t htt_frame_type)1454 void dp_tx_capture_htt_frame_counter(struct dp_pdev *pdev,
1455 				     uint32_t htt_frame_type)
1456 {
1457 }
1458 
1459 #endif
1460 
1461 /**
1462  * dp_rx_cookie_2_mon_link_desc_va() - Converts cookie to a virtual address of
1463  *				   the MSDU Link Descriptor
1464  * @pdev: core txrx pdev context
1465  * @buf_info: buf_info includes cookie that used to lookup virtual address of
1466  * link descriptor. Normally this is just an index into a per pdev array.
1467  * @mac_id: mac id
1468  *
1469  * This is the VA of the link descriptor in monitor mode destination ring,
1470  * that HAL layer later uses to retrieve the list of MSDU's for a given MPDU.
1471  *
1472  * Return: void *: Virtual Address of the Rx descriptor
1473  */
1474 static inline
dp_rx_cookie_2_mon_link_desc_va(struct dp_pdev * pdev,struct hal_buf_info * buf_info,int mac_id)1475 void *dp_rx_cookie_2_mon_link_desc_va(struct dp_pdev *pdev,
1476 				      struct hal_buf_info *buf_info,
1477 				      int mac_id)
1478 {
1479 	void *link_desc_va;
1480 	struct qdf_mem_multi_page_t *pages;
1481 	uint16_t page_id = LINK_DESC_COOKIE_PAGE_ID(buf_info->sw_cookie);
1482 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
1483 
1484 	if (!mon_soc)
1485 		return NULL;
1486 
1487 	pages = &mon_soc->mon_link_desc_pages[mac_id];
1488 	if (!pages)
1489 		return NULL;
1490 
1491 	if (qdf_unlikely(page_id >= pages->num_pages))
1492 		return NULL;
1493 
1494 	link_desc_va = pages->dma_pages[page_id].page_v_addr_start +
1495 		(buf_info->paddr - pages->dma_pages[page_id].page_p_addr);
1496 
1497 	return link_desc_va;
1498 }
1499 
1500 /**
1501  * dp_soc_is_full_mon_enable() - Return if full monitor mode is enabled
1502  * @pdev: point to dp pdev
1503  *
1504  * Return: Full monitor mode status
1505  */
dp_soc_is_full_mon_enable(struct dp_pdev * pdev)1506 static inline bool dp_soc_is_full_mon_enable(struct dp_pdev *pdev)
1507 {
1508 	return (pdev->soc->monitor_soc->full_mon_mode &&
1509 		pdev->monitor_pdev->monitor_configured) ? true : false;
1510 }
1511 
1512 /**
1513  * dp_monitor_is_enable_mcopy_mode() - check if mcopy mode is enabled
1514  * @pdev: point to dp pdev
1515  *
1516  * Return: true if mcopy mode is enabled
1517  */
dp_monitor_is_enable_mcopy_mode(struct dp_pdev * pdev)1518 static inline bool dp_monitor_is_enable_mcopy_mode(struct dp_pdev *pdev)
1519 {
1520 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1521 		return false;
1522 
1523 	return pdev->monitor_pdev->mcopy_mode;
1524 }
1525 
1526 /**
1527  * dp_monitor_is_enable_tx_sniffer() - check if tx sniffer is enabled
1528  * @pdev: point to dp pdev
1529  *
1530  * Return: true if tx sniffer is enabled
1531  */
dp_monitor_is_enable_tx_sniffer(struct dp_pdev * pdev)1532 static inline bool dp_monitor_is_enable_tx_sniffer(struct dp_pdev *pdev)
1533 {
1534 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1535 		return false;
1536 
1537 	return pdev->monitor_pdev->tx_sniffer_enable;
1538 }
1539 
1540 /**
1541  * dp_monitor_is_configured() - check if monitor configured is set
1542  * @pdev: point to dp pdev
1543  *
1544  * Return: true if monitor configured is set
1545  */
dp_monitor_is_configured(struct dp_pdev * pdev)1546 static inline bool dp_monitor_is_configured(struct dp_pdev *pdev)
1547 {
1548 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1549 		return false;
1550 
1551 	return pdev->monitor_pdev->monitor_configured;
1552 }
1553 
1554 /**
1555  * dp_monitor_check_com_info_ppdu_id() - check if msdu ppdu_id matches with
1556  * com info ppdu_id
1557  * @pdev: point to dp pdev
1558  * @rx_desc: point to rx_desc
1559  *
1560  * Return: success if ppdu_id matches
1561  */
dp_monitor_check_com_info_ppdu_id(struct dp_pdev * pdev,void * rx_desc)1562 static inline QDF_STATUS dp_monitor_check_com_info_ppdu_id(struct dp_pdev *pdev,
1563 							   void *rx_desc)
1564 {
1565 	struct cdp_mon_status *rs;
1566 	struct dp_mon_pdev *mon_pdev;
1567 	uint32_t msdu_ppdu_id = 0;
1568 
1569 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1570 		return QDF_STATUS_E_FAILURE;
1571 
1572 	mon_pdev = pdev->monitor_pdev;
1573 	if (qdf_likely(1 != mon_pdev->ppdu_info.rx_status.rxpcu_filter_pass))
1574 		return QDF_STATUS_E_FAILURE;
1575 
1576 	rs = &pdev->monitor_pdev->rx_mon_recv_status;
1577 	if (!rs || rs->cdp_rs_rxdma_err)
1578 		return QDF_STATUS_E_FAILURE;
1579 
1580 	msdu_ppdu_id = hal_rx_get_ppdu_id(pdev->soc->hal_soc, rx_desc);
1581 	if (msdu_ppdu_id != mon_pdev->ppdu_info.com_info.ppdu_id) {
1582 		QDF_TRACE(QDF_MODULE_ID_DP,
1583 			  QDF_TRACE_LEVEL_ERROR,
1584 			  "msdu_ppdu_id=%x,com_info.ppdu_id=%x",
1585 			  msdu_ppdu_id,
1586 			  mon_pdev->ppdu_info.com_info.ppdu_id);
1587 		return QDF_STATUS_E_FAILURE;
1588 	}
1589 
1590 	return QDF_STATUS_SUCCESS;
1591 }
1592 
1593 /**
1594  * dp_monitor_get_rx_status() - get rx status
1595  * @pdev: point to dp pdev
1596  *
1597  * Return: return rx status pointer
1598  */
1599 static inline struct mon_rx_status*
dp_monitor_get_rx_status(struct dp_pdev * pdev)1600 dp_monitor_get_rx_status(struct dp_pdev *pdev)
1601 {
1602 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1603 		return NULL;
1604 
1605 	return &pdev->monitor_pdev->ppdu_info.rx_status;
1606 }
1607 
1608 /**
1609  * dp_monitor_is_chan_band_known() - check if monitor chan band known
1610  * @pdev: point to dp pdev
1611  *
1612  * Return: true if chan band known
1613  */
dp_monitor_is_chan_band_known(struct dp_pdev * pdev)1614 static inline bool dp_monitor_is_chan_band_known(struct dp_pdev *pdev)
1615 {
1616 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1617 		return false;
1618 
1619 	if (pdev->monitor_pdev->mon_chan_band != REG_BAND_UNKNOWN)
1620 		return true;
1621 
1622 	return false;
1623 }
1624 
1625 /**
1626  * dp_monitor_get_chan_band() - get chan band
1627  * @pdev: point to dp pdev
1628  *
1629  * Return: wifi channel band
1630  */
1631 static inline enum reg_wifi_band
dp_monitor_get_chan_band(struct dp_pdev * pdev)1632 dp_monitor_get_chan_band(struct dp_pdev *pdev)
1633 {
1634 	return pdev->monitor_pdev->mon_chan_band;
1635 }
1636 
1637 /**
1638  * dp_monitor_print_tx_stats() - print tx stats from monitor pdev
1639  * @pdev: point to dp pdev
1640  *
1641  */
dp_monitor_print_tx_stats(struct dp_pdev * pdev)1642 static inline void dp_monitor_print_tx_stats(struct dp_pdev *pdev)
1643 {
1644 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1645 		return;
1646 
1647 	DP_PRINT_STATS("ppdu info schedule completion list depth: %d",
1648 		       pdev->monitor_pdev->sched_comp_list_depth);
1649 	DP_PRINT_STATS("delivered sched cmdid: %d",
1650 		       pdev->monitor_pdev->delivered_sched_cmdid);
1651 	DP_PRINT_STATS("cur sched cmdid: %d",
1652 		       pdev->monitor_pdev->last_sched_cmdid);
1653 	DP_PRINT_STATS("ppdu info list depth: %d",
1654 		       pdev->monitor_pdev->list_depth);
1655 }
1656 
1657 /**
1658  * dp_monitor_set_chan_num() - set channel number
1659  * @pdev: point to dp pdev
1660  * @chan_num: channel number
1661  *
1662  */
dp_monitor_set_chan_num(struct dp_pdev * pdev,int chan_num)1663 static inline void dp_monitor_set_chan_num(struct dp_pdev *pdev, int chan_num)
1664 {
1665 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1666 		return;
1667 
1668 	pdev->monitor_pdev->mon_chan_num = chan_num;
1669 }
1670 
1671 /**
1672  * dp_monitor_get_chan_num() - get channel number
1673  * @pdev: DP pdev handle
1674  *
1675  * Return: channel number
1676  */
dp_monitor_get_chan_num(struct dp_pdev * pdev)1677 static inline int dp_monitor_get_chan_num(struct dp_pdev *pdev)
1678 {
1679 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1680 		return 0;
1681 
1682 	return pdev->monitor_pdev->mon_chan_num;
1683 }
1684 
1685 /**
1686  * dp_monitor_set_chan_freq() - set channel frequency
1687  * @pdev: point to dp pdev
1688  * @chan_freq: channel frequency
1689  *
1690  */
1691 static inline void
dp_monitor_set_chan_freq(struct dp_pdev * pdev,qdf_freq_t chan_freq)1692 dp_monitor_set_chan_freq(struct dp_pdev *pdev, qdf_freq_t chan_freq)
1693 {
1694 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1695 		return;
1696 
1697 	pdev->monitor_pdev->mon_chan_freq = chan_freq;
1698 }
1699 
1700 /**
1701  * dp_monitor_get_chan_freq() - get channel frequency
1702  * @pdev: DP pdev handle
1703  *
1704  * Return: channel frequency
1705  */
1706 static inline qdf_freq_t
dp_monitor_get_chan_freq(struct dp_pdev * pdev)1707 dp_monitor_get_chan_freq(struct dp_pdev *pdev)
1708 {
1709 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1710 		return 0;
1711 
1712 	return pdev->monitor_pdev->mon_chan_freq;
1713 }
1714 
1715 /**
1716  * dp_monitor_set_chan_band() - set channel band
1717  * @pdev: point to dp pdev
1718  * @chan_band: channel band
1719  *
1720  */
1721 static inline void
dp_monitor_set_chan_band(struct dp_pdev * pdev,enum reg_wifi_band chan_band)1722 dp_monitor_set_chan_band(struct dp_pdev *pdev, enum reg_wifi_band chan_band)
1723 {
1724 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1725 		return;
1726 
1727 	pdev->monitor_pdev->mon_chan_band = chan_band;
1728 }
1729 
1730 /**
1731  * dp_monitor_get_mpdu_status() - get mpdu status
1732  * @pdev: point to dp pdev
1733  * @soc: point to dp soc
1734  * @rx_tlv_hdr: point to rx tlv header
1735  *
1736  */
dp_monitor_get_mpdu_status(struct dp_pdev * pdev,struct dp_soc * soc,uint8_t * rx_tlv_hdr)1737 static inline void dp_monitor_get_mpdu_status(struct dp_pdev *pdev,
1738 					      struct dp_soc *soc,
1739 					      uint8_t *rx_tlv_hdr)
1740 {
1741 	struct dp_mon_pdev *mon_pdev;
1742 
1743 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
1744 		return;
1745 
1746 	mon_pdev = pdev->monitor_pdev;
1747 	hal_rx_mon_hw_desc_get_mpdu_status(soc->hal_soc, rx_tlv_hdr,
1748 					   &mon_pdev->ppdu_info.rx_status);
1749 }
1750 
1751 #ifdef FEATURE_NAC_RSSI
1752 /**
1753  * dp_monitor_drop_inv_peer_pkts() - drop invalid peer pkts
1754  * @vdev: point to dp vdev
1755  *
1756  * Return: success if sta mode and filter for neighbour peers enabled
1757  */
dp_monitor_drop_inv_peer_pkts(struct dp_vdev * vdev)1758 static inline QDF_STATUS dp_monitor_drop_inv_peer_pkts(struct dp_vdev *vdev)
1759 {
1760 	struct dp_pdev *pdev = vdev->pdev;
1761 	struct dp_soc *soc = pdev->soc;
1762 
1763 	if (!soc->monitor_soc)
1764 		return QDF_STATUS_E_FAILURE;
1765 
1766 	if (!soc->monitor_soc->hw_nac_monitor_support &&
1767 	    pdev->monitor_pdev->filter_neighbour_peers &&
1768 	    vdev->opmode == wlan_op_mode_sta)
1769 		return QDF_STATUS_SUCCESS;
1770 
1771 	return QDF_STATUS_E_FAILURE;
1772 }
1773 #else
dp_monitor_drop_inv_peer_pkts(struct dp_vdev * vdev)1774 static inline QDF_STATUS dp_monitor_drop_inv_peer_pkts(struct dp_vdev *vdev)
1775 {
1776 	return QDF_STATUS_E_FAILURE;
1777 }
1778 #endif
1779 
1780 /**
1781  * dp_peer_ppdu_delayed_ba_init() - Initialize ppdu in peer
1782  * @peer: Datapath peer
1783  *
1784  * return: void
1785  */
1786 #ifdef FEATURE_PERPKT_INFO
dp_peer_ppdu_delayed_ba_init(struct dp_peer * peer)1787 static inline void dp_peer_ppdu_delayed_ba_init(struct dp_peer *peer)
1788 {
1789 	struct dp_mon_peer *mon_peer = peer->monitor_peer;
1790 
1791 	if (!mon_peer)
1792 		return;
1793 
1794 	qdf_mem_zero(&mon_peer->delayed_ba_ppdu_stats,
1795 		     sizeof(struct cdp_delayed_tx_completion_ppdu_user));
1796 	mon_peer->last_delayed_ba = false;
1797 	mon_peer->last_delayed_ba_ppduid = 0;
1798 }
1799 #else
dp_peer_ppdu_delayed_ba_init(struct dp_peer * peer)1800 static inline void dp_peer_ppdu_delayed_ba_init(struct dp_peer *peer)
1801 {
1802 }
1803 #endif
1804 
1805 /**
1806  * dp_monitor_vdev_register_osif() - Register osif rx mon
1807  * @vdev: point to vdev
1808  * @txrx_ops: point to ol txrx ops
1809  *
1810  * Return: void
1811  */
dp_monitor_vdev_register_osif(struct dp_vdev * vdev,struct ol_txrx_ops * txrx_ops)1812 static inline void dp_monitor_vdev_register_osif(struct dp_vdev *vdev,
1813 						 struct ol_txrx_ops *txrx_ops)
1814 {
1815 	if (!vdev->monitor_vdev)
1816 		return;
1817 
1818 	vdev->monitor_vdev->osif_rx_mon = txrx_ops->rx.mon;
1819 }
1820 
1821 /**
1822  * dp_monitor_get_monitor_vdev_from_pdev() - Get monitor vdev
1823  * @pdev: point to pdev
1824  *
1825  * Return: pointer to vdev
1826  */
1827 static inline struct dp_vdev*
dp_monitor_get_monitor_vdev_from_pdev(struct dp_pdev * pdev)1828 dp_monitor_get_monitor_vdev_from_pdev(struct dp_pdev *pdev)
1829 {
1830 	if (!pdev || !pdev->monitor_pdev || !pdev->monitor_pdev->mvdev)
1831 		return NULL;
1832 
1833 	return pdev->monitor_pdev->mvdev;
1834 }
1835 
1836 /**
1837  * dp_monitor_is_vdev_timer_running() - Get vdev timer status
1838  * @soc: point to soc
1839  *
1840  * Return: true if timer running
1841  */
dp_monitor_is_vdev_timer_running(struct dp_soc * soc)1842 static inline bool dp_monitor_is_vdev_timer_running(struct dp_soc *soc)
1843 {
1844 	if (qdf_unlikely(!soc || !soc->monitor_soc))
1845 		return false;
1846 
1847 	return !!(soc->monitor_soc->mon_vdev_timer_state &
1848 		  MON_VDEV_TIMER_RUNNING);
1849 }
1850 
1851 /**
1852  * dp_monitor_get_link_desc_pages() - Get link desc pages
1853  * @soc: point to soc
1854  * @mac_id: mac id
1855  *
1856  * Return: return point to link desc pages
1857  */
1858 static inline struct qdf_mem_multi_page_t*
dp_monitor_get_link_desc_pages(struct dp_soc * soc,uint32_t mac_id)1859 dp_monitor_get_link_desc_pages(struct dp_soc *soc, uint32_t mac_id)
1860 {
1861 	if (qdf_unlikely(!soc || !soc->monitor_soc))
1862 		return NULL;
1863 
1864 	return &soc->monitor_soc->mon_link_desc_pages[mac_id];
1865 }
1866 
1867 #ifndef WLAN_SOFTUMAC_SUPPORT
1868 /*
1869  * dp_monitor_get_link_desc_ring() - Get link desc ring
1870  * @soc: point to soc
1871  * @mac_id: mac id
1872  *
1873  * Return: return point to link desc ring
1874  */
1875 static inline hal_ring_handle_t
dp_monitor_get_link_desc_ring(struct dp_soc * soc,uint32_t mac_id)1876 dp_monitor_get_link_desc_ring(struct dp_soc *soc, uint32_t mac_id)
1877 {
1878 	return soc->rxdma_mon_desc_ring[mac_id].hal_srng;
1879 }
1880 
1881 static inline uint32_t
dp_monitor_get_num_link_desc_ring_entries(struct dp_soc * soc,uint32_t mac_id)1882 dp_monitor_get_num_link_desc_ring_entries(struct dp_soc *soc, uint32_t mac_id)
1883 {
1884 	struct dp_srng *ring;
1885 
1886 	ring = &soc->rxdma_mon_desc_ring[mac_id];
1887 
1888 	return ring->alloc_size / hal_srng_get_entrysize(soc->hal_soc,
1889 							 RXDMA_MONITOR_DESC);
1890 }
1891 #else
1892 static inline hal_ring_handle_t
dp_monitor_get_link_desc_ring(struct dp_soc * soc,uint32_t mac_id)1893 dp_monitor_get_link_desc_ring(struct dp_soc *soc, uint32_t mac_id)
1894 {
1895 	return soc->sw2rxdma_link_ring[mac_id].hal_srng;
1896 }
1897 
1898 static inline uint32_t
dp_monitor_get_num_link_desc_ring_entries(struct dp_soc * soc,uint32_t mac_id)1899 dp_monitor_get_num_link_desc_ring_entries(struct dp_soc *soc, uint32_t mac_id)
1900 {
1901 	struct dp_srng *ring;
1902 
1903 	ring = &soc->sw2rxdma_link_ring[mac_id];
1904 
1905 	return ring->alloc_size / hal_srng_get_entrysize(soc->hal_soc,
1906 							 SW2RXDMA_LINK_RELEASE);
1907 }
1908 #endif
1909 
1910 /**
1911  * dp_monitor_get_total_link_descs() - Get total link descs
1912  * @soc: point to soc
1913  * @mac_id: mac id
1914  *
1915  * Return: return point total link descs
1916  */
1917 static inline uint32_t *
dp_monitor_get_total_link_descs(struct dp_soc * soc,uint32_t mac_id)1918 dp_monitor_get_total_link_descs(struct dp_soc *soc, uint32_t mac_id)
1919 {
1920 	return &soc->monitor_soc->total_mon_link_descs[mac_id];
1921 }
1922 
1923 /**
1924  * dp_monitor_pdev_attach() - Monitor pdev attach
1925  * @pdev: point to pdev
1926  *
1927  * Return: return QDF_STATUS
1928  */
dp_monitor_pdev_attach(struct dp_pdev * pdev)1929 static inline QDF_STATUS dp_monitor_pdev_attach(struct dp_pdev *pdev)
1930 {
1931 	struct dp_mon_ops *monitor_ops;
1932 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
1933 
1934 	/*
1935 	 * mon_soc uninitialized modular support enabled
1936 	 * monitor related attach/detach/init/deinit
1937 	 * will be done while monitor insmod
1938 	 */
1939 	if (!mon_soc)
1940 		return QDF_STATUS_SUCCESS;
1941 
1942 	monitor_ops = mon_soc->mon_ops;
1943 	if (!monitor_ops || !monitor_ops->mon_pdev_attach) {
1944 		dp_mon_debug("callback not registered");
1945 		return QDF_STATUS_E_FAILURE;
1946 	}
1947 
1948 	return monitor_ops->mon_pdev_attach(pdev);
1949 }
1950 
1951 /**
1952  * dp_monitor_pdev_detach() - Monitor pdev detach
1953  * @pdev: point to pdev
1954  *
1955  * Return: return QDF_STATUS
1956  */
dp_monitor_pdev_detach(struct dp_pdev * pdev)1957 static inline QDF_STATUS dp_monitor_pdev_detach(struct dp_pdev *pdev)
1958 {
1959 	struct dp_mon_ops *monitor_ops;
1960 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
1961 
1962 	/*
1963 	 * mon_soc uninitialized modular support enabled
1964 	 * monitor related attach/detach/init/deinit
1965 	 * will be done while monitor insmod
1966 	 */
1967 	if (!mon_soc)
1968 		return QDF_STATUS_SUCCESS;
1969 
1970 	monitor_ops = mon_soc->mon_ops;
1971 	if (!monitor_ops || !monitor_ops->mon_pdev_detach) {
1972 		dp_mon_debug("callback not registered");
1973 		return QDF_STATUS_E_FAILURE;
1974 	}
1975 
1976 	return monitor_ops->mon_pdev_detach(pdev);
1977 }
1978 
1979 /**
1980  * dp_monitor_vdev_attach() - Monitor vdev attach
1981  * @vdev: point to vdev
1982  *
1983  * Return: return QDF_STATUS
1984  */
dp_monitor_vdev_attach(struct dp_vdev * vdev)1985 static inline QDF_STATUS dp_monitor_vdev_attach(struct dp_vdev *vdev)
1986 {
1987 	struct dp_mon_ops *monitor_ops;
1988 	struct dp_mon_soc *mon_soc = vdev->pdev->soc->monitor_soc;
1989 
1990 	if (!mon_soc)
1991 		return QDF_STATUS_E_FAILURE;
1992 
1993 	monitor_ops = mon_soc->mon_ops;
1994 	if (!monitor_ops || !monitor_ops->mon_vdev_attach) {
1995 		dp_mon_debug("callback not registered");
1996 		return QDF_STATUS_E_FAILURE;
1997 	}
1998 
1999 	return monitor_ops->mon_vdev_attach(vdev);
2000 }
2001 
2002 /**
2003  * dp_monitor_vdev_detach() - Monitor vdev detach
2004  * @vdev: point to vdev
2005  *
2006  * Return: return QDF_STATUS
2007  */
dp_monitor_vdev_detach(struct dp_vdev * vdev)2008 static inline QDF_STATUS dp_monitor_vdev_detach(struct dp_vdev *vdev)
2009 {
2010 	struct dp_mon_ops *monitor_ops;
2011 	struct dp_mon_soc *mon_soc = vdev->pdev->soc->monitor_soc;
2012 
2013 	if (!mon_soc)
2014 		return QDF_STATUS_E_FAILURE;
2015 
2016 	monitor_ops = mon_soc->mon_ops;
2017 	if (!monitor_ops || !monitor_ops->mon_vdev_detach) {
2018 		dp_mon_debug("callback not registered");
2019 		return QDF_STATUS_E_FAILURE;
2020 	}
2021 
2022 	return monitor_ops->mon_vdev_detach(vdev);
2023 }
2024 
2025 /**
2026  * dp_monitor_peer_attach() - Monitor peer attach
2027  * @soc: point to soc
2028  * @peer: point to peer
2029  *
2030  * Return: return QDF_STATUS
2031  */
dp_monitor_peer_attach(struct dp_soc * soc,struct dp_peer * peer)2032 static inline QDF_STATUS dp_monitor_peer_attach(struct dp_soc *soc,
2033 						struct dp_peer *peer)
2034 {
2035 	struct dp_mon_ops *monitor_ops;
2036 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2037 
2038 	if (!mon_soc)
2039 		return QDF_STATUS_E_FAILURE;
2040 
2041 	monitor_ops = mon_soc->mon_ops;
2042 	if (!monitor_ops || !monitor_ops->mon_peer_attach) {
2043 		dp_mon_debug("callback not registered");
2044 		return QDF_STATUS_E_FAILURE;
2045 	}
2046 
2047 	return monitor_ops->mon_peer_attach(peer);
2048 }
2049 
2050 /**
2051  * dp_monitor_peer_detach() - Monitor peer detach
2052  * @soc: point to soc
2053  * @peer: point to peer
2054  *
2055  * Return: return QDF_STATUS
2056  */
dp_monitor_peer_detach(struct dp_soc * soc,struct dp_peer * peer)2057 static inline QDF_STATUS dp_monitor_peer_detach(struct dp_soc *soc,
2058 						struct dp_peer *peer)
2059 {
2060 	struct dp_mon_ops *monitor_ops;
2061 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2062 
2063 	if (!mon_soc)
2064 		return QDF_STATUS_E_FAILURE;
2065 
2066 	monitor_ops = mon_soc->mon_ops;
2067 	if (!monitor_ops || !monitor_ops->mon_peer_detach) {
2068 		dp_mon_debug("callback not registered");
2069 		return QDF_STATUS_E_FAILURE;
2070 	}
2071 
2072 	return monitor_ops->mon_peer_detach(peer);
2073 }
2074 
2075 /**
2076  * dp_monitor_peer_get_peerstats_ctx() - Get peerstats context from monitor peer
2077  * @soc: Datapath soc handle
2078  * @peer: Datapath peer handle
2079  *
2080  * Return: peer stats context
2081  */
2082 static inline struct cdp_peer_rate_stats_ctx*
dp_monitor_peer_get_peerstats_ctx(struct dp_soc * soc,struct dp_peer * peer)2083 dp_monitor_peer_get_peerstats_ctx(struct dp_soc *soc, struct dp_peer *peer)
2084 {
2085 	struct dp_mon_ops *monitor_ops;
2086 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2087 
2088 	if (!mon_soc)
2089 		return NULL;
2090 
2091 	monitor_ops = mon_soc->mon_ops;
2092 	if (!monitor_ops || !monitor_ops->mon_peer_get_peerstats_ctx) {
2093 		dp_mon_debug("callback not registered");
2094 		return NULL;
2095 	}
2096 
2097 	return monitor_ops->mon_peer_get_peerstats_ctx(peer);
2098 }
2099 
2100 /**
2101  * dp_monitor_peer_reset_stats() - Reset monitor peer stats
2102  * @soc: Datapath soc handle
2103  * @peer: Datapath peer handle
2104  *
2105  * Return: none
2106  */
dp_monitor_peer_reset_stats(struct dp_soc * soc,struct dp_peer * peer)2107 static inline void dp_monitor_peer_reset_stats(struct dp_soc *soc,
2108 					       struct dp_peer *peer)
2109 {
2110 	struct dp_mon_ops *monitor_ops;
2111 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2112 
2113 	if (!mon_soc)
2114 		return;
2115 
2116 	monitor_ops = mon_soc->mon_ops;
2117 	if (!monitor_ops || !monitor_ops->mon_peer_reset_stats) {
2118 		dp_mon_debug("callback not registered");
2119 		return;
2120 	}
2121 
2122 	monitor_ops->mon_peer_reset_stats(peer);
2123 }
2124 
2125 /**
2126  * dp_monitor_peer_get_stats() - Get monitor peer stats
2127  * @soc: Datapath soc handle
2128  * @peer: Datapath peer handle
2129  * @arg: Pointer to stats struct
2130  * @type: Update type
2131  *
2132  * Return: none
2133  */
2134 static inline
dp_monitor_peer_get_stats(struct dp_soc * soc,struct dp_peer * peer,void * arg,enum cdp_stat_update_type type)2135 void dp_monitor_peer_get_stats(struct dp_soc *soc, struct dp_peer *peer,
2136 			       void *arg, enum cdp_stat_update_type type)
2137 {
2138 	struct dp_mon_ops *monitor_ops;
2139 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2140 
2141 	if (!mon_soc)
2142 		return;
2143 
2144 	monitor_ops = mon_soc->mon_ops;
2145 	if (!monitor_ops || !monitor_ops->mon_peer_get_stats) {
2146 		dp_mon_debug("callback not registered");
2147 		return;
2148 	}
2149 
2150 	monitor_ops->mon_peer_get_stats(peer, arg, type);
2151 }
2152 
2153 /**
2154  * dp_monitor_invalid_peer_update_pdev_stats() - Update pdev stats from
2155  *						invalid monitor peer
2156  * @soc: Datapath soc handle
2157  * @pdev: Datapath pdev handle
2158  *
2159  * Return: none
2160  */
2161 static inline
dp_monitor_invalid_peer_update_pdev_stats(struct dp_soc * soc,struct dp_pdev * pdev)2162 void dp_monitor_invalid_peer_update_pdev_stats(struct dp_soc *soc,
2163 					       struct dp_pdev *pdev)
2164 {
2165 	struct dp_mon_ops *monitor_ops;
2166 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2167 
2168 	if (!mon_soc)
2169 		return;
2170 
2171 	monitor_ops = mon_soc->mon_ops;
2172 	if (!monitor_ops || !monitor_ops->mon_invalid_peer_update_pdev_stats) {
2173 		dp_mon_debug("callback not registered");
2174 		return;
2175 	}
2176 
2177 	monitor_ops->mon_invalid_peer_update_pdev_stats(pdev);
2178 }
2179 
2180 /**
2181  * dp_monitor_peer_get_stats_param() - Get stats param value from monitor peer
2182  * @soc: Datapath soc handle
2183  * @peer: Datapath peer handle
2184  * @type: Stats type requested
2185  * @buf: Pointer to buffer for stats param
2186  *
2187  * Return: QDF_STATUS
2188  */
2189 static inline QDF_STATUS
dp_monitor_peer_get_stats_param(struct dp_soc * soc,struct dp_peer * peer,enum cdp_peer_stats_type type,cdp_peer_stats_param_t * buf)2190 dp_monitor_peer_get_stats_param(struct dp_soc *soc, struct dp_peer *peer,
2191 				enum cdp_peer_stats_type type,
2192 				cdp_peer_stats_param_t *buf)
2193 {
2194 	struct dp_mon_ops *monitor_ops;
2195 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2196 
2197 	if (!mon_soc)
2198 		return QDF_STATUS_E_FAILURE;
2199 
2200 	monitor_ops = mon_soc->mon_ops;
2201 	if (!monitor_ops || !monitor_ops->mon_peer_get_stats_param) {
2202 		dp_mon_debug("callback not registered");
2203 		return QDF_STATUS_E_FAILURE;
2204 	}
2205 
2206 	return monitor_ops->mon_peer_get_stats_param(peer, type, buf);
2207 }
2208 
2209 /**
2210  * dp_monitor_pdev_init() - Monitor pdev init
2211  * @pdev: point to pdev
2212  *
2213  * Return: return QDF_STATUS
2214  */
dp_monitor_pdev_init(struct dp_pdev * pdev)2215 static inline QDF_STATUS dp_monitor_pdev_init(struct dp_pdev *pdev)
2216 {
2217 	struct dp_mon_ops *monitor_ops;
2218 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2219 
2220 	/*
2221 	 * mon_soc uninitialized when modular support enabled
2222 	 * monitor related attach/detach/init/deinit
2223 	 * will be done while monitor insmod
2224 	 */
2225 	if (!mon_soc)
2226 		return QDF_STATUS_SUCCESS;
2227 
2228 	monitor_ops = mon_soc->mon_ops;
2229 	if (!monitor_ops || !monitor_ops->mon_pdev_init) {
2230 		dp_mon_debug("callback not registered");
2231 		return QDF_STATUS_E_FAILURE;
2232 	}
2233 
2234 	return monitor_ops->mon_pdev_init(pdev);
2235 }
2236 
2237 /**
2238  * dp_monitor_pdev_deinit() - Monitor pdev deinit
2239  * @pdev: point to pdev
2240  *
2241  * Return: return QDF_STATUS
2242  */
dp_monitor_pdev_deinit(struct dp_pdev * pdev)2243 static inline QDF_STATUS dp_monitor_pdev_deinit(struct dp_pdev *pdev)
2244 {
2245 	struct dp_mon_ops *monitor_ops;
2246 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2247 
2248 	/*
2249 	 * mon_soc uninitialized modular when support enabled
2250 	 * monitor related attach/detach/init/deinit
2251 	 * will be done while monitor insmod
2252 	 */
2253 	if (!mon_soc)
2254 		return QDF_STATUS_SUCCESS;
2255 
2256 	monitor_ops = mon_soc->mon_ops;
2257 	if (!monitor_ops || !monitor_ops->mon_pdev_deinit) {
2258 		dp_mon_debug("callback not registered");
2259 		return QDF_STATUS_E_FAILURE;
2260 	}
2261 
2262 	return monitor_ops->mon_pdev_deinit(pdev);
2263 }
2264 
2265 /**
2266  * dp_monitor_soc_cfg_init() - Monitor sco cfg init
2267  * @soc: point to soc
2268  *
2269  * Return: return QDF_STATUS
2270  */
dp_monitor_soc_cfg_init(struct dp_soc * soc)2271 static inline QDF_STATUS dp_monitor_soc_cfg_init(struct dp_soc *soc)
2272 {
2273 	struct dp_mon_ops *monitor_ops;
2274 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2275 
2276 	/*
2277 	 * this API is getting call from dp_soc_init,
2278 	 * mon_soc will be uninitialized when monitor support enabled
2279 	 * So returning QDF_STATUS_SUCCESS.
2280 	 * soc cfg init will be done while monitor insmod.
2281 	 */
2282 	if (!mon_soc)
2283 		return QDF_STATUS_SUCCESS;
2284 
2285 	monitor_ops = mon_soc->mon_ops;
2286 	if (!monitor_ops || !monitor_ops->mon_soc_cfg_init) {
2287 		dp_mon_debug("callback not registered");
2288 		return QDF_STATUS_E_FAILURE;
2289 	}
2290 
2291 	return monitor_ops->mon_soc_cfg_init(soc);
2292 }
2293 
2294 /**
2295  * dp_monitor_config_debug_sniffer() - Monitor config debug sniffer
2296  * @pdev: point to pdev
2297  * @val: val
2298  *
2299  * Return: return QDF_STATUS
2300  */
dp_monitor_config_debug_sniffer(struct dp_pdev * pdev,int val)2301 static inline QDF_STATUS dp_monitor_config_debug_sniffer(struct dp_pdev *pdev,
2302 							 int val)
2303 {
2304 	struct dp_mon_ops *monitor_ops;
2305 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2306 
2307 	if (!mon_soc)
2308 		return QDF_STATUS_E_FAILURE;
2309 
2310 	monitor_ops = mon_soc->mon_ops;
2311 	if (!monitor_ops || !monitor_ops->mon_config_debug_sniffer) {
2312 		dp_mon_debug("callback not registered");
2313 		return QDF_STATUS_E_FAILURE;
2314 	}
2315 
2316 	return monitor_ops->mon_config_debug_sniffer(pdev, val);
2317 }
2318 
2319 /**
2320  * dp_monitor_flush_rings() - Flush monitor rings
2321  * @soc: point to soc
2322  *
2323  * Return: None
2324  */
dp_monitor_flush_rings(struct dp_soc * soc)2325 static inline void dp_monitor_flush_rings(struct dp_soc *soc)
2326 {
2327 	struct dp_mon_ops *monitor_ops;
2328 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2329 
2330 	if (!mon_soc) {
2331 		dp_mon_debug("monitor soc is NULL");
2332 		return;
2333 	}
2334 
2335 	monitor_ops = mon_soc->mon_ops;
2336 	if (!monitor_ops || !monitor_ops->mon_flush_rings) {
2337 		dp_mon_debug("callback not registered");
2338 		return;
2339 	}
2340 
2341 	return monitor_ops->mon_flush_rings(soc);
2342 }
2343 
2344 /**
2345  * dp_monitor_config_undecoded_metadata_capture() - Monitor config
2346  * undecoded metadata capture
2347  * @pdev: point to pdev
2348  * @val: val
2349  *
2350  * Return: return QDF_STATUS
2351  */
2352 #ifdef QCA_UNDECODED_METADATA_SUPPORT
2353 static inline
dp_monitor_config_undecoded_metadata_capture(struct dp_pdev * pdev,int val)2354 QDF_STATUS dp_monitor_config_undecoded_metadata_capture(struct dp_pdev *pdev,
2355 							int val)
2356 {
2357 	struct dp_mon_ops *monitor_ops;
2358 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2359 
2360 	if (!mon_soc)
2361 		return QDF_STATUS_E_FAILURE;
2362 
2363 	monitor_ops = mon_soc->mon_ops;
2364 	if (!monitor_ops ||
2365 	    !monitor_ops->mon_config_undecoded_metadata_capture) {
2366 		dp_mon_debug("callback not registered");
2367 		return QDF_STATUS_E_FAILURE;
2368 	}
2369 
2370 	return monitor_ops->mon_config_undecoded_metadata_capture(pdev, val);
2371 }
2372 
2373 static inline QDF_STATUS
dp_monitor_config_undecoded_metadata_phyrx_error_mask(struct dp_pdev * pdev,int mask,int mask_cont)2374 dp_monitor_config_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev,
2375 						      int mask, int mask_cont)
2376 {
2377 	struct dp_mon_ops *monitor_ops;
2378 	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
2379 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2380 
2381 	if (!mon_soc)
2382 		return QDF_STATUS_E_FAILURE;
2383 
2384 	if (!mon_pdev)
2385 		return QDF_STATUS_E_FAILURE;
2386 
2387 	monitor_ops = mon_soc->mon_ops;
2388 	if (!monitor_ops ||
2389 	    !monitor_ops->mon_config_undecoded_metadata_capture) {
2390 		dp_mon_debug("callback not registered");
2391 		return QDF_STATUS_E_FAILURE;
2392 	}
2393 
2394 	if (!mon_pdev->undecoded_metadata_capture) {
2395 		qdf_info("mask:0x%x mask_cont:0x%x", mask, mask_cont);
2396 		return QDF_STATUS_SUCCESS;
2397 	}
2398 
2399 	mon_pdev->phyrx_error_mask = mask;
2400 	mon_pdev->phyrx_error_mask_cont = mask_cont;
2401 
2402 	return monitor_ops->mon_config_undecoded_metadata_capture(pdev, 1);
2403 }
2404 
2405 static inline QDF_STATUS
dp_monitor_get_undecoded_metadata_phyrx_error_mask(struct dp_pdev * pdev,int * mask,int * mask_cont)2406 dp_monitor_get_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev,
2407 						   int *mask, int *mask_cont)
2408 {
2409 	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
2410 
2411 	if (!mon_pdev)
2412 		return QDF_STATUS_E_FAILURE;
2413 
2414 	*mask = mon_pdev->phyrx_error_mask;
2415 	*mask_cont = mon_pdev->phyrx_error_mask_cont;
2416 
2417 	return QDF_STATUS_SUCCESS;
2418 }
2419 #else
2420 static inline
dp_monitor_config_undecoded_metadata_capture(struct dp_pdev * pdev,int val)2421 QDF_STATUS dp_monitor_config_undecoded_metadata_capture(struct dp_pdev *pdev,
2422 							int val)
2423 {
2424 	return QDF_STATUS_SUCCESS;
2425 }
2426 
2427 static inline QDF_STATUS
dp_monitor_config_undecoded_metadata_phyrx_error_mask(struct dp_pdev * pdev,int mask1,int mask2)2428 dp_monitor_config_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev,
2429 						      int mask1, int mask2)
2430 {
2431 	return QDF_STATUS_SUCCESS;
2432 }
2433 
2434 static inline QDF_STATUS
dp_monitor_get_undecoded_metadata_phyrx_error_mask(struct dp_pdev * pdev,int * mask,int * mask_cont)2435 dp_monitor_get_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev,
2436 						   int *mask, int *mask_cont)
2437 {
2438 	return QDF_STATUS_SUCCESS;
2439 }
2440 #endif /* QCA_UNDECODED_METADATA_SUPPORT */
2441 
2442 /**
2443  * dp_monitor_htt_srng_setup() - Setup htt srng
2444  * @soc: point to soc
2445  * @pdev: point to pdev
2446  * @mac_id: lmac id
2447  * @mac_for_pdev: pdev id
2448  *
2449  * Return: QDF_STATUS
2450  */
2451 #if !defined(DISABLE_MON_CONFIG)
dp_monitor_htt_srng_setup(struct dp_soc * soc,struct dp_pdev * pdev,int mac_id,int mac_for_pdev)2452 static inline QDF_STATUS dp_monitor_htt_srng_setup(struct dp_soc *soc,
2453 						   struct dp_pdev *pdev,
2454 						   int mac_id,
2455 						   int mac_for_pdev)
2456 {
2457 	struct dp_mon_ops *monitor_ops;
2458 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2459 	QDF_STATUS status = QDF_STATUS_SUCCESS;
2460 
2461 	if (!mon_soc) {
2462 		dp_mon_debug("monitor soc is NULL");
2463 		return QDF_STATUS_SUCCESS;
2464 	}
2465 
2466 	monitor_ops = mon_soc->mon_ops;
2467 	if (!monitor_ops) {
2468 		dp_mon_err("monitor_ops is NULL");
2469 		return QDF_STATUS_E_FAILURE;
2470 	}
2471 
2472 	if (monitor_ops->mon_pdev_htt_srng_setup[0]) {
2473 		status = monitor_ops->mon_pdev_htt_srng_setup[0](soc, pdev,
2474 							mac_id, mac_for_pdev);
2475 		if (QDF_IS_STATUS_ERROR(status)) {
2476 			dp_mon_err("error: %d", status);
2477 			goto error;
2478 		}
2479 	}
2480 
2481 	if (monitor_ops->mon_pdev_htt_srng_setup[1]) {
2482 		status = monitor_ops->mon_pdev_htt_srng_setup[1](soc, pdev,
2483 							mac_id, mac_for_pdev);
2484 		if (QDF_IS_STATUS_ERROR(status)) {
2485 			dp_mon_err("error: %d", status);
2486 			goto error;
2487 		}
2488 	}
2489 
2490 error:
2491 	return status;
2492 }
2493 
dp_monitor_soc_htt_srng_setup(struct dp_soc * soc)2494 static inline QDF_STATUS dp_monitor_soc_htt_srng_setup(struct dp_soc *soc)
2495 {
2496 	struct dp_mon_ops *monitor_ops;
2497 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2498 
2499 	if (!mon_soc) {
2500 		dp_mon_debug("monitor soc is NULL");
2501 		return QDF_STATUS_SUCCESS;
2502 	}
2503 
2504 	monitor_ops = mon_soc->mon_ops;
2505 	if (!monitor_ops || !monitor_ops->mon_soc_htt_srng_setup) {
2506 		dp_mon_debug("callback not registered");
2507 		return QDF_STATUS_E_FAILURE;
2508 	}
2509 
2510 	return monitor_ops->mon_soc_htt_srng_setup(soc);
2511 }
2512 #else
dp_monitor_htt_srng_setup(struct dp_soc * soc,struct dp_pdev * pdev,int mac_id,int mac_for_pdev)2513 static inline QDF_STATUS dp_monitor_htt_srng_setup(struct dp_soc *soc,
2514 						   struct dp_pdev *pdev,
2515 						   int mac_id,
2516 						   int mac_for_pdev)
2517 {
2518 	return QDF_STATUS_SUCCESS;
2519 }
2520 #endif
2521 
2522 /**
2523  * dp_monitor_service_mon_rings() - service monitor rings
2524  * @soc: point to soc
2525  * @quota: reap budget
2526  *
2527  * Return: None
2528  */
2529 #if defined(DP_CON_MON)
2530 static inline
dp_monitor_service_mon_rings(struct dp_soc * soc,uint32_t quota)2531 void dp_monitor_service_mon_rings(struct dp_soc *soc, uint32_t quota)
2532 {
2533 	struct dp_mon_ops *monitor_ops;
2534 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2535 
2536 	if (!mon_soc) {
2537 		dp_mon_debug("monitor soc is NULL");
2538 		return;
2539 	}
2540 
2541 	monitor_ops = mon_soc->mon_ops;
2542 	if (!monitor_ops || !monitor_ops->mon_service_rings) {
2543 		dp_mon_debug("callback not registered");
2544 		return;
2545 	}
2546 
2547 	return monitor_ops->mon_service_rings(soc, quota);
2548 }
2549 #endif
2550 
2551 /**
2552  * dp_monitor_process() - Process monitor
2553  * @soc: point to soc
2554  * @int_ctx: interrupt ctx
2555  * @mac_id: lma
2556  * @quota:
2557  *
2558  * Return: None
2559  */
2560 #ifndef DISABLE_MON_CONFIG
2561 static inline
dp_monitor_process(struct dp_soc * soc,struct dp_intr * int_ctx,uint32_t mac_id,uint32_t quota)2562 uint32_t dp_monitor_process(struct dp_soc *soc, struct dp_intr *int_ctx,
2563 			       uint32_t mac_id, uint32_t quota)
2564 {
2565 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2566 
2567 	if (!mon_soc) {
2568 		dp_mon_debug("monitor soc is NULL");
2569 		return 0;
2570 	}
2571 
2572 	if (!mon_soc->mon_rx_process) {
2573 		dp_mon_debug("callback not registered");
2574 		return 0;
2575 	}
2576 
2577 	return mon_soc->mon_rx_process(soc, int_ctx, mac_id, quota);
2578 }
2579 
2580 static inline
dp_tx_mon_process(struct dp_soc * soc,struct dp_intr * int_ctx,uint32_t mac_id,uint32_t quota)2581 uint32_t dp_tx_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx,
2582 			   uint32_t mac_id, uint32_t quota)
2583 {
2584 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2585 	struct dp_mon_ops *monitor_ops;
2586 
2587 	if (!mon_soc) {
2588 		dp_mon_debug("monitor soc is NULL");
2589 		return 0;
2590 	}
2591 
2592 	monitor_ops = mon_soc->mon_ops;
2593 	if (!monitor_ops || !monitor_ops->mon_tx_process) {
2594 		dp_mon_debug("callback not registered");
2595 		return 0;
2596 	}
2597 
2598 	return monitor_ops->mon_tx_process(soc, int_ctx, mac_id, quota);
2599 }
2600 
2601 static inline
dp_tx_mon_buf_refill(struct dp_intr * int_ctx)2602 uint32_t dp_tx_mon_buf_refill(struct dp_intr *int_ctx)
2603 {
2604 	struct dp_soc *soc = int_ctx->soc;
2605 	struct dp_mon_ops *monitor_ops;
2606 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2607 
2608 	if (!mon_soc) {
2609 		dp_mon_debug("monitor soc is NULL");
2610 		return 0;
2611 	}
2612 
2613 	monitor_ops = mon_soc->mon_ops;
2614 	if (!monitor_ops || !monitor_ops->tx_mon_refill_buf_ring) {
2615 		dp_mon_debug("callback not registered");
2616 		return 0;
2617 	}
2618 
2619 	return monitor_ops->tx_mon_refill_buf_ring(int_ctx);
2620 }
2621 
2622 static inline
dp_rx_mon_buf_refill(struct dp_intr * int_ctx)2623 uint32_t dp_rx_mon_buf_refill(struct dp_intr *int_ctx)
2624 {
2625 	struct dp_soc *soc = int_ctx->soc;
2626 	struct dp_mon_ops *monitor_ops;
2627 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2628 
2629 	if (!mon_soc) {
2630 		dp_mon_debug("monitor soc is NULL");
2631 		return 0;
2632 	}
2633 
2634 	monitor_ops = mon_soc->mon_ops;
2635 	if (!monitor_ops || !monitor_ops->rx_mon_refill_buf_ring) {
2636 		dp_mon_debug("callback not registered");
2637 		return 0;
2638 	}
2639 
2640 	return monitor_ops->rx_mon_refill_buf_ring(int_ctx);
2641 }
2642 
2643 static inline
dp_print_txmon_ring_stat_from_hal(struct dp_pdev * pdev)2644 void dp_print_txmon_ring_stat_from_hal(struct dp_pdev *pdev)
2645 {
2646 	struct dp_soc *soc = pdev->soc;
2647 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2648 	struct dp_mon_ops *monitor_ops;
2649 
2650 	if (!mon_soc) {
2651 		dp_mon_debug("monitor soc is NULL");
2652 		return;
2653 	}
2654 
2655 	monitor_ops = mon_soc->mon_ops;
2656 	if (!monitor_ops || !monitor_ops->print_txmon_ring_stat) {
2657 		dp_mon_debug("callback not registered");
2658 		return;
2659 	}
2660 
2661 	monitor_ops->print_txmon_ring_stat(pdev);
2662 }
2663 
2664 #else
2665 static inline
dp_monitor_process(struct dp_soc * soc,struct dp_intr * int_ctx,uint32_t mac_id,uint32_t quota)2666 uint32_t dp_monitor_process(struct dp_soc *soc, struct dp_intr *int_ctx,
2667 			       uint32_t mac_id, uint32_t quota)
2668 {
2669 	return 0;
2670 }
2671 
2672 static inline uint32_t
dp_tx_mon_process(struct dp_soc * soc,struct dp_intr * int_ctx,uint32_t mac_id,uint32_t quota)2673 dp_tx_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx,
2674 		  uint32_t mac_id, uint32_t quota)
2675 {
2676 	return 0;
2677 }
2678 
2679 static inline
dp_tx_mon_buf_refill(struct dp_intr * int_ctx)2680 uint32_t dp_tx_mon_buf_refill(struct dp_intr *int_ctx)
2681 {
2682 	return 0;
2683 }
2684 
2685 static inline
dp_rx_mon_buf_refill(struct dp_intr * int_ctx)2686 uint32_t dp_rx_mon_buf_refill(struct dp_intr *int_ctx)
2687 {
2688 	return 0;
2689 }
2690 
2691 static inline
dp_print_txmon_ring_stat_from_hal(struct dp_pdev * pdev)2692 void dp_print_txmon_ring_stat_from_hal(struct dp_pdev *pdev)
2693 {
2694 }
2695 #endif
2696 
2697 /**
2698  * dp_monitor_drop_packets_for_mac() - monitor_drop_packets_for_mac
2699  * @pdev: point to pdev
2700  * @mac_id:
2701  * @quota:
2702  *
2703  * Return:
2704  */
2705 #if !defined(DISABLE_MON_CONFIG) && defined(MON_ENABLE_DROP_FOR_MAC)
2706 static inline
dp_monitor_drop_packets_for_mac(struct dp_pdev * pdev,uint32_t mac_id,uint32_t quota)2707 uint32_t dp_monitor_drop_packets_for_mac(struct dp_pdev *pdev,
2708 					 uint32_t mac_id, uint32_t quota)
2709 {
2710 	struct dp_mon_ops *monitor_ops;
2711 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2712 
2713 	if (!mon_soc) {
2714 		dp_mon_debug("monitor soc is NULL");
2715 		return 0;
2716 	}
2717 
2718 	monitor_ops = mon_soc->mon_ops;
2719 	if (!monitor_ops || !monitor_ops->mon_drop_packets_for_mac) {
2720 		dp_mon_debug("callback not registered");
2721 		return 0;
2722 	}
2723 
2724 	return monitor_ops->mon_drop_packets_for_mac(pdev,
2725 						     mac_id, quota, false);
2726 }
2727 #else
2728 static inline
dp_monitor_drop_packets_for_mac(struct dp_pdev * pdev,uint32_t mac_id,uint32_t quota)2729 uint32_t dp_monitor_drop_packets_for_mac(struct dp_pdev *pdev,
2730 					 uint32_t mac_id, uint32_t quota)
2731 {
2732 	return 0;
2733 }
2734 #endif
2735 
2736 /**
2737  * dp_monitor_peer_tx_init() - peer tx init
2738  * @pdev: point to pdev
2739  * @peer: point to peer
2740  *
2741  * Return: None
2742  */
dp_monitor_peer_tx_init(struct dp_pdev * pdev,struct dp_peer * peer)2743 static inline void dp_monitor_peer_tx_init(struct dp_pdev *pdev,
2744 					   struct dp_peer *peer)
2745 {
2746 	struct dp_mon_ops *monitor_ops;
2747 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2748 
2749 	if (!mon_soc) {
2750 		dp_mon_debug("monitor soc is NULL");
2751 		return;
2752 	}
2753 
2754 	monitor_ops = mon_soc->mon_ops;
2755 	if (!monitor_ops || !monitor_ops->mon_peer_tx_init) {
2756 		dp_mon_debug("callback not registered");
2757 		return;
2758 	}
2759 
2760 	return monitor_ops->mon_peer_tx_init(pdev, peer);
2761 }
2762 
2763 /**
2764  * dp_monitor_peer_tx_cleanup() - peer tx cleanup
2765  * @vdev: point to vdev
2766  * @peer: point to peer
2767  *
2768  * Return: None
2769  */
dp_monitor_peer_tx_cleanup(struct dp_vdev * vdev,struct dp_peer * peer)2770 static inline void dp_monitor_peer_tx_cleanup(struct dp_vdev *vdev,
2771 					      struct dp_peer *peer)
2772 {
2773 	struct dp_mon_ops *monitor_ops;
2774 	struct dp_mon_soc *mon_soc = vdev->pdev->soc->monitor_soc;
2775 
2776 	if (!mon_soc) {
2777 		dp_mon_debug("monitor soc is NULL");
2778 		return;
2779 	}
2780 
2781 	monitor_ops = mon_soc->mon_ops;
2782 	if (!monitor_ops || !monitor_ops->mon_peer_tx_cleanup) {
2783 		dp_mon_debug("callback not registered");
2784 		return;
2785 	}
2786 
2787 	return monitor_ops->mon_peer_tx_cleanup(vdev, peer);
2788 }
2789 
2790 #ifdef WIFI_MONITOR_SUPPORT
2791 /**
2792  * dp_monitor_peer_tid_peer_id_update() - peer tid update
2793  * @soc: point to soc
2794  * @peer: point to peer
2795  * @peer_id: peer id
2796  *
2797  * Return: None
2798  */
2799 static inline
dp_monitor_peer_tid_peer_id_update(struct dp_soc * soc,struct dp_peer * peer,uint16_t peer_id)2800 void dp_monitor_peer_tid_peer_id_update(struct dp_soc *soc,
2801 					struct dp_peer *peer,
2802 					uint16_t peer_id)
2803 {
2804 	struct dp_mon_ops *monitor_ops;
2805 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2806 
2807 	if (!mon_soc) {
2808 		dp_mon_debug("monitor soc is NULL");
2809 		return;
2810 	}
2811 
2812 	monitor_ops = mon_soc->mon_ops;
2813 	if (!monitor_ops || !monitor_ops->mon_peer_tid_peer_id_update) {
2814 		dp_mon_debug("callback not registered");
2815 		return;
2816 	}
2817 
2818 	return monitor_ops->mon_peer_tid_peer_id_update(peer, peer_id);
2819 }
2820 
2821 /**
2822  * dp_monitor_tx_ppdu_stats_attach() - Attach tx ppdu stats
2823  * @pdev: point to pdev
2824  *
2825  * Return: None
2826  */
dp_monitor_tx_ppdu_stats_attach(struct dp_pdev * pdev)2827 static inline void dp_monitor_tx_ppdu_stats_attach(struct dp_pdev *pdev)
2828 {
2829 	struct dp_mon_ops *monitor_ops;
2830 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2831 
2832 	if (!mon_soc) {
2833 		dp_mon_debug("monitor soc is NULL");
2834 		return;
2835 	}
2836 
2837 	monitor_ops = mon_soc->mon_ops;
2838 	if (!monitor_ops || !monitor_ops->mon_tx_ppdu_stats_attach) {
2839 		dp_mon_debug("callback not registered");
2840 		return;
2841 	}
2842 
2843 	return monitor_ops->mon_tx_ppdu_stats_attach(pdev);
2844 }
2845 
2846 /**
2847  * dp_monitor_tx_ppdu_stats_detach() - Detach tx ppdu stats
2848  * @pdev: point to pdev
2849  *
2850  * Return: None
2851  */
dp_monitor_tx_ppdu_stats_detach(struct dp_pdev * pdev)2852 static inline void dp_monitor_tx_ppdu_stats_detach(struct dp_pdev *pdev)
2853 {
2854 	struct dp_mon_ops *monitor_ops;
2855 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2856 
2857 	if (!mon_soc) {
2858 		dp_mon_debug("monitor soc is NULL");
2859 		return;
2860 	}
2861 
2862 	monitor_ops = mon_soc->mon_ops;
2863 	if (!monitor_ops || !monitor_ops->mon_tx_ppdu_stats_detach) {
2864 		dp_mon_debug("callback not registered");
2865 		return;
2866 	}
2867 
2868 	return monitor_ops->mon_tx_ppdu_stats_detach(pdev);
2869 }
2870 
2871 /**
2872  * dp_monitor_tx_capture_debugfs_init() - Init tx capture debugfs
2873  * @pdev: point to pdev
2874  *
2875  * Return: QDF_STATUS_SUCCESS
2876  */
2877 static inline
dp_monitor_tx_capture_debugfs_init(struct dp_pdev * pdev)2878 QDF_STATUS dp_monitor_tx_capture_debugfs_init(struct dp_pdev *pdev)
2879 {
2880 	struct dp_mon_ops *monitor_ops;
2881 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2882 
2883 	if (!mon_soc) {
2884 		dp_mon_debug("monitor soc is NULL");
2885 		return QDF_STATUS_E_FAILURE;
2886 	}
2887 
2888 	monitor_ops = mon_soc->mon_ops;
2889 	if (!monitor_ops || !monitor_ops->mon_tx_capture_debugfs_init) {
2890 		dp_mon_debug("callback not registered");
2891 		return QDF_STATUS_E_FAILURE;
2892 	}
2893 
2894 	return monitor_ops->mon_tx_capture_debugfs_init(pdev);
2895 }
2896 
2897 /**
2898  * dp_monitor_peer_tx_capture_filter_check() - Check tx capture filter
2899  * @pdev: point to pdev
2900  * @peer: point to peer
2901  *
2902  * Return: None
2903  */
dp_monitor_peer_tx_capture_filter_check(struct dp_pdev * pdev,struct dp_peer * peer)2904 static inline void dp_monitor_peer_tx_capture_filter_check(struct dp_pdev *pdev,
2905 							   struct dp_peer *peer)
2906 {
2907 	struct dp_mon_ops *monitor_ops;
2908 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
2909 
2910 	if (!mon_soc) {
2911 		dp_mon_debug("monitor soc is NULL");
2912 		return;
2913 	}
2914 
2915 	monitor_ops = mon_soc->mon_ops;
2916 	if (!monitor_ops || !monitor_ops->mon_peer_tx_capture_filter_check) {
2917 		dp_mon_debug("callback not registered");
2918 		return;
2919 	}
2920 
2921 	return monitor_ops->mon_peer_tx_capture_filter_check(pdev, peer);
2922 }
2923 
2924 /**
2925  * dp_monitor_tx_add_to_comp_queue() - add completion msdu to queue
2926  *
2927  * This API returns QDF_STATUS_SUCCESS in case where buffer is added
2928  * to txmonitor queue successfully caller will not free the buffer in
2929  * this case. In other cases this API return QDF_STATUS_E_FAILURE and
2930  * caller frees the buffer
2931  *
2932  * @soc: point to soc
2933  * @desc: point to tx desc
2934  * @ts: Tx completion status from HAL/HTT descriptor
2935  * @peer_id: DP peer id
2936  *
2937  * Return: QDF_STATUS
2938  *
2939  */
2940 static inline
dp_monitor_tx_add_to_comp_queue(struct dp_soc * soc,struct dp_tx_desc_s * desc,struct hal_tx_completion_status * ts,uint16_t peer_id)2941 QDF_STATUS dp_monitor_tx_add_to_comp_queue(struct dp_soc *soc,
2942 					   struct dp_tx_desc_s *desc,
2943 					   struct hal_tx_completion_status *ts,
2944 					   uint16_t peer_id)
2945 {
2946 	struct dp_mon_ops *monitor_ops;
2947 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2948 
2949 	if (!mon_soc) {
2950 		dp_mon_debug("monitor soc is NULL");
2951 		return QDF_STATUS_E_FAILURE;
2952 	}
2953 
2954 	monitor_ops = mon_soc->mon_ops;
2955 	if (!monitor_ops || !monitor_ops->mon_tx_add_to_comp_queue) {
2956 		dp_mon_debug("callback not registered");
2957 		return QDF_STATUS_E_FAILURE;
2958 	}
2959 
2960 	return monitor_ops->mon_tx_add_to_comp_queue(soc, desc, ts, peer_id);
2961 }
2962 
2963 static inline
monitor_update_msdu_to_list(struct dp_soc * soc,struct dp_pdev * pdev,struct dp_peer * peer,struct hal_tx_completion_status * ts,qdf_nbuf_t netbuf)2964 QDF_STATUS monitor_update_msdu_to_list(struct dp_soc *soc,
2965 				       struct dp_pdev *pdev,
2966 				       struct dp_peer *peer,
2967 				       struct hal_tx_completion_status *ts,
2968 				       qdf_nbuf_t netbuf)
2969 {
2970 	struct dp_mon_ops *monitor_ops;
2971 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
2972 
2973 	if (!mon_soc) {
2974 		dp_mon_debug("monitor soc is NULL");
2975 		return QDF_STATUS_SUCCESS;
2976 	}
2977 
2978 	monitor_ops = mon_soc->mon_ops;
2979 	if (!monitor_ops || !monitor_ops->mon_update_msdu_to_list) {
2980 		dp_mon_debug("callback not registered");
2981 		return QDF_STATUS_E_FAILURE;
2982 	}
2983 
2984 	return monitor_ops->mon_update_msdu_to_list(soc, pdev,
2985 						    peer, ts, netbuf);
2986 }
2987 
2988 /**
2989  * dp_monitor_peer_tx_capture_get_stats - to get Peer Tx Capture stats
2990  * @soc: DP SOC handle
2991  * @peer: DP PEER handle
2992  * @stats: Pointer Peer tx capture stats
2993  *
2994  * Return: QDF_STATUS_E_FAILURE or QDF_STATUS_SUCCESS
2995  */
2996 static inline QDF_STATUS
dp_monitor_peer_tx_capture_get_stats(struct dp_soc * soc,struct dp_peer * peer,struct cdp_peer_tx_capture_stats * stats)2997 dp_monitor_peer_tx_capture_get_stats(struct dp_soc *soc, struct dp_peer *peer,
2998 				     struct cdp_peer_tx_capture_stats *stats)
2999 {
3000 	struct dp_mon_ops *monitor_ops;
3001 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3002 
3003 	if (!mon_soc) {
3004 		dp_mon_debug("monitor soc is NULL");
3005 		return QDF_STATUS_E_FAILURE;
3006 	}
3007 
3008 	monitor_ops = mon_soc->mon_ops;
3009 	if (!monitor_ops || !monitor_ops->mon_peer_tx_capture_get_stats) {
3010 		dp_mon_debug("callback not registered");
3011 		return QDF_STATUS_E_FAILURE;
3012 	}
3013 
3014 	return monitor_ops->mon_peer_tx_capture_get_stats(peer, stats);
3015 }
3016 
3017 /**
3018  * dp_monitor_pdev_tx_capture_get_stats - to get pdev tx capture stats
3019  * @soc: DP SOC handle
3020  * @pdev: DP PDEV handle
3021  * @stats: Pointer to pdev tx capture stats
3022  *
3023  * Return: QDF_STATUS_E_FAILURE or QDF_STATUS_SUCCESS
3024  */
3025 static inline QDF_STATUS
dp_monitor_pdev_tx_capture_get_stats(struct dp_soc * soc,struct dp_pdev * pdev,struct cdp_pdev_tx_capture_stats * stats)3026 dp_monitor_pdev_tx_capture_get_stats(struct dp_soc *soc, struct dp_pdev *pdev,
3027 				     struct cdp_pdev_tx_capture_stats *stats)
3028 {
3029 	struct dp_mon_ops *monitor_ops;
3030 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3031 
3032 	if (!mon_soc) {
3033 		dp_mon_debug("monitor soc is NULL");
3034 		return QDF_STATUS_E_FAILURE;
3035 	}
3036 
3037 	monitor_ops = mon_soc->mon_ops;
3038 	if (!monitor_ops || !monitor_ops->mon_pdev_tx_capture_get_stats) {
3039 		dp_mon_debug("callback not registered");
3040 		return QDF_STATUS_E_FAILURE;
3041 	}
3042 
3043 	return monitor_ops->mon_pdev_tx_capture_get_stats(pdev, stats);
3044 }
3045 #else
3046 static inline
dp_monitor_peer_tid_peer_id_update(struct dp_soc * soc,struct dp_peer * peer,uint16_t peer_id)3047 void dp_monitor_peer_tid_peer_id_update(struct dp_soc *soc,
3048 					struct dp_peer *peer,
3049 					uint16_t peer_id)
3050 {
3051 }
3052 
dp_monitor_tx_ppdu_stats_attach(struct dp_pdev * pdev)3053 static inline void dp_monitor_tx_ppdu_stats_attach(struct dp_pdev *pdev)
3054 {
3055 }
3056 
dp_monitor_tx_ppdu_stats_detach(struct dp_pdev * pdev)3057 static inline void dp_monitor_tx_ppdu_stats_detach(struct dp_pdev *pdev)
3058 {
3059 }
3060 
3061 static inline
dp_monitor_tx_capture_debugfs_init(struct dp_pdev * pdev)3062 QDF_STATUS dp_monitor_tx_capture_debugfs_init(struct dp_pdev *pdev)
3063 {
3064 	return QDF_STATUS_E_FAILURE;
3065 }
3066 
dp_monitor_peer_tx_capture_filter_check(struct dp_pdev * pdev,struct dp_peer * peer)3067 static inline void dp_monitor_peer_tx_capture_filter_check(struct dp_pdev *pdev,
3068 							   struct dp_peer *peer)
3069 {
3070 }
3071 
3072 static inline
dp_monitor_tx_add_to_comp_queue(struct dp_soc * soc,struct dp_tx_desc_s * desc,struct hal_tx_completion_status * ts,uint16_t peer_id)3073 QDF_STATUS dp_monitor_tx_add_to_comp_queue(struct dp_soc *soc,
3074 					   struct dp_tx_desc_s *desc,
3075 					   struct hal_tx_completion_status *ts,
3076 					   uint16_t peer_id)
3077 {
3078 	return QDF_STATUS_E_FAILURE;
3079 }
3080 
3081 static inline
monitor_update_msdu_to_list(struct dp_soc * soc,struct dp_pdev * pdev,struct dp_peer * peer,struct hal_tx_completion_status * ts,qdf_nbuf_t netbuf)3082 QDF_STATUS monitor_update_msdu_to_list(struct dp_soc *soc,
3083 				       struct dp_pdev *pdev,
3084 				       struct dp_peer *peer,
3085 				       struct hal_tx_completion_status *ts,
3086 				       qdf_nbuf_t netbuf)
3087 {
3088 	return QDF_STATUS_E_FAILURE;
3089 }
3090 
3091 static inline QDF_STATUS
dp_monitor_peer_tx_capture_get_stats(struct dp_soc * soc,struct dp_peer * peer,struct cdp_peer_tx_capture_stats * stats)3092 dp_monitor_peer_tx_capture_get_stats(struct dp_soc *soc, struct dp_peer *peer,
3093 				     struct cdp_peer_tx_capture_stats *stats)
3094 {
3095 	return QDF_STATUS_E_FAILURE;
3096 }
3097 
3098 static inline QDF_STATUS
dp_monitor_pdev_tx_capture_get_stats(struct dp_soc * soc,struct dp_pdev * pdev,struct cdp_pdev_tx_capture_stats * stats)3099 dp_monitor_pdev_tx_capture_get_stats(struct dp_soc *soc, struct dp_pdev *pdev,
3100 				     struct cdp_pdev_tx_capture_stats *stats)
3101 {
3102 	return QDF_STATUS_E_FAILURE;
3103 }
3104 #endif
3105 
3106 /**
3107  * dp_monitor_ppdu_stats_ind_handler() - PPDU stats msg handler
3108  * @soc:     HTT SOC handle
3109  * @msg_word:    Pointer to payload
3110  * @htt_t2h_msg: HTT msg nbuf
3111  *
3112  * Return: True if buffer should be freed by caller.
3113  */
3114 #if defined(WDI_EVENT_ENABLE) &&\
3115 	(defined(QCA_ENHANCED_STATS_SUPPORT) || !defined(REMOVE_PKT_LOG) ||\
3116 	 defined(WLAN_FEATURE_PKT_CAPTURE_V2))
dp_monitor_ppdu_stats_ind_handler(struct htt_soc * soc,uint32_t * msg_word,qdf_nbuf_t htt_t2h_msg)3117 static inline bool dp_monitor_ppdu_stats_ind_handler(struct htt_soc *soc,
3118 						     uint32_t *msg_word,
3119 						     qdf_nbuf_t htt_t2h_msg)
3120 {
3121 	struct dp_mon_ops *monitor_ops;
3122 	struct dp_mon_soc *mon_soc = soc->dp_soc->monitor_soc;
3123 
3124 	if (!mon_soc) {
3125 		dp_mon_debug("monitor soc is NULL");
3126 		return true;
3127 	}
3128 
3129 	monitor_ops = mon_soc->mon_ops;
3130 	if (!monitor_ops || !monitor_ops->mon_ppdu_stats_ind_handler) {
3131 		dp_mon_debug("callback not registered");
3132 		return true;
3133 	}
3134 
3135 	return monitor_ops->mon_ppdu_stats_ind_handler(soc, msg_word,
3136 						       htt_t2h_msg);
3137 }
3138 #else
dp_monitor_ppdu_stats_ind_handler(struct htt_soc * soc,uint32_t * msg_word,qdf_nbuf_t htt_t2h_msg)3139 static inline bool dp_monitor_ppdu_stats_ind_handler(struct htt_soc *soc,
3140 						     uint32_t *msg_word,
3141 						     qdf_nbuf_t htt_t2h_msg)
3142 {
3143 	return true;
3144 }
3145 #endif
3146 
3147 /**
3148  * dp_monitor_htt_ppdu_stats_attach() - attach resources for HTT PPDU
3149  * stats processing
3150  * @pdev: Datapath PDEV handle
3151  *
3152  * Return: QDF_STATUS
3153  */
dp_monitor_htt_ppdu_stats_attach(struct dp_pdev * pdev)3154 static inline QDF_STATUS dp_monitor_htt_ppdu_stats_attach(struct dp_pdev *pdev)
3155 {
3156 	struct dp_mon_ops *monitor_ops;
3157 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3158 
3159 	if (!mon_soc) {
3160 		dp_mon_debug("monitor soc is NULL");
3161 		return QDF_STATUS_SUCCESS;
3162 	}
3163 
3164 	monitor_ops = mon_soc->mon_ops;
3165 	if (!monitor_ops || !monitor_ops->mon_htt_ppdu_stats_attach) {
3166 		dp_mon_debug("callback not registered");
3167 		return QDF_STATUS_E_FAILURE;
3168 	}
3169 
3170 	return monitor_ops->mon_htt_ppdu_stats_attach(pdev);
3171 }
3172 
3173 /**
3174  * dp_monitor_htt_ppdu_stats_detach() - detach stats resources
3175  * @pdev: Datapath PDEV handle
3176  *
3177  * Return: void
3178  */
dp_monitor_htt_ppdu_stats_detach(struct dp_pdev * pdev)3179 static inline void dp_monitor_htt_ppdu_stats_detach(struct dp_pdev *pdev)
3180 {
3181 	struct dp_mon_ops *monitor_ops;
3182 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3183 
3184 	if (!mon_soc) {
3185 		dp_mon_debug("monitor soc is NULL");
3186 		return;
3187 	}
3188 
3189 	monitor_ops = mon_soc->mon_ops;
3190 	if (!monitor_ops || !monitor_ops->mon_htt_ppdu_stats_detach) {
3191 		dp_mon_debug("callback not registered");
3192 		return;
3193 	}
3194 
3195 	return monitor_ops->mon_htt_ppdu_stats_detach(pdev);
3196 }
3197 
3198 /**
3199  * dp_monitor_print_pdev_rx_mon_stats() - print rx mon stats
3200  * @pdev: Datapath PDEV handle
3201  *
3202  * Return: void
3203  */
dp_monitor_print_pdev_rx_mon_stats(struct dp_pdev * pdev)3204 static inline void dp_monitor_print_pdev_rx_mon_stats(struct dp_pdev *pdev)
3205 {
3206 	struct dp_mon_ops *monitor_ops;
3207 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3208 
3209 	if (!mon_soc) {
3210 		dp_mon_debug("monitor soc is NULL");
3211 		return;
3212 	}
3213 
3214 	monitor_ops = mon_soc->mon_ops;
3215 	if (!monitor_ops || !monitor_ops->mon_print_pdev_rx_mon_stats) {
3216 		dp_mon_debug("callback not registered");
3217 		return;
3218 	}
3219 
3220 	return monitor_ops->mon_print_pdev_rx_mon_stats(pdev);
3221 }
3222 
3223 #ifdef WIFI_MONITOR_SUPPORT
3224 /**
3225  * dp_monitor_print_pdev_tx_capture_stats() - print tx capture stats
3226  * @pdev: Datapath PDEV handle
3227  *
3228  * Return: void
3229  */
dp_monitor_print_pdev_tx_capture_stats(struct dp_pdev * pdev)3230 static inline void dp_monitor_print_pdev_tx_capture_stats(struct dp_pdev *pdev)
3231 {
3232 	struct dp_mon_ops *monitor_ops;
3233 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3234 
3235 	if (!mon_soc) {
3236 		dp_mon_debug("monitor soc is NULL");
3237 		return;
3238 	}
3239 
3240 	monitor_ops = mon_soc->mon_ops;
3241 	if (!monitor_ops || !monitor_ops->mon_print_pdev_tx_capture_stats) {
3242 		dp_mon_debug("callback not registered");
3243 		return;
3244 	}
3245 
3246 	return monitor_ops->mon_print_pdev_tx_capture_stats(pdev);
3247 }
3248 
3249 /**
3250  * dp_monitor_config_enh_tx_capture() - configure tx capture
3251  * @pdev: Datapath PDEV handle
3252  * @val: mode
3253  *
3254  * Return: status
3255  */
dp_monitor_config_enh_tx_capture(struct dp_pdev * pdev,uint32_t val)3256 static inline QDF_STATUS dp_monitor_config_enh_tx_capture(struct dp_pdev *pdev,
3257 							  uint32_t val)
3258 {
3259 	struct dp_mon_ops *monitor_ops;
3260 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3261 
3262 	if (!mon_soc) {
3263 		dp_mon_debug("monitor soc is NULL");
3264 		return QDF_STATUS_E_FAILURE;
3265 	}
3266 
3267 	monitor_ops = mon_soc->mon_ops;
3268 	if (!monitor_ops || !monitor_ops->mon_config_enh_tx_capture) {
3269 		dp_mon_debug("callback not registered");
3270 		return QDF_STATUS_E_FAILURE;
3271 	}
3272 
3273 	return monitor_ops->mon_config_enh_tx_capture(pdev, val);
3274 }
3275 
3276 /**
3277  * dp_monitor_tx_peer_filter() -  add tx monitor peer filter
3278  * @pdev: Datapath PDEV handle
3279  * @peer: Datapath PEER handle
3280  * @is_tx_pkt_cap_enable: flag for tx capture enable/disable
3281  * @peer_mac: peer mac address
3282  *
3283  * Return: status
3284  */
dp_monitor_tx_peer_filter(struct dp_pdev * pdev,struct dp_peer * peer,uint8_t is_tx_pkt_cap_enable,uint8_t * peer_mac)3285 static inline QDF_STATUS dp_monitor_tx_peer_filter(struct dp_pdev *pdev,
3286 						   struct dp_peer *peer,
3287 						   uint8_t is_tx_pkt_cap_enable,
3288 						   uint8_t *peer_mac)
3289 {
3290 	struct dp_mon_ops *monitor_ops;
3291 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3292 
3293 	if (!mon_soc) {
3294 		qdf_err("monitor soc is NULL");
3295 		return QDF_STATUS_E_FAILURE;
3296 	}
3297 
3298 	monitor_ops = mon_soc->mon_ops;
3299 	if (!monitor_ops || !monitor_ops->mon_tx_peer_filter) {
3300 		qdf_err("callback not registered");
3301 		return QDF_STATUS_E_FAILURE;
3302 	}
3303 
3304 	return monitor_ops->mon_tx_peer_filter(pdev, peer, is_tx_pkt_cap_enable,
3305 					       peer_mac);
3306 }
3307 #endif
3308 
3309 #ifdef WLAN_RX_PKT_CAPTURE_ENH
dp_monitor_config_enh_rx_capture(struct dp_pdev * pdev,uint32_t val)3310 static inline QDF_STATUS dp_monitor_config_enh_rx_capture(struct dp_pdev *pdev,
3311 							  uint32_t val)
3312 {
3313 	struct dp_mon_ops *monitor_ops;
3314 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3315 
3316 	if (!mon_soc) {
3317 		dp_mon_debug("monitor soc is NULL");
3318 		return QDF_STATUS_E_FAILURE;
3319 	}
3320 
3321 	monitor_ops = mon_soc->mon_ops;
3322 	if (!monitor_ops || !monitor_ops->mon_config_enh_rx_capture) {
3323 		dp_mon_debug("callback not registered");
3324 		return QDF_STATUS_E_FAILURE;
3325 	}
3326 
3327 	return monitor_ops->mon_config_enh_rx_capture(pdev, val);
3328 }
3329 #else
dp_monitor_config_enh_rx_capture(struct dp_pdev * pdev,uint32_t val)3330 static inline QDF_STATUS dp_monitor_config_enh_rx_capture(struct dp_pdev *pdev,
3331 							  uint32_t val)
3332 {
3333 	return QDF_STATUS_E_INVAL;
3334 }
3335 #endif
3336 
3337 #ifdef QCA_SUPPORT_BPR
dp_monitor_set_bpr_enable(struct dp_pdev * pdev,uint32_t val)3338 static inline QDF_STATUS dp_monitor_set_bpr_enable(struct dp_pdev *pdev,
3339 						   uint32_t val)
3340 {
3341 	struct dp_mon_ops *monitor_ops;
3342 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3343 
3344 	if (!mon_soc) {
3345 		dp_mon_debug("monitor soc is NULL");
3346 		return QDF_STATUS_E_FAILURE;
3347 	}
3348 
3349 	monitor_ops = mon_soc->mon_ops;
3350 	if (!monitor_ops || !monitor_ops->mon_set_bpr_enable) {
3351 		dp_mon_debug("callback not registered");
3352 		return QDF_STATUS_E_FAILURE;
3353 	}
3354 
3355 	return monitor_ops->mon_set_bpr_enable(pdev, val);
3356 }
3357 #else
dp_monitor_set_bpr_enable(struct dp_pdev * pdev,uint32_t val)3358 static inline QDF_STATUS dp_monitor_set_bpr_enable(struct dp_pdev *pdev,
3359 						   uint32_t val)
3360 {
3361 	return QDF_STATUS_E_FAILURE;
3362 }
3363 #endif
3364 
3365 #ifdef ATH_SUPPORT_NAC
3366 static inline
dp_monitor_set_filter_neigh_peers(struct dp_pdev * pdev,bool val)3367 int dp_monitor_set_filter_neigh_peers(struct dp_pdev *pdev, bool val)
3368 {
3369 	struct dp_mon_ops *monitor_ops;
3370 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3371 
3372 	if (!mon_soc) {
3373 		dp_mon_debug("monitor soc is NULL");
3374 		return 0;
3375 	}
3376 
3377 	monitor_ops = mon_soc->mon_ops;
3378 	if (!monitor_ops || !monitor_ops->mon_set_filter_neigh_peers) {
3379 		dp_mon_debug("callback not registered");
3380 		return 0;
3381 	}
3382 
3383 	return monitor_ops->mon_set_filter_neigh_peers(pdev, val);
3384 }
3385 #else
3386 static inline
dp_monitor_set_filter_neigh_peers(struct dp_pdev * pdev,bool val)3387 int dp_monitor_set_filter_neigh_peers(struct dp_pdev *pdev, bool val)
3388 {
3389 	return 0;
3390 }
3391 #endif
3392 
3393 #ifdef WLAN_ATF_ENABLE
3394 static inline
dp_monitor_set_atf_stats_enable(struct dp_pdev * pdev,bool value)3395 void dp_monitor_set_atf_stats_enable(struct dp_pdev *pdev, bool value)
3396 {
3397 	struct dp_mon_ops *monitor_ops;
3398 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3399 
3400 	if (!mon_soc) {
3401 		dp_mon_debug("monitor soc is NULL");
3402 		return;
3403 	}
3404 
3405 	monitor_ops = mon_soc->mon_ops;
3406 	if (!monitor_ops || !monitor_ops->mon_set_atf_stats_enable) {
3407 		dp_mon_debug("callback not registered");
3408 		return;
3409 	}
3410 
3411 	return monitor_ops->mon_set_atf_stats_enable(pdev, value);
3412 }
3413 #else
3414 static inline
dp_monitor_set_atf_stats_enable(struct dp_pdev * pdev,bool value)3415 void dp_monitor_set_atf_stats_enable(struct dp_pdev *pdev, bool value)
3416 {
3417 }
3418 #endif
3419 
3420 static inline
dp_monitor_set_bsscolor(struct dp_pdev * pdev,uint8_t bsscolor)3421 void dp_monitor_set_bsscolor(struct dp_pdev *pdev, uint8_t bsscolor)
3422 {
3423 	struct dp_mon_ops *monitor_ops;
3424 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3425 
3426 	if (!mon_soc) {
3427 		dp_mon_debug("monitor soc is NULL");
3428 		return;
3429 	}
3430 
3431 	monitor_ops = mon_soc->mon_ops;
3432 	if (!monitor_ops || !monitor_ops->mon_set_bsscolor) {
3433 		dp_mon_debug("callback not registered");
3434 		return;
3435 	}
3436 
3437 	return monitor_ops->mon_set_bsscolor(pdev, bsscolor);
3438 }
3439 
3440 static inline
dp_monitor_pdev_get_filter_mcast_data(struct cdp_pdev * pdev_handle)3441 bool dp_monitor_pdev_get_filter_mcast_data(struct cdp_pdev *pdev_handle)
3442 {
3443 	struct dp_mon_ops *monitor_ops;
3444 	struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
3445 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3446 
3447 	if (!mon_soc) {
3448 		dp_mon_debug("monitor soc is NULL");
3449 		return false;
3450 	}
3451 
3452 	monitor_ops = mon_soc->mon_ops;
3453 	if (!monitor_ops || !monitor_ops->mon_pdev_get_filter_mcast_data) {
3454 		dp_mon_debug("callback not registered");
3455 		return false;
3456 	}
3457 
3458 	return monitor_ops->mon_pdev_get_filter_mcast_data(pdev_handle);
3459 }
3460 
3461 static inline
dp_monitor_pdev_get_filter_non_data(struct cdp_pdev * pdev_handle)3462 bool dp_monitor_pdev_get_filter_non_data(struct cdp_pdev *pdev_handle)
3463 {
3464 	struct dp_mon_ops *monitor_ops;
3465 	struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
3466 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3467 
3468 	if (!mon_soc) {
3469 		dp_mon_debug("monitor soc is NULL");
3470 		return false;
3471 	}
3472 
3473 	monitor_ops = mon_soc->mon_ops;
3474 	if (!monitor_ops || !monitor_ops->mon_pdev_get_filter_non_data) {
3475 		dp_mon_debug("callback not registered");
3476 		return false;
3477 	}
3478 
3479 	return monitor_ops->mon_pdev_get_filter_non_data(pdev_handle);
3480 }
3481 
3482 static inline
dp_monitor_pdev_get_filter_ucast_data(struct cdp_pdev * pdev_handle)3483 bool dp_monitor_pdev_get_filter_ucast_data(struct cdp_pdev *pdev_handle)
3484 {
3485 	struct dp_mon_ops *monitor_ops;
3486 	struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
3487 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3488 
3489 	if (!mon_soc) {
3490 		dp_mon_debug("monitor soc is NULL");
3491 		return false;
3492 	}
3493 
3494 	monitor_ops = mon_soc->mon_ops;
3495 	if (!monitor_ops || !monitor_ops->mon_pdev_get_filter_ucast_data) {
3496 		dp_mon_debug("callback not registered");
3497 		return false;
3498 	}
3499 
3500 	return monitor_ops->mon_pdev_get_filter_ucast_data(pdev_handle);
3501 }
3502 
3503 #ifdef WDI_EVENT_ENABLE
3504 static inline
dp_monitor_set_pktlog_wifi3(struct dp_pdev * pdev,uint32_t event,bool enable)3505 int dp_monitor_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event,
3506 				bool enable)
3507 {
3508 	struct dp_mon_ops *monitor_ops;
3509 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3510 
3511 	if (!mon_soc) {
3512 		dp_mon_debug("monitor soc is NULL");
3513 		return 0;
3514 	}
3515 
3516 	monitor_ops = mon_soc->mon_ops;
3517 	if (!monitor_ops || !monitor_ops->mon_set_pktlog_wifi3) {
3518 		dp_mon_debug("callback not registered");
3519 		return 0;
3520 	}
3521 
3522 	return monitor_ops->mon_set_pktlog_wifi3(pdev, event, enable);
3523 }
3524 #else
3525 static inline
dp_monitor_set_pktlog_wifi3(struct dp_pdev * pdev,uint32_t event,bool enable)3526 int dp_monitor_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event,
3527 				bool enable)
3528 {
3529 	return 0;
3530 }
3531 #endif
3532 
3533 #if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
dp_monitor_pktlogmod_exit(struct dp_pdev * pdev)3534 static inline void dp_monitor_pktlogmod_exit(struct dp_pdev *pdev)
3535 {
3536 	struct dp_mon_ops *monitor_ops;
3537 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3538 
3539 	if (!mon_soc) {
3540 		dp_mon_debug("monitor soc is NULL");
3541 		return;
3542 	}
3543 
3544 	monitor_ops = mon_soc->mon_ops;
3545 	if (!monitor_ops || !monitor_ops->mon_pktlogmod_exit) {
3546 		dp_mon_debug("callback not registered");
3547 		return;
3548 	}
3549 
3550 	return monitor_ops->mon_pktlogmod_exit(pdev);
3551 }
3552 #else
dp_monitor_pktlogmod_exit(struct dp_pdev * pdev)3553 static inline void dp_monitor_pktlogmod_exit(struct dp_pdev *pdev) {}
3554 #endif
3555 
3556 static inline
dp_monitor_vdev_set_monitor_mode_buf_rings(struct dp_pdev * pdev)3557 QDF_STATUS dp_monitor_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev)
3558 {
3559 	struct dp_mon_ops *monitor_ops;
3560 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3561 
3562 	if (!mon_soc) {
3563 		dp_mon_debug("monitor soc is NULL");
3564 		return QDF_STATUS_E_FAILURE;
3565 	}
3566 
3567 	monitor_ops = mon_soc->mon_ops;
3568 	if (!monitor_ops || !monitor_ops->mon_vdev_set_monitor_mode_buf_rings) {
3569 		dp_mon_debug("callback not registered");
3570 		return QDF_STATUS_E_FAILURE;
3571 	}
3572 
3573 	return monitor_ops->mon_vdev_set_monitor_mode_buf_rings(pdev);
3574 }
3575 
3576 static inline
dp_monitor_neighbour_peers_detach(struct dp_pdev * pdev)3577 void dp_monitor_neighbour_peers_detach(struct dp_pdev *pdev)
3578 {
3579 	struct dp_mon_ops *monitor_ops;
3580 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3581 
3582 	if (!mon_soc) {
3583 		dp_mon_debug("monitor soc is NULL");
3584 		return;
3585 	}
3586 
3587 	monitor_ops = mon_soc->mon_ops;
3588 	if (!monitor_ops || !monitor_ops->mon_neighbour_peers_detach) {
3589 		dp_mon_debug("callback not registered");
3590 		return;
3591 	}
3592 
3593 	return monitor_ops->mon_neighbour_peers_detach(pdev);
3594 }
3595 
3596 #ifdef FEATURE_NAC_RSSI
dp_monitor_filter_neighbour_peer(struct dp_pdev * pdev,uint8_t * rx_pkt_hdr)3597 static inline QDF_STATUS dp_monitor_filter_neighbour_peer(struct dp_pdev *pdev,
3598 							  uint8_t *rx_pkt_hdr)
3599 {
3600 	struct dp_mon_ops *monitor_ops;
3601 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3602 
3603 	if (!mon_soc) {
3604 		dp_mon_debug("monitor soc is NULL");
3605 		return QDF_STATUS_E_FAILURE;
3606 	}
3607 
3608 	monitor_ops = mon_soc->mon_ops;
3609 	if (!monitor_ops || !monitor_ops->mon_filter_neighbour_peer) {
3610 		dp_mon_debug("callback not registered");
3611 		return QDF_STATUS_E_FAILURE;
3612 	}
3613 
3614 	return monitor_ops->mon_filter_neighbour_peer(pdev, rx_pkt_hdr);
3615 }
3616 #else
dp_monitor_filter_neighbour_peer(struct dp_pdev * pdev,uint8_t * rx_pkt_hdr)3617 static inline QDF_STATUS dp_monitor_filter_neighbour_peer(struct dp_pdev *pdev,
3618 							  uint8_t *rx_pkt_hdr)
3619 {
3620 	return QDF_STATUS_E_FAILURE;
3621 }
3622 #endif
3623 
3624 static inline
dp_monitor_reap_timer_init(struct dp_soc * soc)3625 void dp_monitor_reap_timer_init(struct dp_soc *soc)
3626 {
3627 	struct dp_mon_ops *monitor_ops;
3628 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3629 
3630 	if (!mon_soc) {
3631 		dp_mon_debug("monitor soc is NULL");
3632 		return;
3633 	}
3634 
3635 	monitor_ops = mon_soc->mon_ops;
3636 	if (!monitor_ops || !monitor_ops->mon_reap_timer_init) {
3637 		dp_mon_debug("callback not registered");
3638 		return;
3639 	}
3640 
3641 	monitor_ops->mon_reap_timer_init(soc);
3642 }
3643 
3644 static inline
dp_monitor_reap_timer_deinit(struct dp_soc * soc)3645 void dp_monitor_reap_timer_deinit(struct dp_soc *soc)
3646 {
3647 	struct dp_mon_ops *monitor_ops;
3648 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3649 
3650 	if (!mon_soc) {
3651 		dp_mon_debug("monitor soc is NULL");
3652 		return;
3653 	}
3654 
3655 	monitor_ops = mon_soc->mon_ops;
3656 	if (!monitor_ops || !monitor_ops->mon_reap_timer_deinit) {
3657 		dp_mon_debug("callback not registered");
3658 		return;
3659 	}
3660 
3661 	monitor_ops->mon_reap_timer_deinit(soc);
3662 }
3663 
3664 /**
3665  * dp_monitor_reap_timer_start() - start reap timer of monitor status ring
3666  * @soc: point to soc
3667  * @source: trigger source
3668  *
3669  * Return: true if timer-start is performed, false otherwise.
3670  */
3671 static inline bool
dp_monitor_reap_timer_start(struct dp_soc * soc,enum cdp_mon_reap_source source)3672 dp_monitor_reap_timer_start(struct dp_soc *soc,
3673 			    enum cdp_mon_reap_source source)
3674 {
3675 	struct dp_mon_ops *monitor_ops;
3676 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3677 
3678 	if (!mon_soc) {
3679 		dp_mon_debug("monitor soc is NULL");
3680 		return false;
3681 	}
3682 
3683 	monitor_ops = mon_soc->mon_ops;
3684 	if (!monitor_ops || !monitor_ops->mon_reap_timer_start) {
3685 		dp_mon_debug("callback not registered");
3686 		return false;
3687 	}
3688 
3689 	return monitor_ops->mon_reap_timer_start(soc, source);
3690 }
3691 
3692 /**
3693  * dp_monitor_reap_timer_stop() - stop reap timer of monitor status ring
3694  * @soc: point to soc
3695  * @source: trigger source
3696  *
3697  * Return: true if timer-stop is performed, false otherwise.
3698  */
3699 static inline bool
dp_monitor_reap_timer_stop(struct dp_soc * soc,enum cdp_mon_reap_source source)3700 dp_monitor_reap_timer_stop(struct dp_soc *soc,
3701 			   enum cdp_mon_reap_source source)
3702 {
3703 	struct dp_mon_ops *monitor_ops;
3704 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3705 
3706 	if (!mon_soc) {
3707 		dp_mon_debug("monitor soc is NULL");
3708 		return false;
3709 	}
3710 
3711 	monitor_ops = mon_soc->mon_ops;
3712 	if (!monitor_ops || !monitor_ops->mon_reap_timer_stop) {
3713 		dp_mon_debug("callback not registered");
3714 		return false;
3715 	}
3716 
3717 	return monitor_ops->mon_reap_timer_stop(soc, source);
3718 }
3719 
3720 static inline
dp_monitor_vdev_timer_init(struct dp_soc * soc)3721 void dp_monitor_vdev_timer_init(struct dp_soc *soc)
3722 {
3723 	struct dp_mon_ops *monitor_ops;
3724 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3725 
3726 	if (!mon_soc) {
3727 		dp_mon_debug("monitor soc is NULL");
3728 		return;
3729 	}
3730 
3731 	monitor_ops = mon_soc->mon_ops;
3732 	if (!monitor_ops || !monitor_ops->mon_vdev_timer_init) {
3733 		dp_mon_debug("callback not registered");
3734 		return;
3735 	}
3736 
3737 	monitor_ops->mon_vdev_timer_init(soc);
3738 }
3739 
3740 static inline
dp_monitor_vdev_timer_deinit(struct dp_soc * soc)3741 void dp_monitor_vdev_timer_deinit(struct dp_soc *soc)
3742 {
3743 	struct dp_mon_ops *monitor_ops;
3744 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3745 
3746 	if (!mon_soc) {
3747 		dp_mon_debug("monitor soc is NULL");
3748 		return;
3749 	}
3750 
3751 	monitor_ops = mon_soc->mon_ops;
3752 	if (!monitor_ops || !monitor_ops->mon_vdev_timer_deinit) {
3753 		dp_mon_debug("callback not registered");
3754 		return;
3755 	}
3756 
3757 	monitor_ops->mon_vdev_timer_deinit(soc);
3758 }
3759 
3760 static inline
dp_monitor_vdev_timer_start(struct dp_soc * soc)3761 void dp_monitor_vdev_timer_start(struct dp_soc *soc)
3762 {
3763 	struct dp_mon_ops *monitor_ops;
3764 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3765 
3766 	if (!mon_soc) {
3767 		dp_mon_debug("monitor soc is NULL");
3768 		return;
3769 	}
3770 
3771 	monitor_ops = mon_soc->mon_ops;
3772 	if (!monitor_ops || !monitor_ops->mon_vdev_timer_start) {
3773 		dp_mon_debug("callback not registered");
3774 		return;
3775 	}
3776 
3777 	monitor_ops->mon_vdev_timer_start(soc);
3778 }
3779 
3780 static inline
dp_monitor_vdev_timer_stop(struct dp_soc * soc)3781 bool dp_monitor_vdev_timer_stop(struct dp_soc *soc)
3782 {
3783 	struct dp_mon_ops *monitor_ops;
3784 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3785 
3786 	if (!mon_soc) {
3787 		dp_mon_debug("monitor soc is NULL");
3788 		return false;
3789 	}
3790 
3791 	monitor_ops = mon_soc->mon_ops;
3792 	if (!monitor_ops || !monitor_ops->mon_vdev_timer_stop) {
3793 		dp_mon_debug("callback not registered");
3794 		return false;
3795 	}
3796 
3797 	return monitor_ops->mon_vdev_timer_stop(soc);
3798 }
3799 
3800 #ifdef QCA_MCOPY_SUPPORT
3801 static inline
dp_monitor_mcopy_check_deliver(struct dp_pdev * pdev,uint16_t peer_id,uint32_t ppdu_id,uint8_t first_msdu)3802 QDF_STATUS dp_monitor_mcopy_check_deliver(struct dp_pdev *pdev,
3803 					  uint16_t peer_id, uint32_t ppdu_id,
3804 					  uint8_t first_msdu)
3805 {
3806 	struct dp_mon_ops *monitor_ops;
3807 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3808 
3809 	if (!mon_soc) {
3810 		dp_mon_debug("monitor soc is NULL");
3811 		return QDF_STATUS_E_FAILURE;
3812 	}
3813 
3814 	monitor_ops = mon_soc->mon_ops;
3815 	if (!monitor_ops || !monitor_ops->mon_mcopy_check_deliver) {
3816 		dp_mon_debug("callback not registered");
3817 		return QDF_STATUS_E_FAILURE;
3818 	}
3819 
3820 	return monitor_ops->mon_mcopy_check_deliver(pdev, peer_id,
3821 						    ppdu_id, first_msdu);
3822 }
3823 #else
3824 static inline
dp_monitor_mcopy_check_deliver(struct dp_pdev * pdev,uint16_t peer_id,uint32_t ppdu_id,uint8_t first_msdu)3825 QDF_STATUS dp_monitor_mcopy_check_deliver(struct dp_pdev *pdev,
3826 					  uint16_t peer_id, uint32_t ppdu_id,
3827 					  uint8_t first_msdu)
3828 {
3829 	return QDF_STATUS_SUCCESS;
3830 }
3831 #endif
3832 
3833 /**
3834  * dp_monitor_neighbour_peer_add_ast() - Add ast entry
3835  * @pdev: point to dp pdev
3836  * @ta_peer: point to peer
3837  * @mac_addr: mac address
3838  * @nbuf: point to nbuf
3839  * @flags: flags
3840  *
3841  * Return: void
3842  */
3843 static inline void
dp_monitor_neighbour_peer_add_ast(struct dp_pdev * pdev,struct dp_peer * ta_peer,uint8_t * mac_addr,qdf_nbuf_t nbuf,uint32_t flags)3844 dp_monitor_neighbour_peer_add_ast(struct dp_pdev *pdev,
3845 				  struct dp_peer *ta_peer,
3846 				  uint8_t *mac_addr,
3847 				  qdf_nbuf_t nbuf,
3848 				  uint32_t flags)
3849 {
3850 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
3851 	struct dp_mon_ops *monitor_ops;
3852 
3853 	if (!mon_soc) {
3854 		dp_mon_debug("monitor soc is NULL");
3855 		return;
3856 	}
3857 
3858 	monitor_ops = mon_soc->mon_ops;
3859 	if (!monitor_ops || !monitor_ops->mon_neighbour_peer_add_ast) {
3860 		dp_mon_debug("callback not registered");
3861 		return;
3862 	}
3863 
3864 	return monitor_ops->mon_neighbour_peer_add_ast(pdev, ta_peer, mac_addr,
3865 						       nbuf, flags);
3866 }
3867 
3868 /**
3869  * dp_monitor_vdev_delete() - delete monitor vdev
3870  * @soc: point to dp soc
3871  * @vdev: point to dp vdev
3872  *
3873  * Return: void
3874  */
dp_monitor_vdev_delete(struct dp_soc * soc,struct dp_vdev * vdev)3875 static inline void dp_monitor_vdev_delete(struct dp_soc *soc,
3876 					  struct dp_vdev *vdev)
3877 {
3878 	if (soc->intr_mode == DP_INTR_POLL) {
3879 		qdf_timer_sync_cancel(&soc->int_timer);
3880 		dp_monitor_flush_rings(soc);
3881 	} else if (soc->intr_mode == DP_INTR_MSI) {
3882 		dp_monitor_vdev_timer_stop(soc);
3883 		dp_monitor_flush_rings(soc);
3884 	}
3885 
3886 	dp_monitor_vdev_detach(vdev);
3887 }
3888 
3889 #ifdef DP_POWER_SAVE
3890 /**
3891  * dp_monitor_reap_timer_suspend() - Stop monitor reap timer
3892  * and reap any pending frames in ring
3893  * @soc: DP soc context
3894  *
3895  * Return: void
3896  */
3897 static inline void
dp_monitor_reap_timer_suspend(struct dp_soc * soc)3898 dp_monitor_reap_timer_suspend(struct dp_soc *soc)
3899 {
3900 	if (dp_monitor_reap_timer_stop(soc, CDP_MON_REAP_SOURCE_ANY))
3901 		dp_monitor_service_mon_rings(soc, DP_MON_REAP_BUDGET);
3902 }
3903 
3904 #endif
3905 
3906 /**
3907  * dp_monitor_neighbour_peer_list_remove() - remove neighbour peer list
3908  * @pdev: point to dp pdev
3909  * @vdev: point to dp vdev
3910  * @peer: point to dp_neighbour_peer
3911  *
3912  * Return: void
3913  */
3914 static inline
dp_monitor_neighbour_peer_list_remove(struct dp_pdev * pdev,struct dp_vdev * vdev,struct dp_neighbour_peer * peer)3915 void dp_monitor_neighbour_peer_list_remove(struct dp_pdev *pdev,
3916 					   struct dp_vdev *vdev,
3917 					   struct dp_neighbour_peer *peer)
3918 {
3919 	struct dp_mon_pdev *mon_pdev;
3920 	struct dp_neighbour_peer *temp_peer = NULL;
3921 
3922 	if (qdf_unlikely(!pdev || !pdev->monitor_pdev))
3923 		return;
3924 
3925 	mon_pdev = pdev->monitor_pdev;
3926 	qdf_spin_lock_bh(&mon_pdev->neighbour_peer_mutex);
3927 	if (!pdev->soc->monitor_soc->hw_nac_monitor_support) {
3928 		TAILQ_FOREACH(peer, &mon_pdev->neighbour_peers_list,
3929 			      neighbour_peer_list_elem) {
3930 				QDF_ASSERT(peer->vdev != vdev);
3931 			}
3932 	} else {
3933 		TAILQ_FOREACH_SAFE(peer, &mon_pdev->neighbour_peers_list,
3934 				   neighbour_peer_list_elem, temp_peer) {
3935 			if (peer->vdev == vdev) {
3936 				TAILQ_REMOVE(&mon_pdev->neighbour_peers_list,
3937 					     peer,
3938 					     neighbour_peer_list_elem);
3939 				qdf_mem_free(peer);
3940 			}
3941 		}
3942 	}
3943 	qdf_spin_unlock_bh(&mon_pdev->neighbour_peer_mutex);
3944 }
3945 
3946 static inline
dp_monitor_pdev_set_mon_vdev(struct dp_vdev * vdev)3947 void dp_monitor_pdev_set_mon_vdev(struct dp_vdev *vdev)
3948 {
3949 	if (!vdev->pdev->monitor_pdev)
3950 		return;
3951 
3952 	vdev->pdev->monitor_pdev->mvdev = vdev;
3953 }
3954 
3955 static inline
dp_monitor_pdev_config_scan_spcl_vap(struct dp_pdev * pdev,bool val)3956 void dp_monitor_pdev_config_scan_spcl_vap(struct dp_pdev *pdev, bool val)
3957 {
3958 	if (!pdev || !pdev->monitor_pdev)
3959 		return;
3960 
3961 	pdev->monitor_pdev->scan_spcl_vap_configured = val;
3962 }
3963 
3964 #ifdef QCA_SUPPORT_SCAN_SPCL_VAP_STATS
3965 static inline
dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev * pdev,bool val)3966 void dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev *pdev,
3967 						      bool val)
3968 {
3969 	if (!pdev || !pdev->monitor_pdev)
3970 		return;
3971 
3972 	pdev->monitor_pdev->reset_scan_spcl_vap_stats_enable = val;
3973 }
3974 #else
3975 static inline
dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev * pdev,bool val)3976 void dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev *pdev,
3977 						      bool val)
3978 {
3979 }
3980 #endif
3981 
3982 #if defined(CONFIG_MON_WORD_BASED_TLV)
3983 static inline void
dp_mon_rx_wmask_subscribe(struct dp_soc * soc,uint32_t * msg_word,int pdev_id,struct htt_rx_ring_tlv_filter * tlv_filter)3984 dp_mon_rx_wmask_subscribe(struct dp_soc *soc,
3985 			  uint32_t *msg_word, int pdev_id,
3986 			  struct htt_rx_ring_tlv_filter *tlv_filter)
3987 {
3988 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
3989 	struct dp_mon_ops *monitor_ops;
3990 
3991 	if (!mon_soc) {
3992 		dp_mon_debug("mon soc is NULL");
3993 		return;
3994 
3995 	}
3996 
3997 	monitor_ops = mon_soc->mon_ops;
3998 	if (!monitor_ops || !monitor_ops->rx_wmask_subscribe) {
3999 		dp_mon_debug("callback not registered");
4000 		return;
4001 	}
4002 
4003 	monitor_ops->rx_wmask_subscribe(soc, msg_word, pdev_id, tlv_filter);
4004 }
4005 #else
4006 static inline void
dp_mon_rx_wmask_subscribe(struct dp_soc * soc,uint32_t * msg_word,int pdev_id,struct htt_rx_ring_tlv_filter * tlv_filter)4007 dp_mon_rx_wmask_subscribe(struct dp_soc *soc,
4008 			  uint32_t *msg_word, int pdev_id,
4009 			  struct htt_rx_ring_tlv_filter *tlv_filter)
4010 {
4011 }
4012 #endif
4013 
4014 static inline void
dp_mon_rx_enable_pkt_tlv_offset(struct dp_soc * soc,uint32_t * msg_word,struct htt_rx_ring_tlv_filter * tlv_filter)4015 dp_mon_rx_enable_pkt_tlv_offset(struct dp_soc *soc, uint32_t *msg_word,
4016 				struct htt_rx_ring_tlv_filter *tlv_filter)
4017 {
4018 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
4019 	struct dp_mon_ops *monitor_ops;
4020 
4021 	if (!mon_soc) {
4022 		dp_mon_debug("mon soc is NULL");
4023 		return;
4024 	}
4025 
4026 	monitor_ops = mon_soc->mon_ops;
4027 	if (!monitor_ops || !monitor_ops->rx_pkt_tlv_offset) {
4028 		dp_mon_debug("callback not registered");
4029 		return;
4030 	}
4031 
4032 	monitor_ops->rx_pkt_tlv_offset(msg_word, tlv_filter);
4033 }
4034 
4035 static inline void
dp_mon_rx_enable_mpdu_logging(struct dp_soc * soc,uint32_t * msg_word,struct htt_rx_ring_tlv_filter * tlv_filter)4036 dp_mon_rx_enable_mpdu_logging(struct dp_soc *soc, uint32_t *msg_word,
4037 			      struct htt_rx_ring_tlv_filter *tlv_filter)
4038 {
4039 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
4040 	struct dp_mon_ops *monitor_ops;
4041 
4042 	if (!mon_soc) {
4043 		dp_mon_debug("mon soc is NULL");
4044 		return;
4045 
4046 	}
4047 
4048 	monitor_ops = mon_soc->mon_ops;
4049 	if (!monitor_ops || !monitor_ops->rx_enable_mpdu_logging) {
4050 		dp_mon_debug("callback not registered");
4051 		return;
4052 	}
4053 
4054 	monitor_ops->rx_enable_mpdu_logging(msg_word, tlv_filter);
4055 }
4056 
4057 /**
4058  * dp_mon_rx_enable_fpmo() - set fpmo filters
4059  * @soc: dp soc handle
4060  * @msg_word: msg word
4061  * @tlv_filter: rx fing filter config
4062  *
4063  * Return: void
4064  */
4065 static inline void
dp_mon_rx_enable_fpmo(struct dp_soc * soc,uint32_t * msg_word,struct htt_rx_ring_tlv_filter * tlv_filter)4066 dp_mon_rx_enable_fpmo(struct dp_soc *soc, uint32_t *msg_word,
4067 		      struct htt_rx_ring_tlv_filter *tlv_filter)
4068 {
4069 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
4070 	struct dp_mon_ops *monitor_ops;
4071 
4072 	if (!mon_soc) {
4073 		dp_mon_debug("mon soc is NULL");
4074 		return;
4075 	}
4076 
4077 	monitor_ops = mon_soc->mon_ops;
4078 	if (!monitor_ops || !monitor_ops->rx_enable_fpmo) {
4079 		dp_mon_debug("callback not registered");
4080 		return;
4081 	}
4082 
4083 	monitor_ops->rx_enable_fpmo(msg_word, tlv_filter);
4084 }
4085 
4086 /**
4087  * dp_mon_rx_hdr_length_set() - set rx hdr tlv length
4088  * @soc: dp soc handle
4089  * @msg_word: msg word
4090  * @tlv_filter: rx fing filter config
4091  *
4092  * Return: void
4093  */
4094 static inline void
dp_mon_rx_hdr_length_set(struct dp_soc * soc,uint32_t * msg_word,struct htt_rx_ring_tlv_filter * tlv_filter)4095 dp_mon_rx_hdr_length_set(struct dp_soc *soc, uint32_t *msg_word,
4096 			 struct htt_rx_ring_tlv_filter *tlv_filter)
4097 {
4098 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
4099 	struct dp_mon_ops *monitor_ops;
4100 
4101 	if (!mon_soc) {
4102 		dp_mon_debug("mon soc is NULL");
4103 		return;
4104 	}
4105 
4106 	monitor_ops = mon_soc->mon_ops;
4107 	if (!monitor_ops || !monitor_ops->rx_hdr_length_set) {
4108 		dp_mon_debug("callback not registered");
4109 		return;
4110 	}
4111 
4112 	monitor_ops->rx_hdr_length_set(msg_word, tlv_filter);
4113 }
4114 
4115 static inline void
dp_mon_rx_packet_length_set(struct dp_soc * soc,uint32_t * msg_word,struct htt_rx_ring_tlv_filter * tlv_filter)4116 dp_mon_rx_packet_length_set(struct dp_soc *soc, uint32_t *msg_word,
4117 			    struct htt_rx_ring_tlv_filter *tlv_filter)
4118 {
4119 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
4120 	struct dp_mon_ops *monitor_ops;
4121 
4122 	if (!mon_soc) {
4123 		dp_mon_debug("mon soc is NULL");
4124 		return;
4125 
4126 	}
4127 
4128 	monitor_ops = mon_soc->mon_ops;
4129 	if (!monitor_ops || !monitor_ops->rx_packet_length_set) {
4130 		dp_mon_debug("callback not registered");
4131 		return;
4132 	}
4133 
4134 	monitor_ops->rx_packet_length_set(msg_word, tlv_filter);
4135 }
4136 
4137 static inline void
dp_rx_mon_enable(struct dp_soc * soc,uint32_t * msg_word,struct htt_rx_ring_tlv_filter * tlv_filter)4138 dp_rx_mon_enable(struct dp_soc *soc, uint32_t *msg_word,
4139 		 struct htt_rx_ring_tlv_filter *tlv_filter)
4140 {
4141 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
4142 	struct dp_mon_ops *monitor_ops;
4143 
4144 	if (!mon_soc) {
4145 		dp_mon_debug("mon soc is NULL");
4146 		return;
4147 	}
4148 
4149 	monitor_ops = mon_soc->mon_ops;
4150 	if (!monitor_ops || !monitor_ops->rx_mon_enable) {
4151 		dp_mon_debug("callback not registered");
4152 		return;
4153 	}
4154 
4155 	monitor_ops->rx_mon_enable(msg_word, tlv_filter);
4156 }
4157 
4158 static inline void
dp_mon_rx_mac_filter_set(struct dp_soc * soc,uint32_t * msg_word,struct htt_rx_ring_tlv_filter * tlv_filter)4159 dp_mon_rx_mac_filter_set(struct dp_soc *soc, uint32_t *msg_word,
4160 			 struct htt_rx_ring_tlv_filter *tlv_filter)
4161 {
4162 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
4163 	struct dp_mon_ops *monitor_ops;
4164 
4165 	if (!mon_soc) {
4166 		dp_mon_debug("mon soc is NULL");
4167 		return;
4168 	}
4169 
4170 	monitor_ops = mon_soc->mon_ops;
4171 	if (!monitor_ops || !monitor_ops->mon_mac_filter_set) {
4172 		dp_mon_debug("callback not registered");
4173 		return;
4174 	}
4175 
4176 	monitor_ops->mon_mac_filter_set(msg_word, tlv_filter);
4177 }
4178 
4179 #ifdef QCA_ENHANCED_STATS_SUPPORT
4180 QDF_STATUS dp_peer_qos_stats_notify(struct dp_pdev *dp_pdev,
4181 				    struct cdp_rx_stats_ppdu_user *ppdu_user);
4182 #endif
4183 
4184 /**
4185  * dp_print_pdev_rx_mon_stats() - print rx mon stats
4186  * @pdev: device object
4187  *
4188  * Return: void
4189  */
4190 void
4191 dp_print_pdev_rx_mon_stats(struct dp_pdev *pdev);
4192 
4193 /**
4194  * dp_mcopy_check_deliver() - mcopy check deliver
4195  * @pdev: DP pdev handle
4196  * @peer_id: peer id
4197  * @ppdu_id: ppdu
4198  * @first_msdu: flag to indicate first msdu of ppdu
4199  * Return: 0 on success, not 0 on failure
4200  */
4201 QDF_STATUS dp_mcopy_check_deliver(struct dp_pdev *pdev,
4202 				  uint16_t peer_id,
4203 				  uint32_t ppdu_id,
4204 				  uint8_t first_msdu);
4205 
4206 /**
4207  * dp_pdev_set_advance_monitor_filter() - Set DP PDEV monitor filter
4208  * @soc_hdl: soc handle
4209  * @pdev_id: id of Datapath PDEV handle
4210  * @filter_val: Flag to select Filter for monitor mode
4211  *
4212  * Return: 0 on success, not 0 on failure
4213  */
4214 #ifdef QCA_ADVANCE_MON_FILTER_SUPPORT
4215 QDF_STATUS
4216 dp_pdev_set_advance_monitor_filter(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
4217 				   struct cdp_monitor_filter *filter_val);
4218 #else
4219 static inline QDF_STATUS
dp_pdev_set_advance_monitor_filter(struct cdp_soc_t * soc_hdl,uint8_t pdev_id,struct cdp_monitor_filter * filter_val)4220 dp_pdev_set_advance_monitor_filter(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
4221 				   struct cdp_monitor_filter *filter_val)
4222 {
4223 	return QDF_STATUS_E_INVAL;
4224 }
4225 #endif /* QCA_ADVANCE_MON_FILTER_SUPPORT */
4226 
4227 /**
4228  * dp_deliver_tx_mgmt() - Deliver mgmt frame for tx capture
4229  * @cdp_soc : data path soc handle
4230  * @pdev_id : pdev_id
4231  * @nbuf: Management frame buffer
4232  *
4233  * Return: QDF_STATUS_SUCCESS on success
4234  *	   QDF_STATUS_E_FAILURE on failure
4235  */
4236 QDF_STATUS
4237 dp_deliver_tx_mgmt(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, qdf_nbuf_t nbuf);
4238 
4239 /**
4240  * dp_filter_neighbour_peer() - API to filter neighbour peer
4241  * @pdev : DP pdev handle
4242  * @rx_pkt_hdr : packet header
4243  *
4244  * Return: QDF_STATUS_SUCCESS on success
4245  *	   QDF_STATUS_E_FAILURE on failure
4246  */
4247 #ifdef FEATURE_NAC_RSSI
4248 QDF_STATUS dp_filter_neighbour_peer(struct dp_pdev *pdev,
4249 				    uint8_t *rx_pkt_hdr);
4250 #else
4251 static inline
dp_filter_neighbour_peer(struct dp_pdev * pdev,uint8_t * rx_pkt_hdr)4252 QDF_STATUS dp_filter_neighbour_peer(struct dp_pdev *pdev,
4253 				    uint8_t *rx_pkt_hdr)
4254 {
4255 	return QDF_STATUS_SUCCESS;
4256 }
4257 #endif /* FEATURE_NAC_RSSI */
4258 
4259 /**
4260  * dp_neighbour_peers_detach() - Detach neighbour peers(nac clients)
4261  * @pdev: device object
4262  *
4263  * Return: void
4264  */
4265 void dp_neighbour_peers_detach(struct dp_pdev *pdev);
4266 
4267 /**
4268  * dp_reset_monitor_mode() - Disable monitor mode
4269  * @soc_hdl: Datapath soc handle
4270  * @pdev_id: id of datapath PDEV handle
4271  * @smart_monitor: smart monitor flag
4272  *
4273  * Return: QDF_STATUS
4274  */
4275 QDF_STATUS dp_reset_monitor_mode(struct cdp_soc_t *soc_hdl,
4276 				 uint8_t pdev_id,
4277 				 uint8_t smart_monitor);
4278 
4279 /**
4280  * dp_reset_monitor_mode_unlock() - Disable monitor mode with no locks
4281  * @soc_hdl: Datapath soc handle
4282  * @pdev_id: id of datapath PDEV handle
4283  * @smart_monitor: smart monitor flag
4284  *
4285  * Return: QDF_STATUS
4286  */
4287 #ifdef WIFI_MONITOR_SUPPORT
4288 QDF_STATUS dp_reset_monitor_mode_unlock(struct cdp_soc_t *soc_hdl,
4289 					uint8_t pdev_id,
4290 					uint8_t smart_monitor);
4291 #else
dp_reset_monitor_mode_unlock(struct cdp_soc_t * soc_hdl,uint8_t pdev_id,uint8_t smart_monitor)4292 QDF_STATUS dp_reset_monitor_mode_unlock(struct cdp_soc_t *soc_hdl,
4293 					uint8_t pdev_id,
4294 					uint8_t smart_monitor)
4295 {
4296 	return QDF_STATUS_SUCCESS;
4297 }
4298 #endif
4299 
4300 static inline
dp_mon_ops_get(struct dp_soc * soc)4301 struct dp_mon_ops *dp_mon_ops_get(struct dp_soc *soc)
4302 {
4303 	if (soc && soc->monitor_soc)
4304 		return soc->monitor_soc->mon_ops;
4305 
4306 	return NULL;
4307 }
4308 
4309 static inline
dp_mon_cdp_ops_get(struct dp_soc * soc)4310 struct cdp_mon_ops *dp_mon_cdp_ops_get(struct dp_soc *soc)
4311 {
4312 	struct cdp_ops *ops = soc->cdp_soc.ops;
4313 
4314 	return ops->mon_ops;
4315 }
4316 
4317 /**
4318  * dp_monitor_soc_attach() - Monitor SOC attach
4319  * @soc: DP soc handle
4320  *
4321  * Return: void
4322  */
dp_monitor_soc_attach(struct dp_soc * soc)4323 static inline void dp_monitor_soc_attach(struct dp_soc *soc)
4324 {
4325 	struct dp_mon_ops *mon_ops;
4326 
4327 	mon_ops = dp_mon_ops_get(soc);
4328 
4329 	if (mon_ops && mon_ops->mon_soc_attach[0])
4330 		mon_ops->mon_soc_attach[0](soc);
4331 
4332 	if (mon_ops && mon_ops->mon_soc_attach[1])
4333 		mon_ops->mon_soc_attach[1](soc);
4334 }
4335 
4336 /**
4337  * dp_monitor_soc_detach() - Monitor SOC detach
4338  * @soc: DP soc handle
4339  *
4340  * Return: void
4341  */
dp_monitor_soc_detach(struct dp_soc * soc)4342 static inline void dp_monitor_soc_detach(struct dp_soc *soc)
4343 {
4344 	struct dp_mon_ops *mon_ops;
4345 
4346 	mon_ops = dp_mon_ops_get(soc);
4347 
4348 	if (mon_ops && mon_ops->mon_soc_detach[0])
4349 		mon_ops->mon_soc_detach[0](soc);
4350 
4351 	if (mon_ops && mon_ops->mon_soc_detach[1])
4352 		mon_ops->mon_soc_detach[1](soc);
4353 }
4354 
4355 /**
4356  * dp_monitor_soc_init() - Monitor SOC init
4357  * @soc: DP soc handle
4358  *
4359  * Return: void
4360  */
dp_monitor_soc_init(struct dp_soc * soc)4361 static inline void dp_monitor_soc_init(struct dp_soc *soc)
4362 {
4363 	struct dp_mon_ops *mon_ops;
4364 
4365 	mon_ops = dp_mon_ops_get(soc);
4366 
4367 	if (mon_ops && mon_ops->mon_soc_init[0])
4368 		mon_ops->mon_soc_init[0](soc);
4369 
4370 	if (mon_ops && mon_ops->mon_soc_init[1])
4371 		mon_ops->mon_soc_init[1](soc);
4372 }
4373 
4374 /**
4375  * dp_monitor_soc_deinit() - Monitor SOC deinit
4376  * @soc: DP soc handle
4377  *
4378  * Return: void
4379  */
dp_monitor_soc_deinit(struct dp_soc * soc)4380 static inline void dp_monitor_soc_deinit(struct dp_soc *soc)
4381 {
4382 	struct dp_mon_ops *mon_ops;
4383 
4384 	mon_ops = dp_mon_ops_get(soc);
4385 
4386 	if (mon_ops && mon_ops->mon_soc_deinit[0])
4387 		mon_ops->mon_soc_deinit[0](soc);
4388 
4389 	if (mon_ops && mon_ops->mon_soc_deinit[1])
4390 		mon_ops->mon_soc_deinit[1](soc);
4391 }
4392 
4393 /**
4394  * dp_ppdu_desc_user_stats_update(): Function to update TX user stats
4395  * @pdev: DP pdev handle
4396  * @ppdu_info: per PPDU TLV descriptor
4397  *
4398  * Return: void
4399  */
4400 #ifdef QCA_ENHANCED_STATS_SUPPORT
4401 void
4402 dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
4403 			       struct ppdu_info *ppdu_info);
4404 #else
4405 static inline void
dp_ppdu_desc_user_stats_update(struct dp_pdev * pdev,struct ppdu_info * ppdu_info)4406 dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
4407 			       struct ppdu_info *ppdu_info)
4408 {
4409 }
4410 #endif /* QCA_ENHANCED_STATS_SUPPORT */
4411 
4412 /**
4413  * dp_mon_ops_register_1_0(): register legacy monitor ops
4414  * @mon_soc: monitor soc handle
4415  *
4416  * return: void
4417  */
4418 void dp_mon_ops_register_1_0(struct dp_mon_soc *mon_soc);
4419 
4420 /**
4421  * dp_mon_cdp_ops_register_1_0(): register legacy monitor cdp ops
4422  * @ops: cdp ops handle
4423  *
4424  * return: void
4425  */
4426 void dp_mon_cdp_ops_register_1_0(struct cdp_ops *ops);
4427 
4428 #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE)
4429 /**
4430  * dp_cfr_filter_register_1_0(): register cfr filter setting API
4431  * @ops: cdp ops handle
4432  *
4433  * return: void
4434  */
4435 void dp_cfr_filter_register_1_0(struct cdp_ops *ops);
4436 #endif
4437 
4438 QDF_STATUS dp_mon_pdev_htt_srng_setup_2_0(struct dp_soc *soc,
4439 					  struct dp_pdev *pdev,
4440 					  int mac_id,
4441 					  int mac_for_pdev);
4442 QDF_STATUS dp_mon_soc_htt_srng_setup_2_0(struct dp_soc *soc);
4443 QDF_STATUS dp_mon_soc_attach_2_0(struct dp_soc *soc);
4444 QDF_STATUS dp_mon_soc_init_2_0(struct dp_soc *soc);
4445 void dp_mon_soc_deinit_2_0(struct dp_soc *soc);
4446 QDF_STATUS dp_mon_soc_detach_2_0(struct dp_soc *soc);
4447 void dp_pdev_mon_rings_deinit_2_0(struct dp_pdev *pdev);
4448 QDF_STATUS dp_pdev_mon_rings_init_2_0(struct dp_pdev *pdev);
4449 void dp_pdev_mon_rings_free_2_0(struct dp_pdev *pdev);
4450 QDF_STATUS dp_pdev_mon_rings_alloc_2_0(struct dp_pdev *pdev);
4451 
4452 #ifdef WLAN_PKT_CAPTURE_TX_2_0
4453 /**
4454  * dp_mon_ops_register_tx_2_0(): register monitor tx ops 2.0
4455  * @mon_soc: monitor soc handle
4456  *
4457  * return: void
4458  */
4459 void dp_mon_ops_register_tx_2_0(struct dp_mon_soc *mon_soc);
4460 #else
4461 static inline
dp_mon_ops_register_tx_2_0(struct dp_mon_soc * mon_soc)4462 void dp_mon_ops_register_tx_2_0(struct dp_mon_soc *mon_soc)
4463 {
4464 }
4465 #endif /* WLAN_PKT_CAPTURE_TX_2_0 */
4466 
4467 #if defined(WLAN_PKT_CAPTURE_TX_2_0) || \
4468 defined(WLAN_PKT_CAPTURE_RX_2_0)
4469 /**
4470  * dp_mon_ops_register_2_0(): register monitor ops
4471  * @mon_soc: monitor soc handle
4472  *
4473  * return: void
4474  */
4475 void dp_mon_ops_register_2_0(struct dp_mon_soc *mon_soc);
4476 
4477 /**
4478  * dp_mon_cdp_ops_register_2_0(): register monitor cdp ops
4479  * @ops: cdp ops handle
4480  *
4481  * return: void
4482  */
4483 void dp_mon_cdp_ops_register_2_0(struct cdp_ops *ops);
4484 
4485 #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE)
4486 /**
4487  * dp_cfr_filter_register_2_0(): register cfr filter setting API
4488  * @ops: cdp ops handle
4489  *
4490  * return: void
4491  */
4492 void dp_cfr_filter_register_2_0(struct cdp_ops *ops);
4493 #endif
4494 void dp_mon_ops_register_cmn_2_0(struct dp_mon_soc *mon_soc);
4495 #else
4496 static inline void
dp_mon_ops_register_2_0(struct dp_mon_soc * mon_soc)4497 dp_mon_ops_register_2_0(struct dp_mon_soc *mon_soc)
4498 {
4499 }
4500 
4501 static inline void
dp_mon_cdp_ops_register_2_0(struct cdp_ops * ops)4502 dp_mon_cdp_ops_register_2_0(struct cdp_ops *ops)
4503 {
4504 }
4505 
4506 static inline void
dp_mon_ops_register_cmn_2_0(struct dp_mon_soc * mon_soc)4507 dp_mon_ops_register_cmn_2_0(struct dp_mon_soc *mon_soc)
4508 {
4509 }
4510 #endif /* WLAN_PKT_CAPTURE_TX_2_0 OR WLAN_PKT_CAPTURE_RX_2_0 */
4511 
4512 #ifdef WLAN_PKT_CAPTURE_RX_2_0
4513 /**
4514  * dp_mon_ops_register_rx_2_0(): register monitor rx ops 2.0
4515  * @mon_soc: monitor soc handle
4516  *
4517  * return: void
4518  */
4519 void dp_mon_ops_register_rx_2_0(struct dp_mon_soc *mon_soc);
4520 #else
4521 static inline
dp_mon_ops_register_rx_2_0(struct dp_mon_soc * mon_soc)4522 void dp_mon_ops_register_rx_2_0(struct dp_mon_soc *mon_soc)
4523 {
4524 }
4525 #endif
4526 
4527 /**
4528  * dp_mon_register_feature_ops(): Register mon feature ops
4529  * @soc: Datapath soc context
4530  *
4531  * return: void
4532  */
4533 static inline
dp_mon_register_feature_ops(struct dp_soc * soc)4534 void dp_mon_register_feature_ops(struct dp_soc *soc)
4535 {
4536 	struct dp_mon_ops *mon_ops = NULL;
4537 
4538 	mon_ops = dp_mon_ops_get(soc);
4539 	if (!mon_ops) {
4540 		dp_mon_err("Monitor ops is NULL");
4541 		return;
4542 	}
4543 	if (mon_ops->mon_register_feature_ops)
4544 		mon_ops->mon_register_feature_ops(soc);
4545 }
4546 
4547 /**
4548  * dp_pdev_get_rx_mon_stats(): Get pdev Rx monitor stats
4549  * @soc_hdl: soc handle
4550  * @pdev_id: id of pdev handle
4551  * @stats: User allocated stats buffer
4552  *
4553  * return: status success/failure
4554  */
4555 QDF_STATUS dp_pdev_get_rx_mon_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
4556 				    struct cdp_pdev_mon_stats *stats);
4557 
4558 /**
4559  * dp_enable_mon_reap_timer() - enable/disable reap timer
4560  * @soc_hdl: Datapath soc handle
4561  * @source: trigger source of the timer
4562  * @enable: Enable/Disable reap timer of monitor status ring
4563  *
4564  * Return: true if a timer-start/stop is performed, false otherwise.
4565  */
4566 bool dp_enable_mon_reap_timer(struct cdp_soc_t *soc_hdl,
4567 			      enum cdp_mon_reap_source source, bool enable);
4568 
4569 QDF_STATUS dp_vdev_set_monitor_mode(struct cdp_soc_t *dp_soc,
4570 				    uint8_t vdev_id,
4571 				    uint8_t special_monitor);
4572 
4573 #ifdef QCA_ENHANCED_STATS_SUPPORT
4574 /**
4575  * dp_enable_enhanced_stats() - enable enhanced and MLD Link Peer stats
4576  * @soc: Datapath soc handle
4577  * @pdev_id: Pdev Id on which stats will get enable
4578  *
4579  * Return: status success/failure
4580  */
4581 QDF_STATUS
4582 dp_enable_enhanced_stats(struct cdp_soc_t *soc, uint8_t pdev_id);
4583 
4584 /**
4585  * dp_disable_enhanced_stats() - disable enhanced and MLD Link Peer stats
4586  * @soc: Datapath soc handle
4587  * @pdev_id: Pdev Id on which stats will get disable
4588  *
4589  * Return: status success/failure
4590  */
4591 QDF_STATUS
4592 dp_disable_enhanced_stats(struct cdp_soc_t *soc, uint8_t pdev_id);
4593 #endif /* QCA_ENHANCED_STATS_SUPPORT */
4594 
4595 /*
4596  * dp_monitor_lite_mon_disable_rx() - disables rx lite mon
4597  * @pdev: dp pdev
4598  *
4599  * Return: void
4600  */
4601 static inline void
dp_monitor_lite_mon_disable_rx(struct dp_pdev * pdev)4602 dp_monitor_lite_mon_disable_rx(struct dp_pdev *pdev)
4603 {
4604 	struct dp_mon_ops *monitor_ops;
4605 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
4606 
4607 	if (!mon_soc) {
4608 		dp_mon_debug("monitor soc is NULL");
4609 		return;
4610 }
4611 
4612 	monitor_ops = mon_soc->mon_ops;
4613 	if (!monitor_ops ||
4614 	    !monitor_ops->mon_lite_mon_disable_rx) {
4615 		dp_mon_debug("callback not registered");
4616 		return;
4617 }
4618 
4619 	return monitor_ops->mon_lite_mon_disable_rx(pdev);
4620 }
4621 
4622 /*
4623  * dp_monitor_lite_mon_is_rx_adv_filter_enable()
4624  *   - check if advance mon filter is already applied
4625  * @pdev: dp pdev
4626  *
4627  * Return: bool
4628  */
4629 static inline bool
dp_monitor_lite_mon_is_rx_adv_filter_enable(struct dp_pdev * pdev)4630 dp_monitor_lite_mon_is_rx_adv_filter_enable(struct dp_pdev *pdev)
4631 {
4632 	struct dp_mon_ops *monitor_ops;
4633 	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
4634 
4635 	if (!mon_soc) {
4636 		dp_mon_debug("monitor soc is NULL");
4637 		return false;
4638 	}
4639 
4640 	monitor_ops = mon_soc->mon_ops;
4641 	if (!monitor_ops ||
4642 	    !monitor_ops->mon_lite_mon_disable_rx) {
4643 		dp_mon_debug("callback not registered");
4644 		return false;
4645 	}
4646 
4647 	return monitor_ops->mon_lite_mon_is_rx_adv_filter_enable(pdev);
4648 }
4649 
4650 #ifndef QCA_SUPPORT_LITE_MONITOR
4651 static inline void
dp_lite_mon_disable_rx(struct dp_pdev * pdev)4652 dp_lite_mon_disable_rx(struct dp_pdev *pdev)
4653 {
4654 }
4655 
4656 static inline void
dp_lite_mon_disable_tx(struct dp_pdev * pdev)4657 dp_lite_mon_disable_tx(struct dp_pdev *pdev)
4658 {
4659 }
4660 
4661 static inline bool
dp_lite_mon_is_rx_adv_filter_enable(struct dp_pdev * pdev)4662 dp_lite_mon_is_rx_adv_filter_enable(struct dp_pdev *pdev)
4663 {
4664 	return false;
4665 }
4666 
4667 static inline bool
dp_lite_mon_get_filter_ucast_data(struct cdp_pdev * pdev_handle)4668 dp_lite_mon_get_filter_ucast_data(struct cdp_pdev *pdev_handle)
4669 {
4670 	return false;
4671 }
4672 
4673 static inline bool
dp_lite_mon_get_filter_mcast_data(struct cdp_pdev * pdev_handle)4674 dp_lite_mon_get_filter_mcast_data(struct cdp_pdev *pdev_handle)
4675 {
4676 	return false;
4677 }
4678 
4679 static inline bool
dp_lite_mon_get_filter_non_data(struct cdp_pdev * pdev_handle)4680 dp_lite_mon_get_filter_non_data(struct cdp_pdev *pdev_handle)
4681 {
4682 	return false;
4683 }
4684 
4685 static inline int
dp_lite_mon_is_level_msdu(struct dp_mon_pdev * mon_pdev)4686 dp_lite_mon_is_level_msdu(struct dp_mon_pdev *mon_pdev)
4687 {
4688 	return 0;
4689 }
4690 
4691 static inline int
dp_lite_mon_is_rx_enabled(struct dp_mon_pdev * mon_pdev)4692 dp_lite_mon_is_rx_enabled(struct dp_mon_pdev *mon_pdev)
4693 {
4694 	return 0;
4695 }
4696 
4697 static inline int
dp_lite_mon_is_tx_enabled(struct dp_mon_pdev * mon_pdev)4698 dp_lite_mon_is_tx_enabled(struct dp_mon_pdev *mon_pdev)
4699 {
4700 	return 0;
4701 }
4702 
4703 static inline QDF_STATUS
dp_lite_mon_alloc(struct dp_pdev * pdev)4704 dp_lite_mon_alloc(struct dp_pdev *pdev)
4705 {
4706 	return QDF_STATUS_SUCCESS;
4707 }
4708 
4709 static inline void
dp_lite_mon_dealloc(struct dp_pdev * pdev)4710 dp_lite_mon_dealloc(struct dp_pdev *pdev)
4711 {
4712 }
4713 
4714 static inline void
dp_lite_mon_vdev_delete(struct dp_pdev * pdev,struct dp_vdev * vdev)4715 dp_lite_mon_vdev_delete(struct dp_pdev *pdev, struct dp_vdev *vdev)
4716 {
4717 }
4718 
4719 static inline int
dp_lite_mon_config_nac_peer(struct cdp_soc_t * soc_hdl,uint8_t vdev_id,uint32_t cmd,uint8_t * macaddr)4720 dp_lite_mon_config_nac_peer(struct cdp_soc_t *soc_hdl,
4721 			    uint8_t vdev_id,
4722 			    uint32_t cmd, uint8_t *macaddr)
4723 {
4724 	return 0;
4725 }
4726 
4727 static inline QDF_STATUS
dp_lite_mon_config_nac_rssi_peer(struct cdp_soc_t * soc_hdl,uint8_t vdev_id,enum cdp_nac_param_cmd cmd,char * bssid,char * macaddr,uint8_t chan_num)4728 dp_lite_mon_config_nac_rssi_peer(struct cdp_soc_t *soc_hdl,
4729 				 uint8_t vdev_id,
4730 				 enum cdp_nac_param_cmd cmd,
4731 				 char *bssid, char *macaddr,
4732 				 uint8_t chan_num)
4733 {
4734 	return QDF_STATUS_E_FAILURE;
4735 }
4736 
4737 static inline QDF_STATUS
dp_lite_mon_get_nac_peer_rssi(struct cdp_soc_t * soc_hdl,uint8_t vdev_id,char * macaddr,uint8_t * rssi)4738 dp_lite_mon_get_nac_peer_rssi(struct cdp_soc_t *soc_hdl,
4739 			      uint8_t vdev_id, char *macaddr,
4740 			      uint8_t *rssi)
4741 {
4742 	return QDF_STATUS_E_FAILURE;
4743 }
4744 
4745 static inline QDF_STATUS
dp_lite_mon_rx_mpdu_process(struct dp_pdev * pdev,struct hal_rx_ppdu_info * ppdu_info,qdf_nbuf_t mon_mpdu,uint16_t mpdu_id,uint8_t user)4746 dp_lite_mon_rx_mpdu_process(struct dp_pdev *pdev,
4747 			    struct hal_rx_ppdu_info *ppdu_info,
4748 			    qdf_nbuf_t mon_mpdu, uint16_t mpdu_id,
4749 			    uint8_t user)
4750 {
4751 	return QDF_STATUS_E_FAILURE;
4752 }
4753 
4754 static inline int
dp_lite_mon_get_legacy_feature_enabled(struct cdp_soc_t * soc,uint8_t pdev_id,uint8_t direction)4755 dp_lite_mon_get_legacy_feature_enabled(struct cdp_soc_t *soc,
4756 				       uint8_t pdev_id,
4757 				       uint8_t direction)
4758 {
4759 	return 0;
4760 }
4761 #endif
4762 
4763 #ifdef WLAN_CONFIG_TELEMETRY_AGENT
4764 static inline
dp_monitor_peer_telemetry_stats(struct dp_peer * peer,struct cdp_peer_telemetry_stats * stats)4765 void dp_monitor_peer_telemetry_stats(struct dp_peer *peer,
4766 				     struct cdp_peer_telemetry_stats *stats)
4767 {
4768 	struct dp_mon_peer_stats *mon_peer_stats = NULL;
4769 	uint8_t ac;
4770 
4771 	if (qdf_unlikely(!peer->monitor_peer))
4772 		return;
4773 
4774 	mon_peer_stats = &peer->monitor_peer->stats;
4775 	for (ac = 0; ac < WME_AC_MAX; ac++) {
4776 		stats->tx_airtime_consumption[ac] =
4777 			mon_peer_stats->airtime_stats.tx_airtime_consumption[ac].avg_consumption_per_sec;
4778 		stats->rx_airtime_consumption[ac] =
4779 			mon_peer_stats->airtime_stats.rx_airtime_consumption[ac].avg_consumption_per_sec;
4780 	}
4781 	stats->tx_mpdu_retried = mon_peer_stats->tx.retries;
4782 	stats->tx_mpdu_total = mon_peer_stats->tx.tx_mpdus_tried;
4783 	stats->rx_mpdu_retried = mon_peer_stats->rx.mpdu_retry_cnt;
4784 	stats->rx_mpdu_total = mon_peer_stats->rx.rx_mpdus;
4785 	stats->snr = CDP_SNR_OUT(mon_peer_stats->rx.avg_snr);
4786 }
4787 
4788 static inline
dp_monitor_peer_deter_stats(struct dp_peer * peer,struct cdp_peer_deter_stats * stats)4789 void dp_monitor_peer_deter_stats(struct dp_peer *peer,
4790 				 struct cdp_peer_deter_stats *stats)
4791 {
4792 	struct dp_mon_peer_stats *mon_peer_stats = NULL;
4793 	struct cdp_peer_deter_stats *deter_stats;
4794 
4795 	if (qdf_unlikely(!peer->monitor_peer))
4796 		return;
4797 
4798 	mon_peer_stats = &peer->monitor_peer->stats;
4799 	deter_stats = &mon_peer_stats->deter_stats.deter[0];
4800 	qdf_mem_copy(stats, deter_stats, sizeof(*stats) * CDP_DATA_TID_MAX);
4801 }
4802 #endif
4803 
4804 /**
4805  * dp_monitor_is_tx_cap_enabled() - get tx-cature enabled/disabled
4806  * @peer: DP peer handle
4807  *
4808  * Return: true if tx-capture is enabled
4809  */
dp_monitor_is_tx_cap_enabled(struct dp_peer * peer)4810 static inline bool dp_monitor_is_tx_cap_enabled(struct dp_peer *peer)
4811 {
4812 	return peer->monitor_peer ? peer->monitor_peer->tx_cap_enabled : 0;
4813 }
4814 
4815 /**
4816  * dp_monitor_is_rx_cap_enabled() - get rx-cature enabled/disabled
4817  * @peer: DP peer handle
4818  *
4819  * Return: true if rx-capture is enabled
4820  */
dp_monitor_is_rx_cap_enabled(struct dp_peer * peer)4821 static inline bool dp_monitor_is_rx_cap_enabled(struct dp_peer *peer)
4822 {
4823 	return peer->monitor_peer ? peer->monitor_peer->rx_cap_enabled : 0;
4824 }
4825 
4826 #if !(!defined(DISABLE_MON_CONFIG) && (defined(WLAN_PKT_CAPTURE_TX_2_0) || \
4827 	defined(WLAN_PKT_CAPTURE_RX_2_0)))
4828 /**
4829  * dp_mon_get_context_size_be() - get BE specific size for mon pdev/soc
4830  * @context_type: context type for which the size is needed
4831  *
4832  * Return: size in bytes for the context_type
4833  */
4834 static inline
dp_mon_get_context_size_be(enum dp_context_type context_type)4835 qdf_size_t dp_mon_get_context_size_be(enum dp_context_type context_type)
4836 {
4837 	switch (context_type) {
4838 	case DP_CONTEXT_TYPE_MON_SOC:
4839 		return sizeof(struct dp_mon_soc);
4840 	case DP_CONTEXT_TYPE_MON_PDEV:
4841 		return sizeof(struct dp_mon_pdev);
4842 	default:
4843 		return 0;
4844 	}
4845 }
4846 #endif
4847 
4848 /**
4849  * dp_mon_rx_print_advanced_stats() - print advanced monitor stats
4850  * @soc: DP soc handle
4851  * @pdev: DP pdev handle
4852  *
4853  * Return: void
4854  */
4855 static inline void
dp_mon_rx_print_advanced_stats(struct dp_soc * soc,struct dp_pdev * pdev)4856 dp_mon_rx_print_advanced_stats(struct dp_soc *soc,
4857 			       struct dp_pdev *pdev)
4858 {
4859 	struct dp_mon_soc *mon_soc = soc->monitor_soc;
4860 	struct dp_mon_ops *monitor_ops;
4861 
4862 	if (!mon_soc) {
4863 		dp_mon_debug("mon soc is NULL");
4864 		return;
4865 	}
4866 
4867 	monitor_ops = mon_soc->mon_ops;
4868 	if (!monitor_ops ||
4869 	    !monitor_ops->mon_rx_print_advanced_stats) {
4870 		dp_mon_debug("callback not registered");
4871 		return;
4872 	}
4873 	return monitor_ops->mon_rx_print_advanced_stats(soc, pdev);
4874 }
4875 
4876 #ifdef WLAN_CONFIG_TELEMETRY_AGENT
4877 /*
4878  * dp_update_pdev_mon_telemetry_airtime_stats() - update telemetry airtime
4879  * stats in monitor pdev
4880  *
4881  *@soc: dp soc handle
4882  *@pdev_id: pdev id
4883  *
4884  * This API is used to update telemetry airtime stats in monitor pdev
4885  *
4886  * Return: Success if stats are updated, else failure
4887  */
4888 
4889 QDF_STATUS dp_pdev_update_telemetry_airtime_stats(struct cdp_soc_t *soc,
4890 						  uint8_t pdev_id);
4891 #endif
4892 
4893 /*
4894  * dp_mon_register_lpc_ops_1_0() - set local packet capture 1_0 mon ops
4895  * @mon_ops: monitor ops
4896  *
4897  * This function initializes the mon_ops callbacks.
4898  * index [0] is for Monitor 1.0 and index [1] is for Monitor 2.0
4899  * based on the @WLAN_FEATURE_LOCAL_PKT_CAPTURE macro, it sets the
4900  * appropriate callbacks
4901  *
4902  * Return: None
4903  */
4904 void dp_mon_register_lpc_ops_1_0(struct dp_mon_ops *mon_ops);
4905 
4906 /*
4907  * dp_mon_register_tx_pkt_enh_ops_1_0() - set tx pkt enh mon ops
4908  * @mon_ops: monitor ops
4909  *
4910  * Return: None
4911  */
4912 void dp_mon_register_tx_pkt_enh_ops_1_0(struct dp_mon_ops *mon_ops);
4913 
4914 #ifdef WLAN_FEATURE_LOCAL_PKT_CAPTURE
4915 /*
4916  * dp_local_pkt_capture_tx_config() - local packet capture tx config
4917  * @pdev: physical device handle
4918  *
4919  * Return: QDF_STATUS
4920  */
4921 QDF_STATUS dp_local_pkt_capture_tx_config(struct dp_pdev *pdev);
4922 
4923 /*
4924  * dp_mon_mode_local_pkt_capture() - Check if in LPC mode
4925  * @soc: DP SOC handle
4926  *
4927  * Return: True in case of LPC mode else false
4928  *
4929  */
4930 static inline bool
dp_mon_mode_local_pkt_capture(struct dp_soc * soc)4931 dp_mon_mode_local_pkt_capture(struct dp_soc *soc)
4932 {
4933 	/* Currently there is no way to distinguish between
4934 	 * Local Packet Capture and STA+Mon mode as both mode
4935 	 * uses same monitor interface. So to distinguish between
4936 	 * two mode in local_packet_capture enable case use
4937 	 * mon_flags which can be passed during monitor interface
4938 	 * add time. If "flags otherbss" is passed during
4939 	 * monitor interface add driver will consider current mode
4940 	 * as STA+MON mode, LPC otherwise.
4941 	 */
4942 	if (wlan_cfg_get_local_pkt_capture(soc->wlan_cfg_ctx) &&
4943 	    !(soc->mon_flags & QDF_MONITOR_FLAG_OTHER_BSS))
4944 		return true;
4945 
4946 	return false;
4947 }
4948 #else
4949 static inline
dp_local_pkt_capture_tx_config(struct dp_pdev * pdev)4950 QDF_STATUS dp_local_pkt_capture_tx_config(struct dp_pdev *pdev)
4951 {
4952 	return QDF_STATUS_SUCCESS;
4953 }
4954 
4955 static inline bool
dp_mon_mode_local_pkt_capture(struct dp_soc * soc)4956 dp_mon_mode_local_pkt_capture(struct dp_soc *soc)
4957 {
4958 	return false;
4959 }
4960 #endif
4961 
4962 #ifdef WIFI_MONITOR_SUPPORT
4963 void
4964 dp_check_and_dump_full_mon_info(struct dp_soc *soc, struct dp_pdev *pdev,
4965 				int mac_id, int war);
4966 
4967 /**
4968  * dp_mon_rx_ppdu_status_reset() - reset and clear ppdu rx status
4969  * @mon_pdev: monitor pdev
4970  *
4971  * Return: none
4972  */
4973 static inline void
dp_mon_rx_ppdu_status_reset(struct dp_mon_pdev * mon_pdev)4974 dp_mon_rx_ppdu_status_reset(struct dp_mon_pdev *mon_pdev)
4975 {
4976 	mon_pdev->mon_ppdu_status = DP_PPDU_STATUS_START;
4977 	mon_pdev->ppdu_info.com_info.num_users = 0;
4978 	qdf_mem_zero(&mon_pdev->ppdu_info.rx_status,
4979 		     sizeof(mon_pdev->ppdu_info.rx_status));
4980 }
4981 #else
4982 void
4983 dp_check_and_dump_full_mon_info(struct dp_soc *soc, struct dp_pdev *pdev,
4984 				int mac_id, int war);
4985 
4986 {
4987 }
4988 
4989 static inline void
dp_mon_rx_ppdu_status_reset(struct dp_mon_pdev * mon_pdev)4990 dp_mon_rx_ppdu_status_reset(struct dp_mon_pdev *mon_pdev)
4991 {
4992 }
4993 #endif
4994 
4995 static inline void
dp_mon_pdev_filter_init(struct dp_mon_pdev * mon_pdev)4996 dp_mon_pdev_filter_init(struct dp_mon_pdev *mon_pdev)
4997 {
4998 	if (!mon_pdev)
4999 		return;
5000 
5001 	mon_pdev->mon_filter_mode = MON_FILTER_ALL;
5002 	mon_pdev->fp_mgmt_filter = FILTER_MGMT_ALL;
5003 	mon_pdev->fp_ctrl_filter = FILTER_CTRL_ALL;
5004 	mon_pdev->fp_data_filter = FILTER_DATA_ALL;
5005 	mon_pdev->mo_mgmt_filter = FILTER_MGMT_ALL;
5006 	mon_pdev->mo_ctrl_filter = FILTER_CTRL_ALL;
5007 	mon_pdev->mo_data_filter = FILTER_DATA_ALL;
5008 }
5009 #endif /* _DP_MON_H_ */
5010