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 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #ifndef _DP_INTERNAL_H_ 21 #define _DP_INTERNAL_H_ 22 23 #include "dp_types.h" 24 #include "dp_htt.h" 25 26 #define RX_BUFFER_SIZE_PKTLOG_LITE 1024 27 28 #define DP_PEER_WDS_COUNT_INVALID UINT_MAX 29 30 #define DP_BLOCKMEM_SIZE 4096 31 32 /* Alignment for consistent memory for DP rings*/ 33 #define DP_RING_BASE_ALIGN 32 34 35 #define DP_RSSI_INVAL 0x80 36 #define DP_RSSI_AVG_WEIGHT 2 37 /* 38 * Formula to derive avg_rssi is taken from wifi2.o firmware 39 */ 40 #define DP_GET_AVG_RSSI(avg_rssi, last_rssi) \ 41 (((avg_rssi) - (((uint8_t)(avg_rssi)) >> DP_RSSI_AVG_WEIGHT)) \ 42 + ((((uint8_t)(last_rssi)) >> DP_RSSI_AVG_WEIGHT))) 43 44 /* Macro For NYSM value received in VHT TLV */ 45 #define VHT_SGI_NYSM 3 46 47 #define INVALID_WBM_RING_NUM 0xF 48 49 /* struct htt_dbgfs_cfg - structure to maintain required htt data 50 * @msg_word: htt msg sent to upper layer 51 * @m: qdf debugfs file pointer 52 */ 53 struct htt_dbgfs_cfg { 54 uint32_t *msg_word; 55 qdf_debugfs_file_t m; 56 }; 57 58 /* Cookie MSB bits assigned for different use case. 59 * Note: User can't use last 3 bits, as it is reserved for pdev_id. 60 * If in future number of pdev are more than 3. 61 */ 62 /* Reserve for default case */ 63 #define DBG_STATS_COOKIE_DEFAULT 0x0 64 65 /* Reserve for DP Stats: 3rd bit */ 66 #define DBG_STATS_COOKIE_DP_STATS BIT(3) 67 68 /* Reserve for HTT Stats debugfs support: 4th bit */ 69 #define DBG_STATS_COOKIE_HTT_DBGFS BIT(4) 70 71 /*Reserve for HTT Stats debugfs support: 5th bit */ 72 #define DBG_SYSFS_STATS_COOKIE BIT(5) 73 74 /* Reserve for HTT Stats OBSS PD support: 6th bit */ 75 #define DBG_STATS_COOKIE_HTT_OBSS BIT(6) 76 77 /** 78 * Bitmap of HTT PPDU TLV types for Default mode 79 */ 80 #define HTT_PPDU_DEFAULT_TLV_BITMAP \ 81 (1 << HTT_PPDU_STATS_COMMON_TLV) | \ 82 (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ 83 (1 << HTT_PPDU_STATS_USR_RATE_TLV) | \ 84 (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \ 85 (1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \ 86 (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) 87 88 /* PPDU STATS CFG */ 89 #define DP_PPDU_STATS_CFG_ALL 0xFFFF 90 91 /* PPDU stats mask sent to FW to enable enhanced stats */ 92 #define DP_PPDU_STATS_CFG_ENH_STATS \ 93 (HTT_PPDU_DEFAULT_TLV_BITMAP) | \ 94 (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \ 95 (1 << HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV) | \ 96 (1 << HTT_PPDU_STATS_USERS_INFO_TLV) 97 98 /* PPDU stats mask sent to FW to support debug sniffer feature */ 99 #define DP_PPDU_STATS_CFG_SNIFFER \ 100 (HTT_PPDU_DEFAULT_TLV_BITMAP) | \ 101 (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV) | \ 102 (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV) | \ 103 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV) | \ 104 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \ 105 (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \ 106 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \ 107 (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \ 108 (1 << HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV) | \ 109 (1 << HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) | \ 110 (1 << HTT_PPDU_STATS_USERS_INFO_TLV) 111 112 /* PPDU stats mask sent to FW to support BPR feature*/ 113 #define DP_PPDU_STATS_CFG_BPR \ 114 (1 << HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) | \ 115 (1 << HTT_PPDU_STATS_USERS_INFO_TLV) 116 117 /* PPDU stats mask sent to FW to support BPR and enhanced stats feature */ 118 #define DP_PPDU_STATS_CFG_BPR_ENH (DP_PPDU_STATS_CFG_BPR | \ 119 DP_PPDU_STATS_CFG_ENH_STATS) 120 /* PPDU stats mask sent to FW to support BPR and pcktlog stats feature */ 121 #define DP_PPDU_STATS_CFG_BPR_PKTLOG (DP_PPDU_STATS_CFG_BPR | \ 122 DP_PPDU_TXLITE_STATS_BITMASK_CFG) 123 124 /** 125 * Bitmap of HTT PPDU delayed ba TLV types for Default mode 126 */ 127 #define HTT_PPDU_DELAYED_BA_TLV_BITMAP \ 128 (1 << HTT_PPDU_STATS_COMMON_TLV) | \ 129 (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ 130 (1 << HTT_PPDU_STATS_USR_RATE_TLV) 131 132 /** 133 * Bitmap of HTT PPDU TLV types for Delayed BA 134 */ 135 #define HTT_PPDU_STATUS_TLV_BITMAP \ 136 (1 << HTT_PPDU_STATS_COMMON_TLV) | \ 137 (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) 138 139 /** 140 * Bitmap of HTT PPDU TLV types for Sniffer mode bitmap 64 141 */ 142 #define HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_64 \ 143 ((1 << HTT_PPDU_STATS_COMMON_TLV) | \ 144 (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ 145 (1 << HTT_PPDU_STATS_USR_RATE_TLV) | \ 146 (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \ 147 (1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \ 148 (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) | \ 149 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV) | \ 150 (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV)) 151 152 /** 153 * Bitmap of HTT PPDU TLV types for Sniffer mode bitmap 256 154 */ 155 #define HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_256 \ 156 ((1 << HTT_PPDU_STATS_COMMON_TLV) | \ 157 (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ 158 (1 << HTT_PPDU_STATS_USR_RATE_TLV) | \ 159 (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \ 160 (1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \ 161 (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) | \ 162 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \ 163 (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV)) 164 165 static const enum cdp_packet_type hal_2_dp_pkt_type_map[HAL_DOT11_MAX] = { 166 [HAL_DOT11A] = DOT11_A, 167 [HAL_DOT11B] = DOT11_B, 168 [HAL_DOT11N_MM] = DOT11_N, 169 [HAL_DOT11AC] = DOT11_AC, 170 [HAL_DOT11AX] = DOT11_AX, 171 [HAL_DOT11BA] = DOT11_MAX, 172 #ifdef WLAN_FEATURE_11BE 173 [HAL_DOT11BE] = DOT11_BE, 174 #else 175 [HAL_DOT11BE] = DOT11_MAX, 176 #endif 177 [HAL_DOT11AZ] = DOT11_MAX, 178 [HAL_DOT11N_GF] = DOT11_MAX, 179 }; 180 181 #ifdef WLAN_FEATURE_11BE 182 /** 183 * dp_get_mcs_array_index_by_pkt_type_mcs () - get the destination mcs index 184 in array 185 * @pkt_type: host SW pkt type 186 * @mcs: mcs value for TX/RX rate 187 * 188 * Return: succeeded - valid index in mcs array 189 fail - same value as MCS_MAX 190 */ 191 static inline uint8_t 192 dp_get_mcs_array_index_by_pkt_type_mcs(uint32_t pkt_type, uint32_t mcs) 193 { 194 uint8_t dst_mcs_idx = MCS_INVALID_ARRAY_INDEX; 195 196 switch (pkt_type) { 197 case DOT11_A: 198 dst_mcs_idx = 199 mcs >= MAX_MCS_11A ? (MAX_MCS - 1) : mcs; 200 break; 201 case DOT11_B: 202 dst_mcs_idx = 203 mcs >= MAX_MCS_11B ? (MAX_MCS - 1) : mcs; 204 break; 205 case DOT11_N: 206 dst_mcs_idx = 207 mcs >= MAX_MCS_11N ? (MAX_MCS - 1) : mcs; 208 break; 209 case DOT11_AC: 210 dst_mcs_idx = 211 mcs >= MAX_MCS_11AC ? (MAX_MCS - 1) : mcs; 212 break; 213 case DOT11_AX: 214 dst_mcs_idx = 215 mcs >= MAX_MCS_11AX ? (MAX_MCS - 1) : mcs; 216 break; 217 case DOT11_BE: 218 dst_mcs_idx = 219 mcs >= MAX_MCS_11BE ? (MAX_MCS - 1) : mcs; 220 break; 221 default: 222 break; 223 } 224 225 return dst_mcs_idx; 226 } 227 #else 228 static inline uint8_t 229 dp_get_mcs_array_index_by_pkt_type_mcs(uint32_t pkt_type, uint32_t mcs) 230 { 231 uint8_t dst_mcs_idx = MCS_INVALID_ARRAY_INDEX; 232 233 switch (pkt_type) { 234 case DOT11_A: 235 dst_mcs_idx = 236 mcs >= MAX_MCS_11A ? (MAX_MCS - 1) : mcs; 237 break; 238 case DOT11_B: 239 dst_mcs_idx = 240 mcs >= MAX_MCS_11B ? (MAX_MCS - 1) : mcs; 241 break; 242 case DOT11_N: 243 dst_mcs_idx = 244 mcs >= MAX_MCS_11N ? (MAX_MCS - 1) : mcs; 245 break; 246 case DOT11_AC: 247 dst_mcs_idx = 248 mcs >= MAX_MCS_11AC ? (MAX_MCS - 1) : mcs; 249 break; 250 case DOT11_AX: 251 dst_mcs_idx = 252 mcs >= MAX_MCS_11AX ? (MAX_MCS - 1) : mcs; 253 break; 254 default: 255 break; 256 } 257 258 return dst_mcs_idx; 259 } 260 #endif 261 262 QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc); 263 QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc); 264 265 /* 266 * dp_rx_err_match_dhost() - function to check whether dest-mac is correct 267 * @eh: Ethernet header of incoming packet 268 * @vdev: dp_vdev object of the VAP on which this data packet is received 269 * 270 * Return: 1 if the destination mac is correct, 271 * 0 if this frame is not correctly destined to this VAP/MLD 272 */ 273 int dp_rx_err_match_dhost(qdf_ether_header_t *eh, struct dp_vdev *vdev); 274 275 #ifdef MONITOR_MODULARIZED_ENABLE 276 static inline bool dp_monitor_modularized_enable(void) 277 { 278 return TRUE; 279 } 280 281 static inline QDF_STATUS 282 dp_mon_soc_attach_wrapper(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } 283 284 static inline QDF_STATUS 285 dp_mon_soc_detach_wrapper(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } 286 #else 287 static inline bool dp_monitor_modularized_enable(void) 288 { 289 return FALSE; 290 } 291 292 static inline QDF_STATUS dp_mon_soc_attach_wrapper(struct dp_soc *soc) 293 { 294 return dp_mon_soc_attach(soc); 295 } 296 297 static inline QDF_STATUS dp_mon_soc_detach_wrapper(struct dp_soc *soc) 298 { 299 return dp_mon_soc_detach(soc); 300 } 301 #endif 302 303 #ifndef WIFI_MONITOR_SUPPORT 304 #define MON_BUF_MIN_ENTRIES 64 305 306 static inline QDF_STATUS dp_monitor_pdev_attach(struct dp_pdev *pdev) 307 { 308 return QDF_STATUS_SUCCESS; 309 } 310 311 static inline QDF_STATUS dp_monitor_pdev_detach(struct dp_pdev *pdev) 312 { 313 return QDF_STATUS_SUCCESS; 314 } 315 316 static inline QDF_STATUS dp_monitor_vdev_attach(struct dp_vdev *vdev) 317 { 318 return QDF_STATUS_E_FAILURE; 319 } 320 321 static inline QDF_STATUS dp_monitor_vdev_detach(struct dp_vdev *vdev) 322 { 323 return QDF_STATUS_E_FAILURE; 324 } 325 326 static inline QDF_STATUS dp_monitor_peer_attach(struct dp_soc *soc, 327 struct dp_peer *peer) 328 { 329 return QDF_STATUS_SUCCESS; 330 } 331 332 static inline QDF_STATUS dp_monitor_peer_detach(struct dp_soc *soc, 333 struct dp_peer *peer) 334 { 335 return QDF_STATUS_E_FAILURE; 336 } 337 338 static inline struct cdp_peer_rate_stats_ctx* 339 dp_monitor_peer_get_peerstats_ctx(struct dp_soc *soc, struct dp_peer *peer) 340 { 341 return NULL; 342 } 343 344 static inline 345 void dp_monitor_peer_reset_stats(struct dp_soc *soc, struct dp_peer *peer) 346 { 347 } 348 349 static inline 350 void dp_monitor_peer_get_stats(struct dp_soc *soc, struct dp_peer *peer, 351 void *arg, enum cdp_stat_update_type type) 352 { 353 } 354 355 static inline 356 void dp_monitor_invalid_peer_update_pdev_stats(struct dp_soc *soc, 357 struct dp_pdev *pdev) 358 { 359 } 360 361 static inline 362 QDF_STATUS dp_monitor_peer_get_stats_param(struct dp_soc *soc, 363 struct dp_peer *peer, 364 enum cdp_peer_stats_type type, 365 cdp_peer_stats_param_t *buf) 366 { 367 return QDF_STATUS_E_FAILURE; 368 } 369 370 static inline QDF_STATUS dp_monitor_pdev_init(struct dp_pdev *pdev) 371 { 372 return QDF_STATUS_SUCCESS; 373 } 374 375 static inline QDF_STATUS dp_monitor_pdev_deinit(struct dp_pdev *pdev) 376 { 377 return QDF_STATUS_SUCCESS; 378 } 379 380 static inline QDF_STATUS dp_monitor_soc_cfg_init(struct dp_soc *soc) 381 { 382 return QDF_STATUS_SUCCESS; 383 } 384 385 static inline QDF_STATUS dp_monitor_config_debug_sniffer(struct dp_pdev *pdev, 386 int val) 387 { 388 return QDF_STATUS_E_FAILURE; 389 } 390 391 static inline void dp_monitor_flush_rings(struct dp_soc *soc) 392 { 393 } 394 395 static inline QDF_STATUS dp_monitor_htt_srng_setup(struct dp_soc *soc, 396 struct dp_pdev *pdev, 397 int mac_id, 398 int mac_for_pdev) 399 { 400 return QDF_STATUS_SUCCESS; 401 } 402 403 static inline void dp_monitor_service_mon_rings(struct dp_soc *soc, 404 uint32_t quota) 405 { 406 } 407 408 static inline 409 uint32_t dp_monitor_process(struct dp_soc *soc, struct dp_intr *int_ctx, 410 uint32_t mac_id, uint32_t quota) 411 { 412 return 0; 413 } 414 415 static inline 416 uint32_t dp_monitor_drop_packets_for_mac(struct dp_pdev *pdev, 417 uint32_t mac_id, uint32_t quota) 418 { 419 return 0; 420 } 421 422 static inline void dp_monitor_peer_tx_init(struct dp_pdev *pdev, 423 struct dp_peer *peer) 424 { 425 } 426 427 static inline void dp_monitor_peer_tx_cleanup(struct dp_vdev *vdev, 428 struct dp_peer *peer) 429 { 430 } 431 432 static inline 433 void dp_monitor_peer_tid_peer_id_update(struct dp_soc *soc, 434 struct dp_peer *peer, 435 uint16_t peer_id) 436 { 437 } 438 439 static inline void dp_monitor_tx_ppdu_stats_attach(struct dp_pdev *pdev) 440 { 441 } 442 443 static inline void dp_monitor_tx_ppdu_stats_detach(struct dp_pdev *pdev) 444 { 445 } 446 447 static inline 448 QDF_STATUS dp_monitor_tx_capture_debugfs_init(struct dp_pdev *pdev) 449 { 450 return QDF_STATUS_SUCCESS; 451 } 452 453 static inline void dp_monitor_peer_tx_capture_filter_check(struct dp_pdev *pdev, 454 struct dp_peer *peer) 455 { 456 } 457 458 static inline 459 QDF_STATUS dp_monitor_tx_add_to_comp_queue(struct dp_soc *soc, 460 struct dp_tx_desc_s *desc, 461 struct hal_tx_completion_status *ts, 462 uint16_t peer_id) 463 { 464 return QDF_STATUS_E_FAILURE; 465 } 466 467 static inline 468 QDF_STATUS monitor_update_msdu_to_list(struct dp_soc *soc, 469 struct dp_pdev *pdev, 470 struct dp_peer *peer, 471 struct hal_tx_completion_status *ts, 472 qdf_nbuf_t netbuf) 473 { 474 return QDF_STATUS_E_FAILURE; 475 } 476 477 static inline bool dp_monitor_ppdu_stats_ind_handler(struct htt_soc *soc, 478 uint32_t *msg_word, 479 qdf_nbuf_t htt_t2h_msg) 480 { 481 return true; 482 } 483 484 static inline QDF_STATUS dp_monitor_htt_ppdu_stats_attach(struct dp_pdev *pdev) 485 { 486 return QDF_STATUS_SUCCESS; 487 } 488 489 static inline void dp_monitor_htt_ppdu_stats_detach(struct dp_pdev *pdev) 490 { 491 } 492 493 static inline void dp_monitor_print_pdev_rx_mon_stats(struct dp_pdev *pdev) 494 { 495 } 496 497 static inline QDF_STATUS dp_monitor_config_enh_tx_capture(struct dp_pdev *pdev, 498 uint32_t val) 499 { 500 return QDF_STATUS_E_INVAL; 501 } 502 503 static inline QDF_STATUS dp_monitor_tx_peer_filter(struct dp_pdev *pdev, 504 struct dp_peer *peer, 505 uint8_t is_tx_pkt_cap_enable, 506 uint8_t *peer_mac) 507 { 508 return QDF_STATUS_E_INVAL; 509 } 510 511 static inline QDF_STATUS dp_monitor_config_enh_rx_capture(struct dp_pdev *pdev, 512 uint32_t val) 513 { 514 return QDF_STATUS_E_INVAL; 515 } 516 517 static inline 518 QDF_STATUS dp_monitor_set_bpr_enable(struct dp_pdev *pdev, uint32_t val) 519 { 520 return QDF_STATUS_E_FAILURE; 521 } 522 523 static inline 524 int dp_monitor_set_filter_neigh_peers(struct dp_pdev *pdev, bool val) 525 { 526 return 0; 527 } 528 529 static inline 530 void dp_monitor_set_atf_stats_enable(struct dp_pdev *pdev, bool value) 531 { 532 } 533 534 static inline 535 void dp_monitor_set_bsscolor(struct dp_pdev *pdev, uint8_t bsscolor) 536 { 537 } 538 539 static inline 540 bool dp_monitor_pdev_get_filter_mcast_data(struct cdp_pdev *pdev_handle) 541 { 542 return false; 543 } 544 545 static inline 546 bool dp_monitor_pdev_get_filter_non_data(struct cdp_pdev *pdev_handle) 547 { 548 return false; 549 } 550 551 static inline 552 bool dp_monitor_pdev_get_filter_ucast_data(struct cdp_pdev *pdev_handle) 553 { 554 return false; 555 } 556 557 static inline 558 int dp_monitor_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event, 559 bool enable) 560 { 561 return 0; 562 } 563 564 static inline void dp_monitor_pktlogmod_exit(struct dp_pdev *pdev) 565 { 566 } 567 568 static inline 569 QDF_STATUS dp_monitor_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev) 570 { 571 return QDF_STATUS_E_FAILURE; 572 } 573 574 static inline 575 void dp_monitor_neighbour_peers_detach(struct dp_pdev *pdev) 576 { 577 } 578 579 static inline QDF_STATUS dp_monitor_filter_neighbour_peer(struct dp_pdev *pdev, 580 uint8_t *rx_pkt_hdr) 581 { 582 return QDF_STATUS_E_FAILURE; 583 } 584 585 static inline void dp_monitor_print_pdev_tx_capture_stats(struct dp_pdev *pdev) 586 { 587 } 588 589 static inline 590 void dp_monitor_reap_timer_init(struct dp_soc *soc) 591 { 592 } 593 594 static inline 595 void dp_monitor_reap_timer_deinit(struct dp_soc *soc) 596 { 597 } 598 599 static inline 600 bool dp_monitor_reap_timer_start(struct dp_soc *soc, 601 enum cdp_mon_reap_source source) 602 { 603 return false; 604 } 605 606 static inline 607 bool dp_monitor_reap_timer_stop(struct dp_soc *soc, 608 enum cdp_mon_reap_source source) 609 { 610 return false; 611 } 612 613 static inline 614 void dp_monitor_vdev_timer_init(struct dp_soc *soc) 615 { 616 } 617 618 static inline 619 void dp_monitor_vdev_timer_deinit(struct dp_soc *soc) 620 { 621 } 622 623 static inline 624 void dp_monitor_vdev_timer_start(struct dp_soc *soc) 625 { 626 } 627 628 static inline 629 bool dp_monitor_vdev_timer_stop(struct dp_soc *soc) 630 { 631 return false; 632 } 633 634 static inline struct qdf_mem_multi_page_t* 635 dp_monitor_get_link_desc_pages(struct dp_soc *soc, uint32_t mac_id) 636 { 637 return NULL; 638 } 639 640 static inline uint32_t * 641 dp_monitor_get_total_link_descs(struct dp_soc *soc, uint32_t mac_id) 642 { 643 return NULL; 644 } 645 646 static inline QDF_STATUS dp_monitor_drop_inv_peer_pkts(struct dp_vdev *vdev) 647 { 648 return QDF_STATUS_E_FAILURE; 649 } 650 651 static inline bool dp_is_enable_reap_timer_non_pkt(struct dp_pdev *pdev) 652 { 653 return false; 654 } 655 656 static inline void dp_monitor_vdev_register_osif(struct dp_vdev *vdev, 657 struct ol_txrx_ops *txrx_ops) 658 { 659 } 660 661 static inline bool dp_monitor_is_vdev_timer_running(struct dp_soc *soc) 662 { 663 return false; 664 } 665 666 static inline 667 void dp_monitor_pdev_set_mon_vdev(struct dp_vdev *vdev) 668 { 669 } 670 671 static inline void dp_monitor_vdev_delete(struct dp_soc *soc, 672 struct dp_vdev *vdev) 673 { 674 } 675 676 static inline void dp_peer_ppdu_delayed_ba_init(struct dp_peer *peer) 677 { 678 } 679 680 static inline void dp_monitor_neighbour_peer_add_ast(struct dp_pdev *pdev, 681 struct dp_peer *ta_peer, 682 uint8_t *mac_addr, 683 qdf_nbuf_t nbuf, 684 uint32_t flags) 685 { 686 } 687 688 static inline void 689 dp_monitor_set_chan_band(struct dp_pdev *pdev, enum reg_wifi_band chan_band) 690 { 691 } 692 693 static inline void 694 dp_monitor_set_chan_freq(struct dp_pdev *pdev, qdf_freq_t chan_freq) 695 { 696 } 697 698 static inline void dp_monitor_set_chan_num(struct dp_pdev *pdev, int chan_num) 699 { 700 } 701 702 static inline bool dp_monitor_is_enable_mcopy_mode(struct dp_pdev *pdev) 703 { 704 return false; 705 } 706 707 static inline 708 void dp_monitor_neighbour_peer_list_remove(struct dp_pdev *pdev, 709 struct dp_vdev *vdev, 710 struct dp_neighbour_peer *peer) 711 { 712 } 713 714 static inline bool dp_monitor_is_chan_band_known(struct dp_pdev *pdev) 715 { 716 return false; 717 } 718 719 static inline enum reg_wifi_band 720 dp_monitor_get_chan_band(struct dp_pdev *pdev) 721 { 722 return 0; 723 } 724 725 static inline int 726 dp_monitor_get_chan_num(struct dp_pdev *pdev) 727 { 728 return 0; 729 } 730 731 static inline qdf_freq_t 732 dp_monitor_get_chan_freq(struct dp_pdev *pdev) 733 { 734 return 0; 735 } 736 737 static inline void dp_monitor_get_mpdu_status(struct dp_pdev *pdev, 738 struct dp_soc *soc, 739 uint8_t *rx_tlv_hdr) 740 { 741 } 742 743 static inline void dp_monitor_print_tx_stats(struct dp_pdev *pdev) 744 { 745 } 746 747 static inline 748 QDF_STATUS dp_monitor_mcopy_check_deliver(struct dp_pdev *pdev, 749 uint16_t peer_id, uint32_t ppdu_id, 750 uint8_t first_msdu) 751 { 752 return QDF_STATUS_SUCCESS; 753 } 754 755 static inline bool dp_monitor_is_enable_tx_sniffer(struct dp_pdev *pdev) 756 { 757 return false; 758 } 759 760 static inline struct dp_vdev* 761 dp_monitor_get_monitor_vdev_from_pdev(struct dp_pdev *pdev) 762 { 763 return NULL; 764 } 765 766 static inline QDF_STATUS dp_monitor_check_com_info_ppdu_id(struct dp_pdev *pdev, 767 void *rx_desc) 768 { 769 return QDF_STATUS_E_FAILURE; 770 } 771 772 static inline struct mon_rx_status* 773 dp_monitor_get_rx_status(struct dp_pdev *pdev) 774 { 775 return NULL; 776 } 777 778 static inline 779 void dp_monitor_pdev_config_scan_spcl_vap(struct dp_pdev *pdev, bool val) 780 { 781 } 782 783 static inline 784 void dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev *pdev, 785 bool val) 786 { 787 } 788 789 static inline QDF_STATUS 790 dp_monitor_peer_tx_capture_get_stats(struct dp_soc *soc, struct dp_peer *peer, 791 struct cdp_peer_tx_capture_stats *stats) 792 { 793 return QDF_STATUS_E_FAILURE; 794 } 795 796 static inline QDF_STATUS 797 dp_monitor_pdev_tx_capture_get_stats(struct dp_soc *soc, struct dp_pdev *pdev, 798 struct cdp_pdev_tx_capture_stats *stats) 799 { 800 return QDF_STATUS_E_FAILURE; 801 } 802 803 #ifdef DP_POWER_SAVE 804 static inline 805 void dp_monitor_pktlog_reap_pending_frames(struct dp_pdev *pdev) 806 { 807 } 808 809 static inline 810 void dp_monitor_pktlog_start_reap_timer(struct dp_pdev *pdev) 811 { 812 } 813 #endif 814 815 static inline bool dp_monitor_is_configured(struct dp_pdev *pdev) 816 { 817 return false; 818 } 819 820 static inline void 821 dp_mon_rx_hdr_length_set(struct dp_soc *soc, uint32_t *msg_word, 822 struct htt_rx_ring_tlv_filter *tlv_filter) 823 { 824 } 825 826 static inline void dp_monitor_soc_init(struct dp_soc *soc) 827 { 828 } 829 830 static inline void dp_monitor_soc_deinit(struct dp_soc *soc) 831 { 832 } 833 834 static inline 835 QDF_STATUS dp_monitor_config_undecoded_metadata_capture(struct dp_pdev *pdev, 836 int val) 837 { 838 return QDF_STATUS_SUCCESS; 839 } 840 841 static inline QDF_STATUS 842 dp_monitor_config_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev, 843 int mask1, int mask2) 844 { 845 return QDF_STATUS_SUCCESS; 846 } 847 848 static inline QDF_STATUS 849 dp_monitor_get_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev, 850 int *mask, int *mask_cont) 851 { 852 return QDF_STATUS_SUCCESS; 853 } 854 855 static inline QDF_STATUS dp_monitor_soc_htt_srng_setup(struct dp_soc *soc) 856 { 857 return QDF_STATUS_E_FAILURE; 858 } 859 860 static inline bool dp_is_monitor_mode_using_poll(struct dp_soc *soc) 861 { 862 return false; 863 } 864 865 static inline 866 uint32_t dp_tx_mon_buf_refill(struct dp_intr *int_ctx) 867 { 868 return 0; 869 } 870 871 static inline uint32_t 872 dp_tx_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx, 873 uint32_t mac_id, uint32_t quota) 874 { 875 return 0; 876 } 877 878 static inline 879 uint32_t dp_rx_mon_buf_refill(struct dp_intr *int_ctx) 880 { 881 return 0; 882 } 883 884 static inline bool dp_monitor_is_tx_cap_enabled(struct dp_peer *peer) 885 { 886 return 0; 887 } 888 889 static inline bool dp_monitor_is_rx_cap_enabled(struct dp_peer *peer) 890 { 891 return 0; 892 } 893 894 static inline void 895 dp_rx_mon_enable(struct dp_soc *soc, uint32_t *msg_word, 896 struct htt_rx_ring_tlv_filter *tlv_filter) 897 { 898 } 899 900 static inline void 901 dp_mon_rx_packet_length_set(struct dp_soc *soc, uint32_t *msg_word, 902 struct htt_rx_ring_tlv_filter *tlv_filter) 903 { 904 } 905 906 static inline void 907 dp_mon_rx_enable_mpdu_logging(struct dp_soc *soc, uint32_t *msg_word, 908 struct htt_rx_ring_tlv_filter *tlv_filter) 909 { 910 } 911 912 static inline void 913 dp_mon_rx_wmask_subscribe(struct dp_soc *soc, uint32_t *msg_word, 914 struct htt_rx_ring_tlv_filter *tlv_filter) 915 { 916 } 917 918 static inline 919 void dp_monitor_peer_telemetry_stats(struct dp_peer *peer, 920 struct cdp_peer_telemetry_stats *stats) 921 { 922 } 923 #endif 924 925 /** 926 * cdp_soc_t_to_dp_soc() - typecast cdp_soc_t to 927 * dp soc handle 928 * @psoc: CDP psoc handle 929 * 930 * Return: struct dp_soc pointer 931 */ 932 static inline 933 struct dp_soc *cdp_soc_t_to_dp_soc(struct cdp_soc_t *psoc) 934 { 935 return (struct dp_soc *)psoc; 936 } 937 938 #define DP_MAX_TIMER_EXEC_TIME_TICKS \ 939 (QDF_LOG_TIMESTAMP_CYCLES_PER_10_US * 100 * 20) 940 941 /** 942 * enum timer_yield_status - yield status code used in monitor mode timer. 943 * @DP_TIMER_NO_YIELD: do not yield 944 * @DP_TIMER_WORK_DONE: yield because work is done 945 * @DP_TIMER_WORK_EXHAUST: yield because work quota is exhausted 946 * @DP_TIMER_TIME_EXHAUST: yield due to time slot exhausted 947 */ 948 enum timer_yield_status { 949 DP_TIMER_NO_YIELD, 950 DP_TIMER_WORK_DONE, 951 DP_TIMER_WORK_EXHAUST, 952 DP_TIMER_TIME_EXHAUST, 953 }; 954 955 #if DP_PRINT_ENABLE 956 #include <qdf_types.h> /* qdf_vprint */ 957 #include <cdp_txrx_handle.h> 958 959 enum { 960 /* FATAL_ERR - print only irrecoverable error messages */ 961 DP_PRINT_LEVEL_FATAL_ERR, 962 963 /* ERR - include non-fatal err messages */ 964 DP_PRINT_LEVEL_ERR, 965 966 /* WARN - include warnings */ 967 DP_PRINT_LEVEL_WARN, 968 969 /* INFO1 - include fundamental, infrequent events */ 970 DP_PRINT_LEVEL_INFO1, 971 972 /* INFO2 - include non-fundamental but infrequent events */ 973 DP_PRINT_LEVEL_INFO2, 974 }; 975 976 #define dp_print(level, fmt, ...) do { \ 977 if (level <= g_txrx_print_level) \ 978 qdf_print(fmt, ## __VA_ARGS__); \ 979 while (0) 980 #define DP_PRINT(level, fmt, ...) do { \ 981 dp_print(level, "DP: " fmt, ## __VA_ARGS__); \ 982 while (0) 983 #else 984 #define DP_PRINT(level, fmt, ...) 985 #endif /* DP_PRINT_ENABLE */ 986 987 #define DP_TRACE(LVL, fmt, args ...) \ 988 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_##LVL, \ 989 fmt, ## args) 990 991 #ifdef WLAN_SYSFS_DP_STATS 992 void DP_PRINT_STATS(const char *fmt, ...); 993 #else /* WLAN_SYSFS_DP_STATS */ 994 #ifdef DP_PRINT_NO_CONSOLE 995 /* Stat prints should not go to console or kernel logs.*/ 996 #define DP_PRINT_STATS(fmt, args ...)\ 997 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO_HIGH, \ 998 fmt, ## args) 999 #else 1000 #define DP_PRINT_STATS(fmt, args ...)\ 1001 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL,\ 1002 fmt, ## args) 1003 #endif 1004 #endif /* WLAN_SYSFS_DP_STATS */ 1005 1006 #define DP_STATS_INIT(_handle) \ 1007 qdf_mem_zero(&((_handle)->stats), sizeof((_handle)->stats)) 1008 1009 #define DP_STATS_CLR(_handle) \ 1010 qdf_mem_zero(&((_handle)->stats), sizeof((_handle)->stats)) 1011 1012 #ifndef DISABLE_DP_STATS 1013 #define DP_STATS_INC(_handle, _field, _delta) \ 1014 { \ 1015 if (likely(_handle)) \ 1016 _handle->stats._field += _delta; \ 1017 } 1018 1019 #define DP_PEER_STATS_FLAT_INC(_handle, _field, _delta) \ 1020 { \ 1021 if (likely(_handle)) \ 1022 _handle->_field += _delta; \ 1023 } 1024 1025 #define DP_STATS_INCC(_handle, _field, _delta, _cond) \ 1026 { \ 1027 if (_cond && likely(_handle)) \ 1028 _handle->stats._field += _delta; \ 1029 } 1030 1031 #define DP_STATS_DEC(_handle, _field, _delta) \ 1032 { \ 1033 if (likely(_handle)) \ 1034 _handle->stats._field -= _delta; \ 1035 } 1036 1037 #define DP_PEER_STATS_FLAT_DEC(_handle, _field, _delta) \ 1038 { \ 1039 if (likely(_handle)) \ 1040 _handle->_field -= _delta; \ 1041 } 1042 1043 #define DP_STATS_UPD(_handle, _field, _delta) \ 1044 { \ 1045 if (likely(_handle)) \ 1046 _handle->stats._field = _delta; \ 1047 } 1048 1049 #define DP_STATS_INC_PKT(_handle, _field, _count, _bytes) \ 1050 { \ 1051 DP_STATS_INC(_handle, _field.num, _count); \ 1052 DP_STATS_INC(_handle, _field.bytes, _bytes) \ 1053 } 1054 1055 #define DP_PEER_STATS_FLAT_INC_PKT(_handle, _field, _count, _bytes) \ 1056 { \ 1057 DP_PEER_STATS_FLAT_INC(_handle, _field.num, _count); \ 1058 DP_PEER_STATS_FLAT_INC(_handle, _field.bytes, _bytes) \ 1059 } 1060 1061 #define DP_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond) \ 1062 { \ 1063 DP_STATS_INCC(_handle, _field.num, _count, _cond); \ 1064 DP_STATS_INCC(_handle, _field.bytes, _bytes, _cond) \ 1065 } 1066 1067 #define DP_STATS_AGGR(_handle_a, _handle_b, _field) \ 1068 { \ 1069 _handle_a->stats._field += _handle_b->stats._field; \ 1070 } 1071 1072 #define DP_STATS_AGGR_PKT(_handle_a, _handle_b, _field) \ 1073 { \ 1074 DP_STATS_AGGR(_handle_a, _handle_b, _field.num); \ 1075 DP_STATS_AGGR(_handle_a, _handle_b, _field.bytes);\ 1076 } 1077 1078 #define DP_STATS_UPD_STRUCT(_handle_a, _handle_b, _field) \ 1079 { \ 1080 _handle_a->stats._field = _handle_b->stats._field; \ 1081 } 1082 1083 #else 1084 #define DP_STATS_INC(_handle, _field, _delta) 1085 #define DP_PEER_STATS_FLAT_INC(_handle, _field, _delta) 1086 #define DP_STATS_INCC(_handle, _field, _delta, _cond) 1087 #define DP_STATS_DEC(_handle, _field, _delta) 1088 #define DP_PEER_STATS_FLAT_DEC(_handle, _field, _delta) 1089 #define DP_STATS_UPD(_handle, _field, _delta) 1090 #define DP_STATS_INC_PKT(_handle, _field, _count, _bytes) 1091 #define DP_PEER_STATS_FLAT_INC_PKT(_handle, _field, _count, _bytes) 1092 #define DP_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond) 1093 #define DP_STATS_AGGR(_handle_a, _handle_b, _field) 1094 #define DP_STATS_AGGR_PKT(_handle_a, _handle_b, _field) 1095 #endif 1096 1097 #define DP_PEER_PER_PKT_STATS_INC(_handle, _field, _delta) \ 1098 { \ 1099 DP_STATS_INC(_handle, per_pkt_stats._field, _delta); \ 1100 } 1101 1102 #define DP_PEER_PER_PKT_STATS_INCC(_handle, _field, _delta, _cond) \ 1103 { \ 1104 DP_STATS_INCC(_handle, per_pkt_stats._field, _delta, _cond); \ 1105 } 1106 1107 #define DP_PEER_PER_PKT_STATS_INC_PKT(_handle, _field, _count, _bytes) \ 1108 { \ 1109 DP_PEER_PER_PKT_STATS_INC(_handle, _field.num, _count); \ 1110 DP_PEER_PER_PKT_STATS_INC(_handle, _field.bytes, _bytes) \ 1111 } 1112 1113 #define DP_PEER_PER_PKT_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond) \ 1114 { \ 1115 DP_PEER_PER_PKT_STATS_INCC(_handle, _field.num, _count, _cond); \ 1116 DP_PEER_PER_PKT_STATS_INCC(_handle, _field.bytes, _bytes, _cond) \ 1117 } 1118 1119 #ifndef QCA_ENHANCED_STATS_SUPPORT 1120 #define DP_PEER_EXTD_STATS_INC(_handle, _field, _delta) \ 1121 { \ 1122 DP_STATS_INC(_handle, extd_stats._field, _delta); \ 1123 } 1124 1125 #define DP_PEER_EXTD_STATS_INCC(_handle, _field, _delta, _cond) \ 1126 { \ 1127 DP_STATS_INCC(_handle, extd_stats._field, _delta, _cond); \ 1128 } 1129 1130 #define DP_PEER_EXTD_STATS_UPD(_handle, _field, _delta) \ 1131 { \ 1132 DP_STATS_UPD(_handle, extd_stats._field, _delta); \ 1133 } 1134 #endif 1135 1136 #if defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT) && \ 1137 defined(QCA_ENHANCED_STATS_SUPPORT) 1138 #define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \ 1139 { \ 1140 if (_cond || !(_handle->hw_txrx_stats_en)) \ 1141 DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); \ 1142 } 1143 1144 #define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \ 1145 { \ 1146 if (_cond || !(_handle->hw_txrx_stats_en)) \ 1147 DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); \ 1148 } 1149 1150 #define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond) \ 1151 { \ 1152 if (_cond || !(_handle->hw_txrx_stats_en)) \ 1153 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes); \ 1154 } 1155 1156 #define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond) \ 1157 { \ 1158 if (_cond || !(_handle->hw_txrx_stats_en)) \ 1159 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes); \ 1160 } 1161 #elif defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT) 1162 #define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \ 1163 { \ 1164 if (!(_handle->hw_txrx_stats_en)) \ 1165 DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); \ 1166 } 1167 1168 #define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \ 1169 { \ 1170 if (!(_handle->hw_txrx_stats_en)) \ 1171 DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); \ 1172 } 1173 1174 #define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond) \ 1175 { \ 1176 if (!(_handle->hw_txrx_stats_en)) \ 1177 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes); \ 1178 } 1179 1180 #define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond) \ 1181 { \ 1182 if (!(_handle->hw_txrx_stats_en)) \ 1183 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes); \ 1184 } 1185 #else 1186 #define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \ 1187 DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); 1188 1189 #define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \ 1190 DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); 1191 1192 #define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond) \ 1193 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes); 1194 1195 #define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond) \ 1196 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes); 1197 #endif 1198 1199 #ifdef ENABLE_DP_HIST_STATS 1200 #define DP_HIST_INIT() \ 1201 uint32_t num_of_packets[MAX_PDEV_CNT] = {0}; 1202 1203 #define DP_HIST_PACKET_COUNT_INC(_pdev_id) \ 1204 { \ 1205 ++num_of_packets[_pdev_id]; \ 1206 } 1207 1208 #define DP_TX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) \ 1209 do { \ 1210 if (_p_cntrs == 1) { \ 1211 DP_STATS_INC(_pdev, \ 1212 tx_comp_histogram.pkts_1, 1); \ 1213 } else if (_p_cntrs > 1 && _p_cntrs <= 20) { \ 1214 DP_STATS_INC(_pdev, \ 1215 tx_comp_histogram.pkts_2_20, 1); \ 1216 } else if (_p_cntrs > 20 && _p_cntrs <= 40) { \ 1217 DP_STATS_INC(_pdev, \ 1218 tx_comp_histogram.pkts_21_40, 1); \ 1219 } else if (_p_cntrs > 40 && _p_cntrs <= 60) { \ 1220 DP_STATS_INC(_pdev, \ 1221 tx_comp_histogram.pkts_41_60, 1); \ 1222 } else if (_p_cntrs > 60 && _p_cntrs <= 80) { \ 1223 DP_STATS_INC(_pdev, \ 1224 tx_comp_histogram.pkts_61_80, 1); \ 1225 } else if (_p_cntrs > 80 && _p_cntrs <= 100) { \ 1226 DP_STATS_INC(_pdev, \ 1227 tx_comp_histogram.pkts_81_100, 1); \ 1228 } else if (_p_cntrs > 100 && _p_cntrs <= 200) { \ 1229 DP_STATS_INC(_pdev, \ 1230 tx_comp_histogram.pkts_101_200, 1); \ 1231 } else if (_p_cntrs > 200) { \ 1232 DP_STATS_INC(_pdev, \ 1233 tx_comp_histogram.pkts_201_plus, 1); \ 1234 } \ 1235 } while (0) 1236 1237 #define DP_RX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) \ 1238 do { \ 1239 if (_p_cntrs == 1) { \ 1240 DP_STATS_INC(_pdev, \ 1241 rx_ind_histogram.pkts_1, 1); \ 1242 } else if (_p_cntrs > 1 && _p_cntrs <= 20) { \ 1243 DP_STATS_INC(_pdev, \ 1244 rx_ind_histogram.pkts_2_20, 1); \ 1245 } else if (_p_cntrs > 20 && _p_cntrs <= 40) { \ 1246 DP_STATS_INC(_pdev, \ 1247 rx_ind_histogram.pkts_21_40, 1); \ 1248 } else if (_p_cntrs > 40 && _p_cntrs <= 60) { \ 1249 DP_STATS_INC(_pdev, \ 1250 rx_ind_histogram.pkts_41_60, 1); \ 1251 } else if (_p_cntrs > 60 && _p_cntrs <= 80) { \ 1252 DP_STATS_INC(_pdev, \ 1253 rx_ind_histogram.pkts_61_80, 1); \ 1254 } else if (_p_cntrs > 80 && _p_cntrs <= 100) { \ 1255 DP_STATS_INC(_pdev, \ 1256 rx_ind_histogram.pkts_81_100, 1); \ 1257 } else if (_p_cntrs > 100 && _p_cntrs <= 200) { \ 1258 DP_STATS_INC(_pdev, \ 1259 rx_ind_histogram.pkts_101_200, 1); \ 1260 } else if (_p_cntrs > 200) { \ 1261 DP_STATS_INC(_pdev, \ 1262 rx_ind_histogram.pkts_201_plus, 1); \ 1263 } \ 1264 } while (0) 1265 1266 #define DP_TX_HIST_STATS_PER_PDEV() \ 1267 do { \ 1268 uint8_t hist_stats = 0; \ 1269 for (hist_stats = 0; hist_stats < soc->pdev_count; \ 1270 hist_stats++) { \ 1271 DP_TX_HISTOGRAM_UPDATE(soc->pdev_list[hist_stats], \ 1272 num_of_packets[hist_stats]); \ 1273 } \ 1274 } while (0) 1275 1276 1277 #define DP_RX_HIST_STATS_PER_PDEV() \ 1278 do { \ 1279 uint8_t hist_stats = 0; \ 1280 for (hist_stats = 0; hist_stats < soc->pdev_count; \ 1281 hist_stats++) { \ 1282 DP_RX_HISTOGRAM_UPDATE(soc->pdev_list[hist_stats], \ 1283 num_of_packets[hist_stats]); \ 1284 } \ 1285 } while (0) 1286 1287 #else 1288 #define DP_HIST_INIT() 1289 #define DP_HIST_PACKET_COUNT_INC(_pdev_id) 1290 #define DP_TX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) 1291 #define DP_RX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) 1292 #define DP_RX_HIST_STATS_PER_PDEV() 1293 #define DP_TX_HIST_STATS_PER_PDEV() 1294 #endif /* DISABLE_DP_STATS */ 1295 1296 #define FRAME_MASK_IPV4_ARP 1 1297 #define FRAME_MASK_IPV4_DHCP 2 1298 #define FRAME_MASK_IPV4_EAPOL 4 1299 #define FRAME_MASK_IPV6_DHCP 8 1300 1301 static inline int dp_log2_ceil(unsigned int value) 1302 { 1303 unsigned int tmp = value; 1304 int log2 = -1; 1305 1306 while (tmp) { 1307 log2++; 1308 tmp >>= 1; 1309 } 1310 if (1 << log2 != value) 1311 log2++; 1312 return log2; 1313 } 1314 1315 #ifdef QCA_SUPPORT_PEER_ISOLATION 1316 #define dp_get_peer_isolation(_peer) ((_peer)->isolation) 1317 1318 static inline void dp_set_peer_isolation(struct dp_txrx_peer *txrx_peer, 1319 bool val) 1320 { 1321 txrx_peer->isolation = val; 1322 } 1323 1324 #else 1325 #define dp_get_peer_isolation(_peer) (0) 1326 1327 static inline void dp_set_peer_isolation(struct dp_txrx_peer *peer, bool val) 1328 { 1329 } 1330 #endif /* QCA_SUPPORT_PEER_ISOLATION */ 1331 1332 #ifdef QCA_SUPPORT_WDS_EXTENDED 1333 static inline void dp_wds_ext_peer_init(struct dp_txrx_peer *txrx_peer) 1334 { 1335 txrx_peer->wds_ext.init = 0; 1336 } 1337 #else 1338 static inline void dp_wds_ext_peer_init(struct dp_txrx_peer *txrx_peer) 1339 { 1340 } 1341 #endif /* QCA_SUPPORT_WDS_EXTENDED */ 1342 1343 #ifdef QCA_HOST2FW_RXBUF_RING 1344 static inline 1345 struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) 1346 { 1347 return &pdev->rx_mac_buf_ring[lmac_id]; 1348 } 1349 #else 1350 static inline 1351 struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) 1352 { 1353 return &pdev->soc->rx_refill_buf_ring[lmac_id]; 1354 } 1355 #endif 1356 1357 /** 1358 * The lmac ID for a particular channel band is fixed. 1359 * 2.4GHz band uses lmac_id = 1 1360 * 5GHz/6GHz band uses lmac_id=0 1361 */ 1362 #define DP_INVALID_LMAC_ID (-1) 1363 #define DP_MON_INVALID_LMAC_ID (-1) 1364 #define DP_MAC0_LMAC_ID 0 1365 #define DP_MAC1_LMAC_ID 1 1366 1367 #ifdef FEATURE_TSO_STATS 1368 /** 1369 * dp_init_tso_stats() - Clear tso stats 1370 * @pdev: pdev handle 1371 * 1372 * Return: None 1373 */ 1374 static inline 1375 void dp_init_tso_stats(struct dp_pdev *pdev) 1376 { 1377 if (pdev) { 1378 qdf_mem_zero(&((pdev)->stats.tso_stats), 1379 sizeof((pdev)->stats.tso_stats)); 1380 qdf_atomic_init(&pdev->tso_idx); 1381 } 1382 } 1383 1384 /** 1385 * dp_stats_tso_segment_histogram_update() - TSO Segment Histogram 1386 * @pdev: pdev handle 1387 * @_p_cntrs: number of tso segments for a tso packet 1388 * 1389 * Return: None 1390 */ 1391 void dp_stats_tso_segment_histogram_update(struct dp_pdev *pdev, 1392 uint8_t _p_cntrs); 1393 1394 /** 1395 * dp_tso_segment_update() - Collect tso segment information 1396 * @pdev: pdev handle 1397 * @stats_idx: tso packet number 1398 * @idx: tso segment number 1399 * @seg: tso segment 1400 * 1401 * Return: None 1402 */ 1403 void dp_tso_segment_update(struct dp_pdev *pdev, 1404 uint32_t stats_idx, 1405 uint8_t idx, 1406 struct qdf_tso_seg_t seg); 1407 1408 /** 1409 * dp_tso_packet_update() - TSO Packet information 1410 * @pdev: pdev handle 1411 * @stats_idx: tso packet number 1412 * @msdu: nbuf handle 1413 * @num_segs: tso segments 1414 * 1415 * Return: None 1416 */ 1417 void dp_tso_packet_update(struct dp_pdev *pdev, uint32_t stats_idx, 1418 qdf_nbuf_t msdu, uint16_t num_segs); 1419 1420 /** 1421 * dp_tso_segment_stats_update() - TSO Segment stats 1422 * @pdev: pdev handle 1423 * @stats_seg: tso segment list 1424 * @stats_idx: tso packet number 1425 * 1426 * Return: None 1427 */ 1428 void dp_tso_segment_stats_update(struct dp_pdev *pdev, 1429 struct qdf_tso_seg_elem_t *stats_seg, 1430 uint32_t stats_idx); 1431 1432 /** 1433 * dp_print_tso_stats() - dump tso statistics 1434 * @soc:soc handle 1435 * @level: verbosity level 1436 * 1437 * Return: None 1438 */ 1439 void dp_print_tso_stats(struct dp_soc *soc, 1440 enum qdf_stats_verbosity_level level); 1441 1442 /** 1443 * dp_txrx_clear_tso_stats() - clear tso stats 1444 * @soc: soc handle 1445 * 1446 * Return: None 1447 */ 1448 void dp_txrx_clear_tso_stats(struct dp_soc *soc); 1449 #else 1450 static inline 1451 void dp_init_tso_stats(struct dp_pdev *pdev) 1452 { 1453 } 1454 1455 static inline 1456 void dp_stats_tso_segment_histogram_update(struct dp_pdev *pdev, 1457 uint8_t _p_cntrs) 1458 { 1459 } 1460 1461 static inline 1462 void dp_tso_segment_update(struct dp_pdev *pdev, 1463 uint32_t stats_idx, 1464 uint32_t idx, 1465 struct qdf_tso_seg_t seg) 1466 { 1467 } 1468 1469 static inline 1470 void dp_tso_packet_update(struct dp_pdev *pdev, uint32_t stats_idx, 1471 qdf_nbuf_t msdu, uint16_t num_segs) 1472 { 1473 } 1474 1475 static inline 1476 void dp_tso_segment_stats_update(struct dp_pdev *pdev, 1477 struct qdf_tso_seg_elem_t *stats_seg, 1478 uint32_t stats_idx) 1479 { 1480 } 1481 1482 static inline 1483 void dp_print_tso_stats(struct dp_soc *soc, 1484 enum qdf_stats_verbosity_level level) 1485 { 1486 } 1487 1488 static inline 1489 void dp_txrx_clear_tso_stats(struct dp_soc *soc) 1490 { 1491 } 1492 #endif /* FEATURE_TSO_STATS */ 1493 1494 /* dp_txrx_get_peer_per_pkt_stats_param() - Get peer per pkt stats param 1495 * @peer: DP peer handle 1496 * @type: Requested stats type 1497 * @ buf: Buffer to hold the value 1498 * 1499 * Return: status success/failure 1500 */ 1501 QDF_STATUS dp_txrx_get_peer_per_pkt_stats_param(struct dp_peer *peer, 1502 enum cdp_peer_stats_type type, 1503 cdp_peer_stats_param_t *buf); 1504 1505 /* dp_txrx_get_peer_extd_stats_param() - Get peer extd stats param 1506 * @peer: DP peer handle 1507 * @type: Requested stats type 1508 * @ buf: Buffer to hold the value 1509 * 1510 * Return: status success/failure 1511 */ 1512 QDF_STATUS dp_txrx_get_peer_extd_stats_param(struct dp_peer *peer, 1513 enum cdp_peer_stats_type type, 1514 cdp_peer_stats_param_t *buf); 1515 1516 #define DP_HTT_T2H_HP_PIPE 5 1517 /** 1518 * dp_update_pdev_stats(): Update the pdev stats 1519 * @tgtobj: pdev handle 1520 * @srcobj: vdev stats structure 1521 * 1522 * Update the pdev stats from the specified vdev stats 1523 * 1524 * return: None 1525 */ 1526 void dp_update_pdev_stats(struct dp_pdev *tgtobj, 1527 struct cdp_vdev_stats *srcobj); 1528 1529 /** 1530 * dp_update_vdev_ingress_stats(): Update the vdev ingress stats 1531 * @tgtobj: vdev handle 1532 * 1533 * Update the vdev ingress stats 1534 * 1535 * return: None 1536 */ 1537 void dp_update_vdev_ingress_stats(struct dp_vdev *tgtobj); 1538 1539 /** 1540 * dp_update_vdev_rate_stats() - Update the vdev rate stats 1541 * @tgtobj: tgt buffer for vdev stats 1542 * @srcobj: srcobj vdev stats 1543 * 1544 * Return: None 1545 */ 1546 void dp_update_vdev_rate_stats(struct cdp_vdev_stats *tgtobj, 1547 struct cdp_vdev_stats *srcobj); 1548 1549 /** 1550 * dp_update_pdev_ingress_stats(): Update the pdev ingress stats 1551 * @tgtobj: pdev handle 1552 * @srcobj: vdev stats structure 1553 * 1554 * Update the pdev ingress stats from the specified vdev stats 1555 * 1556 * return: None 1557 */ 1558 void dp_update_pdev_ingress_stats(struct dp_pdev *tgtobj, 1559 struct dp_vdev *srcobj); 1560 1561 /** 1562 * dp_update_vdev_stats(): Update the vdev stats 1563 * @soc: soc handle 1564 * @srcobj: DP_PEER object 1565 * @arg: point to vdev stats structure 1566 * 1567 * Update the vdev stats from the specified peer stats 1568 * 1569 * return: None 1570 */ 1571 void dp_update_vdev_stats(struct dp_soc *soc, 1572 struct dp_peer *srcobj, 1573 void *arg); 1574 1575 /** 1576 * dp_update_vdev_stats_on_peer_unmap() - Update the vdev stats on peer unmap 1577 * @vdev: DP_VDEV handle 1578 * @peer: DP_PEER handle 1579 * 1580 * Return: None 1581 */ 1582 void dp_update_vdev_stats_on_peer_unmap(struct dp_vdev *vdev, 1583 struct dp_peer *peer); 1584 1585 #define DP_UPDATE_STATS(_tgtobj, _srcobj) \ 1586 do { \ 1587 uint8_t i; \ 1588 uint8_t pream_type; \ 1589 for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \ 1590 for (i = 0; i < MAX_MCS; i++) { \ 1591 DP_STATS_AGGR(_tgtobj, _srcobj, \ 1592 tx.pkt_type[pream_type].mcs_count[i]); \ 1593 DP_STATS_AGGR(_tgtobj, _srcobj, \ 1594 rx.pkt_type[pream_type].mcs_count[i]); \ 1595 } \ 1596 } \ 1597 \ 1598 for (i = 0; i < MAX_BW; i++) { \ 1599 DP_STATS_AGGR(_tgtobj, _srcobj, tx.bw[i]); \ 1600 DP_STATS_AGGR(_tgtobj, _srcobj, rx.bw[i]); \ 1601 } \ 1602 \ 1603 for (i = 0; i < SS_COUNT; i++) { \ 1604 DP_STATS_AGGR(_tgtobj, _srcobj, rx.nss[i]); \ 1605 DP_STATS_AGGR(_tgtobj, _srcobj, tx.nss[i]); \ 1606 } \ 1607 for (i = 0; i < WME_AC_MAX; i++) { \ 1608 DP_STATS_AGGR(_tgtobj, _srcobj, tx.wme_ac_type[i]); \ 1609 DP_STATS_AGGR(_tgtobj, _srcobj, rx.wme_ac_type[i]); \ 1610 DP_STATS_AGGR(_tgtobj, _srcobj, tx.excess_retries_per_ac[i]); \ 1611 \ 1612 } \ 1613 \ 1614 for (i = 0; i < MAX_GI; i++) { \ 1615 DP_STATS_AGGR(_tgtobj, _srcobj, tx.sgi_count[i]); \ 1616 DP_STATS_AGGR(_tgtobj, _srcobj, rx.sgi_count[i]); \ 1617 } \ 1618 \ 1619 for (i = 0; i < MAX_RECEPTION_TYPES; i++) \ 1620 DP_STATS_AGGR(_tgtobj, _srcobj, rx.reception_type[i]); \ 1621 \ 1622 if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { \ 1623 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.comp_pkt); \ 1624 DP_STATS_AGGR(_tgtobj, _srcobj, tx.tx_failed); \ 1625 } \ 1626 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.ucast); \ 1627 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.mcast); \ 1628 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.bcast); \ 1629 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_success); \ 1630 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.nawds_mcast); \ 1631 DP_STATS_AGGR(_tgtobj, _srcobj, tx.nawds_mcast_drop); \ 1632 DP_STATS_AGGR(_tgtobj, _srcobj, tx.ofdma); \ 1633 DP_STATS_AGGR(_tgtobj, _srcobj, tx.stbc); \ 1634 DP_STATS_AGGR(_tgtobj, _srcobj, tx.ldpc); \ 1635 DP_STATS_AGGR(_tgtobj, _srcobj, tx.retries); \ 1636 DP_STATS_AGGR(_tgtobj, _srcobj, tx.non_amsdu_cnt); \ 1637 DP_STATS_AGGR(_tgtobj, _srcobj, tx.amsdu_cnt); \ 1638 DP_STATS_AGGR(_tgtobj, _srcobj, tx.non_ampdu_cnt); \ 1639 DP_STATS_AGGR(_tgtobj, _srcobj, tx.ampdu_cnt); \ 1640 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.dropped.fw_rem); \ 1641 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_tx); \ 1642 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_notx); \ 1643 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason1); \ 1644 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason2); \ 1645 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason3); \ 1646 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_queue_disable); \ 1647 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_no_match); \ 1648 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.drop_threshold); \ 1649 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.drop_link_desc_na); \ 1650 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.invalid_drop); \ 1651 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.mcast_vdev_drop); \ 1652 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.invalid_rr); \ 1653 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.age_out); \ 1654 \ 1655 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.mic_err); \ 1656 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.decrypt_err); \ 1657 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.fcserr); \ 1658 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.pn_err); \ 1659 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.oor_err); \ 1660 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.jump_2k_err); \ 1661 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.rxdma_wifi_parse_err); \ 1662 if (_srcobj->stats.rx.snr != 0) \ 1663 DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.snr); \ 1664 DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.rx_rate); \ 1665 DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_ampdu_cnt); \ 1666 DP_STATS_AGGR(_tgtobj, _srcobj, rx.ampdu_cnt); \ 1667 DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_amsdu_cnt); \ 1668 DP_STATS_AGGR(_tgtobj, _srcobj, rx.amsdu_cnt); \ 1669 DP_STATS_AGGR(_tgtobj, _srcobj, rx.nawds_mcast_drop); \ 1670 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.to_stack); \ 1671 \ 1672 for (i = 0; i < CDP_MAX_RX_RINGS; i++) \ 1673 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.rcvd_reo[i]); \ 1674 \ 1675 for (i = 0; i < CDP_MAX_LMACS; i++) \ 1676 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.rx_lmac[i]); \ 1677 \ 1678 _srcobj->stats.rx.unicast.num = \ 1679 _srcobj->stats.rx.to_stack.num - \ 1680 _srcobj->stats.rx.multicast.num; \ 1681 _srcobj->stats.rx.unicast.bytes = \ 1682 _srcobj->stats.rx.to_stack.bytes - \ 1683 _srcobj->stats.rx.multicast.bytes; \ 1684 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.unicast); \ 1685 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.multicast); \ 1686 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.bcast); \ 1687 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.raw); \ 1688 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.intra_bss.pkts); \ 1689 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.intra_bss.fail); \ 1690 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.mec_drop); \ 1691 \ 1692 _tgtobj->stats.tx.last_ack_rssi = \ 1693 _srcobj->stats.tx.last_ack_rssi; \ 1694 DP_STATS_AGGR(_tgtobj, _srcobj, rx.multipass_rx_pkt_drop); \ 1695 DP_STATS_AGGR(_tgtobj, _srcobj, rx.peer_unauth_rx_pkt_drop); \ 1696 DP_STATS_AGGR(_tgtobj, _srcobj, rx.policy_check_drop); \ 1697 } while (0) 1698 1699 #ifdef VDEV_PEER_PROTOCOL_COUNT 1700 #define DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj) \ 1701 { \ 1702 uint8_t j; \ 1703 for (j = 0; j < CDP_TRACE_MAX; j++) { \ 1704 _tgtobj->tx.protocol_trace_cnt[j].egress_cnt += \ 1705 _srcobj->tx.protocol_trace_cnt[j].egress_cnt; \ 1706 _tgtobj->tx.protocol_trace_cnt[j].ingress_cnt += \ 1707 _srcobj->tx.protocol_trace_cnt[j].ingress_cnt; \ 1708 _tgtobj->rx.protocol_trace_cnt[j].egress_cnt += \ 1709 _srcobj->rx.protocol_trace_cnt[j].egress_cnt; \ 1710 _tgtobj->rx.protocol_trace_cnt[j].ingress_cnt += \ 1711 _srcobj->rx.protocol_trace_cnt[j].ingress_cnt; \ 1712 } \ 1713 } 1714 #else 1715 #define DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj) 1716 #endif 1717 1718 #ifdef WLAN_FEATURE_11BE 1719 #define DP_UPDATE_11BE_STATS(_tgtobj, _srcobj) \ 1720 do { \ 1721 uint8_t i, mu_type; \ 1722 for (i = 0; i < MAX_MCS; i++) { \ 1723 _tgtobj->tx.su_be_ppdu_cnt.mcs_count[i] += \ 1724 _srcobj->tx.su_be_ppdu_cnt.mcs_count[i]; \ 1725 _tgtobj->rx.su_be_ppdu_cnt.mcs_count[i] += \ 1726 _srcobj->rx.su_be_ppdu_cnt.mcs_count[i]; \ 1727 } \ 1728 for (mu_type = 0; mu_type < TXRX_TYPE_MU_MAX; mu_type++) { \ 1729 for (i = 0; i < MAX_MCS; i++) { \ 1730 _tgtobj->tx.mu_be_ppdu_cnt[mu_type].mcs_count[i] += \ 1731 _srcobj->tx.mu_be_ppdu_cnt[mu_type].mcs_count[i]; \ 1732 _tgtobj->rx.mu_be_ppdu_cnt[mu_type].mcs_count[i] += \ 1733 _srcobj->rx.mu_be_ppdu_cnt[mu_type].mcs_count[i]; \ 1734 } \ 1735 } \ 1736 for (i = 0; i < MAX_PUNCTURED_MODE; i++) { \ 1737 _tgtobj->tx.punc_bw[i] += _srcobj->tx.punc_bw[i]; \ 1738 _tgtobj->rx.punc_bw[i] += _srcobj->rx.punc_bw[i]; \ 1739 } \ 1740 } while (0) 1741 #else 1742 #define DP_UPDATE_11BE_STATS(_tgtobj, _srcobj) 1743 #endif 1744 1745 #define DP_UPDATE_PER_PKT_STATS(_tgtobj, _srcobj) \ 1746 do { \ 1747 uint8_t i; \ 1748 _tgtobj->tx.ucast.num += _srcobj->tx.ucast.num; \ 1749 _tgtobj->tx.ucast.bytes += _srcobj->tx.ucast.bytes; \ 1750 _tgtobj->tx.mcast.num += _srcobj->tx.mcast.num; \ 1751 _tgtobj->tx.mcast.bytes += _srcobj->tx.mcast.bytes; \ 1752 _tgtobj->tx.bcast.num += _srcobj->tx.bcast.num; \ 1753 _tgtobj->tx.bcast.bytes += _srcobj->tx.bcast.bytes; \ 1754 _tgtobj->tx.nawds_mcast.num += _srcobj->tx.nawds_mcast.num; \ 1755 _tgtobj->tx.nawds_mcast.bytes += \ 1756 _srcobj->tx.nawds_mcast.bytes; \ 1757 _tgtobj->tx.tx_success.num += _srcobj->tx.tx_success.num; \ 1758 _tgtobj->tx.tx_success.bytes += _srcobj->tx.tx_success.bytes; \ 1759 _tgtobj->tx.nawds_mcast_drop += _srcobj->tx.nawds_mcast_drop; \ 1760 _tgtobj->tx.ofdma += _srcobj->tx.ofdma; \ 1761 _tgtobj->tx.non_amsdu_cnt += _srcobj->tx.non_amsdu_cnt; \ 1762 _tgtobj->tx.amsdu_cnt += _srcobj->tx.amsdu_cnt; \ 1763 _tgtobj->tx.dropped.fw_rem.num += \ 1764 _srcobj->tx.dropped.fw_rem.num; \ 1765 _tgtobj->tx.dropped.fw_rem.bytes += \ 1766 _srcobj->tx.dropped.fw_rem.bytes; \ 1767 _tgtobj->tx.dropped.fw_rem_notx += \ 1768 _srcobj->tx.dropped.fw_rem_notx; \ 1769 _tgtobj->tx.dropped.fw_rem_tx += \ 1770 _srcobj->tx.dropped.fw_rem_tx; \ 1771 _tgtobj->tx.dropped.age_out += _srcobj->tx.dropped.age_out; \ 1772 _tgtobj->tx.dropped.fw_reason1 += \ 1773 _srcobj->tx.dropped.fw_reason1; \ 1774 _tgtobj->tx.dropped.fw_reason2 += \ 1775 _srcobj->tx.dropped.fw_reason2; \ 1776 _tgtobj->tx.dropped.fw_reason3 += \ 1777 _srcobj->tx.dropped.fw_reason3; \ 1778 _tgtobj->tx.dropped.fw_rem_queue_disable += \ 1779 _srcobj->tx.dropped.fw_rem_queue_disable; \ 1780 _tgtobj->tx.dropped.fw_rem_no_match += \ 1781 _srcobj->tx.dropped.fw_rem_no_match; \ 1782 _tgtobj->tx.dropped.drop_threshold += \ 1783 _srcobj->tx.dropped.drop_threshold; \ 1784 _tgtobj->tx.dropped.drop_link_desc_na += \ 1785 _srcobj->tx.dropped.drop_link_desc_na; \ 1786 _tgtobj->tx.dropped.invalid_drop += \ 1787 _srcobj->tx.dropped.invalid_drop; \ 1788 _tgtobj->tx.dropped.mcast_vdev_drop += \ 1789 _srcobj->tx.dropped.mcast_vdev_drop; \ 1790 _tgtobj->tx.dropped.invalid_rr += \ 1791 _srcobj->tx.dropped.invalid_rr; \ 1792 _tgtobj->tx.failed_retry_count += \ 1793 _srcobj->tx.failed_retry_count; \ 1794 _tgtobj->tx.retry_count += _srcobj->tx.retry_count; \ 1795 _tgtobj->tx.multiple_retry_count += \ 1796 _srcobj->tx.multiple_retry_count; \ 1797 _tgtobj->tx.tx_success_twt.num += \ 1798 _srcobj->tx.tx_success_twt.num; \ 1799 _tgtobj->tx.tx_success_twt.bytes += \ 1800 _srcobj->tx.tx_success_twt.bytes; \ 1801 _tgtobj->tx.last_tx_ts = _srcobj->tx.last_tx_ts; \ 1802 _tgtobj->tx.release_src_not_tqm += \ 1803 _srcobj->tx.release_src_not_tqm; \ 1804 for (i = 0; i < QDF_PROTO_SUBTYPE_MAX; i++) { \ 1805 _tgtobj->tx.no_ack_count[i] += \ 1806 _srcobj->tx.no_ack_count[i];\ 1807 } \ 1808 \ 1809 _tgtobj->rx.multicast.num += _srcobj->rx.multicast.num; \ 1810 _tgtobj->rx.multicast.bytes += _srcobj->rx.multicast.bytes; \ 1811 _tgtobj->rx.bcast.num += _srcobj->rx.bcast.num; \ 1812 _tgtobj->rx.bcast.bytes += _srcobj->rx.bcast.bytes; \ 1813 if (_tgtobj->rx.to_stack.num >= _tgtobj->rx.multicast.num) \ 1814 _tgtobj->rx.unicast.num = \ 1815 _tgtobj->rx.to_stack.num - _tgtobj->rx.multicast.num; \ 1816 if (_tgtobj->rx.to_stack.bytes >= _tgtobj->rx.multicast.bytes) \ 1817 _tgtobj->rx.unicast.bytes = \ 1818 _tgtobj->rx.to_stack.bytes - _tgtobj->rx.multicast.bytes; \ 1819 _tgtobj->rx.raw.num += _srcobj->rx.raw.num; \ 1820 _tgtobj->rx.raw.bytes += _srcobj->rx.raw.bytes; \ 1821 _tgtobj->rx.nawds_mcast_drop += _srcobj->rx.nawds_mcast_drop; \ 1822 _tgtobj->rx.mcast_3addr_drop += _srcobj->rx.mcast_3addr_drop; \ 1823 _tgtobj->rx.mec_drop.num += _srcobj->rx.mec_drop.num; \ 1824 _tgtobj->rx.mec_drop.bytes += _srcobj->rx.mec_drop.bytes; \ 1825 _tgtobj->rx.intra_bss.pkts.num += \ 1826 _srcobj->rx.intra_bss.pkts.num; \ 1827 _tgtobj->rx.intra_bss.pkts.bytes += \ 1828 _srcobj->rx.intra_bss.pkts.bytes; \ 1829 _tgtobj->rx.intra_bss.fail.num += \ 1830 _srcobj->rx.intra_bss.fail.num; \ 1831 _tgtobj->rx.intra_bss.fail.bytes += \ 1832 _srcobj->rx.intra_bss.fail.bytes; \ 1833 _tgtobj->rx.intra_bss.mdns_no_fwd += \ 1834 _srcobj->rx.intra_bss.mdns_no_fwd; \ 1835 _tgtobj->rx.err.mic_err += _srcobj->rx.err.mic_err; \ 1836 _tgtobj->rx.err.decrypt_err += _srcobj->rx.err.decrypt_err; \ 1837 _tgtobj->rx.err.fcserr += _srcobj->rx.err.fcserr; \ 1838 _tgtobj->rx.err.pn_err += _srcobj->rx.err.pn_err; \ 1839 _tgtobj->rx.err.oor_err += _srcobj->rx.err.oor_err; \ 1840 _tgtobj->rx.err.jump_2k_err += _srcobj->rx.err.jump_2k_err; \ 1841 _tgtobj->rx.err.rxdma_wifi_parse_err += \ 1842 _srcobj->rx.err.rxdma_wifi_parse_err; \ 1843 _tgtobj->rx.non_amsdu_cnt += _srcobj->rx.non_amsdu_cnt; \ 1844 _tgtobj->rx.amsdu_cnt += _srcobj->rx.amsdu_cnt; \ 1845 _tgtobj->rx.rx_retries += _srcobj->rx.rx_retries; \ 1846 _tgtobj->rx.multipass_rx_pkt_drop += \ 1847 _srcobj->rx.multipass_rx_pkt_drop; \ 1848 _tgtobj->rx.peer_unauth_rx_pkt_drop += \ 1849 _srcobj->rx.peer_unauth_rx_pkt_drop; \ 1850 _tgtobj->rx.policy_check_drop += \ 1851 _srcobj->rx.policy_check_drop; \ 1852 _tgtobj->rx.to_stack_twt.num += _srcobj->rx.to_stack_twt.num; \ 1853 _tgtobj->rx.to_stack_twt.bytes += \ 1854 _srcobj->rx.to_stack_twt.bytes; \ 1855 _tgtobj->rx.last_rx_ts = _srcobj->rx.last_rx_ts; \ 1856 for (i = 0; i < CDP_MAX_RX_RINGS; i++) { \ 1857 _tgtobj->rx.rcvd_reo[i].num += \ 1858 _srcobj->rx.rcvd_reo[i].num; \ 1859 _tgtobj->rx.rcvd_reo[i].bytes += \ 1860 _srcobj->rx.rcvd_reo[i].bytes; \ 1861 } \ 1862 for (i = 0; i < CDP_MAX_LMACS; i++) { \ 1863 _tgtobj->rx.rx_lmac[i].num += \ 1864 _srcobj->rx.rx_lmac[i].num; \ 1865 _tgtobj->rx.rx_lmac[i].bytes += \ 1866 _srcobj->rx.rx_lmac[i].bytes; \ 1867 } \ 1868 DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj); \ 1869 } while (0) 1870 1871 #define DP_UPDATE_EXTD_STATS(_tgtobj, _srcobj) \ 1872 do { \ 1873 uint8_t i, pream_type, mu_type; \ 1874 _tgtobj->tx.stbc += _srcobj->tx.stbc; \ 1875 _tgtobj->tx.ldpc += _srcobj->tx.ldpc; \ 1876 _tgtobj->tx.retries += _srcobj->tx.retries; \ 1877 _tgtobj->tx.ampdu_cnt += _srcobj->tx.ampdu_cnt; \ 1878 _tgtobj->tx.non_ampdu_cnt += _srcobj->tx.non_ampdu_cnt; \ 1879 _tgtobj->tx.num_ppdu_cookie_valid += \ 1880 _srcobj->tx.num_ppdu_cookie_valid; \ 1881 _tgtobj->tx.tx_ppdus += _srcobj->tx.tx_ppdus; \ 1882 _tgtobj->tx.tx_mpdus_success += _srcobj->tx.tx_mpdus_success; \ 1883 _tgtobj->tx.tx_mpdus_tried += _srcobj->tx.tx_mpdus_tried; \ 1884 _tgtobj->tx.tx_rate = _srcobj->tx.tx_rate; \ 1885 _tgtobj->tx.last_tx_rate = _srcobj->tx.last_tx_rate; \ 1886 _tgtobj->tx.last_tx_rate_mcs = _srcobj->tx.last_tx_rate_mcs; \ 1887 _tgtobj->tx.mcast_last_tx_rate = \ 1888 _srcobj->tx.mcast_last_tx_rate; \ 1889 _tgtobj->tx.mcast_last_tx_rate_mcs = \ 1890 _srcobj->tx.mcast_last_tx_rate_mcs; \ 1891 _tgtobj->tx.rnd_avg_tx_rate = _srcobj->tx.rnd_avg_tx_rate; \ 1892 _tgtobj->tx.avg_tx_rate = _srcobj->tx.avg_tx_rate; \ 1893 _tgtobj->tx.tx_ratecode = _srcobj->tx.tx_ratecode; \ 1894 _tgtobj->tx.pream_punct_cnt += _srcobj->tx.pream_punct_cnt; \ 1895 _tgtobj->tx.ru_start = _srcobj->tx.ru_start; \ 1896 _tgtobj->tx.ru_tones = _srcobj->tx.ru_tones; \ 1897 _tgtobj->tx.last_ack_rssi = _srcobj->tx.last_ack_rssi; \ 1898 _tgtobj->tx.nss_info = _srcobj->tx.nss_info; \ 1899 _tgtobj->tx.mcs_info = _srcobj->tx.mcs_info; \ 1900 _tgtobj->tx.bw_info = _srcobj->tx.bw_info; \ 1901 _tgtobj->tx.gi_info = _srcobj->tx.gi_info; \ 1902 _tgtobj->tx.preamble_info = _srcobj->tx.preamble_info; \ 1903 _tgtobj->tx.retries_mpdu += _srcobj->tx.retries_mpdu; \ 1904 _tgtobj->tx.mpdu_success_with_retries += \ 1905 _srcobj->tx.mpdu_success_with_retries; \ 1906 for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \ 1907 for (i = 0; i < MAX_MCS; i++) \ 1908 _tgtobj->tx.pkt_type[pream_type].mcs_count[i] += \ 1909 _srcobj->tx.pkt_type[pream_type].mcs_count[i]; \ 1910 } \ 1911 for (i = 0; i < WME_AC_MAX; i++) { \ 1912 _tgtobj->tx.wme_ac_type[i] += _srcobj->tx.wme_ac_type[i]; \ 1913 _tgtobj->tx.excess_retries_per_ac[i] += \ 1914 _srcobj->tx.excess_retries_per_ac[i]; \ 1915 } \ 1916 for (i = 0; i < MAX_GI; i++) { \ 1917 _tgtobj->tx.sgi_count[i] += _srcobj->tx.sgi_count[i]; \ 1918 } \ 1919 for (i = 0; i < SS_COUNT; i++) { \ 1920 _tgtobj->tx.nss[i] += _srcobj->tx.nss[i]; \ 1921 } \ 1922 for (i = 0; i < MAX_BW; i++) { \ 1923 _tgtobj->tx.bw[i] += _srcobj->tx.bw[i]; \ 1924 } \ 1925 for (i = 0; i < MAX_RU_LOCATIONS; i++) { \ 1926 _tgtobj->tx.ru_loc[i].num_msdu += \ 1927 _srcobj->tx.ru_loc[i].num_msdu; \ 1928 _tgtobj->tx.ru_loc[i].num_mpdu += \ 1929 _srcobj->tx.ru_loc[i].num_mpdu; \ 1930 _tgtobj->tx.ru_loc[i].mpdu_tried += \ 1931 _srcobj->tx.ru_loc[i].mpdu_tried; \ 1932 } \ 1933 for (i = 0; i < MAX_TRANSMIT_TYPES; i++) { \ 1934 _tgtobj->tx.transmit_type[i].num_msdu += \ 1935 _srcobj->tx.transmit_type[i].num_msdu; \ 1936 _tgtobj->tx.transmit_type[i].num_mpdu += \ 1937 _srcobj->tx.transmit_type[i].num_mpdu; \ 1938 _tgtobj->tx.transmit_type[i].mpdu_tried += \ 1939 _srcobj->tx.transmit_type[i].mpdu_tried; \ 1940 } \ 1941 for (i = 0; i < MAX_MU_GROUP_ID; i++) { \ 1942 _tgtobj->tx.mu_group_id[i] = _srcobj->tx.mu_group_id[i]; \ 1943 } \ 1944 \ 1945 _tgtobj->rx.mpdu_cnt_fcs_ok += _srcobj->rx.mpdu_cnt_fcs_ok; \ 1946 _tgtobj->rx.mpdu_cnt_fcs_err += _srcobj->rx.mpdu_cnt_fcs_err; \ 1947 _tgtobj->rx.non_ampdu_cnt += _srcobj->rx.non_ampdu_cnt; \ 1948 _tgtobj->rx.ampdu_cnt += _srcobj->rx.ampdu_cnt; \ 1949 _tgtobj->rx.rx_mpdus += _srcobj->rx.rx_mpdus; \ 1950 _tgtobj->rx.rx_ppdus += _srcobj->rx.rx_ppdus; \ 1951 _tgtobj->rx.rx_rate = _srcobj->rx.rx_rate; \ 1952 _tgtobj->rx.last_rx_rate = _srcobj->rx.last_rx_rate; \ 1953 _tgtobj->rx.rnd_avg_rx_rate = _srcobj->rx.rnd_avg_rx_rate; \ 1954 _tgtobj->rx.avg_rx_rate = _srcobj->rx.avg_rx_rate; \ 1955 _tgtobj->rx.rx_ratecode = _srcobj->rx.rx_ratecode; \ 1956 _tgtobj->rx.avg_snr = _srcobj->rx.avg_snr; \ 1957 _tgtobj->rx.rx_snr_measured_time = \ 1958 _srcobj->rx.rx_snr_measured_time; \ 1959 _tgtobj->rx.snr = _srcobj->rx.snr; \ 1960 _tgtobj->rx.last_snr = _srcobj->rx.last_snr; \ 1961 _tgtobj->rx.nss_info = _srcobj->rx.nss_info; \ 1962 _tgtobj->rx.mcs_info = _srcobj->rx.mcs_info; \ 1963 _tgtobj->rx.bw_info = _srcobj->rx.bw_info; \ 1964 _tgtobj->rx.gi_info = _srcobj->rx.gi_info; \ 1965 _tgtobj->rx.preamble_info = _srcobj->rx.preamble_info; \ 1966 _tgtobj->rx.mpdu_retry_cnt += _srcobj->rx.mpdu_retry_cnt; \ 1967 for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \ 1968 for (i = 0; i < MAX_MCS; i++) { \ 1969 _tgtobj->rx.pkt_type[pream_type].mcs_count[i] += \ 1970 _srcobj->rx.pkt_type[pream_type].mcs_count[i]; \ 1971 } \ 1972 } \ 1973 for (i = 0; i < WME_AC_MAX; i++) { \ 1974 _tgtobj->rx.wme_ac_type[i] += _srcobj->rx.wme_ac_type[i]; \ 1975 } \ 1976 for (i = 0; i < MAX_MCS; i++) { \ 1977 _tgtobj->rx.su_ax_ppdu_cnt.mcs_count[i] += \ 1978 _srcobj->rx.su_ax_ppdu_cnt.mcs_count[i]; \ 1979 _tgtobj->rx.rx_mpdu_cnt[i] += _srcobj->rx.rx_mpdu_cnt[i]; \ 1980 } \ 1981 for (mu_type = 0 ; mu_type < TXRX_TYPE_MU_MAX; mu_type++) { \ 1982 _tgtobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_ok += \ 1983 _srcobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_ok; \ 1984 _tgtobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_err += \ 1985 _srcobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_err; \ 1986 for (i = 0; i < SS_COUNT; i++) \ 1987 _tgtobj->rx.rx_mu[mu_type].ppdu_nss[i] += \ 1988 _srcobj->rx.rx_mu[mu_type].ppdu_nss[i]; \ 1989 for (i = 0; i < MAX_MCS; i++) \ 1990 _tgtobj->rx.rx_mu[mu_type].ppdu.mcs_count[i] += \ 1991 _srcobj->rx.rx_mu[mu_type].ppdu.mcs_count[i]; \ 1992 } \ 1993 for (i = 0; i < MAX_RECEPTION_TYPES; i++) { \ 1994 _tgtobj->rx.reception_type[i] += \ 1995 _srcobj->rx.reception_type[i]; \ 1996 _tgtobj->rx.ppdu_cnt[i] += _srcobj->rx.ppdu_cnt[i]; \ 1997 } \ 1998 for (i = 0; i < MAX_GI; i++) { \ 1999 _tgtobj->rx.sgi_count[i] += _srcobj->rx.sgi_count[i]; \ 2000 } \ 2001 for (i = 0; i < SS_COUNT; i++) { \ 2002 _tgtobj->rx.nss[i] += _srcobj->rx.nss[i]; \ 2003 _tgtobj->rx.ppdu_nss[i] += _srcobj->rx.ppdu_nss[i]; \ 2004 } \ 2005 for (i = 0; i < MAX_BW; i++) { \ 2006 _tgtobj->rx.bw[i] += _srcobj->rx.bw[i]; \ 2007 } \ 2008 DP_UPDATE_11BE_STATS(_tgtobj, _srcobj); \ 2009 } while (0) 2010 2011 /** 2012 * dp_peer_find_attach() - Allocates memory for peer objects 2013 * @soc: SoC handle 2014 * 2015 * Return: QDF_STATUS 2016 */ 2017 QDF_STATUS dp_peer_find_attach(struct dp_soc *soc); 2018 extern void dp_peer_find_detach(struct dp_soc *soc); 2019 extern void dp_peer_find_hash_add(struct dp_soc *soc, struct dp_peer *peer); 2020 extern void dp_peer_find_hash_remove(struct dp_soc *soc, struct dp_peer *peer); 2021 extern void dp_peer_find_hash_erase(struct dp_soc *soc); 2022 void dp_peer_vdev_list_add(struct dp_soc *soc, struct dp_vdev *vdev, 2023 struct dp_peer *peer); 2024 void dp_peer_vdev_list_remove(struct dp_soc *soc, struct dp_vdev *vdev, 2025 struct dp_peer *peer); 2026 void dp_peer_find_id_to_obj_add(struct dp_soc *soc, 2027 struct dp_peer *peer, 2028 uint16_t peer_id); 2029 void dp_txrx_peer_attach_add(struct dp_soc *soc, 2030 struct dp_peer *peer, 2031 struct dp_txrx_peer *txrx_peer); 2032 void dp_peer_find_id_to_obj_remove(struct dp_soc *soc, 2033 uint16_t peer_id); 2034 void dp_vdev_unref_delete(struct dp_soc *soc, struct dp_vdev *vdev, 2035 enum dp_mod_id mod_id); 2036 2037 /* 2038 * dp_peer_ppdu_delayed_ba_cleanup() free ppdu allocated in peer 2039 * @peer: Datapath peer 2040 * 2041 * return: void 2042 */ 2043 void dp_peer_ppdu_delayed_ba_cleanup(struct dp_peer *peer); 2044 2045 extern void dp_peer_rx_init(struct dp_pdev *pdev, struct dp_peer *peer); 2046 void dp_peer_cleanup(struct dp_vdev *vdev, struct dp_peer *peer); 2047 void dp_peer_rx_cleanup(struct dp_vdev *vdev, struct dp_peer *peer); 2048 2049 #ifdef DP_PEER_EXTENDED_API 2050 /** 2051 * dp_register_peer() - Register peer into physical device 2052 * @soc_hdl - data path soc handle 2053 * @pdev_id - device instance id 2054 * @sta_desc - peer description 2055 * 2056 * Register peer into physical device 2057 * 2058 * Return: QDF_STATUS_SUCCESS registration success 2059 * QDF_STATUS_E_FAULT peer not found 2060 */ 2061 QDF_STATUS dp_register_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 2062 struct ol_txrx_desc_type *sta_desc); 2063 2064 /** 2065 * dp_clear_peer() - remove peer from physical device 2066 * @soc_hdl - data path soc handle 2067 * @pdev_id - device instance id 2068 * @peer_addr - peer mac address 2069 * 2070 * remove peer from physical device 2071 * 2072 * Return: QDF_STATUS_SUCCESS registration success 2073 * QDF_STATUS_E_FAULT peer not found 2074 */ 2075 QDF_STATUS dp_clear_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 2076 struct qdf_mac_addr peer_addr); 2077 2078 /* 2079 * dp_find_peer_exist - find peer if already exists 2080 * @soc: datapath soc handle 2081 * @pdev_id: physical device instance id 2082 * @peer_mac_addr: peer mac address 2083 * 2084 * Return: true or false 2085 */ 2086 bool dp_find_peer_exist(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 2087 uint8_t *peer_addr); 2088 2089 /* 2090 * dp_find_peer_exist_on_vdev - find if peer exists on the given vdev 2091 * @soc: datapath soc handle 2092 * @vdev_id: vdev instance id 2093 * @peer_mac_addr: peer mac address 2094 * 2095 * Return: true or false 2096 */ 2097 bool dp_find_peer_exist_on_vdev(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 2098 uint8_t *peer_addr); 2099 2100 /* 2101 * dp_find_peer_exist_on_other_vdev - find if peer exists 2102 * on other than the given vdev 2103 * @soc: datapath soc handle 2104 * @vdev_id: vdev instance id 2105 * @peer_mac_addr: peer mac address 2106 * @max_bssid: max number of bssids 2107 * 2108 * Return: true or false 2109 */ 2110 bool dp_find_peer_exist_on_other_vdev(struct cdp_soc_t *soc_hdl, 2111 uint8_t vdev_id, uint8_t *peer_addr, 2112 uint16_t max_bssid); 2113 2114 /** 2115 * dp_peer_state_update() - update peer local state 2116 * @pdev - data path device instance 2117 * @peer_addr - peer mac address 2118 * @state - new peer local state 2119 * 2120 * update peer local state 2121 * 2122 * Return: QDF_STATUS_SUCCESS registration success 2123 */ 2124 QDF_STATUS dp_peer_state_update(struct cdp_soc_t *soc, uint8_t *peer_mac, 2125 enum ol_txrx_peer_state state); 2126 2127 /** 2128 * dp_get_vdevid() - Get virtual interface id which peer registered 2129 * @soc - datapath soc handle 2130 * @peer_mac - peer mac address 2131 * @vdev_id - virtual interface id which peer registered 2132 * 2133 * Get virtual interface id which peer registered 2134 * 2135 * Return: QDF_STATUS_SUCCESS registration success 2136 */ 2137 QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac, 2138 uint8_t *vdev_id); 2139 struct cdp_vdev *dp_get_vdev_by_peer_addr(struct cdp_pdev *pdev_handle, 2140 struct qdf_mac_addr peer_addr); 2141 struct cdp_vdev *dp_get_vdev_for_peer(void *peer); 2142 uint8_t *dp_peer_get_peer_mac_addr(void *peer); 2143 2144 /** 2145 * dp_get_peer_state() - Get local peer state 2146 * @soc - datapath soc handle 2147 * @vdev_id - vdev id 2148 * @peer_mac - peer mac addr 2149 * 2150 * Get local peer state 2151 * 2152 * Return: peer status 2153 */ 2154 int dp_get_peer_state(struct cdp_soc_t *soc, uint8_t vdev_id, 2155 uint8_t *peer_mac); 2156 void dp_local_peer_id_pool_init(struct dp_pdev *pdev); 2157 void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer); 2158 void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer); 2159 /** 2160 * dp_set_peer_as_tdls_peer() - set tdls peer flag to peer 2161 * @soc_hdl: datapath soc handle 2162 * @vdev_id: vdev_id 2163 * @peer_mac: peer mac addr 2164 * @val: tdls peer flag 2165 * 2166 * Return: none 2167 */ 2168 void dp_set_peer_as_tdls_peer(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 2169 uint8_t *peer_mac, bool val); 2170 #else 2171 /** 2172 * dp_get_vdevid() - Get virtual interface id which peer registered 2173 * @soc - datapath soc handle 2174 * @peer_mac - peer mac address 2175 * @vdev_id - virtual interface id which peer registered 2176 * 2177 * Get virtual interface id which peer registered 2178 * 2179 * Return: QDF_STATUS_SUCCESS registration success 2180 */ 2181 static inline 2182 QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac, 2183 uint8_t *vdev_id) 2184 { 2185 return QDF_STATUS_E_NOSUPPORT; 2186 } 2187 2188 static inline void dp_local_peer_id_pool_init(struct dp_pdev *pdev) 2189 { 2190 } 2191 2192 static inline 2193 void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer) 2194 { 2195 } 2196 2197 static inline 2198 void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer) 2199 { 2200 } 2201 2202 static inline 2203 void dp_set_peer_as_tdls_peer(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 2204 uint8_t *peer_mac, bool val) 2205 { 2206 } 2207 #endif 2208 2209 int dp_addba_resp_tx_completion_wifi3(struct cdp_soc_t *cdp_soc, 2210 uint8_t *peer_mac, uint16_t vdev_id, 2211 uint8_t tid, 2212 int status); 2213 int dp_addba_requestprocess_wifi3(struct cdp_soc_t *cdp_soc, 2214 uint8_t *peer_mac, uint16_t vdev_id, 2215 uint8_t dialogtoken, uint16_t tid, 2216 uint16_t batimeout, 2217 uint16_t buffersize, 2218 uint16_t startseqnum); 2219 QDF_STATUS dp_addba_responsesetup_wifi3(struct cdp_soc_t *cdp_soc, 2220 uint8_t *peer_mac, uint16_t vdev_id, 2221 uint8_t tid, uint8_t *dialogtoken, 2222 uint16_t *statuscode, 2223 uint16_t *buffersize, 2224 uint16_t *batimeout); 2225 QDF_STATUS dp_set_addba_response(struct cdp_soc_t *cdp_soc, 2226 uint8_t *peer_mac, 2227 uint16_t vdev_id, uint8_t tid, 2228 uint16_t statuscode); 2229 int dp_delba_process_wifi3(struct cdp_soc_t *cdp_soc, uint8_t *peer_mac, 2230 uint16_t vdev_id, int tid, 2231 uint16_t reasoncode); 2232 2233 /** 2234 * dp_rx_tid_update_ba_win_size() - Update the DP tid BA window size 2235 * @soc: soc handle 2236 * @peer_mac: mac address of peer handle 2237 * @vdev_id: id of vdev handle 2238 * @tid: tid 2239 * @buffersize: BA window size 2240 * 2241 * Return: success/failure of tid update 2242 */ 2243 QDF_STATUS dp_rx_tid_update_ba_win_size(struct cdp_soc_t *cdp_soc, 2244 uint8_t *peer_mac, uint16_t vdev_id, 2245 uint8_t tid, uint16_t buffersize); 2246 2247 /* 2248 * dp_delba_tx_completion_wifi3() - Handle delba tx completion 2249 * 2250 * @cdp_soc: soc handle 2251 * @vdev_id: id of the vdev handle 2252 * @peer_mac: peer mac address 2253 * @tid: Tid number 2254 * @status: Tx completion status 2255 * Indicate status of delba Tx to DP for stats update and retry 2256 * delba if tx failed. 2257 * 2258 */ 2259 int dp_delba_tx_completion_wifi3(struct cdp_soc_t *cdp_soc, uint8_t *peer_mac, 2260 uint16_t vdev_id, uint8_t tid, 2261 int status); 2262 extern QDF_STATUS dp_rx_tid_setup_wifi3(struct dp_peer *peer, int tid, 2263 uint32_t ba_window_size, 2264 uint32_t start_seq); 2265 2266 #ifdef DP_UMAC_HW_RESET_SUPPORT 2267 void dp_pause_reo_send_cmd(struct dp_soc *soc); 2268 2269 void dp_resume_reo_send_cmd(struct dp_soc *soc); 2270 void dp_cleanup_reo_cmd_module(struct dp_soc *soc); 2271 void dp_reo_desc_freelist_destroy(struct dp_soc *soc); 2272 void dp_reset_rx_reo_tid_queue(struct dp_soc *soc, void *hw_qdesc_vaddr, 2273 uint32_t size); 2274 #endif 2275 2276 extern QDF_STATUS dp_reo_send_cmd(struct dp_soc *soc, 2277 enum hal_reo_cmd_type type, struct hal_reo_cmd_params *params, 2278 void (*callback_fn), void *data); 2279 2280 extern void dp_reo_cmdlist_destroy(struct dp_soc *soc); 2281 2282 /** 2283 * dp_reo_status_ring_handler - Handler for REO Status ring 2284 * @int_ctx: pointer to DP interrupt context 2285 * @soc: DP Soc handle 2286 * 2287 * Returns: Number of descriptors reaped 2288 */ 2289 uint32_t dp_reo_status_ring_handler(struct dp_intr *int_ctx, 2290 struct dp_soc *soc); 2291 void dp_aggregate_vdev_stats(struct dp_vdev *vdev, 2292 struct cdp_vdev_stats *vdev_stats); 2293 void dp_rx_tid_stats_cb(struct dp_soc *soc, void *cb_ctxt, 2294 union hal_reo_status *reo_status); 2295 void dp_rx_bar_stats_cb(struct dp_soc *soc, void *cb_ctxt, 2296 union hal_reo_status *reo_status); 2297 uint16_t dp_tx_me_send_convert_ucast(struct cdp_soc_t *soc, uint8_t vdev_id, 2298 qdf_nbuf_t nbuf, 2299 uint8_t newmac[][QDF_MAC_ADDR_SIZE], 2300 uint8_t new_mac_cnt, uint8_t tid, 2301 bool is_igmp, bool is_dms_pkt); 2302 void dp_tx_me_alloc_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id); 2303 2304 void dp_tx_me_free_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id); 2305 QDF_STATUS dp_h2t_ext_stats_msg_send(struct dp_pdev *pdev, 2306 uint32_t stats_type_upload_mask, uint32_t config_param_0, 2307 uint32_t config_param_1, uint32_t config_param_2, 2308 uint32_t config_param_3, int cookie, int cookie_msb, 2309 uint8_t mac_id); 2310 void dp_htt_stats_print_tag(struct dp_pdev *pdev, 2311 uint8_t tag_type, uint32_t *tag_buf); 2312 void dp_htt_stats_copy_tag(struct dp_pdev *pdev, uint8_t tag_type, uint32_t *tag_buf); 2313 QDF_STATUS dp_h2t_3tuple_config_send(struct dp_pdev *pdev, uint32_t tuple_mask, 2314 uint8_t mac_id); 2315 /** 2316 * dp_rxtid_stats_cmd_cb - function pointer for peer 2317 * rx tid stats cmd call_back 2318 */ 2319 typedef void (*dp_rxtid_stats_cmd_cb)(struct dp_soc *soc, void *cb_ctxt, 2320 union hal_reo_status *reo_status); 2321 int dp_peer_rxtid_stats(struct dp_peer *peer, 2322 dp_rxtid_stats_cmd_cb dp_stats_cmd_cb, 2323 void *cb_ctxt); 2324 #ifdef IPA_OFFLOAD 2325 void dp_peer_update_tid_stats_from_reo(struct dp_soc *soc, void *cb_ctxt, 2326 union hal_reo_status *reo_status); 2327 int dp_peer_get_rxtid_stats_ipa(struct dp_peer *peer, 2328 dp_rxtid_stats_cmd_cb dp_stats_cmd_cb); 2329 #endif 2330 QDF_STATUS 2331 dp_set_pn_check_wifi3(struct cdp_soc_t *soc, uint8_t vdev_id, 2332 uint8_t *peer_mac, enum cdp_sec_type sec_type, 2333 uint32_t *rx_pn); 2334 2335 QDF_STATUS 2336 dp_set_key_sec_type_wifi3(struct cdp_soc_t *soc, uint8_t vdev_id, 2337 uint8_t *peer_mac, enum cdp_sec_type sec_type, 2338 bool is_unicast); 2339 2340 void *dp_get_pdev_for_mac_id(struct dp_soc *soc, uint32_t mac_id); 2341 2342 QDF_STATUS 2343 dp_set_michael_key(struct cdp_soc_t *soc, uint8_t vdev_id, 2344 uint8_t *peer_mac, 2345 bool is_unicast, uint32_t *key); 2346 2347 /** 2348 * dp_check_pdev_exists() - Validate pdev before use 2349 * @soc - dp soc handle 2350 * @data - pdev handle 2351 * 2352 * Return: 0 - success/invalid - failure 2353 */ 2354 bool dp_check_pdev_exists(struct dp_soc *soc, struct dp_pdev *data); 2355 2356 /** 2357 * dp_update_delay_stats() - Update delay statistics in structure 2358 * and fill min, max and avg delay 2359 * @tstats: tid tx stats 2360 * @rstats: tid rx stats 2361 * @delay: delay in ms 2362 * @tid: tid value 2363 * @mode: type of tx delay mode 2364 * @ring id: ring number 2365 * @delay_in_us: flag to indicate whether the delay is in ms or us 2366 * 2367 * Return: none 2368 */ 2369 void dp_update_delay_stats(struct cdp_tid_tx_stats *tstats, 2370 struct cdp_tid_rx_stats *rstats, uint32_t delay, 2371 uint8_t tid, uint8_t mode, uint8_t ring_id, 2372 bool delay_in_us); 2373 2374 /** 2375 * dp_print_ring_stats(): Print tail and head pointer 2376 * @pdev: DP_PDEV handle 2377 * 2378 * Return:void 2379 */ 2380 void dp_print_ring_stats(struct dp_pdev *pdev); 2381 2382 /** 2383 * dp_print_ring_stat_from_hal(): Print tail and head pointer through hal 2384 * @soc: soc handle 2385 * @srng: srng handle 2386 * @ring_type: ring type 2387 * 2388 * Return:void 2389 */ 2390 void 2391 dp_print_ring_stat_from_hal(struct dp_soc *soc, struct dp_srng *srng, 2392 enum hal_ring_type ring_type); 2393 /** 2394 * dp_print_pdev_cfg_params() - Print the pdev cfg parameters 2395 * @pdev_handle: DP pdev handle 2396 * 2397 * Return - void 2398 */ 2399 void dp_print_pdev_cfg_params(struct dp_pdev *pdev); 2400 2401 /** 2402 * dp_print_soc_cfg_params()- Dump soc wlan config parameters 2403 * @soc_handle: Soc handle 2404 * 2405 * Return: void 2406 */ 2407 void dp_print_soc_cfg_params(struct dp_soc *soc); 2408 2409 /** 2410 * dp_srng_get_str_from_ring_type() - Return string name for a ring 2411 * @ring_type: Ring 2412 * 2413 * Return: char const pointer 2414 */ 2415 const 2416 char *dp_srng_get_str_from_hal_ring_type(enum hal_ring_type ring_type); 2417 2418 /* 2419 * dp_txrx_path_stats() - Function to display dump stats 2420 * @soc - soc handle 2421 * 2422 * return: none 2423 */ 2424 void dp_txrx_path_stats(struct dp_soc *soc); 2425 2426 /* 2427 * dp_print_per_ring_stats(): Packet count per ring 2428 * @soc - soc handle 2429 * 2430 * Return - None 2431 */ 2432 void dp_print_per_ring_stats(struct dp_soc *soc); 2433 2434 /** 2435 * dp_aggregate_pdev_stats(): Consolidate stats at PDEV level 2436 * @pdev: DP PDEV handle 2437 * 2438 * return: void 2439 */ 2440 void dp_aggregate_pdev_stats(struct dp_pdev *pdev); 2441 2442 /** 2443 * dp_print_rx_rates(): Print Rx rate stats 2444 * @vdev: DP_VDEV handle 2445 * 2446 * Return:void 2447 */ 2448 void dp_print_rx_rates(struct dp_vdev *vdev); 2449 2450 /** 2451 * dp_print_tx_rates(): Print tx rates 2452 * @vdev: DP_VDEV handle 2453 * 2454 * Return:void 2455 */ 2456 void dp_print_tx_rates(struct dp_vdev *vdev); 2457 2458 /** 2459 * dp_print_peer_stats():print peer stats 2460 * @peer: DP_PEER handle 2461 * @peer_stats: buffer holding peer stats 2462 * 2463 * return void 2464 */ 2465 void dp_print_peer_stats(struct dp_peer *peer, 2466 struct cdp_peer_stats *peer_stats); 2467 2468 /** 2469 * dp_print_pdev_tx_stats(): Print Pdev level TX stats 2470 * @pdev: DP_PDEV Handle 2471 * 2472 * Return:void 2473 */ 2474 void 2475 dp_print_pdev_tx_stats(struct dp_pdev *pdev); 2476 2477 /** 2478 * dp_print_pdev_rx_stats(): Print Pdev level RX stats 2479 * @pdev: DP_PDEV Handle 2480 * 2481 * Return: void 2482 */ 2483 void 2484 dp_print_pdev_rx_stats(struct dp_pdev *pdev); 2485 2486 /** 2487 * dp_print_soc_tx_stats(): Print SOC level stats 2488 * @soc DP_SOC Handle 2489 * 2490 * Return: void 2491 */ 2492 void dp_print_soc_tx_stats(struct dp_soc *soc); 2493 2494 /** 2495 * dp_print_soc_interrupt_stats() - Print interrupt stats for the soc 2496 * @soc: dp_soc handle 2497 * 2498 * Return: None 2499 */ 2500 void dp_print_soc_interrupt_stats(struct dp_soc *soc); 2501 2502 #ifdef WLAN_DP_SRNG_USAGE_WM_TRACKING 2503 /** 2504 * dp_dump_srng_high_wm_stats() - Print the ring usage high watermark stats 2505 * for all SRNGs 2506 * @soc: DP soc handle 2507 * @srng_mask: SRNGs mask for dumping usage watermark stats 2508 * 2509 * Return: None 2510 */ 2511 void dp_dump_srng_high_wm_stats(struct dp_soc *soc, uint64_t srng_mask); 2512 #else 2513 /** 2514 * dp_dump_srng_high_wm_stats() - Print the ring usage high watermark stats 2515 * for all SRNGs 2516 * @soc: DP soc handle 2517 * @srng_mask: SRNGs mask for dumping usage watermark stats 2518 * 2519 * Return: None 2520 */ 2521 static inline 2522 void dp_dump_srng_high_wm_stats(struct dp_soc *soc, uint64_t srng_mask) 2523 { 2524 } 2525 #endif 2526 2527 /** 2528 * dp_print_soc_rx_stats: Print SOC level Rx stats 2529 * @soc: DP_SOC Handle 2530 * 2531 * Return:void 2532 */ 2533 void dp_print_soc_rx_stats(struct dp_soc *soc); 2534 2535 /** 2536 * dp_get_mac_id_for_pdev() - Return mac corresponding to pdev for mac 2537 * 2538 * @mac_id: MAC id 2539 * @pdev_id: pdev_id corresponding to pdev, 0 for MCL 2540 * 2541 * Single pdev using both MACs will operate on both MAC rings, 2542 * which is the case for MCL. 2543 * For WIN each PDEV will operate one ring, so index is zero. 2544 * 2545 */ 2546 static inline int dp_get_mac_id_for_pdev(uint32_t mac_id, uint32_t pdev_id) 2547 { 2548 if (mac_id && pdev_id) { 2549 qdf_print("Both mac_id and pdev_id cannot be non zero"); 2550 QDF_BUG(0); 2551 return 0; 2552 } 2553 return (mac_id + pdev_id); 2554 } 2555 2556 /** 2557 * dp_get_lmac_id_for_pdev_id() - Return lmac id corresponding to host pdev id 2558 * @soc: soc pointer 2559 * @mac_id: MAC id 2560 * @pdev_id: pdev_id corresponding to pdev, 0 for MCL 2561 * 2562 * For MCL, Single pdev using both MACs will operate on both MAC rings. 2563 * 2564 * For WIN, each PDEV will operate one ring. 2565 * 2566 */ 2567 static inline int 2568 dp_get_lmac_id_for_pdev_id 2569 (struct dp_soc *soc, uint32_t mac_id, uint32_t pdev_id) 2570 { 2571 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) { 2572 if (mac_id && pdev_id) { 2573 qdf_print("Both mac_id and pdev_id cannot be non zero"); 2574 QDF_BUG(0); 2575 return 0; 2576 } 2577 return (mac_id + pdev_id); 2578 } 2579 2580 return soc->pdev_list[pdev_id]->lmac_id; 2581 } 2582 2583 /** 2584 * dp_get_pdev_for_lmac_id() - Return pdev pointer corresponding to lmac id 2585 * @soc: soc pointer 2586 * @lmac_id: LMAC id 2587 * 2588 * For MCL, Single pdev exists 2589 * 2590 * For WIN, each PDEV will operate one ring. 2591 * 2592 */ 2593 static inline struct dp_pdev * 2594 dp_get_pdev_for_lmac_id(struct dp_soc *soc, uint32_t lmac_id) 2595 { 2596 uint8_t i = 0; 2597 2598 if (wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) { 2599 i = wlan_cfg_get_pdev_idx(soc->wlan_cfg_ctx, lmac_id); 2600 return ((i < MAX_PDEV_CNT) ? soc->pdev_list[i] : NULL); 2601 } 2602 2603 /* Typically for MCL as there only 1 PDEV*/ 2604 return soc->pdev_list[0]; 2605 } 2606 2607 /** 2608 * dp_calculate_target_pdev_id_from_host_pdev_id() - Return target pdev 2609 * corresponding to host pdev id 2610 * @soc: soc pointer 2611 * @mac_for_pdev: pdev_id corresponding to host pdev for WIN, mac id for MCL 2612 * 2613 * returns target pdev_id for host pdev id. For WIN, this is derived through 2614 * a two step process: 2615 * 1. Get lmac_id corresponding to host pdev_id (lmac_id can change 2616 * during mode switch) 2617 * 2. Get target pdev_id (set up during WMI ready) from lmac_id 2618 * 2619 * For MCL, return the offset-1 translated mac_id 2620 */ 2621 static inline int 2622 dp_calculate_target_pdev_id_from_host_pdev_id 2623 (struct dp_soc *soc, uint32_t mac_for_pdev) 2624 { 2625 struct dp_pdev *pdev; 2626 2627 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) 2628 return DP_SW2HW_MACID(mac_for_pdev); 2629 2630 pdev = soc->pdev_list[mac_for_pdev]; 2631 2632 /*non-MCL case, get original target_pdev mapping*/ 2633 return wlan_cfg_get_target_pdev_id(soc->wlan_cfg_ctx, pdev->lmac_id); 2634 } 2635 2636 /** 2637 * dp_get_target_pdev_id_for_host_pdev_id() - Return target pdev corresponding 2638 * to host pdev id 2639 * @soc: soc pointer 2640 * @mac_for_pdev: pdev_id corresponding to host pdev for WIN, mac id for MCL 2641 * 2642 * returns target pdev_id for host pdev id. 2643 * For WIN, return the value stored in pdev object. 2644 * For MCL, return the offset-1 translated mac_id. 2645 */ 2646 static inline int 2647 dp_get_target_pdev_id_for_host_pdev_id 2648 (struct dp_soc *soc, uint32_t mac_for_pdev) 2649 { 2650 struct dp_pdev *pdev; 2651 2652 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) 2653 return DP_SW2HW_MACID(mac_for_pdev); 2654 2655 pdev = soc->pdev_list[mac_for_pdev]; 2656 2657 return pdev->target_pdev_id; 2658 } 2659 2660 /** 2661 * dp_get_host_pdev_id_for_target_pdev_id() - Return host pdev corresponding 2662 * to target pdev id 2663 * @soc: soc pointer 2664 * @pdev_id: pdev_id corresponding to target pdev 2665 * 2666 * returns host pdev_id for target pdev id. For WIN, this is derived through 2667 * a two step process: 2668 * 1. Get lmac_id corresponding to target pdev_id 2669 * 2. Get host pdev_id (set up during WMI ready) from lmac_id 2670 * 2671 * For MCL, return the 0-offset pdev_id 2672 */ 2673 static inline int 2674 dp_get_host_pdev_id_for_target_pdev_id 2675 (struct dp_soc *soc, uint32_t pdev_id) 2676 { 2677 struct dp_pdev *pdev; 2678 int lmac_id; 2679 2680 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) 2681 return DP_HW2SW_MACID(pdev_id); 2682 2683 /*non-MCL case, get original target_lmac mapping from target pdev*/ 2684 lmac_id = wlan_cfg_get_hw_mac_idx(soc->wlan_cfg_ctx, 2685 DP_HW2SW_MACID(pdev_id)); 2686 2687 /*Get host pdev from lmac*/ 2688 pdev = dp_get_pdev_for_lmac_id(soc, lmac_id); 2689 2690 return pdev ? pdev->pdev_id : INVALID_PDEV_ID; 2691 } 2692 2693 /* 2694 * dp_get_mac_id_for_mac() - Return mac corresponding WIN and MCL mac_ids 2695 * 2696 * @soc: handle to DP soc 2697 * @mac_id: MAC id 2698 * 2699 * Single pdev using both MACs will operate on both MAC rings, 2700 * which is the case for MCL. 2701 * For WIN each PDEV will operate one ring, so index is zero. 2702 * 2703 */ 2704 static inline int dp_get_mac_id_for_mac(struct dp_soc *soc, uint32_t mac_id) 2705 { 2706 /* 2707 * Single pdev using both MACs will operate on both MAC rings, 2708 * which is the case for MCL. 2709 */ 2710 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) 2711 return mac_id; 2712 2713 /* For WIN each PDEV will operate one ring, so index is zero. */ 2714 return 0; 2715 } 2716 2717 /* 2718 * dp_is_subtype_data() - check if the frame subtype is data 2719 * 2720 * @frame_ctrl: Frame control field 2721 * 2722 * check the frame control field and verify if the packet 2723 * is a data packet. 2724 * 2725 * Return: true or false 2726 */ 2727 static inline bool dp_is_subtype_data(uint16_t frame_ctrl) 2728 { 2729 if (((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_TYPE_MASK) == 2730 QDF_IEEE80211_FC0_TYPE_DATA) && 2731 (((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_SUBTYPE_MASK) == 2732 QDF_IEEE80211_FC0_SUBTYPE_DATA) || 2733 ((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_SUBTYPE_MASK) == 2734 QDF_IEEE80211_FC0_SUBTYPE_QOS))) { 2735 return true; 2736 } 2737 2738 return false; 2739 } 2740 2741 #ifdef WDI_EVENT_ENABLE 2742 QDF_STATUS dp_h2t_cfg_stats_msg_send(struct dp_pdev *pdev, 2743 uint32_t stats_type_upload_mask, 2744 uint8_t mac_id); 2745 2746 int dp_wdi_event_unsub(struct cdp_soc_t *soc, uint8_t pdev_id, 2747 wdi_event_subscribe *event_cb_sub_handle, 2748 uint32_t event); 2749 2750 int dp_wdi_event_sub(struct cdp_soc_t *soc, uint8_t pdev_id, 2751 wdi_event_subscribe *event_cb_sub_handle, 2752 uint32_t event); 2753 2754 void dp_wdi_event_handler(enum WDI_EVENT event, struct dp_soc *soc, 2755 void *data, u_int16_t peer_id, 2756 int status, u_int8_t pdev_id); 2757 2758 int dp_wdi_event_attach(struct dp_pdev *txrx_pdev); 2759 int dp_wdi_event_detach(struct dp_pdev *txrx_pdev); 2760 2761 static inline void 2762 dp_hif_update_pipe_callback(struct dp_soc *dp_soc, 2763 void *cb_context, 2764 QDF_STATUS (*callback)(void *, qdf_nbuf_t, uint8_t), 2765 uint8_t pipe_id) 2766 { 2767 struct hif_msg_callbacks hif_pipe_callbacks = { 0 }; 2768 2769 /* TODO: Temporary change to bypass HTC connection for this new 2770 * HIF pipe, which will be used for packet log and other high- 2771 * priority HTT messages. Proper HTC connection to be added 2772 * later once required FW changes are available 2773 */ 2774 hif_pipe_callbacks.rxCompletionHandler = callback; 2775 hif_pipe_callbacks.Context = cb_context; 2776 hif_update_pipe_callback(dp_soc->hif_handle, 2777 DP_HTT_T2H_HP_PIPE, &hif_pipe_callbacks); 2778 } 2779 #else 2780 static inline int dp_wdi_event_unsub(struct cdp_soc_t *soc, uint8_t pdev_id, 2781 wdi_event_subscribe *event_cb_sub_handle, 2782 uint32_t event) 2783 { 2784 return 0; 2785 } 2786 2787 static inline int dp_wdi_event_sub(struct cdp_soc_t *soc, uint8_t pdev_id, 2788 wdi_event_subscribe *event_cb_sub_handle, 2789 uint32_t event) 2790 { 2791 return 0; 2792 } 2793 2794 static inline 2795 void dp_wdi_event_handler(enum WDI_EVENT event, 2796 struct dp_soc *soc, 2797 void *data, u_int16_t peer_id, 2798 int status, u_int8_t pdev_id) 2799 { 2800 } 2801 2802 static inline int dp_wdi_event_attach(struct dp_pdev *txrx_pdev) 2803 { 2804 return 0; 2805 } 2806 2807 static inline int dp_wdi_event_detach(struct dp_pdev *txrx_pdev) 2808 { 2809 return 0; 2810 } 2811 2812 static inline QDF_STATUS dp_h2t_cfg_stats_msg_send(struct dp_pdev *pdev, 2813 uint32_t stats_type_upload_mask, uint8_t mac_id) 2814 { 2815 return 0; 2816 } 2817 2818 static inline void 2819 dp_hif_update_pipe_callback(struct dp_soc *dp_soc, void *cb_context, 2820 QDF_STATUS (*callback)(void *, qdf_nbuf_t, uint8_t), 2821 uint8_t pipe_id) 2822 { 2823 } 2824 #endif /* CONFIG_WIN */ 2825 2826 #ifdef VDEV_PEER_PROTOCOL_COUNT 2827 /** 2828 * dp_vdev_peer_stats_update_protocol_cnt() - update per-peer protocol counters 2829 * @vdev: VDEV DP object 2830 * @nbuf: data packet 2831 * @peer: DP TXRX Peer object 2832 * @is_egress: whether egress or ingress 2833 * @is_rx: whether rx or tx 2834 * 2835 * This function updates the per-peer protocol counters 2836 * Return: void 2837 */ 2838 void dp_vdev_peer_stats_update_protocol_cnt(struct dp_vdev *vdev, 2839 qdf_nbuf_t nbuf, 2840 struct dp_txrx_peer *txrx_peer, 2841 bool is_egress, 2842 bool is_rx); 2843 2844 /** 2845 * dp_vdev_peer_stats_update_protocol_cnt() - update per-peer protocol counters 2846 * @soc: SOC DP object 2847 * @vdev_id: vdev_id 2848 * @nbuf: data packet 2849 * @is_egress: whether egress or ingress 2850 * @is_rx: whether rx or tx 2851 * 2852 * This function updates the per-peer protocol counters 2853 * Return: void 2854 */ 2855 2856 void dp_peer_stats_update_protocol_cnt(struct cdp_soc_t *soc, 2857 int8_t vdev_id, 2858 qdf_nbuf_t nbuf, 2859 bool is_egress, 2860 bool is_rx); 2861 2862 void dp_vdev_peer_stats_update_protocol_cnt_tx(struct dp_vdev *vdev_hdl, 2863 qdf_nbuf_t nbuf); 2864 2865 #else 2866 #define dp_vdev_peer_stats_update_protocol_cnt(vdev, nbuf, txrx_peer, \ 2867 is_egress, is_rx) 2868 2869 static inline 2870 void dp_vdev_peer_stats_update_protocol_cnt_tx(struct dp_vdev *vdev_hdl, 2871 qdf_nbuf_t nbuf) 2872 { 2873 } 2874 2875 #endif 2876 2877 #ifdef QCA_LL_TX_FLOW_CONTROL_V2 2878 void dp_tx_dump_flow_pool_info(struct cdp_soc_t *soc_hdl); 2879 2880 /** 2881 * dp_tx_dump_flow_pool_info_compact() - dump flow pool info 2882 * @soc: DP soc context 2883 * 2884 * Return: none 2885 */ 2886 void dp_tx_dump_flow_pool_info_compact(struct dp_soc *soc); 2887 int dp_tx_delete_flow_pool(struct dp_soc *soc, struct dp_tx_desc_pool_s *pool, 2888 bool force); 2889 #else 2890 static inline void dp_tx_dump_flow_pool_info_compact(struct dp_soc *soc) 2891 { 2892 } 2893 #endif /* QCA_LL_TX_FLOW_CONTROL_V2 */ 2894 2895 #ifdef QCA_OL_DP_SRNG_LOCK_LESS_ACCESS 2896 static inline int 2897 dp_hal_srng_access_start(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) 2898 { 2899 return hal_srng_access_start_unlocked(soc, hal_ring_hdl); 2900 } 2901 2902 static inline void 2903 dp_hal_srng_access_end(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) 2904 { 2905 hal_srng_access_end_unlocked(soc, hal_ring_hdl); 2906 } 2907 2908 #else 2909 static inline int 2910 dp_hal_srng_access_start(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) 2911 { 2912 return hal_srng_access_start(soc, hal_ring_hdl); 2913 } 2914 2915 static inline void 2916 dp_hal_srng_access_end(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) 2917 { 2918 hal_srng_access_end(soc, hal_ring_hdl); 2919 } 2920 #endif 2921 2922 #ifdef WLAN_FEATURE_DP_EVENT_HISTORY 2923 /** 2924 * dp_srng_access_start() - Wrapper function to log access start of a hal ring 2925 * @int_ctx: pointer to DP interrupt context. This should not be NULL 2926 * @soc: DP Soc handle 2927 * @hal_ring: opaque pointer to the HAL Rx Error Ring, which will be serviced 2928 * 2929 * Return: 0 on success; error on failure 2930 */ 2931 int dp_srng_access_start(struct dp_intr *int_ctx, struct dp_soc *dp_soc, 2932 hal_ring_handle_t hal_ring_hdl); 2933 2934 /** 2935 * dp_srng_access_end() - Wrapper function to log access end of a hal ring 2936 * @int_ctx: pointer to DP interrupt context. This should not be NULL 2937 * @soc: DP Soc handle 2938 * @hal_ring: opaque pointer to the HAL Rx Error Ring, which will be serviced 2939 * 2940 * Return: void 2941 */ 2942 void dp_srng_access_end(struct dp_intr *int_ctx, struct dp_soc *dp_soc, 2943 hal_ring_handle_t hal_ring_hdl); 2944 2945 #else 2946 static inline int dp_srng_access_start(struct dp_intr *int_ctx, 2947 struct dp_soc *dp_soc, 2948 hal_ring_handle_t hal_ring_hdl) 2949 { 2950 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 2951 2952 return dp_hal_srng_access_start(hal_soc, hal_ring_hdl); 2953 } 2954 2955 static inline void dp_srng_access_end(struct dp_intr *int_ctx, 2956 struct dp_soc *dp_soc, 2957 hal_ring_handle_t hal_ring_hdl) 2958 { 2959 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 2960 2961 return dp_hal_srng_access_end(hal_soc, hal_ring_hdl); 2962 } 2963 #endif /* WLAN_FEATURE_DP_EVENT_HISTORY */ 2964 2965 #ifdef QCA_CACHED_RING_DESC 2966 /** 2967 * dp_srng_dst_get_next() - Wrapper function to get next ring desc 2968 * @dp_socsoc: DP Soc handle 2969 * @hal_ring: opaque pointer to the HAL Destination Ring 2970 * 2971 * Return: HAL ring descriptor 2972 */ 2973 static inline void *dp_srng_dst_get_next(struct dp_soc *dp_soc, 2974 hal_ring_handle_t hal_ring_hdl) 2975 { 2976 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 2977 2978 return hal_srng_dst_get_next_cached(hal_soc, hal_ring_hdl); 2979 } 2980 2981 /** 2982 * dp_srng_dst_inv_cached_descs() - Wrapper function to invalidate cached 2983 * descriptors 2984 * @dp_socsoc: DP Soc handle 2985 * @hal_ring: opaque pointer to the HAL Rx Destination ring 2986 * @num_entries: Entry count 2987 * 2988 * Return: None 2989 */ 2990 static inline void dp_srng_dst_inv_cached_descs(struct dp_soc *dp_soc, 2991 hal_ring_handle_t hal_ring_hdl, 2992 uint32_t num_entries) 2993 { 2994 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 2995 2996 hal_srng_dst_inv_cached_descs(hal_soc, hal_ring_hdl, num_entries); 2997 } 2998 #else 2999 static inline void *dp_srng_dst_get_next(struct dp_soc *dp_soc, 3000 hal_ring_handle_t hal_ring_hdl) 3001 { 3002 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 3003 3004 return hal_srng_dst_get_next(hal_soc, hal_ring_hdl); 3005 } 3006 3007 static inline void dp_srng_dst_inv_cached_descs(struct dp_soc *dp_soc, 3008 hal_ring_handle_t hal_ring_hdl, 3009 uint32_t num_entries) 3010 { 3011 } 3012 #endif /* QCA_CACHED_RING_DESC */ 3013 3014 #if defined(QCA_CACHED_RING_DESC) && \ 3015 (defined(QCA_DP_RX_HW_SW_NBUF_DESC_PREFETCH) || \ 3016 defined(QCA_DP_TX_HW_SW_NBUF_DESC_PREFETCH)) 3017 /** 3018 * dp_srng_dst_prefetch() - Wrapper function to prefetch descs from dest ring 3019 * @hal_soc_hdl: HAL SOC handle 3020 * @hal_ring: opaque pointer to the HAL Rx Destination ring 3021 * @num_entries: Entry count 3022 * 3023 * Return: None 3024 */ 3025 static inline void *dp_srng_dst_prefetch(hal_soc_handle_t hal_soc, 3026 hal_ring_handle_t hal_ring_hdl, 3027 uint32_t num_entries) 3028 { 3029 return hal_srng_dst_prefetch(hal_soc, hal_ring_hdl, num_entries); 3030 } 3031 3032 /** 3033 * dp_srng_dst_prefetch_32_byte_desc() - Wrapper function to prefetch 3034 * 32 byte descriptor starting at 3035 * 64 byte offset 3036 * @hal_soc_hdl: HAL SOC handle 3037 * @hal_ring: opaque pointer to the HAL Rx Destination ring 3038 * @num_entries: Entry count 3039 * 3040 * Return: None 3041 */ 3042 static inline 3043 void *dp_srng_dst_prefetch_32_byte_desc(hal_soc_handle_t hal_soc, 3044 hal_ring_handle_t hal_ring_hdl, 3045 uint32_t num_entries) 3046 { 3047 return hal_srng_dst_prefetch_32_byte_desc(hal_soc, hal_ring_hdl, 3048 num_entries); 3049 } 3050 #else 3051 static inline void *dp_srng_dst_prefetch(hal_soc_handle_t hal_soc, 3052 hal_ring_handle_t hal_ring_hdl, 3053 uint32_t num_entries) 3054 { 3055 return NULL; 3056 } 3057 3058 static inline 3059 void *dp_srng_dst_prefetch_32_byte_desc(hal_soc_handle_t hal_soc, 3060 hal_ring_handle_t hal_ring_hdl, 3061 uint32_t num_entries) 3062 { 3063 return NULL; 3064 } 3065 #endif 3066 3067 #ifdef QCA_ENH_V3_STATS_SUPPORT 3068 /** 3069 * dp_pdev_print_delay_stats(): Print pdev level delay stats 3070 * @pdev: DP_PDEV handle 3071 * 3072 * Return:void 3073 */ 3074 void dp_pdev_print_delay_stats(struct dp_pdev *pdev); 3075 3076 /** 3077 * dp_pdev_print_tid_stats(): Print pdev level tid stats 3078 * @pdev: DP_PDEV handle 3079 * 3080 * Return:void 3081 */ 3082 void dp_pdev_print_tid_stats(struct dp_pdev *pdev); 3083 3084 /** 3085 * dp_pdev_print_rx_error_stats(): Print pdev level rx error stats 3086 * @pdev: DP_PDEV handle 3087 * 3088 * Return:void 3089 */ 3090 void dp_pdev_print_rx_error_stats(struct dp_pdev *pdev); 3091 #endif /* QCA_ENH_V3_STATS_SUPPORT */ 3092 3093 /** 3094 * dp_pdev_get_tid_stats(): Get accumulated pdev level tid_stats 3095 * @soc_hdl: soc handle 3096 * @pdev_id: id of dp_pdev handle 3097 * @tid_stats: Pointer for cdp_tid_stats_intf 3098 * 3099 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_E_INVAL 3100 */ 3101 QDF_STATUS dp_pdev_get_tid_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 3102 struct cdp_tid_stats_intf *tid_stats); 3103 3104 void dp_soc_set_txrx_ring_map(struct dp_soc *soc); 3105 3106 /** 3107 * dp_vdev_to_cdp_vdev() - typecast dp vdev to cdp vdev 3108 * @vdev: DP vdev handle 3109 * 3110 * Return: struct cdp_vdev pointer 3111 */ 3112 static inline 3113 struct cdp_vdev *dp_vdev_to_cdp_vdev(struct dp_vdev *vdev) 3114 { 3115 return (struct cdp_vdev *)vdev; 3116 } 3117 3118 /** 3119 * dp_pdev_to_cdp_pdev() - typecast dp pdev to cdp pdev 3120 * @pdev: DP pdev handle 3121 * 3122 * Return: struct cdp_pdev pointer 3123 */ 3124 static inline 3125 struct cdp_pdev *dp_pdev_to_cdp_pdev(struct dp_pdev *pdev) 3126 { 3127 return (struct cdp_pdev *)pdev; 3128 } 3129 3130 /** 3131 * dp_soc_to_cdp_soc() - typecast dp psoc to cdp psoc 3132 * @psoc: DP psoc handle 3133 * 3134 * Return: struct cdp_soc pointer 3135 */ 3136 static inline 3137 struct cdp_soc *dp_soc_to_cdp_soc(struct dp_soc *psoc) 3138 { 3139 return (struct cdp_soc *)psoc; 3140 } 3141 3142 /** 3143 * dp_soc_to_cdp_soc_t() - typecast dp psoc to 3144 * ol txrx soc handle 3145 * @psoc: DP psoc handle 3146 * 3147 * Return: struct cdp_soc_t pointer 3148 */ 3149 static inline 3150 struct cdp_soc_t *dp_soc_to_cdp_soc_t(struct dp_soc *psoc) 3151 { 3152 return (struct cdp_soc_t *)psoc; 3153 } 3154 3155 #if defined(WLAN_SUPPORT_RX_FLOW_TAG) || defined(WLAN_SUPPORT_RX_FISA) 3156 /** 3157 * dp_rx_flow_update_fse_stats() - Update a flow's statistics 3158 * @pdev: pdev handle 3159 * @flow_id: flow index (truncated hash) in the Rx FST 3160 * 3161 * Return: Success when flow statistcs is updated, error on failure 3162 */ 3163 QDF_STATUS dp_rx_flow_get_fse_stats(struct dp_pdev *pdev, 3164 struct cdp_rx_flow_info *rx_flow_info, 3165 struct cdp_flow_stats *stats); 3166 3167 /** 3168 * dp_rx_flow_delete_entry() - Delete a flow entry from flow search table 3169 * @pdev: pdev handle 3170 * @rx_flow_info: DP flow parameters 3171 * 3172 * Return: Success when flow is deleted, error on failure 3173 */ 3174 QDF_STATUS dp_rx_flow_delete_entry(struct dp_pdev *pdev, 3175 struct cdp_rx_flow_info *rx_flow_info); 3176 3177 /** 3178 * dp_rx_flow_add_entry() - Add a flow entry to flow search table 3179 * @pdev: DP pdev instance 3180 * @rx_flow_info: DP flow paramaters 3181 * 3182 * Return: Success when flow is added, no-memory or already exists on error 3183 */ 3184 QDF_STATUS dp_rx_flow_add_entry(struct dp_pdev *pdev, 3185 struct cdp_rx_flow_info *rx_flow_info); 3186 3187 /** 3188 * dp_rx_fst_attach() - Initialize Rx FST and setup necessary parameters 3189 * @soc: SoC handle 3190 * @pdev: Pdev handle 3191 * 3192 * Return: Handle to flow search table entry 3193 */ 3194 QDF_STATUS dp_rx_fst_attach(struct dp_soc *soc, struct dp_pdev *pdev); 3195 3196 /** 3197 * dp_rx_fst_detach() - De-initialize Rx FST 3198 * @soc: SoC handle 3199 * @pdev: Pdev handle 3200 * 3201 * Return: None 3202 */ 3203 void dp_rx_fst_detach(struct dp_soc *soc, struct dp_pdev *pdev); 3204 3205 /** 3206 * dp_rx_flow_send_fst_fw_setup() - Program FST parameters in FW/HW post-attach 3207 * @soc: SoC handle 3208 * @pdev: Pdev handle 3209 * 3210 * Return: Success when fst parameters are programmed in FW, error otherwise 3211 */ 3212 QDF_STATUS dp_rx_flow_send_fst_fw_setup(struct dp_soc *soc, 3213 struct dp_pdev *pdev); 3214 3215 /** dp_mon_rx_update_rx_flow_tag_stats() - Update a mon flow's statistics 3216 * @pdev: pdev handle 3217 * @flow_id: flow index (truncated hash) in the Rx FST 3218 * 3219 * Return: Success when flow statistcs is updated, error on failure 3220 */ 3221 QDF_STATUS 3222 dp_mon_rx_update_rx_flow_tag_stats(struct dp_pdev *pdev, uint32_t flow_id); 3223 3224 #else /* !((WLAN_SUPPORT_RX_FLOW_TAG) || defined(WLAN_SUPPORT_RX_FISA)) */ 3225 3226 /** 3227 * dp_rx_fst_attach() - Initialize Rx FST and setup necessary parameters 3228 * @soc: SoC handle 3229 * @pdev: Pdev handle 3230 * 3231 * Return: Handle to flow search table entry 3232 */ 3233 static inline 3234 QDF_STATUS dp_rx_fst_attach(struct dp_soc *soc, struct dp_pdev *pdev) 3235 { 3236 return QDF_STATUS_SUCCESS; 3237 } 3238 3239 /** 3240 * dp_rx_fst_detach() - De-initialize Rx FST 3241 * @soc: SoC handle 3242 * @pdev: Pdev handle 3243 * 3244 * Return: None 3245 */ 3246 static inline 3247 void dp_rx_fst_detach(struct dp_soc *soc, struct dp_pdev *pdev) 3248 { 3249 } 3250 #endif 3251 3252 /** 3253 * dp_vdev_get_ref() - API to take a reference for VDEV object 3254 * 3255 * @soc : core DP soc context 3256 * @vdev : DP vdev 3257 * @mod_id : module id 3258 * 3259 * Return: QDF_STATUS_SUCCESS if reference held successfully 3260 * else QDF_STATUS_E_INVAL 3261 */ 3262 static inline 3263 QDF_STATUS dp_vdev_get_ref(struct dp_soc *soc, struct dp_vdev *vdev, 3264 enum dp_mod_id mod_id) 3265 { 3266 if (!qdf_atomic_inc_not_zero(&vdev->ref_cnt)) 3267 return QDF_STATUS_E_INVAL; 3268 3269 qdf_atomic_inc(&vdev->mod_refs[mod_id]); 3270 3271 return QDF_STATUS_SUCCESS; 3272 } 3273 3274 /** 3275 * dp_vdev_get_ref_by_id() - Returns vdev object given the vdev id 3276 * @soc: core DP soc context 3277 * @vdev_id: vdev id from vdev object can be retrieved 3278 * @mod_id: module id which is requesting the reference 3279 * 3280 * Return: struct dp_vdev*: Pointer to DP vdev object 3281 */ 3282 static inline struct dp_vdev * 3283 dp_vdev_get_ref_by_id(struct dp_soc *soc, uint8_t vdev_id, 3284 enum dp_mod_id mod_id) 3285 { 3286 struct dp_vdev *vdev = NULL; 3287 if (qdf_unlikely(vdev_id >= MAX_VDEV_CNT)) 3288 return NULL; 3289 3290 qdf_spin_lock_bh(&soc->vdev_map_lock); 3291 vdev = soc->vdev_id_map[vdev_id]; 3292 3293 if (!vdev || dp_vdev_get_ref(soc, vdev, mod_id) != QDF_STATUS_SUCCESS) { 3294 qdf_spin_unlock_bh(&soc->vdev_map_lock); 3295 return NULL; 3296 } 3297 qdf_spin_unlock_bh(&soc->vdev_map_lock); 3298 3299 return vdev; 3300 } 3301 3302 /** 3303 * dp_get_pdev_from_soc_pdev_id_wifi3() - Returns pdev object given the pdev id 3304 * @soc: core DP soc context 3305 * @pdev_id: pdev id from pdev object can be retrieved 3306 * 3307 * Return: struct dp_pdev*: Pointer to DP pdev object 3308 */ 3309 static inline struct dp_pdev * 3310 dp_get_pdev_from_soc_pdev_id_wifi3(struct dp_soc *soc, 3311 uint8_t pdev_id) 3312 { 3313 if (qdf_unlikely(pdev_id >= MAX_PDEV_CNT)) 3314 return NULL; 3315 3316 return soc->pdev_list[pdev_id]; 3317 } 3318 3319 /* 3320 * dp_rx_tid_update_wifi3() – Update receive TID state 3321 * @peer: Datapath peer handle 3322 * @tid: TID 3323 * @ba_window_size: BlockAck window size 3324 * @start_seq: Starting sequence number 3325 * @bar_update: BAR update triggered 3326 * 3327 * Return: QDF_STATUS code 3328 */ 3329 QDF_STATUS dp_rx_tid_update_wifi3(struct dp_peer *peer, int tid, uint32_t 3330 ba_window_size, uint32_t start_seq, 3331 bool bar_update); 3332 3333 /** 3334 * dp_get_peer_mac_list(): function to get peer mac list of vdev 3335 * @soc: Datapath soc handle 3336 * @vdev_id: vdev id 3337 * @newmac: Table of the clients mac 3338 * @mac_cnt: No. of MACs required 3339 * @limit: Limit the number of clients 3340 * 3341 * return: no of clients 3342 */ 3343 uint16_t dp_get_peer_mac_list(ol_txrx_soc_handle soc, uint8_t vdev_id, 3344 u_int8_t newmac[][QDF_MAC_ADDR_SIZE], 3345 u_int16_t mac_cnt, bool limit); 3346 3347 /* 3348 * dp_update_num_mac_rings_for_dbs() - Update No of MAC rings based on 3349 * DBS check 3350 * @soc: DP SoC context 3351 * @max_mac_rings: Pointer to variable for No of MAC rings 3352 * 3353 * Return: None 3354 */ 3355 void dp_update_num_mac_rings_for_dbs(struct dp_soc *soc, 3356 int *max_mac_rings); 3357 3358 3359 #if defined(WLAN_SUPPORT_RX_FISA) 3360 void dp_rx_dump_fisa_table(struct dp_soc *soc); 3361 3362 /** 3363 * dp_print_fisa_stats() - Print FISA stats 3364 * @soc: DP soc handle 3365 * 3366 * Return: None 3367 */ 3368 void dp_print_fisa_stats(struct dp_soc *soc); 3369 3370 /* 3371 * dp_rx_fst_update_cmem_params() - Update CMEM FST params 3372 * @soc: DP SoC context 3373 * @num_entries: Number of flow search entries 3374 * @cmem_ba_lo: CMEM base address low 3375 * @cmem_ba_hi: CMEM base address high 3376 * 3377 * Return: None 3378 */ 3379 void dp_rx_fst_update_cmem_params(struct dp_soc *soc, uint16_t num_entries, 3380 uint32_t cmem_ba_lo, uint32_t cmem_ba_hi); 3381 3382 void 3383 dp_rx_fst_update_pm_suspend_status(struct dp_soc *soc, bool suspended); 3384 #else 3385 static inline void 3386 dp_rx_fst_update_cmem_params(struct dp_soc *soc, uint16_t num_entries, 3387 uint32_t cmem_ba_lo, uint32_t cmem_ba_hi) 3388 { 3389 } 3390 3391 static inline void 3392 dp_rx_fst_update_pm_suspend_status(struct dp_soc *soc, bool suspended) 3393 { 3394 } 3395 3396 static inline void dp_print_fisa_stats(struct dp_soc *soc) 3397 { 3398 } 3399 #endif /* WLAN_SUPPORT_RX_FISA */ 3400 3401 #ifdef MAX_ALLOC_PAGE_SIZE 3402 /** 3403 * dp_set_page_size() - Set the max page size for hw link desc. 3404 * For MCL the page size is set to OS defined value and for WIN 3405 * the page size is set to the max_alloc_size cfg ini 3406 * param. 3407 * This is to ensure that WIN gets contiguous memory allocations 3408 * as per requirement. 3409 * @pages: link desc page handle 3410 * @max_alloc_size: max_alloc_size 3411 * 3412 * Return: None 3413 */ 3414 static inline 3415 void dp_set_max_page_size(struct qdf_mem_multi_page_t *pages, 3416 uint32_t max_alloc_size) 3417 { 3418 pages->page_size = qdf_page_size; 3419 } 3420 3421 #else 3422 static inline 3423 void dp_set_max_page_size(struct qdf_mem_multi_page_t *pages, 3424 uint32_t max_alloc_size) 3425 { 3426 pages->page_size = max_alloc_size; 3427 } 3428 #endif /* MAX_ALLOC_PAGE_SIZE */ 3429 3430 /** 3431 * dp_history_get_next_index() - get the next entry to record an entry 3432 * in the history. 3433 * @curr_idx: Current index where the last entry is written. 3434 * @max_entries: Max number of entries in the history 3435 * 3436 * This function assumes that the max number os entries is a power of 2. 3437 * 3438 * Returns: The index where the next entry is to be written. 3439 */ 3440 static inline uint32_t dp_history_get_next_index(qdf_atomic_t *curr_idx, 3441 uint32_t max_entries) 3442 { 3443 uint32_t idx = qdf_atomic_inc_return(curr_idx); 3444 3445 return idx & (max_entries - 1); 3446 } 3447 3448 /** 3449 * dp_rx_skip_tlvs() - Skip TLVs len + L2 hdr_offset, save in nbuf->cb 3450 * @nbuf: nbuf cb to be updated 3451 * @l2_hdr_offset: l2_hdr_offset 3452 * 3453 * Return: None 3454 */ 3455 void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding); 3456 3457 #ifndef FEATURE_WDS 3458 static inline void 3459 dp_hmwds_ast_add_notify(struct dp_peer *peer, 3460 uint8_t *mac_addr, 3461 enum cdp_txrx_ast_entry_type type, 3462 QDF_STATUS err, 3463 bool is_peer_map) 3464 { 3465 } 3466 #endif 3467 3468 #ifdef HTT_STATS_DEBUGFS_SUPPORT 3469 /* dp_pdev_htt_stats_dbgfs_init() - Function to allocate memory and initialize 3470 * debugfs for HTT stats 3471 * @pdev: dp pdev handle 3472 * 3473 * Return: QDF_STATUS 3474 */ 3475 QDF_STATUS dp_pdev_htt_stats_dbgfs_init(struct dp_pdev *pdev); 3476 3477 /* dp_pdev_htt_stats_dbgfs_deinit() - Function to remove debugfs entry for 3478 * HTT stats 3479 * @pdev: dp pdev handle 3480 * 3481 * Return: none 3482 */ 3483 void dp_pdev_htt_stats_dbgfs_deinit(struct dp_pdev *pdev); 3484 #else 3485 3486 /* dp_pdev_htt_stats_dbgfs_init() - Function to allocate memory and initialize 3487 * debugfs for HTT stats 3488 * @pdev: dp pdev handle 3489 * 3490 * Return: QDF_STATUS 3491 */ 3492 static inline QDF_STATUS 3493 dp_pdev_htt_stats_dbgfs_init(struct dp_pdev *pdev) 3494 { 3495 return QDF_STATUS_SUCCESS; 3496 } 3497 3498 /* dp_pdev_htt_stats_dbgfs_deinit() - Function to remove debugfs entry for 3499 * HTT stats 3500 * @pdev: dp pdev handle 3501 * 3502 * Return: none 3503 */ 3504 static inline void 3505 dp_pdev_htt_stats_dbgfs_deinit(struct dp_pdev *pdev) 3506 { 3507 } 3508 #endif /* HTT_STATS_DEBUGFS_SUPPORT */ 3509 3510 #ifndef WLAN_DP_FEATURE_SW_LATENCY_MGR 3511 /** 3512 * dp_soc_swlm_attach() - attach the software latency manager resources 3513 * @soc: Datapath global soc handle 3514 * 3515 * Returns: QDF_STATUS 3516 */ 3517 static inline QDF_STATUS dp_soc_swlm_attach(struct dp_soc *soc) 3518 { 3519 return QDF_STATUS_SUCCESS; 3520 } 3521 3522 /** 3523 * dp_soc_swlm_detach() - detach the software latency manager resources 3524 * @soc: Datapath global soc handle 3525 * 3526 * Returns: QDF_STATUS 3527 */ 3528 static inline QDF_STATUS dp_soc_swlm_detach(struct dp_soc *soc) 3529 { 3530 return QDF_STATUS_SUCCESS; 3531 } 3532 #endif /* !WLAN_DP_FEATURE_SW_LATENCY_MGR */ 3533 3534 /** 3535 * dp_get_peer_id(): function to get peer id by mac 3536 * @soc: Datapath soc handle 3537 * @vdev_id: vdev id 3538 * @mac: Peer mac address 3539 * 3540 * return: valid peer id on success 3541 * HTT_INVALID_PEER on failure 3542 */ 3543 uint16_t dp_get_peer_id(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac); 3544 3545 #ifdef QCA_SUPPORT_WDS_EXTENDED 3546 /** 3547 * dp_wds_ext_set_peer_state(): function to set peer state 3548 * @soc: Datapath soc handle 3549 * @vdev_id: vdev id 3550 * @mac: Peer mac address 3551 * @rx: rx function pointer 3552 * 3553 * return: QDF_STATUS_SUCCESS on success 3554 * QDF_STATUS_E_INVAL if peer is not found 3555 * QDF_STATUS_E_ALREADY if rx is already set/unset 3556 */ 3557 QDF_STATUS dp_wds_ext_set_peer_rx(ol_txrx_soc_handle soc, 3558 uint8_t vdev_id, 3559 uint8_t *mac, 3560 ol_txrx_rx_fp rx, 3561 ol_osif_peer_handle osif_peer); 3562 #endif /* QCA_SUPPORT_WDS_EXTENDED */ 3563 3564 #ifdef DP_MEM_PRE_ALLOC 3565 3566 /** 3567 * dp_context_alloc_mem() - allocate memory for DP context 3568 * @soc: datapath soc handle 3569 * @ctxt_type: DP context type 3570 * @ctxt_size: DP context size 3571 * 3572 * Return: DP context address 3573 */ 3574 void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 3575 size_t ctxt_size); 3576 3577 /** 3578 * dp_context_free_mem() - Free memory of DP context 3579 * @soc: datapath soc handle 3580 * @ctxt_type: DP context type 3581 * @vaddr: Address of context memory 3582 * 3583 * Return: None 3584 */ 3585 void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 3586 void *vaddr); 3587 3588 /** 3589 * dp_desc_multi_pages_mem_alloc() - alloc memory over multiple pages 3590 * @soc: datapath soc handle 3591 * @desc_type: memory request source type 3592 * @pages: multi page information storage 3593 * @element_size: each element size 3594 * @element_num: total number of elements should be allocated 3595 * @memctxt: memory context 3596 * @cacheable: coherent memory or cacheable memory 3597 * 3598 * This function is a wrapper for memory allocation over multiple 3599 * pages, if dp prealloc method is registered, then will try prealloc 3600 * firstly. if prealloc failed, fall back to regular way over 3601 * qdf_mem_multi_pages_alloc(). 3602 * 3603 * Return: None 3604 */ 3605 void dp_desc_multi_pages_mem_alloc(struct dp_soc *soc, 3606 enum dp_desc_type desc_type, 3607 struct qdf_mem_multi_page_t *pages, 3608 size_t element_size, 3609 uint32_t element_num, 3610 qdf_dma_context_t memctxt, 3611 bool cacheable); 3612 3613 /** 3614 * dp_desc_multi_pages_mem_free() - free multiple pages memory 3615 * @soc: datapath soc handle 3616 * @desc_type: memory request source type 3617 * @pages: multi page information storage 3618 * @memctxt: memory context 3619 * @cacheable: coherent memory or cacheable memory 3620 * 3621 * This function is a wrapper for multiple pages memory free, 3622 * if memory is got from prealloc pool, put it back to pool. 3623 * otherwise free by qdf_mem_multi_pages_free(). 3624 * 3625 * Return: None 3626 */ 3627 void dp_desc_multi_pages_mem_free(struct dp_soc *soc, 3628 enum dp_desc_type desc_type, 3629 struct qdf_mem_multi_page_t *pages, 3630 qdf_dma_context_t memctxt, 3631 bool cacheable); 3632 3633 #else 3634 static inline 3635 void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 3636 size_t ctxt_size) 3637 { 3638 return qdf_mem_malloc(ctxt_size); 3639 } 3640 3641 static inline 3642 void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 3643 void *vaddr) 3644 { 3645 qdf_mem_free(vaddr); 3646 } 3647 3648 static inline 3649 void dp_desc_multi_pages_mem_alloc(struct dp_soc *soc, 3650 enum dp_desc_type desc_type, 3651 struct qdf_mem_multi_page_t *pages, 3652 size_t element_size, 3653 uint32_t element_num, 3654 qdf_dma_context_t memctxt, 3655 bool cacheable) 3656 { 3657 qdf_mem_multi_pages_alloc(soc->osdev, pages, element_size, 3658 element_num, memctxt, cacheable); 3659 } 3660 3661 static inline 3662 void dp_desc_multi_pages_mem_free(struct dp_soc *soc, 3663 enum dp_desc_type desc_type, 3664 struct qdf_mem_multi_page_t *pages, 3665 qdf_dma_context_t memctxt, 3666 bool cacheable) 3667 { 3668 qdf_mem_multi_pages_free(soc->osdev, pages, 3669 memctxt, cacheable); 3670 } 3671 #endif 3672 3673 /** 3674 * struct dp_frag_history_opaque_atomic - Opaque struct for adding a fragmented 3675 * history. 3676 * @index: atomic index 3677 * @num_entries_per_slot: Number of entries per slot 3678 * @allocated: is allocated or not 3679 * @entry: pointers to array of records 3680 */ 3681 struct dp_frag_history_opaque_atomic { 3682 qdf_atomic_t index; 3683 uint16_t num_entries_per_slot; 3684 uint16_t allocated; 3685 void *entry[0]; 3686 }; 3687 3688 static inline QDF_STATUS 3689 dp_soc_frag_history_attach(struct dp_soc *soc, void *history_hdl, 3690 uint32_t max_slots, uint32_t max_entries_per_slot, 3691 uint32_t entry_size, 3692 bool attempt_prealloc, enum dp_ctxt_type ctxt_type) 3693 { 3694 struct dp_frag_history_opaque_atomic *history = 3695 (struct dp_frag_history_opaque_atomic *)history_hdl; 3696 size_t alloc_size = max_entries_per_slot * entry_size; 3697 int i; 3698 3699 for (i = 0; i < max_slots; i++) { 3700 if (attempt_prealloc) 3701 history->entry[i] = dp_context_alloc_mem(soc, ctxt_type, 3702 alloc_size); 3703 else 3704 history->entry[i] = qdf_mem_malloc(alloc_size); 3705 3706 if (!history->entry[i]) 3707 goto exit; 3708 } 3709 3710 qdf_atomic_init(&history->index); 3711 history->allocated = 1; 3712 history->num_entries_per_slot = max_entries_per_slot; 3713 3714 return QDF_STATUS_SUCCESS; 3715 exit: 3716 for (i = i - 1; i >= 0; i--) { 3717 if (attempt_prealloc) 3718 dp_context_free_mem(soc, ctxt_type, history->entry[i]); 3719 else 3720 qdf_mem_free(history->entry[i]); 3721 } 3722 3723 return QDF_STATUS_E_NOMEM; 3724 } 3725 3726 static inline 3727 void dp_soc_frag_history_detach(struct dp_soc *soc, 3728 void *history_hdl, uint32_t max_slots, 3729 bool attempt_prealloc, 3730 enum dp_ctxt_type ctxt_type) 3731 { 3732 struct dp_frag_history_opaque_atomic *history = 3733 (struct dp_frag_history_opaque_atomic *)history_hdl; 3734 int i; 3735 3736 for (i = 0; i < max_slots; i++) { 3737 if (attempt_prealloc) 3738 dp_context_free_mem(soc, ctxt_type, history->entry[i]); 3739 else 3740 qdf_mem_free(history->entry[i]); 3741 } 3742 3743 history->allocated = 0; 3744 } 3745 3746 /** 3747 * dp_get_frag_hist_next_atomic_idx() - get the next entry index to record an 3748 * entry in a fragmented history with 3749 * index being atomic. 3750 * @curr_idx: address of the current index where the last entry was written 3751 * @next_idx: pointer to update the next index 3752 * @slot: pointer to update the history slot to be selected 3753 * @slot_shift: BITwise shift mask for slot (in index) 3754 * @max_entries_per_slot: Max number of entries in a slot of history 3755 * @max_entries: Total number of entries in the history (sum of all slots) 3756 * 3757 * This function assumes that the "max_entries_per_slot" and "max_entries" 3758 * are a power-of-2. 3759 * 3760 * Return: None 3761 */ 3762 static inline void 3763 dp_get_frag_hist_next_atomic_idx(qdf_atomic_t *curr_idx, uint32_t *next_idx, 3764 uint16_t *slot, uint32_t slot_shift, 3765 uint32_t max_entries_per_slot, 3766 uint32_t max_entries) 3767 { 3768 uint32_t idx; 3769 3770 idx = qdf_do_div_rem(qdf_atomic_inc_return(curr_idx), max_entries); 3771 3772 *slot = idx >> slot_shift; 3773 *next_idx = idx & (max_entries_per_slot - 1); 3774 } 3775 3776 #ifdef FEATURE_RUNTIME_PM 3777 /** 3778 * dp_runtime_get() - Get dp runtime refcount 3779 * @soc: Datapath soc handle 3780 * 3781 * Get dp runtime refcount by increment of an atomic variable, which can block 3782 * dp runtime resume to wait to flush pending tx by runtime suspend. 3783 * 3784 * Return: Current refcount 3785 */ 3786 static inline int32_t dp_runtime_get(struct dp_soc *soc) 3787 { 3788 return qdf_atomic_inc_return(&soc->dp_runtime_refcount); 3789 } 3790 3791 /** 3792 * dp_runtime_put() - Return dp runtime refcount 3793 * @soc: Datapath soc handle 3794 * 3795 * Return dp runtime refcount by decrement of an atomic variable, allow dp 3796 * runtime resume finish. 3797 * 3798 * Return: Current refcount 3799 */ 3800 static inline int32_t dp_runtime_put(struct dp_soc *soc) 3801 { 3802 return qdf_atomic_dec_return(&soc->dp_runtime_refcount); 3803 } 3804 3805 /** 3806 * dp_runtime_get_refcount() - Get dp runtime refcount 3807 * @soc: Datapath soc handle 3808 * 3809 * Get dp runtime refcount by returning an atomic variable 3810 * 3811 * Return: Current refcount 3812 */ 3813 static inline int32_t dp_runtime_get_refcount(struct dp_soc *soc) 3814 { 3815 return qdf_atomic_read(&soc->dp_runtime_refcount); 3816 } 3817 3818 /** 3819 * dp_runtime_init() - Init DP related runtime PM clients and runtime refcount 3820 * @soc: Datapath soc handle 3821 * 3822 * Return: QDF_STATUS 3823 */ 3824 static inline void dp_runtime_init(struct dp_soc *soc) 3825 { 3826 hif_rtpm_register(HIF_RTPM_ID_DP, NULL); 3827 hif_rtpm_register(HIF_RTPM_ID_DP_RING_STATS, NULL); 3828 qdf_atomic_init(&soc->dp_runtime_refcount); 3829 } 3830 3831 /** 3832 * dp_runtime_deinit() - Deinit DP related runtime PM clients 3833 * 3834 * Return: None 3835 */ 3836 static inline void dp_runtime_deinit(void) 3837 { 3838 hif_rtpm_deregister(HIF_RTPM_ID_DP); 3839 hif_rtpm_deregister(HIF_RTPM_ID_DP_RING_STATS); 3840 } 3841 3842 /** 3843 * dp_runtime_pm_mark_last_busy() - Mark last busy when rx path in use 3844 * @soc: Datapath soc handle 3845 * 3846 * Return: None 3847 */ 3848 static inline void dp_runtime_pm_mark_last_busy(struct dp_soc *soc) 3849 { 3850 soc->rx_last_busy = qdf_get_log_timestamp_usecs(); 3851 3852 hif_rtpm_mark_last_busy(HIF_RTPM_ID_DP); 3853 } 3854 #else 3855 static inline int32_t dp_runtime_get(struct dp_soc *soc) 3856 { 3857 return 0; 3858 } 3859 3860 static inline int32_t dp_runtime_put(struct dp_soc *soc) 3861 { 3862 return 0; 3863 } 3864 3865 static inline QDF_STATUS dp_runtime_init(struct dp_soc *soc) 3866 { 3867 return QDF_STATUS_SUCCESS; 3868 } 3869 3870 static inline void dp_runtime_deinit(void) 3871 { 3872 } 3873 3874 static inline void dp_runtime_pm_mark_last_busy(struct dp_soc *soc) 3875 { 3876 } 3877 #endif 3878 3879 static inline enum QDF_GLOBAL_MODE dp_soc_get_con_mode(struct dp_soc *soc) 3880 { 3881 if (soc->cdp_soc.ol_ops->get_con_mode) 3882 return soc->cdp_soc.ol_ops->get_con_mode(); 3883 3884 return QDF_GLOBAL_MAX_MODE; 3885 } 3886 3887 /* 3888 * dp_pdev_bkp_stats_detach() - detach resources for back pressure stats 3889 * processing 3890 * @pdev: Datapath PDEV handle 3891 * 3892 */ 3893 void dp_pdev_bkp_stats_detach(struct dp_pdev *pdev); 3894 3895 /* 3896 * dp_pdev_bkp_stats_attach() - attach resources for back pressure stats 3897 * processing 3898 * @pdev: Datapath PDEV handle 3899 * 3900 * Return: QDF_STATUS_SUCCESS: Success 3901 * QDF_STATUS_E_NOMEM: Error 3902 */ 3903 3904 QDF_STATUS dp_pdev_bkp_stats_attach(struct dp_pdev *pdev); 3905 3906 /** 3907 * dp_peer_flush_frags() - Flush all fragments for a particular 3908 * peer 3909 * @soc_hdl - data path soc handle 3910 * @vdev_id - vdev id 3911 * @peer_addr - peer mac address 3912 * 3913 * Return: None 3914 */ 3915 void dp_peer_flush_frags(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 3916 uint8_t *peer_mac); 3917 3918 /** 3919 * dp_soc_reset_mon_intr_mask() - reset mon intr mask 3920 * @soc: pointer to dp_soc handle 3921 * 3922 * Return: 3923 */ 3924 void dp_soc_reset_mon_intr_mask(struct dp_soc *soc); 3925 3926 /** 3927 * dp_txrx_get_soc_stats() - will return cdp_soc_stats 3928 * @soc_hdl: soc handle 3929 * @soc_stats: buffer to hold the values 3930 * 3931 * Return: QDF_STATUS_SUCCESS: Success 3932 * QDF_STATUS_E_FAILURE: Error 3933 */ 3934 QDF_STATUS dp_txrx_get_soc_stats(struct cdp_soc_t *soc_hdl, 3935 struct cdp_soc_stats *soc_stats); 3936 3937 /** 3938 * dp_txrx_get_peer_delay_stats() - to get peer delay stats per TIDs 3939 * @soc: soc handle 3940 * @vdev_id: id of vdev handle 3941 * @peer_mac: mac of DP_PEER handle 3942 * @delay_stats: pointer to delay stats array 3943 * 3944 * Return: QDF_STATUS_SUCCESS: Success 3945 * QDF_STATUS_E_FAILURE: Error 3946 */ 3947 QDF_STATUS 3948 dp_txrx_get_peer_delay_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 3949 uint8_t *peer_mac, 3950 struct cdp_delay_tid_stats *delay_stats); 3951 3952 /** 3953 * dp_txrx_get_peer_jitter_stats() - to get peer jitter stats per TIDs 3954 * @soc: soc handle 3955 * @pdev_id: id of pdev handle 3956 * @vdev_id: id of vdev handle 3957 * @peer_mac: mac of DP_PEER handle 3958 * @tid_stats: pointer to jitter stats array 3959 * 3960 * Return: QDF_STATUS_SUCCESS: Success 3961 * QDF_STATUS_E_FAILURE: Error 3962 */ 3963 QDF_STATUS 3964 dp_txrx_get_peer_jitter_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 3965 uint8_t vdev_id, uint8_t *peer_mac, 3966 struct cdp_peer_tid_stats *tid_stats); 3967 3968 /* dp_peer_get_tx_capture_stats - to get peer Tx Capture stats 3969 * @soc_hdl: soc handle 3970 * @vdev_id: id of vdev handle 3971 * @peer_mac: mac of DP_PEER handle 3972 * @stats: pointer to peer tx capture stats 3973 * 3974 * Return: QDF_STATUS_SUCCESS: Success 3975 * QDF_STATUS_E_FAILURE: Error 3976 */ 3977 QDF_STATUS 3978 dp_peer_get_tx_capture_stats(struct cdp_soc_t *soc_hdl, 3979 uint8_t vdev_id, uint8_t *peer_mac, 3980 struct cdp_peer_tx_capture_stats *stats); 3981 3982 /* dp_pdev_get_tx_capture_stats - to get pdev Tx Capture stats 3983 * @soc_hdl: soc handle 3984 * @pdev_id: id of pdev handle 3985 * @stats: pointer to pdev tx capture stats 3986 * 3987 * Return: QDF_STATUS_SUCCESS: Success 3988 * QDF_STATUS_E_FAILURE: Error 3989 */ 3990 QDF_STATUS 3991 dp_pdev_get_tx_capture_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 3992 struct cdp_pdev_tx_capture_stats *stats); 3993 3994 #ifdef HW_TX_DELAY_STATS_ENABLE 3995 /* 3996 * dp_is_vdev_tx_delay_stats_enabled(): Check if tx delay stats 3997 * is enabled for vdev 3998 * @vdev: dp vdev 3999 * 4000 * Return: true if tx delay stats is enabled for vdev else false 4001 */ 4002 static inline uint8_t dp_is_vdev_tx_delay_stats_enabled(struct dp_vdev *vdev) 4003 { 4004 return vdev->hw_tx_delay_stats_enabled; 4005 } 4006 4007 /* 4008 * dp_pdev_print_tx_delay_stats(): Print vdev tx delay stats 4009 * for pdev 4010 * @soc: dp soc 4011 * 4012 * Return: None 4013 */ 4014 void dp_pdev_print_tx_delay_stats(struct dp_soc *soc); 4015 4016 /** 4017 * dp_pdev_clear_tx_delay_stats() - clear tx delay stats 4018 * @soc: soc handle 4019 * 4020 * Return: None 4021 */ 4022 void dp_pdev_clear_tx_delay_stats(struct dp_soc *soc); 4023 #else 4024 static inline uint8_t dp_is_vdev_tx_delay_stats_enabled(struct dp_vdev *vdev) 4025 { 4026 return 0; 4027 } 4028 4029 static inline void dp_pdev_print_tx_delay_stats(struct dp_soc *soc) 4030 { 4031 } 4032 4033 static inline void dp_pdev_clear_tx_delay_stats(struct dp_soc *soc) 4034 { 4035 } 4036 #endif 4037 4038 static inline void 4039 dp_get_rx_hash_key_bytes(struct cdp_lro_hash_config *lro_hash) 4040 { 4041 qdf_get_random_bytes(lro_hash->toeplitz_hash_ipv4, 4042 (sizeof(lro_hash->toeplitz_hash_ipv4[0]) * 4043 LRO_IPV4_SEED_ARR_SZ)); 4044 qdf_get_random_bytes(lro_hash->toeplitz_hash_ipv6, 4045 (sizeof(lro_hash->toeplitz_hash_ipv6[0]) * 4046 LRO_IPV6_SEED_ARR_SZ)); 4047 } 4048 4049 #ifdef WLAN_TELEMETRY_STATS_SUPPORT 4050 /* 4051 * dp_get_pdev_telemetry_stats- API to get pdev telemetry stats 4052 * @soc_hdl: soc handle 4053 * @pdev_id: id of pdev handle 4054 * @stats: pointer to pdev telemetry stats 4055 * 4056 * Return: QDF_STATUS_SUCCESS: Success 4057 * QDF_STATUS_E_FAILURE: Error 4058 */ 4059 QDF_STATUS 4060 dp_get_pdev_telemetry_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 4061 struct cdp_pdev_telemetry_stats *stats); 4062 4063 /* 4064 * dp_get_peer_telemetry_stats- API to get peer telemetry stats 4065 * @soc_hdl: soc handle 4066 * @addr: peer mac 4067 * @stats: pointer to peer telemetry stats 4068 * 4069 * Return: QDF_STATUS_SUCCESS: Success 4070 * QDF_STATUS_E_FAILURE: Error 4071 */ 4072 QDF_STATUS 4073 dp_get_peer_telemetry_stats(struct cdp_soc_t *soc_hdl, uint8_t *addr, 4074 struct cdp_peer_telemetry_stats *stats); 4075 #endif /* WLAN_TELEMETRY_STATS_SUPPORT */ 4076 4077 #ifdef CONNECTIVITY_PKTLOG 4078 /* 4079 * dp_tx_send_pktlog() - send tx packet log 4080 * @soc: soc handle 4081 * @pdev: pdev handle 4082 * @tx_desc: TX software descriptor 4083 * @nbuf: nbuf 4084 * @status: status of tx packet 4085 * 4086 * This function is used to send tx packet for logging 4087 * 4088 * Return: None 4089 * 4090 */ 4091 static inline 4092 void dp_tx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 4093 struct dp_tx_desc_s *tx_desc, 4094 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) 4095 { 4096 ol_txrx_pktdump_cb packetdump_cb = pdev->dp_tx_packetdump_cb; 4097 4098 if (qdf_unlikely(packetdump_cb) && 4099 dp_tx_frm_std == tx_desc->frm_type) { 4100 packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id, 4101 QDF_NBUF_CB_TX_VDEV_CTX(nbuf), 4102 nbuf, status, QDF_TX_DATA_PKT); 4103 } 4104 } 4105 4106 /* 4107 * dp_rx_send_pktlog() - send rx packet log 4108 * @soc: soc handle 4109 * @pdev: pdev handle 4110 * @nbuf: nbuf 4111 * @status: status of rx packet 4112 * 4113 * This function is used to send rx packet for logging 4114 * 4115 * Return: None 4116 * 4117 */ 4118 static inline 4119 void dp_rx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 4120 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) 4121 { 4122 ol_txrx_pktdump_cb packetdump_cb = pdev->dp_rx_packetdump_cb; 4123 4124 if (qdf_unlikely(packetdump_cb)) { 4125 packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id, 4126 QDF_NBUF_CB_RX_VDEV_ID(nbuf), 4127 nbuf, status, QDF_RX_DATA_PKT); 4128 } 4129 } 4130 4131 /* 4132 * dp_rx_err_send_pktlog() - send rx error packet log 4133 * @soc: soc handle 4134 * @pdev: pdev handle 4135 * @mpdu_desc_info: MPDU descriptor info 4136 * @nbuf: nbuf 4137 * @status: status of rx packet 4138 * @set_pktlen: weither to set packet length 4139 * 4140 * This API should only be called when we have not removed 4141 * Rx TLV from head, and head is pointing to rx_tlv 4142 * 4143 * This function is used to send rx packet from erro path 4144 * for logging for which rx packet tlv is not removed. 4145 * 4146 * Return: None 4147 * 4148 */ 4149 static inline 4150 void dp_rx_err_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 4151 struct hal_rx_mpdu_desc_info *mpdu_desc_info, 4152 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status, 4153 bool set_pktlen) 4154 { 4155 ol_txrx_pktdump_cb packetdump_cb = pdev->dp_rx_packetdump_cb; 4156 qdf_size_t skip_size; 4157 uint16_t msdu_len, nbuf_len; 4158 uint8_t *rx_tlv_hdr; 4159 struct hal_rx_msdu_metadata msdu_metadata; 4160 4161 if (qdf_unlikely(packetdump_cb)) { 4162 rx_tlv_hdr = qdf_nbuf_data(nbuf); 4163 nbuf_len = hal_rx_msdu_start_msdu_len_get(soc->hal_soc, 4164 rx_tlv_hdr); 4165 hal_rx_msdu_metadata_get(soc->hal_soc, rx_tlv_hdr, 4166 &msdu_metadata); 4167 4168 if (mpdu_desc_info->bar_frame || 4169 (mpdu_desc_info->mpdu_flags & HAL_MPDU_F_FRAGMENT)) 4170 skip_size = soc->rx_pkt_tlv_size; 4171 else 4172 skip_size = soc->rx_pkt_tlv_size + 4173 msdu_metadata.l3_hdr_pad; 4174 4175 if (set_pktlen) { 4176 msdu_len = nbuf_len + skip_size; 4177 qdf_nbuf_set_pktlen(nbuf, qdf_min(msdu_len, 4178 (uint16_t)RX_DATA_BUFFER_SIZE)); 4179 } 4180 4181 qdf_nbuf_pull_head(nbuf, skip_size); 4182 packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id, 4183 QDF_NBUF_CB_RX_VDEV_ID(nbuf), 4184 nbuf, status, QDF_RX_DATA_PKT); 4185 qdf_nbuf_push_head(nbuf, skip_size); 4186 } 4187 } 4188 4189 #else 4190 static inline 4191 void dp_tx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 4192 struct dp_tx_desc_s *tx_desc, 4193 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) 4194 { 4195 } 4196 4197 static inline 4198 void dp_rx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 4199 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) 4200 { 4201 } 4202 4203 static inline 4204 void dp_rx_err_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 4205 struct hal_rx_mpdu_desc_info *mpdu_desc_info, 4206 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status, 4207 bool set_pktlen) 4208 { 4209 } 4210 #endif 4211 4212 /* 4213 * dp_pdev_update_fast_rx_flag() - Update Fast rx flag for a PDEV 4214 * @soc : Data path soc handle 4215 * @pdev : PDEV handle 4216 * 4217 * return: None 4218 */ 4219 void dp_pdev_update_fast_rx_flag(struct dp_soc *soc, struct dp_pdev *pdev); 4220 #endif /* #ifndef _DP_INTERNAL_H_ */ 4221