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