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