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