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