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