1 /* 2 * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2024 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 #include "dp_rx_tid.h" 26 27 #define RX_BUFFER_SIZE_PKTLOG_LITE 1024 28 29 #define DP_PEER_WDS_COUNT_INVALID UINT_MAX 30 31 #define DP_BLOCKMEM_SIZE 4096 32 #define WBM2_SW_PPE_REL_RING_ID 6 33 #define WBM2_SW_PPE_REL_MAP_ID 11 34 #define DP_TX_PPEDS_POOL_ID 0xF 35 36 /* Alignment for consistent memory for DP rings*/ 37 #define DP_RING_BASE_ALIGN 32 38 39 #define DP_RSSI_INVAL 0x80 40 #define DP_RSSI_AVG_WEIGHT 2 41 /* 42 * Formula to derive avg_rssi is taken from wifi2.o firmware 43 */ 44 #define DP_GET_AVG_RSSI(avg_rssi, last_rssi) \ 45 (((avg_rssi) - (((uint8_t)(avg_rssi)) >> DP_RSSI_AVG_WEIGHT)) \ 46 + ((((uint8_t)(last_rssi)) >> DP_RSSI_AVG_WEIGHT))) 47 48 /* Macro For NYSM value received in VHT TLV */ 49 #define VHT_SGI_NYSM 3 50 51 #define INVALID_WBM_RING_NUM 0xF 52 53 #ifdef FEATURE_DIRECT_LINK 54 #define DIRECT_LINK_REFILL_RING_ENTRIES 64 55 #ifdef IPA_OFFLOAD 56 #ifdef IPA_WDI3_VLAN_SUPPORT 57 #define DIRECT_LINK_REFILL_RING_IDX 4 58 #else 59 #define DIRECT_LINK_REFILL_RING_IDX 3 60 #endif 61 #else 62 #define DIRECT_LINK_REFILL_RING_IDX 2 63 #endif 64 #endif 65 66 #define DP_MAX_VLAN_IDS 4096 67 #define DP_VLAN_UNTAGGED 0 68 #define DP_VLAN_TAGGED_MULTICAST 1 69 #define DP_VLAN_TAGGED_UNICAST 2 70 71 /** 72 * struct htt_dbgfs_cfg - structure to maintain required htt data 73 * @msg_word: htt msg sent to upper layer 74 * @m: qdf debugfs file pointer 75 */ 76 struct htt_dbgfs_cfg { 77 uint32_t *msg_word; 78 qdf_debugfs_file_t m; 79 }; 80 81 /* Cookie MSB bits assigned for different use case. 82 * Note: User can't use last 3 bits, as it is reserved for pdev_id. 83 * If in future number of pdev are more than 3. 84 */ 85 /* Reserve for default case */ 86 #define DBG_STATS_COOKIE_DEFAULT 0x0 87 88 /* Reserve for DP Stats: 3rd bit */ 89 #define DBG_STATS_COOKIE_DP_STATS BIT(3) 90 91 /* Reserve for HTT Stats debugfs support: 4th bit */ 92 #define DBG_STATS_COOKIE_HTT_DBGFS BIT(4) 93 94 /*Reserve for HTT Stats debugfs support: 5th bit */ 95 #define DBG_SYSFS_STATS_COOKIE BIT(5) 96 97 /* Reserve for HTT Stats OBSS PD support: 6th bit */ 98 #define DBG_STATS_COOKIE_HTT_OBSS BIT(6) 99 100 /* 101 * Bitmap of HTT PPDU TLV types for Default mode 102 */ 103 #define HTT_PPDU_DEFAULT_TLV_BITMAP \ 104 (1 << HTT_PPDU_STATS_COMMON_TLV) | \ 105 (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ 106 (1 << HTT_PPDU_STATS_USR_RATE_TLV) | \ 107 (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \ 108 (1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \ 109 (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) 110 111 /* PPDU STATS CFG */ 112 #define DP_PPDU_STATS_CFG_ALL 0xFFFF 113 114 /* PPDU stats mask sent to FW to enable enhanced stats */ 115 #define DP_PPDU_STATS_CFG_ENH_STATS \ 116 (HTT_PPDU_DEFAULT_TLV_BITMAP) | \ 117 (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \ 118 (1 << HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV) | \ 119 (1 << HTT_PPDU_STATS_USERS_INFO_TLV) 120 121 /* PPDU stats mask sent to FW to support debug sniffer feature */ 122 #define DP_PPDU_STATS_CFG_SNIFFER \ 123 (HTT_PPDU_DEFAULT_TLV_BITMAP) | \ 124 (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV) | \ 125 (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV) | \ 126 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV) | \ 127 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \ 128 (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \ 129 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \ 130 (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \ 131 (1 << HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV) | \ 132 (1 << HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) | \ 133 (1 << HTT_PPDU_STATS_USERS_INFO_TLV) 134 135 /* PPDU stats mask sent to FW to support BPR feature*/ 136 #define DP_PPDU_STATS_CFG_BPR \ 137 (1 << HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) | \ 138 (1 << HTT_PPDU_STATS_USERS_INFO_TLV) 139 140 /* PPDU stats mask sent to FW to support BPR and enhanced stats feature */ 141 #define DP_PPDU_STATS_CFG_BPR_ENH (DP_PPDU_STATS_CFG_BPR | \ 142 DP_PPDU_STATS_CFG_ENH_STATS) 143 /* PPDU stats mask sent to FW to support BPR and pcktlog stats feature */ 144 #define DP_PPDU_STATS_CFG_BPR_PKTLOG (DP_PPDU_STATS_CFG_BPR | \ 145 DP_PPDU_TXLITE_STATS_BITMASK_CFG) 146 147 /* 148 * Bitmap of HTT PPDU delayed ba TLV types for Default mode 149 */ 150 #define HTT_PPDU_DELAYED_BA_TLV_BITMAP \ 151 (1 << HTT_PPDU_STATS_COMMON_TLV) | \ 152 (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ 153 (1 << HTT_PPDU_STATS_USR_RATE_TLV) 154 155 /* 156 * Bitmap of HTT PPDU TLV types for Delayed BA 157 */ 158 #define HTT_PPDU_STATUS_TLV_BITMAP \ 159 (1 << HTT_PPDU_STATS_COMMON_TLV) | \ 160 (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) 161 162 /* 163 * Bitmap of HTT PPDU TLV types for Sniffer mode bitmap 64 164 */ 165 #define HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_64 \ 166 ((1 << HTT_PPDU_STATS_COMMON_TLV) | \ 167 (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ 168 (1 << HTT_PPDU_STATS_USR_RATE_TLV) | \ 169 (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \ 170 (1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \ 171 (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) | \ 172 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV) | \ 173 (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV)) 174 175 /* 176 * Bitmap of HTT PPDU TLV types for Sniffer mode bitmap 256 177 */ 178 #define HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_256 \ 179 ((1 << HTT_PPDU_STATS_COMMON_TLV) | \ 180 (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ 181 (1 << HTT_PPDU_STATS_USR_RATE_TLV) | \ 182 (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \ 183 (1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \ 184 (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) | \ 185 (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \ 186 (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV)) 187 188 static const enum cdp_packet_type hal_2_dp_pkt_type_map[HAL_DOT11_MAX] = { 189 [HAL_DOT11A] = DOT11_A, 190 [HAL_DOT11B] = DOT11_B, 191 [HAL_DOT11N_MM] = DOT11_N, 192 [HAL_DOT11AC] = DOT11_AC, 193 [HAL_DOT11AX] = DOT11_AX, 194 [HAL_DOT11BA] = DOT11_MAX, 195 #ifdef WLAN_FEATURE_11BE 196 [HAL_DOT11BE] = DOT11_BE, 197 #else 198 [HAL_DOT11BE] = DOT11_MAX, 199 #endif 200 [HAL_DOT11AZ] = DOT11_MAX, 201 [HAL_DOT11N_GF] = DOT11_MAX, 202 }; 203 204 #ifdef GLOBAL_ASSERT_AVOIDANCE 205 #define dp_assert_always_internal_stat(_expr, _handle, _field) \ 206 (qdf_unlikely(!(_expr)) ? ((_handle)->stats._field++, true) : false) 207 208 #define dp_assert_always_internal_ds_stat(_expr, _handle, _field) \ 209 ((_handle)->ppeds_stats._field++) 210 211 static inline bool dp_assert_always_internal(bool expr) 212 { 213 return !expr; 214 } 215 #else 216 static inline bool __dp_assert_always_internal(bool expr) 217 { 218 qdf_assert_always(expr); 219 220 return false; 221 } 222 223 #define dp_assert_always_internal(_expr) __dp_assert_always_internal(_expr) 224 225 #define dp_assert_always_internal_stat(_expr, _handle, _field) \ 226 dp_assert_always_internal(_expr) 227 228 #define dp_assert_always_internal_ds_stat(_expr, _handle, _field) \ 229 dp_assert_always_internal(_expr) 230 #endif 231 232 #ifdef WLAN_FEATURE_11BE 233 /** 234 * dp_get_mcs_array_index_by_pkt_type_mcs() - get the destination mcs index 235 * in array 236 * @pkt_type: host SW pkt type 237 * @mcs: mcs value for TX/RX rate 238 * 239 * Return: succeeded - valid index in mcs array 240 * fail - same value as MCS_MAX 241 */ 242 static inline uint8_t 243 dp_get_mcs_array_index_by_pkt_type_mcs(uint32_t pkt_type, uint32_t mcs) 244 { 245 uint8_t dst_mcs_idx = MCS_INVALID_ARRAY_INDEX; 246 247 switch (pkt_type) { 248 case DOT11_A: 249 dst_mcs_idx = 250 mcs >= MAX_MCS_11A ? (MAX_MCS - 1) : mcs; 251 break; 252 case DOT11_B: 253 dst_mcs_idx = 254 mcs >= MAX_MCS_11B ? (MAX_MCS - 1) : mcs; 255 break; 256 case DOT11_N: 257 dst_mcs_idx = 258 mcs >= MAX_MCS_11N ? (MAX_MCS - 1) : mcs; 259 break; 260 case DOT11_AC: 261 dst_mcs_idx = 262 mcs >= MAX_MCS_11AC ? (MAX_MCS - 1) : mcs; 263 break; 264 case DOT11_AX: 265 dst_mcs_idx = 266 mcs >= MAX_MCS_11AX ? (MAX_MCS - 1) : mcs; 267 break; 268 case DOT11_BE: 269 dst_mcs_idx = 270 mcs >= MAX_MCS_11BE ? (MAX_MCS - 1) : mcs; 271 break; 272 default: 273 break; 274 } 275 276 return dst_mcs_idx; 277 } 278 #else 279 static inline uint8_t 280 dp_get_mcs_array_index_by_pkt_type_mcs(uint32_t pkt_type, uint32_t mcs) 281 { 282 uint8_t dst_mcs_idx = MCS_INVALID_ARRAY_INDEX; 283 284 switch (pkt_type) { 285 case DOT11_A: 286 dst_mcs_idx = 287 mcs >= MAX_MCS_11A ? (MAX_MCS - 1) : mcs; 288 break; 289 case DOT11_B: 290 dst_mcs_idx = 291 mcs >= MAX_MCS_11B ? (MAX_MCS - 1) : mcs; 292 break; 293 case DOT11_N: 294 dst_mcs_idx = 295 mcs >= MAX_MCS_11N ? (MAX_MCS - 1) : mcs; 296 break; 297 case DOT11_AC: 298 dst_mcs_idx = 299 mcs >= MAX_MCS_11AC ? (MAX_MCS - 1) : mcs; 300 break; 301 case DOT11_AX: 302 dst_mcs_idx = 303 mcs >= MAX_MCS_11AX ? (MAX_MCS - 1) : mcs; 304 break; 305 default: 306 break; 307 } 308 309 return dst_mcs_idx; 310 } 311 #endif 312 313 #ifdef WIFI_MONITOR_SUPPORT 314 QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc); 315 QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc); 316 #else 317 static inline 318 QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc) 319 { 320 return QDF_STATUS_SUCCESS; 321 } 322 323 static inline 324 QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc) 325 { 326 return QDF_STATUS_SUCCESS; 327 } 328 #endif 329 330 /** 331 * dp_rx_err_match_dhost() - function to check whether dest-mac is correct 332 * @eh: Ethernet header of incoming packet 333 * @vdev: dp_vdev object of the VAP on which this data packet is received 334 * 335 * Return: 1 if the destination mac is correct, 336 * 0 if this frame is not correctly destined to this VAP/MLD 337 */ 338 int dp_rx_err_match_dhost(qdf_ether_header_t *eh, struct dp_vdev *vdev); 339 340 #ifdef MONITOR_MODULARIZED_ENABLE 341 static inline bool dp_monitor_modularized_enable(void) 342 { 343 return TRUE; 344 } 345 346 static inline QDF_STATUS 347 dp_mon_soc_attach_wrapper(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } 348 349 static inline QDF_STATUS 350 dp_mon_soc_detach_wrapper(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } 351 #else 352 static inline bool dp_monitor_modularized_enable(void) 353 { 354 return FALSE; 355 } 356 357 static inline QDF_STATUS dp_mon_soc_attach_wrapper(struct dp_soc *soc) 358 { 359 return dp_mon_soc_attach(soc); 360 } 361 362 static inline QDF_STATUS dp_mon_soc_detach_wrapper(struct dp_soc *soc) 363 { 364 return dp_mon_soc_detach(soc); 365 } 366 #endif 367 368 #ifndef WIFI_MONITOR_SUPPORT 369 #define MON_BUF_MIN_ENTRIES 64 370 371 static inline QDF_STATUS dp_monitor_pdev_attach(struct dp_pdev *pdev) 372 { 373 return QDF_STATUS_SUCCESS; 374 } 375 376 static inline QDF_STATUS dp_monitor_pdev_detach(struct dp_pdev *pdev) 377 { 378 return QDF_STATUS_SUCCESS; 379 } 380 381 static inline QDF_STATUS dp_monitor_vdev_attach(struct dp_vdev *vdev) 382 { 383 return QDF_STATUS_E_FAILURE; 384 } 385 386 static inline QDF_STATUS dp_monitor_vdev_detach(struct dp_vdev *vdev) 387 { 388 return QDF_STATUS_E_FAILURE; 389 } 390 391 static inline QDF_STATUS dp_monitor_peer_attach(struct dp_soc *soc, 392 struct dp_peer *peer) 393 { 394 return QDF_STATUS_SUCCESS; 395 } 396 397 static inline QDF_STATUS dp_monitor_peer_detach(struct dp_soc *soc, 398 struct dp_peer *peer) 399 { 400 return QDF_STATUS_E_FAILURE; 401 } 402 403 static inline struct cdp_peer_rate_stats_ctx* 404 dp_monitor_peer_get_peerstats_ctx(struct dp_soc *soc, struct dp_peer *peer) 405 { 406 return NULL; 407 } 408 409 static inline 410 void dp_monitor_peer_reset_stats(struct dp_soc *soc, struct dp_peer *peer) 411 { 412 } 413 414 static inline 415 void dp_monitor_peer_get_stats(struct dp_soc *soc, struct dp_peer *peer, 416 void *arg, enum cdp_stat_update_type type) 417 { 418 } 419 420 static inline 421 void dp_monitor_invalid_peer_update_pdev_stats(struct dp_soc *soc, 422 struct dp_pdev *pdev) 423 { 424 } 425 426 static inline 427 QDF_STATUS dp_monitor_peer_get_stats_param(struct dp_soc *soc, 428 struct dp_peer *peer, 429 enum cdp_peer_stats_type type, 430 cdp_peer_stats_param_t *buf) 431 { 432 return QDF_STATUS_E_FAILURE; 433 } 434 435 static inline QDF_STATUS dp_monitor_pdev_init(struct dp_pdev *pdev) 436 { 437 return QDF_STATUS_SUCCESS; 438 } 439 440 static inline QDF_STATUS dp_monitor_pdev_deinit(struct dp_pdev *pdev) 441 { 442 return QDF_STATUS_SUCCESS; 443 } 444 445 static inline QDF_STATUS dp_monitor_soc_cfg_init(struct dp_soc *soc) 446 { 447 return QDF_STATUS_SUCCESS; 448 } 449 450 static inline QDF_STATUS dp_monitor_config_debug_sniffer(struct dp_pdev *pdev, 451 int val) 452 { 453 return QDF_STATUS_E_FAILURE; 454 } 455 456 static inline void dp_monitor_flush_rings(struct dp_soc *soc) 457 { 458 } 459 460 static inline QDF_STATUS dp_monitor_htt_srng_setup(struct dp_soc *soc, 461 struct dp_pdev *pdev, 462 int mac_id, 463 int mac_for_pdev) 464 { 465 return QDF_STATUS_SUCCESS; 466 } 467 468 static inline void dp_monitor_service_mon_rings(struct dp_soc *soc, 469 uint32_t quota) 470 { 471 } 472 473 static inline 474 uint32_t dp_monitor_process(struct dp_soc *soc, struct dp_intr *int_ctx, 475 uint32_t mac_id, uint32_t quota) 476 { 477 return 0; 478 } 479 480 static inline 481 uint32_t dp_monitor_drop_packets_for_mac(struct dp_pdev *pdev, 482 uint32_t mac_id, uint32_t quota) 483 { 484 return 0; 485 } 486 487 static inline void dp_monitor_peer_tx_init(struct dp_pdev *pdev, 488 struct dp_peer *peer) 489 { 490 } 491 492 static inline void dp_monitor_peer_tx_cleanup(struct dp_vdev *vdev, 493 struct dp_peer *peer) 494 { 495 } 496 497 static inline 498 void dp_monitor_peer_tid_peer_id_update(struct dp_soc *soc, 499 struct dp_peer *peer, 500 uint16_t peer_id) 501 { 502 } 503 504 static inline void dp_monitor_tx_ppdu_stats_attach(struct dp_pdev *pdev) 505 { 506 } 507 508 static inline void dp_monitor_tx_ppdu_stats_detach(struct dp_pdev *pdev) 509 { 510 } 511 512 static inline 513 QDF_STATUS dp_monitor_tx_capture_debugfs_init(struct dp_pdev *pdev) 514 { 515 return QDF_STATUS_SUCCESS; 516 } 517 518 static inline void dp_monitor_peer_tx_capture_filter_check(struct dp_pdev *pdev, 519 struct dp_peer *peer) 520 { 521 } 522 523 static inline 524 QDF_STATUS dp_monitor_tx_add_to_comp_queue(struct dp_soc *soc, 525 struct dp_tx_desc_s *desc, 526 struct hal_tx_completion_status *ts, 527 uint16_t peer_id) 528 { 529 return QDF_STATUS_E_FAILURE; 530 } 531 532 static inline 533 QDF_STATUS monitor_update_msdu_to_list(struct dp_soc *soc, 534 struct dp_pdev *pdev, 535 struct dp_peer *peer, 536 struct hal_tx_completion_status *ts, 537 qdf_nbuf_t netbuf) 538 { 539 return QDF_STATUS_E_FAILURE; 540 } 541 542 static inline bool dp_monitor_ppdu_stats_ind_handler(struct htt_soc *soc, 543 uint32_t *msg_word, 544 qdf_nbuf_t htt_t2h_msg) 545 { 546 return true; 547 } 548 549 static inline QDF_STATUS dp_monitor_htt_ppdu_stats_attach(struct dp_pdev *pdev) 550 { 551 return QDF_STATUS_SUCCESS; 552 } 553 554 static inline void dp_monitor_htt_ppdu_stats_detach(struct dp_pdev *pdev) 555 { 556 } 557 558 static inline void dp_monitor_print_pdev_rx_mon_stats(struct dp_pdev *pdev) 559 { 560 } 561 562 static inline QDF_STATUS dp_monitor_config_enh_tx_capture(struct dp_pdev *pdev, 563 uint32_t val) 564 { 565 return QDF_STATUS_E_INVAL; 566 } 567 568 static inline QDF_STATUS dp_monitor_tx_peer_filter(struct dp_pdev *pdev, 569 struct dp_peer *peer, 570 uint8_t is_tx_pkt_cap_enable, 571 uint8_t *peer_mac) 572 { 573 return QDF_STATUS_E_INVAL; 574 } 575 576 static inline QDF_STATUS dp_monitor_config_enh_rx_capture(struct dp_pdev *pdev, 577 uint32_t val) 578 { 579 return QDF_STATUS_E_INVAL; 580 } 581 582 static inline 583 QDF_STATUS dp_monitor_set_bpr_enable(struct dp_pdev *pdev, uint32_t val) 584 { 585 return QDF_STATUS_E_FAILURE; 586 } 587 588 static inline 589 int dp_monitor_set_filter_neigh_peers(struct dp_pdev *pdev, bool val) 590 { 591 return 0; 592 } 593 594 static inline 595 void dp_monitor_set_atf_stats_enable(struct dp_pdev *pdev, bool value) 596 { 597 } 598 599 static inline 600 void dp_monitor_set_bsscolor(struct dp_pdev *pdev, uint8_t bsscolor) 601 { 602 } 603 604 static inline 605 bool dp_monitor_pdev_get_filter_mcast_data(struct cdp_pdev *pdev_handle) 606 { 607 return false; 608 } 609 610 static inline 611 bool dp_monitor_pdev_get_filter_non_data(struct cdp_pdev *pdev_handle) 612 { 613 return false; 614 } 615 616 static inline 617 bool dp_monitor_pdev_get_filter_ucast_data(struct cdp_pdev *pdev_handle) 618 { 619 return false; 620 } 621 622 static inline 623 int dp_monitor_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event, 624 bool enable) 625 { 626 return 0; 627 } 628 629 static inline void dp_monitor_pktlogmod_exit(struct dp_pdev *pdev) 630 { 631 } 632 633 static inline 634 QDF_STATUS dp_monitor_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev) 635 { 636 return QDF_STATUS_E_FAILURE; 637 } 638 639 static inline 640 void dp_monitor_neighbour_peers_detach(struct dp_pdev *pdev) 641 { 642 } 643 644 static inline QDF_STATUS dp_monitor_filter_neighbour_peer(struct dp_pdev *pdev, 645 uint8_t *rx_pkt_hdr) 646 { 647 return QDF_STATUS_E_FAILURE; 648 } 649 650 static inline void dp_monitor_print_pdev_tx_capture_stats(struct dp_pdev *pdev) 651 { 652 } 653 654 static inline 655 void dp_monitor_reap_timer_init(struct dp_soc *soc) 656 { 657 } 658 659 static inline 660 void dp_monitor_reap_timer_deinit(struct dp_soc *soc) 661 { 662 } 663 664 static inline 665 bool dp_monitor_reap_timer_start(struct dp_soc *soc, 666 enum cdp_mon_reap_source source) 667 { 668 return false; 669 } 670 671 static inline 672 bool dp_monitor_reap_timer_stop(struct dp_soc *soc, 673 enum cdp_mon_reap_source source) 674 { 675 return false; 676 } 677 678 static inline void 679 dp_monitor_reap_timer_suspend(struct dp_soc *soc) 680 { 681 } 682 683 static inline 684 void dp_monitor_vdev_timer_init(struct dp_soc *soc) 685 { 686 } 687 688 static inline 689 void dp_monitor_vdev_timer_deinit(struct dp_soc *soc) 690 { 691 } 692 693 static inline 694 void dp_monitor_vdev_timer_start(struct dp_soc *soc) 695 { 696 } 697 698 static inline 699 bool dp_monitor_vdev_timer_stop(struct dp_soc *soc) 700 { 701 return false; 702 } 703 704 static inline struct qdf_mem_multi_page_t* 705 dp_monitor_get_link_desc_pages(struct dp_soc *soc, uint32_t mac_id) 706 { 707 return NULL; 708 } 709 710 static inline struct dp_srng* 711 dp_monitor_get_link_desc_ring(struct dp_soc *soc, uint32_t mac_id) 712 { 713 return NULL; 714 } 715 716 static inline uint32_t 717 dp_monitor_get_num_link_desc_ring_entries(struct dp_soc *soc) 718 { 719 return 0; 720 } 721 722 static inline uint32_t * 723 dp_monitor_get_total_link_descs(struct dp_soc *soc, uint32_t mac_id) 724 { 725 return NULL; 726 } 727 728 static inline QDF_STATUS dp_monitor_drop_inv_peer_pkts(struct dp_vdev *vdev) 729 { 730 return QDF_STATUS_E_FAILURE; 731 } 732 733 static inline bool dp_is_enable_reap_timer_non_pkt(struct dp_pdev *pdev) 734 { 735 return false; 736 } 737 738 static inline void dp_monitor_vdev_register_osif(struct dp_vdev *vdev, 739 struct ol_txrx_ops *txrx_ops) 740 { 741 } 742 743 static inline bool dp_monitor_is_vdev_timer_running(struct dp_soc *soc) 744 { 745 return false; 746 } 747 748 static inline 749 void dp_monitor_pdev_set_mon_vdev(struct dp_vdev *vdev) 750 { 751 } 752 753 static inline void dp_monitor_vdev_delete(struct dp_soc *soc, 754 struct dp_vdev *vdev) 755 { 756 } 757 758 static inline void dp_peer_ppdu_delayed_ba_init(struct dp_peer *peer) 759 { 760 } 761 762 static inline void dp_monitor_neighbour_peer_add_ast(struct dp_pdev *pdev, 763 struct dp_peer *ta_peer, 764 uint8_t *mac_addr, 765 qdf_nbuf_t nbuf, 766 uint32_t flags) 767 { 768 } 769 770 static inline void 771 dp_monitor_set_chan_band(struct dp_pdev *pdev, enum reg_wifi_band chan_band) 772 { 773 } 774 775 static inline void 776 dp_monitor_set_chan_freq(struct dp_pdev *pdev, qdf_freq_t chan_freq) 777 { 778 } 779 780 static inline void dp_monitor_set_chan_num(struct dp_pdev *pdev, int chan_num) 781 { 782 } 783 784 static inline bool dp_monitor_is_enable_mcopy_mode(struct dp_pdev *pdev) 785 { 786 return false; 787 } 788 789 static inline 790 void dp_monitor_neighbour_peer_list_remove(struct dp_pdev *pdev, 791 struct dp_vdev *vdev, 792 struct dp_neighbour_peer *peer) 793 { 794 } 795 796 static inline bool dp_monitor_is_chan_band_known(struct dp_pdev *pdev) 797 { 798 return false; 799 } 800 801 static inline enum reg_wifi_band 802 dp_monitor_get_chan_band(struct dp_pdev *pdev) 803 { 804 return 0; 805 } 806 807 static inline int 808 dp_monitor_get_chan_num(struct dp_pdev *pdev) 809 { 810 return 0; 811 } 812 813 static inline qdf_freq_t 814 dp_monitor_get_chan_freq(struct dp_pdev *pdev) 815 { 816 return 0; 817 } 818 819 static inline void dp_monitor_get_mpdu_status(struct dp_pdev *pdev, 820 struct dp_soc *soc, 821 uint8_t *rx_tlv_hdr) 822 { 823 } 824 825 static inline void dp_monitor_print_tx_stats(struct dp_pdev *pdev) 826 { 827 } 828 829 static inline 830 QDF_STATUS dp_monitor_mcopy_check_deliver(struct dp_pdev *pdev, 831 uint16_t peer_id, uint32_t ppdu_id, 832 uint8_t first_msdu) 833 { 834 return QDF_STATUS_SUCCESS; 835 } 836 837 static inline bool dp_monitor_is_enable_tx_sniffer(struct dp_pdev *pdev) 838 { 839 return false; 840 } 841 842 static inline struct dp_vdev* 843 dp_monitor_get_monitor_vdev_from_pdev(struct dp_pdev *pdev) 844 { 845 return NULL; 846 } 847 848 static inline QDF_STATUS dp_monitor_check_com_info_ppdu_id(struct dp_pdev *pdev, 849 void *rx_desc) 850 { 851 return QDF_STATUS_E_FAILURE; 852 } 853 854 static inline struct mon_rx_status* 855 dp_monitor_get_rx_status(struct dp_pdev *pdev) 856 { 857 return NULL; 858 } 859 860 static inline 861 void dp_monitor_pdev_config_scan_spcl_vap(struct dp_pdev *pdev, bool val) 862 { 863 } 864 865 static inline 866 void dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev *pdev, 867 bool val) 868 { 869 } 870 871 static inline QDF_STATUS 872 dp_monitor_peer_tx_capture_get_stats(struct dp_soc *soc, struct dp_peer *peer, 873 struct cdp_peer_tx_capture_stats *stats) 874 { 875 return QDF_STATUS_E_FAILURE; 876 } 877 878 static inline QDF_STATUS 879 dp_monitor_pdev_tx_capture_get_stats(struct dp_soc *soc, struct dp_pdev *pdev, 880 struct cdp_pdev_tx_capture_stats *stats) 881 { 882 return QDF_STATUS_E_FAILURE; 883 } 884 885 #ifdef DP_POWER_SAVE 886 static inline 887 void dp_monitor_pktlog_reap_pending_frames(struct dp_pdev *pdev) 888 { 889 } 890 891 static inline 892 void dp_monitor_pktlog_start_reap_timer(struct dp_pdev *pdev) 893 { 894 } 895 #endif 896 897 static inline bool dp_monitor_is_configured(struct dp_pdev *pdev) 898 { 899 return false; 900 } 901 902 static inline void 903 dp_mon_rx_hdr_length_set(struct dp_soc *soc, uint32_t *msg_word, 904 struct htt_rx_ring_tlv_filter *tlv_filter) 905 { 906 } 907 908 static inline void dp_monitor_soc_init(struct dp_soc *soc) 909 { 910 } 911 912 static inline void dp_monitor_soc_deinit(struct dp_soc *soc) 913 { 914 } 915 916 static inline 917 QDF_STATUS dp_monitor_config_undecoded_metadata_capture(struct dp_pdev *pdev, 918 int val) 919 { 920 return QDF_STATUS_SUCCESS; 921 } 922 923 static inline QDF_STATUS 924 dp_monitor_config_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev, 925 int mask1, int mask2) 926 { 927 return QDF_STATUS_SUCCESS; 928 } 929 930 static inline QDF_STATUS 931 dp_monitor_get_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev, 932 int *mask, int *mask_cont) 933 { 934 return QDF_STATUS_SUCCESS; 935 } 936 937 static inline QDF_STATUS dp_monitor_soc_htt_srng_setup(struct dp_soc *soc) 938 { 939 return QDF_STATUS_E_FAILURE; 940 } 941 942 static inline bool dp_is_monitor_mode_using_poll(struct dp_soc *soc) 943 { 944 return false; 945 } 946 947 static inline 948 uint32_t dp_tx_mon_buf_refill(struct dp_intr *int_ctx) 949 { 950 return 0; 951 } 952 953 static inline uint32_t 954 dp_tx_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx, 955 uint32_t mac_id, uint32_t quota) 956 { 957 return 0; 958 } 959 960 static inline uint32_t 961 dp_print_txmon_ring_stat_from_hal(struct dp_pdev *pdev) 962 { 963 return 0; 964 } 965 966 static inline 967 uint32_t dp_rx_mon_buf_refill(struct dp_intr *int_ctx) 968 { 969 return 0; 970 } 971 972 static inline bool dp_monitor_is_tx_cap_enabled(struct dp_peer *peer) 973 { 974 return 0; 975 } 976 977 static inline bool dp_monitor_is_rx_cap_enabled(struct dp_peer *peer) 978 { 979 return 0; 980 } 981 982 static inline void 983 dp_rx_mon_enable(struct dp_soc *soc, uint32_t *msg_word, 984 struct htt_rx_ring_tlv_filter *tlv_filter) 985 { 986 } 987 988 static inline void 989 dp_mon_rx_packet_length_set(struct dp_soc *soc, uint32_t *msg_word, 990 struct htt_rx_ring_tlv_filter *tlv_filter) 991 { 992 } 993 994 static inline void 995 dp_mon_rx_enable_mpdu_logging(struct dp_soc *soc, uint32_t *msg_word, 996 struct htt_rx_ring_tlv_filter *tlv_filter) 997 { 998 } 999 1000 static inline void 1001 dp_mon_rx_wmask_subscribe(struct dp_soc *soc, 1002 uint32_t *msg_word, int pdev_id, 1003 struct htt_rx_ring_tlv_filter *tlv_filter) 1004 { 1005 } 1006 1007 static inline void 1008 dp_mon_rx_mac_filter_set(struct dp_soc *soc, uint32_t *msg_word, 1009 struct htt_rx_ring_tlv_filter *tlv_filter) 1010 { 1011 } 1012 1013 static inline void 1014 dp_mon_rx_enable_pkt_tlv_offset(struct dp_soc *soc, uint32_t *msg_word, 1015 struct htt_rx_ring_tlv_filter *tlv_filter) 1016 { 1017 } 1018 1019 static inline void 1020 dp_mon_rx_enable_fpmo(struct dp_soc *soc, uint32_t *msg_word, 1021 struct htt_rx_ring_tlv_filter *tlv_filter) 1022 { 1023 } 1024 1025 #ifdef WLAN_CONFIG_TELEMETRY_AGENT 1026 static inline 1027 void dp_monitor_peer_telemetry_stats(struct dp_peer *peer, 1028 struct cdp_peer_telemetry_stats *stats) 1029 { 1030 } 1031 1032 static inline 1033 void dp_monitor_peer_deter_stats(struct dp_peer *peer, 1034 struct cdp_peer_telemetry_stats *stats) 1035 { 1036 } 1037 #endif /* WLAN_CONFIG_TELEMETRY_AGENT */ 1038 #endif /* !WIFI_MONITOR_SUPPORT */ 1039 1040 /** 1041 * cdp_soc_t_to_dp_soc() - typecast cdp_soc_t to 1042 * dp soc handle 1043 * @psoc: CDP psoc handle 1044 * 1045 * Return: struct dp_soc pointer 1046 */ 1047 static inline 1048 struct dp_soc *cdp_soc_t_to_dp_soc(struct cdp_soc_t *psoc) 1049 { 1050 return (struct dp_soc *)psoc; 1051 } 1052 1053 #define DP_MAX_TIMER_EXEC_TIME_TICKS \ 1054 (QDF_LOG_TIMESTAMP_CYCLES_PER_10_US * 100 * 20) 1055 1056 /** 1057 * enum timer_yield_status - yield status code used in monitor mode timer. 1058 * @DP_TIMER_NO_YIELD: do not yield 1059 * @DP_TIMER_WORK_DONE: yield because work is done 1060 * @DP_TIMER_WORK_EXHAUST: yield because work quota is exhausted 1061 * @DP_TIMER_TIME_EXHAUST: yield due to time slot exhausted 1062 */ 1063 enum timer_yield_status { 1064 DP_TIMER_NO_YIELD, 1065 DP_TIMER_WORK_DONE, 1066 DP_TIMER_WORK_EXHAUST, 1067 DP_TIMER_TIME_EXHAUST, 1068 }; 1069 1070 #if DP_PRINT_ENABLE 1071 #include <qdf_types.h> /* qdf_vprint */ 1072 #include <cdp_txrx_handle.h> 1073 1074 enum { 1075 /* FATAL_ERR - print only irrecoverable error messages */ 1076 DP_PRINT_LEVEL_FATAL_ERR, 1077 1078 /* ERR - include non-fatal err messages */ 1079 DP_PRINT_LEVEL_ERR, 1080 1081 /* WARN - include warnings */ 1082 DP_PRINT_LEVEL_WARN, 1083 1084 /* INFO1 - include fundamental, infrequent events */ 1085 DP_PRINT_LEVEL_INFO1, 1086 1087 /* INFO2 - include non-fundamental but infrequent events */ 1088 DP_PRINT_LEVEL_INFO2, 1089 }; 1090 1091 #define dp_print(level, fmt, ...) do { \ 1092 if (level <= g_txrx_print_level) \ 1093 qdf_print(fmt, ## __VA_ARGS__); \ 1094 while (0) 1095 #define DP_PRINT(level, fmt, ...) do { \ 1096 dp_print(level, "DP: " fmt, ## __VA_ARGS__); \ 1097 while (0) 1098 #else 1099 #define DP_PRINT(level, fmt, ...) 1100 #endif /* DP_PRINT_ENABLE */ 1101 1102 #define DP_TRACE(LVL, fmt, args ...) \ 1103 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_##LVL, \ 1104 fmt, ## args) 1105 1106 #ifdef WLAN_SYSFS_DP_STATS 1107 void DP_PRINT_STATS(const char *fmt, ...); 1108 #else /* WLAN_SYSFS_DP_STATS */ 1109 #ifdef DP_PRINT_NO_CONSOLE 1110 /* Stat prints should not go to console or kernel logs.*/ 1111 #define DP_PRINT_STATS(fmt, args ...)\ 1112 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO_HIGH, \ 1113 fmt, ## args) 1114 #else 1115 #define DP_PRINT_STATS(fmt, args ...)\ 1116 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL,\ 1117 fmt, ## args) 1118 #endif 1119 #endif /* WLAN_SYSFS_DP_STATS */ 1120 1121 #define DP_STATS_INIT(_handle) \ 1122 qdf_mem_zero(&((_handle)->stats), sizeof((_handle)->stats)) 1123 1124 #define DP_TXRX_PEER_STATS_INIT(_handle, size) \ 1125 qdf_mem_zero(&((_handle)->stats[0]), size) 1126 1127 #define DP_STATS_CLR(_handle) \ 1128 qdf_mem_zero(&((_handle)->stats), sizeof((_handle)->stats)) 1129 1130 #define DP_TXRX_PEER_STATS_CLR(_handle, size) \ 1131 qdf_mem_zero(&((_handle)->stats[0]), size) 1132 1133 #ifndef DISABLE_DP_STATS 1134 #define DP_STATS_INC(_handle, _field, _delta) \ 1135 { \ 1136 if (likely(_handle)) \ 1137 _handle->stats._field += _delta; \ 1138 } 1139 1140 #define DP_PEER_LINK_STATS_INC(_handle, _field, _delta, _link) \ 1141 { \ 1142 if (likely(_handle)) \ 1143 _handle->stats[_link]._field += _delta; \ 1144 } 1145 1146 #define DP_PEER_STATS_FLAT_INC(_handle, _field, _delta) \ 1147 { \ 1148 if (likely(_handle)) \ 1149 _handle->_field += _delta; \ 1150 } 1151 1152 #define DP_STATS_INCC(_handle, _field, _delta, _cond) \ 1153 { \ 1154 if (_cond && likely(_handle)) \ 1155 _handle->stats._field += _delta; \ 1156 } 1157 1158 #define DP_PEER_LINK_STATS_INCC(_handle, _field, _delta, _cond, _link) \ 1159 { \ 1160 if (_cond && likely(_handle)) \ 1161 _handle->stats[_link]._field += _delta; \ 1162 } 1163 1164 #define DP_STATS_DEC(_handle, _field, _delta) \ 1165 { \ 1166 if (likely(_handle)) \ 1167 _handle->stats._field -= _delta; \ 1168 } 1169 1170 #define DP_PEER_STATS_FLAT_DEC(_handle, _field, _delta) \ 1171 { \ 1172 if (likely(_handle)) \ 1173 _handle->_field -= _delta; \ 1174 } 1175 1176 #define DP_STATS_UPD(_handle, _field, _delta) \ 1177 { \ 1178 if (likely(_handle)) \ 1179 _handle->stats._field = _delta; \ 1180 } 1181 1182 #define DP_PEER_LINK_STATS_UPD(_handle, _field, _delta, _link) \ 1183 { \ 1184 if (likely(_handle)) \ 1185 _handle->stats[_link]._field = _delta; \ 1186 } 1187 1188 #define DP_STATS_INC_PKT(_handle, _field, _count, _bytes) \ 1189 { \ 1190 DP_STATS_INC(_handle, _field.num, _count); \ 1191 DP_STATS_INC(_handle, _field.bytes, _bytes) \ 1192 } 1193 1194 #define DP_PEER_STATS_FLAT_INC_PKT(_handle, _field, _count, _bytes) \ 1195 { \ 1196 DP_PEER_STATS_FLAT_INC(_handle, _field.num, _count); \ 1197 DP_PEER_STATS_FLAT_INC(_handle, _field.bytes, _bytes) \ 1198 } 1199 1200 #define DP_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond) \ 1201 { \ 1202 DP_STATS_INCC(_handle, _field.num, _count, _cond); \ 1203 DP_STATS_INCC(_handle, _field.bytes, _bytes, _cond) \ 1204 } 1205 1206 #define DP_STATS_AGGR(_handle_a, _handle_b, _field) \ 1207 { \ 1208 _handle_a->stats._field += _handle_b->stats._field; \ 1209 } 1210 1211 #define DP_STATS_AGGR_PKT(_handle_a, _handle_b, _field) \ 1212 { \ 1213 DP_STATS_AGGR(_handle_a, _handle_b, _field.num); \ 1214 DP_STATS_AGGR(_handle_a, _handle_b, _field.bytes);\ 1215 } 1216 1217 #define DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field, _idx) \ 1218 { \ 1219 _handle_a->stats._arr._field += _handle_b->stats._arr[_idx]._field; \ 1220 } 1221 1222 #define DP_STATS_AGGR_PKT_IDX(_handle_a, _handle_b, _arr, _field, _idx)\ 1223 { \ 1224 DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field.num, _idx); \ 1225 DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field.bytes, _idx);\ 1226 } 1227 1228 #define DP_STATS_UPD_STRUCT(_handle_a, _handle_b, _field) \ 1229 { \ 1230 _handle_a->stats._field = _handle_b->stats._field; \ 1231 } 1232 1233 #else 1234 #define DP_STATS_INC(_handle, _field, _delta) 1235 #define DP_PEER_LINK_STATS_INC(_handle, _field, _delta, _link) 1236 #define DP_PEER_STATS_FLAT_INC(_handle, _field, _delta) 1237 #define DP_STATS_INCC(_handle, _field, _delta, _cond) 1238 #define DP_PEER_LINK_STATS_INCC(_handle, _field, _delta, _cond, _link) 1239 #define DP_STATS_DEC(_handle, _field, _delta) 1240 #define DP_PEER_STATS_FLAT_DEC(_handle, _field, _delta) 1241 #define DP_STATS_UPD(_handle, _field, _delta) 1242 #define DP_PEER_LINK_STATS_UPD(_handle, _field, _delta, _link) 1243 #define DP_STATS_INC_PKT(_handle, _field, _count, _bytes) 1244 #define DP_PEER_STATS_FLAT_INC_PKT(_handle, _field, _count, _bytes) 1245 #define DP_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond) 1246 #define DP_STATS_AGGR(_handle_a, _handle_b, _field) 1247 #define DP_STATS_AGGR_PKT(_handle_a, _handle_b, _field) 1248 #define DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field, _idx) 1249 #define DP_STATS_AGGR_PKT_IDX(_handle_a, _handle_b, _arr, _field, _idx) 1250 #endif 1251 1252 #define DP_PEER_PER_PKT_STATS_INC(_handle, _field, _delta, _link) \ 1253 { \ 1254 DP_PEER_LINK_STATS_INC(_handle, per_pkt_stats._field, _delta, _link); \ 1255 } 1256 1257 #define DP_PEER_PER_PKT_STATS_INCC(_handle, _field, _delta, _cond, _link) \ 1258 { \ 1259 DP_PEER_LINK_STATS_INCC(_handle, per_pkt_stats._field, _delta, _cond, _link); \ 1260 } 1261 1262 #define DP_PEER_PER_PKT_STATS_INC_PKT(_handle, _field, _count, _bytes, _link) \ 1263 { \ 1264 DP_PEER_PER_PKT_STATS_INC(_handle, _field.num, _count, _link); \ 1265 DP_PEER_PER_PKT_STATS_INC(_handle, _field.bytes, _bytes, _link) \ 1266 } 1267 1268 #define DP_PEER_PER_PKT_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond, _link) \ 1269 { \ 1270 DP_PEER_PER_PKT_STATS_INCC(_handle, _field.num, _count, _cond, _link); \ 1271 DP_PEER_PER_PKT_STATS_INCC(_handle, _field.bytes, _bytes, _cond, _link) \ 1272 } 1273 1274 #define DP_PEER_PER_PKT_STATS_UPD(_handle, _field, _delta, _link) \ 1275 { \ 1276 DP_PEER_LINK_STATS_UPD(_handle, per_pkt_stats._field, _delta, _link); \ 1277 } 1278 1279 #ifndef QCA_ENHANCED_STATS_SUPPORT 1280 #define DP_PEER_EXTD_STATS_INC(_handle, _field, _delta, _link) \ 1281 { \ 1282 DP_PEER_LINK_STATS_INC(_handle, extd_stats._field, _delta, _link); \ 1283 } 1284 1285 #define DP_PEER_EXTD_STATS_INCC(_handle, _field, _delta, _cond, _link) \ 1286 { \ 1287 DP_PEER_LINK_STATS_INCC(_handle, extd_stats._field, _delta, _cond, _link); \ 1288 } 1289 1290 #define DP_PEER_EXTD_STATS_UPD(_handle, _field, _delta, _link) \ 1291 { \ 1292 DP_PEER_LINK_STATS_UPD(_handle, extd_stats._field, _delta, _link); \ 1293 } 1294 #endif 1295 1296 #if defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT) && \ 1297 defined(QCA_ENHANCED_STATS_SUPPORT) 1298 #define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \ 1299 { \ 1300 if (_cond || !(_handle->hw_txrx_stats_en)) \ 1301 DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); \ 1302 } 1303 1304 #define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \ 1305 { \ 1306 if (_cond || !(_handle->hw_txrx_stats_en)) \ 1307 DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); \ 1308 } 1309 1310 #define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ 1311 { \ 1312 if (_cond || !(_handle->hw_txrx_stats_en)) \ 1313 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes, _link); \ 1314 } 1315 1316 #define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ 1317 { \ 1318 if (_cond || !(_handle->hw_txrx_stats_en)) \ 1319 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes, _link); \ 1320 } 1321 1322 #define DP_PEER_UC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ 1323 { \ 1324 if (_cond || !(_handle->hw_txrx_stats_en)) \ 1325 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.unicast, _count, _bytes, _link); \ 1326 } 1327 #elif defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT) 1328 #define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \ 1329 { \ 1330 if (!(_handle->hw_txrx_stats_en)) \ 1331 DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); \ 1332 } 1333 1334 #define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \ 1335 { \ 1336 if (!(_handle->hw_txrx_stats_en)) \ 1337 DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); \ 1338 } 1339 1340 #define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ 1341 { \ 1342 if (!(_handle->hw_txrx_stats_en)) \ 1343 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes, _link); \ 1344 } 1345 1346 #define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ 1347 { \ 1348 if (!(_handle->hw_txrx_stats_en)) \ 1349 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes, _link); \ 1350 } 1351 1352 #define DP_PEER_UC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ 1353 { \ 1354 if (!(_handle->hw_txrx_stats_en)) \ 1355 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.unicast, _count, _bytes, _link); \ 1356 } 1357 #else 1358 #define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \ 1359 DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); 1360 1361 #define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \ 1362 DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); 1363 1364 #define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ 1365 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes, _link); 1366 1367 #define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ 1368 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes, _link); 1369 1370 #define DP_PEER_UC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ 1371 DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.unicast, _count, _bytes, _link); 1372 #endif 1373 1374 #ifdef ENABLE_DP_HIST_STATS 1375 #define DP_HIST_INIT() \ 1376 uint32_t num_of_packets[MAX_PDEV_CNT] = {0}; 1377 1378 #define DP_HIST_PACKET_COUNT_INC(_pdev_id) \ 1379 { \ 1380 ++num_of_packets[_pdev_id]; \ 1381 } 1382 1383 #define DP_TX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) \ 1384 do { \ 1385 if (_p_cntrs == 1) { \ 1386 DP_STATS_INC(_pdev, \ 1387 tx_comp_histogram.pkts_1, 1); \ 1388 } else if (_p_cntrs > 1 && _p_cntrs <= 20) { \ 1389 DP_STATS_INC(_pdev, \ 1390 tx_comp_histogram.pkts_2_20, 1); \ 1391 } else if (_p_cntrs > 20 && _p_cntrs <= 40) { \ 1392 DP_STATS_INC(_pdev, \ 1393 tx_comp_histogram.pkts_21_40, 1); \ 1394 } else if (_p_cntrs > 40 && _p_cntrs <= 60) { \ 1395 DP_STATS_INC(_pdev, \ 1396 tx_comp_histogram.pkts_41_60, 1); \ 1397 } else if (_p_cntrs > 60 && _p_cntrs <= 80) { \ 1398 DP_STATS_INC(_pdev, \ 1399 tx_comp_histogram.pkts_61_80, 1); \ 1400 } else if (_p_cntrs > 80 && _p_cntrs <= 100) { \ 1401 DP_STATS_INC(_pdev, \ 1402 tx_comp_histogram.pkts_81_100, 1); \ 1403 } else if (_p_cntrs > 100 && _p_cntrs <= 200) { \ 1404 DP_STATS_INC(_pdev, \ 1405 tx_comp_histogram.pkts_101_200, 1); \ 1406 } else if (_p_cntrs > 200) { \ 1407 DP_STATS_INC(_pdev, \ 1408 tx_comp_histogram.pkts_201_plus, 1); \ 1409 } \ 1410 } while (0) 1411 1412 #define DP_RX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) \ 1413 do { \ 1414 if (_p_cntrs == 1) { \ 1415 DP_STATS_INC(_pdev, \ 1416 rx_ind_histogram.pkts_1, 1); \ 1417 } else if (_p_cntrs > 1 && _p_cntrs <= 20) { \ 1418 DP_STATS_INC(_pdev, \ 1419 rx_ind_histogram.pkts_2_20, 1); \ 1420 } else if (_p_cntrs > 20 && _p_cntrs <= 40) { \ 1421 DP_STATS_INC(_pdev, \ 1422 rx_ind_histogram.pkts_21_40, 1); \ 1423 } else if (_p_cntrs > 40 && _p_cntrs <= 60) { \ 1424 DP_STATS_INC(_pdev, \ 1425 rx_ind_histogram.pkts_41_60, 1); \ 1426 } else if (_p_cntrs > 60 && _p_cntrs <= 80) { \ 1427 DP_STATS_INC(_pdev, \ 1428 rx_ind_histogram.pkts_61_80, 1); \ 1429 } else if (_p_cntrs > 80 && _p_cntrs <= 100) { \ 1430 DP_STATS_INC(_pdev, \ 1431 rx_ind_histogram.pkts_81_100, 1); \ 1432 } else if (_p_cntrs > 100 && _p_cntrs <= 200) { \ 1433 DP_STATS_INC(_pdev, \ 1434 rx_ind_histogram.pkts_101_200, 1); \ 1435 } else if (_p_cntrs > 200) { \ 1436 DP_STATS_INC(_pdev, \ 1437 rx_ind_histogram.pkts_201_plus, 1); \ 1438 } \ 1439 } while (0) 1440 1441 #define DP_TX_HIST_STATS_PER_PDEV() \ 1442 do { \ 1443 uint8_t hist_stats = 0; \ 1444 for (hist_stats = 0; hist_stats < soc->pdev_count; \ 1445 hist_stats++) { \ 1446 DP_TX_HISTOGRAM_UPDATE(soc->pdev_list[hist_stats], \ 1447 num_of_packets[hist_stats]); \ 1448 } \ 1449 } while (0) 1450 1451 1452 #define DP_RX_HIST_STATS_PER_PDEV() \ 1453 do { \ 1454 uint8_t hist_stats = 0; \ 1455 for (hist_stats = 0; hist_stats < soc->pdev_count; \ 1456 hist_stats++) { \ 1457 DP_RX_HISTOGRAM_UPDATE(soc->pdev_list[hist_stats], \ 1458 num_of_packets[hist_stats]); \ 1459 } \ 1460 } while (0) 1461 1462 #else 1463 #define DP_HIST_INIT() 1464 #define DP_HIST_PACKET_COUNT_INC(_pdev_id) 1465 #define DP_TX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) 1466 #define DP_RX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) 1467 #define DP_RX_HIST_STATS_PER_PDEV() 1468 #define DP_TX_HIST_STATS_PER_PDEV() 1469 #endif /* DISABLE_DP_STATS */ 1470 1471 #define FRAME_MASK_IPV4_ARP 1 1472 #define FRAME_MASK_IPV4_DHCP 2 1473 #define FRAME_MASK_IPV4_EAPOL 4 1474 #define FRAME_MASK_IPV6_DHCP 8 1475 1476 static inline int dp_log2_ceil(unsigned int value) 1477 { 1478 unsigned int tmp = value; 1479 int log2 = -1; 1480 1481 if (qdf_unlikely(value == 0)) 1482 return 0; 1483 while (tmp) { 1484 log2++; 1485 tmp >>= 1; 1486 } 1487 if (1 << log2 != value) 1488 log2++; 1489 return log2; 1490 } 1491 1492 #ifdef QCA_SUPPORT_PEER_ISOLATION 1493 #define dp_get_peer_isolation(_peer) ((_peer)->isolation) 1494 1495 static inline void dp_set_peer_isolation(struct dp_txrx_peer *txrx_peer, 1496 bool val) 1497 { 1498 txrx_peer->isolation = val; 1499 } 1500 1501 #else 1502 #define dp_get_peer_isolation(_peer) (0) 1503 1504 static inline void dp_set_peer_isolation(struct dp_txrx_peer *peer, bool val) 1505 { 1506 } 1507 #endif /* QCA_SUPPORT_PEER_ISOLATION */ 1508 1509 bool dp_vdev_is_wds_ext_enabled(struct dp_vdev *vdev); 1510 1511 #ifdef QCA_SUPPORT_WDS_EXTENDED 1512 static inline void dp_wds_ext_peer_init(struct dp_txrx_peer *txrx_peer) 1513 { 1514 txrx_peer->wds_ext.osif_peer = NULL; 1515 txrx_peer->wds_ext.init = 0; 1516 } 1517 #else 1518 static inline void dp_wds_ext_peer_init(struct dp_txrx_peer *txrx_peer) 1519 { 1520 } 1521 #endif /* QCA_SUPPORT_WDS_EXTENDED */ 1522 1523 #ifdef QCA_HOST2FW_RXBUF_RING 1524 static inline 1525 struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) 1526 { 1527 return &pdev->rx_mac_buf_ring[lmac_id]; 1528 } 1529 #else 1530 static inline 1531 struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) 1532 { 1533 return &pdev->soc->rx_refill_buf_ring[lmac_id]; 1534 } 1535 #endif 1536 1537 /* 1538 * The lmac ID for a particular channel band is fixed. 1539 * 2.4GHz band uses lmac_id = 1 1540 * 5GHz/6GHz band uses lmac_id=0 1541 */ 1542 #define DP_INVALID_LMAC_ID (-1) 1543 #define DP_MON_INVALID_LMAC_ID (-1) 1544 #define DP_MAC0_LMAC_ID 0 1545 #define DP_MAC1_LMAC_ID 1 1546 1547 #ifdef FEATURE_TSO_STATS 1548 /** 1549 * dp_init_tso_stats() - Clear tso stats 1550 * @pdev: pdev handle 1551 * 1552 * Return: None 1553 */ 1554 static inline 1555 void dp_init_tso_stats(struct dp_pdev *pdev) 1556 { 1557 if (pdev) { 1558 qdf_mem_zero(&((pdev)->stats.tso_stats), 1559 sizeof((pdev)->stats.tso_stats)); 1560 qdf_atomic_init(&pdev->tso_idx); 1561 } 1562 } 1563 1564 /** 1565 * dp_stats_tso_segment_histogram_update() - TSO Segment Histogram 1566 * @pdev: pdev handle 1567 * @_p_cntrs: number of tso segments for a tso packet 1568 * 1569 * Return: None 1570 */ 1571 void dp_stats_tso_segment_histogram_update(struct dp_pdev *pdev, 1572 uint8_t _p_cntrs); 1573 1574 /** 1575 * dp_tso_segment_update() - Collect tso segment information 1576 * @pdev: pdev handle 1577 * @stats_idx: tso packet number 1578 * @idx: tso segment number 1579 * @seg: tso segment 1580 * 1581 * Return: None 1582 */ 1583 void dp_tso_segment_update(struct dp_pdev *pdev, 1584 uint32_t stats_idx, 1585 uint8_t idx, 1586 struct qdf_tso_seg_t seg); 1587 1588 /** 1589 * dp_tso_packet_update() - TSO Packet information 1590 * @pdev: pdev handle 1591 * @stats_idx: tso packet number 1592 * @msdu: nbuf handle 1593 * @num_segs: tso segments 1594 * 1595 * Return: None 1596 */ 1597 void dp_tso_packet_update(struct dp_pdev *pdev, uint32_t stats_idx, 1598 qdf_nbuf_t msdu, uint16_t num_segs); 1599 1600 /** 1601 * dp_tso_segment_stats_update() - TSO Segment stats 1602 * @pdev: pdev handle 1603 * @stats_seg: tso segment list 1604 * @stats_idx: tso packet number 1605 * 1606 * Return: None 1607 */ 1608 void dp_tso_segment_stats_update(struct dp_pdev *pdev, 1609 struct qdf_tso_seg_elem_t *stats_seg, 1610 uint32_t stats_idx); 1611 1612 /** 1613 * dp_print_tso_stats() - dump tso statistics 1614 * @soc:soc handle 1615 * @level: verbosity level 1616 * 1617 * Return: None 1618 */ 1619 void dp_print_tso_stats(struct dp_soc *soc, 1620 enum qdf_stats_verbosity_level level); 1621 1622 /** 1623 * dp_txrx_clear_tso_stats() - clear tso stats 1624 * @soc: soc handle 1625 * 1626 * Return: None 1627 */ 1628 void dp_txrx_clear_tso_stats(struct dp_soc *soc); 1629 #else 1630 static inline 1631 void dp_init_tso_stats(struct dp_pdev *pdev) 1632 { 1633 } 1634 1635 static inline 1636 void dp_stats_tso_segment_histogram_update(struct dp_pdev *pdev, 1637 uint8_t _p_cntrs) 1638 { 1639 } 1640 1641 static inline 1642 void dp_tso_segment_update(struct dp_pdev *pdev, 1643 uint32_t stats_idx, 1644 uint32_t idx, 1645 struct qdf_tso_seg_t seg) 1646 { 1647 } 1648 1649 static inline 1650 void dp_tso_packet_update(struct dp_pdev *pdev, uint32_t stats_idx, 1651 qdf_nbuf_t msdu, uint16_t num_segs) 1652 { 1653 } 1654 1655 static inline 1656 void dp_tso_segment_stats_update(struct dp_pdev *pdev, 1657 struct qdf_tso_seg_elem_t *stats_seg, 1658 uint32_t stats_idx) 1659 { 1660 } 1661 1662 static inline 1663 void dp_print_tso_stats(struct dp_soc *soc, 1664 enum qdf_stats_verbosity_level level) 1665 { 1666 } 1667 1668 static inline 1669 void dp_txrx_clear_tso_stats(struct dp_soc *soc) 1670 { 1671 } 1672 #endif /* FEATURE_TSO_STATS */ 1673 1674 /** 1675 * dp_txrx_get_peer_per_pkt_stats_param() - Get peer per pkt stats param 1676 * @peer: DP peer handle 1677 * @type: Requested stats type 1678 * @buf: Buffer to hold the value 1679 * 1680 * Return: status success/failure 1681 */ 1682 QDF_STATUS dp_txrx_get_peer_per_pkt_stats_param(struct dp_peer *peer, 1683 enum cdp_peer_stats_type type, 1684 cdp_peer_stats_param_t *buf); 1685 1686 /** 1687 * dp_txrx_get_peer_extd_stats_param() - Get peer extd stats param 1688 * @peer: DP peer handle 1689 * @type: Requested stats type 1690 * @buf: Buffer to hold the value 1691 * 1692 * Return: status success/failure 1693 */ 1694 QDF_STATUS dp_txrx_get_peer_extd_stats_param(struct dp_peer *peer, 1695 enum cdp_peer_stats_type type, 1696 cdp_peer_stats_param_t *buf); 1697 1698 #define DP_HTT_T2H_HP_PIPE 5 1699 /** 1700 * dp_update_pdev_stats(): Update the pdev stats 1701 * @tgtobj: pdev handle 1702 * @srcobj: vdev stats structure 1703 * 1704 * Update the pdev stats from the specified vdev stats 1705 * 1706 * Return: None 1707 */ 1708 void dp_update_pdev_stats(struct dp_pdev *tgtobj, 1709 struct cdp_vdev_stats *srcobj); 1710 1711 /** 1712 * dp_update_vdev_ingress_stats(): Update the vdev ingress stats 1713 * @tgtobj: vdev handle 1714 * 1715 * Update the vdev ingress stats 1716 * 1717 * Return: None 1718 */ 1719 void dp_update_vdev_ingress_stats(struct dp_vdev *tgtobj); 1720 1721 /** 1722 * dp_update_vdev_rate_stats() - Update the vdev rate stats 1723 * @tgtobj: tgt buffer for cdp vdev stats 1724 * @srcobj: srcobj dp vdev stats 1725 * 1726 * Return: None 1727 */ 1728 void dp_update_vdev_rate_stats(struct cdp_vdev_stats *tgtobj, 1729 struct dp_vdev_stats *srcobj); 1730 1731 /** 1732 * dp_update_pdev_ingress_stats(): Update the pdev ingress stats 1733 * @tgtobj: pdev handle 1734 * @srcobj: vdev stats structure 1735 * 1736 * Update the pdev ingress stats from the specified vdev stats 1737 * 1738 * Return: None 1739 */ 1740 void dp_update_pdev_ingress_stats(struct dp_pdev *tgtobj, 1741 struct dp_vdev *srcobj); 1742 1743 /** 1744 * dp_copy_vdev_stats_to_tgt_buf(): Update the cdp vdev ingress stats from 1745 * dp vdev ingress stats 1746 * @vdev_stats: cdp vdev stats structure 1747 * @stats: dp vdev stats structure 1748 * @xmit_type: xmit type of packet - MLD/Link 1749 * 1750 * Update the cdp vdev ingress stats from dp vdev ingress stats 1751 * 1752 * Return: None 1753 */ 1754 1755 void dp_copy_vdev_stats_to_tgt_buf(struct cdp_vdev_stats *vdev_stats, 1756 struct dp_vdev_stats *stats, 1757 enum dp_pkt_xmit_type xmit_type); 1758 1759 /** 1760 * dp_update_vdev_stats(): Update the vdev stats 1761 * @soc: soc handle 1762 * @srcobj: DP_PEER object 1763 * @arg: point to vdev stats structure 1764 * 1765 * Update the vdev stats from the specified peer stats 1766 * 1767 * Return: None 1768 */ 1769 void dp_update_vdev_stats(struct dp_soc *soc, 1770 struct dp_peer *srcobj, 1771 void *arg); 1772 1773 /** 1774 * dp_update_vdev_stats_on_peer_unmap() - Update the vdev stats on peer unmap 1775 * @vdev: DP_VDEV handle 1776 * @peer: DP_PEER handle 1777 * 1778 * Return: None 1779 */ 1780 void dp_update_vdev_stats_on_peer_unmap(struct dp_vdev *vdev, 1781 struct dp_peer *peer); 1782 1783 #ifdef IPA_OFFLOAD 1784 #define DP_IPA_UPDATE_RX_STATS(__tgtobj, __srcobj) \ 1785 { \ 1786 DP_STATS_AGGR_PKT(__tgtobj, __srcobj, rx.rx_total); \ 1787 } 1788 1789 #define DP_IPA_UPDATE_PER_PKT_RX_STATS(__tgtobj, __srcobj) \ 1790 { \ 1791 (__tgtobj)->rx.rx_total.num += (__srcobj)->rx.rx_total.num; \ 1792 (__tgtobj)->rx.rx_total.bytes += (__srcobj)->rx.rx_total.bytes; \ 1793 } 1794 #else 1795 #define DP_IPA_UPDATE_PER_PKT_RX_STATS(tgtobj, srcobj) \ 1796 1797 #define DP_IPA_UPDATE_RX_STATS(tgtobj, srcobj) 1798 #endif 1799 1800 #define DP_UPDATE_STATS(_tgtobj, _srcobj) \ 1801 do { \ 1802 uint8_t i; \ 1803 uint8_t pream_type; \ 1804 for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \ 1805 for (i = 0; i < MAX_MCS; i++) { \ 1806 DP_STATS_AGGR(_tgtobj, _srcobj, \ 1807 tx.pkt_type[pream_type].mcs_count[i]); \ 1808 DP_STATS_AGGR(_tgtobj, _srcobj, \ 1809 rx.pkt_type[pream_type].mcs_count[i]); \ 1810 } \ 1811 } \ 1812 \ 1813 for (i = 0; i < MAX_BW; i++) { \ 1814 DP_STATS_AGGR(_tgtobj, _srcobj, tx.bw[i]); \ 1815 DP_STATS_AGGR(_tgtobj, _srcobj, rx.bw[i]); \ 1816 } \ 1817 \ 1818 for (i = 0; i < SS_COUNT; i++) { \ 1819 DP_STATS_AGGR(_tgtobj, _srcobj, rx.nss[i]); \ 1820 DP_STATS_AGGR(_tgtobj, _srcobj, tx.nss[i]); \ 1821 } \ 1822 for (i = 0; i < WME_AC_MAX; i++) { \ 1823 DP_STATS_AGGR(_tgtobj, _srcobj, tx.wme_ac_type[i]); \ 1824 DP_STATS_AGGR(_tgtobj, _srcobj, rx.wme_ac_type[i]); \ 1825 DP_STATS_AGGR(_tgtobj, _srcobj, \ 1826 tx.wme_ac_type_bytes[i]); \ 1827 DP_STATS_AGGR(_tgtobj, _srcobj, \ 1828 rx.wme_ac_type_bytes[i]); \ 1829 DP_STATS_AGGR(_tgtobj, _srcobj, tx.excess_retries_per_ac[i]); \ 1830 \ 1831 } \ 1832 \ 1833 for (i = 0; i < MAX_GI; i++) { \ 1834 DP_STATS_AGGR(_tgtobj, _srcobj, tx.sgi_count[i]); \ 1835 DP_STATS_AGGR(_tgtobj, _srcobj, rx.sgi_count[i]); \ 1836 } \ 1837 \ 1838 for (i = 0; i < MAX_RECEPTION_TYPES; i++) \ 1839 DP_STATS_AGGR(_tgtobj, _srcobj, rx.reception_type[i]); \ 1840 \ 1841 if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { \ 1842 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.comp_pkt); \ 1843 DP_STATS_AGGR(_tgtobj, _srcobj, tx.tx_failed); \ 1844 } \ 1845 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.ucast); \ 1846 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.mcast); \ 1847 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.bcast); \ 1848 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_success); \ 1849 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.nawds_mcast); \ 1850 DP_STATS_AGGR(_tgtobj, _srcobj, tx.nawds_mcast_drop); \ 1851 DP_STATS_AGGR(_tgtobj, _srcobj, tx.ofdma); \ 1852 DP_STATS_AGGR(_tgtobj, _srcobj, tx.stbc); \ 1853 DP_STATS_AGGR(_tgtobj, _srcobj, tx.ldpc); \ 1854 DP_STATS_AGGR(_tgtobj, _srcobj, tx.retries); \ 1855 DP_STATS_AGGR(_tgtobj, _srcobj, tx.non_amsdu_cnt); \ 1856 DP_STATS_AGGR(_tgtobj, _srcobj, tx.amsdu_cnt); \ 1857 DP_STATS_AGGR(_tgtobj, _srcobj, tx.non_ampdu_cnt); \ 1858 DP_STATS_AGGR(_tgtobj, _srcobj, tx.ampdu_cnt); \ 1859 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.dropped.fw_rem); \ 1860 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_tx); \ 1861 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_notx); \ 1862 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason1); \ 1863 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason2); \ 1864 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason3); \ 1865 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_queue_disable); \ 1866 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_no_match); \ 1867 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.drop_threshold); \ 1868 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.drop_link_desc_na); \ 1869 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.invalid_drop); \ 1870 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.mcast_vdev_drop); \ 1871 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.invalid_rr); \ 1872 DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.age_out); \ 1873 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_ucast_total); \ 1874 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_ucast_success); \ 1875 \ 1876 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.mic_err); \ 1877 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.decrypt_err); \ 1878 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.fcserr); \ 1879 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.pn_err); \ 1880 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.oor_err); \ 1881 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.jump_2k_err); \ 1882 DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.rxdma_wifi_parse_err); \ 1883 if (_srcobj->stats.rx.snr != 0) \ 1884 DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.snr); \ 1885 DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.rx_rate); \ 1886 DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_ampdu_cnt); \ 1887 DP_STATS_AGGR(_tgtobj, _srcobj, rx.ampdu_cnt); \ 1888 DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_amsdu_cnt); \ 1889 DP_STATS_AGGR(_tgtobj, _srcobj, rx.amsdu_cnt); \ 1890 DP_STATS_AGGR(_tgtobj, _srcobj, rx.nawds_mcast_drop); \ 1891 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.to_stack); \ 1892 \ 1893 for (i = 0; i < CDP_MAX_RX_RINGS; i++) \ 1894 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.rcvd_reo[i]); \ 1895 \ 1896 for (i = 0; i < CDP_MAX_LMACS; i++) \ 1897 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.rx_lmac[i]); \ 1898 \ 1899 _srcobj->stats.rx.unicast.num = \ 1900 _srcobj->stats.rx.to_stack.num - \ 1901 _srcobj->stats.rx.multicast.num; \ 1902 _srcobj->stats.rx.unicast.bytes = \ 1903 _srcobj->stats.rx.to_stack.bytes - \ 1904 _srcobj->stats.rx.multicast.bytes; \ 1905 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.unicast); \ 1906 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.multicast); \ 1907 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.bcast); \ 1908 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.raw); \ 1909 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.intra_bss.pkts); \ 1910 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.intra_bss.fail); \ 1911 DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.mec_drop); \ 1912 \ 1913 _tgtobj->stats.tx.last_ack_rssi = \ 1914 _srcobj->stats.tx.last_ack_rssi; \ 1915 DP_STATS_AGGR(_tgtobj, _srcobj, rx.multipass_rx_pkt_drop); \ 1916 DP_STATS_AGGR(_tgtobj, _srcobj, rx.peer_unauth_rx_pkt_drop); \ 1917 DP_STATS_AGGR(_tgtobj, _srcobj, rx.policy_check_drop); \ 1918 DP_IPA_UPDATE_RX_STATS(_tgtobj, _srcobj); \ 1919 } while (0) 1920 1921 #ifdef VDEV_PEER_PROTOCOL_COUNT 1922 #define DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj) \ 1923 { \ 1924 uint8_t j; \ 1925 for (j = 0; j < CDP_TRACE_MAX; j++) { \ 1926 _tgtobj->tx.protocol_trace_cnt[j].egress_cnt += \ 1927 _srcobj->tx.protocol_trace_cnt[j].egress_cnt; \ 1928 _tgtobj->tx.protocol_trace_cnt[j].ingress_cnt += \ 1929 _srcobj->tx.protocol_trace_cnt[j].ingress_cnt; \ 1930 _tgtobj->rx.protocol_trace_cnt[j].egress_cnt += \ 1931 _srcobj->rx.protocol_trace_cnt[j].egress_cnt; \ 1932 _tgtobj->rx.protocol_trace_cnt[j].ingress_cnt += \ 1933 _srcobj->rx.protocol_trace_cnt[j].ingress_cnt; \ 1934 } \ 1935 } 1936 #else 1937 #define DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj) 1938 #endif 1939 1940 #ifdef WLAN_FEATURE_11BE 1941 #define DP_UPDATE_11BE_STATS(_tgtobj, _srcobj) \ 1942 do { \ 1943 uint8_t i, mu_type; \ 1944 for (i = 0; i < MAX_MCS; i++) { \ 1945 _tgtobj->tx.su_be_ppdu_cnt.mcs_count[i] += \ 1946 _srcobj->tx.su_be_ppdu_cnt.mcs_count[i]; \ 1947 _tgtobj->rx.su_be_ppdu_cnt.mcs_count[i] += \ 1948 _srcobj->rx.su_be_ppdu_cnt.mcs_count[i]; \ 1949 } \ 1950 for (mu_type = 0; mu_type < TXRX_TYPE_MU_MAX; mu_type++) { \ 1951 for (i = 0; i < MAX_MCS; i++) { \ 1952 _tgtobj->tx.mu_be_ppdu_cnt[mu_type].mcs_count[i] += \ 1953 _srcobj->tx.mu_be_ppdu_cnt[mu_type].mcs_count[i]; \ 1954 _tgtobj->rx.mu_be_ppdu_cnt[mu_type].mcs_count[i] += \ 1955 _srcobj->rx.mu_be_ppdu_cnt[mu_type].mcs_count[i]; \ 1956 } \ 1957 } \ 1958 for (i = 0; i < MAX_PUNCTURED_MODE; i++) { \ 1959 _tgtobj->tx.punc_bw[i] += _srcobj->tx.punc_bw[i]; \ 1960 _tgtobj->rx.punc_bw[i] += _srcobj->rx.punc_bw[i]; \ 1961 } \ 1962 } while (0) 1963 #else 1964 #define DP_UPDATE_11BE_STATS(_tgtobj, _srcobj) 1965 #endif 1966 1967 #define DP_UPDATE_BASIC_STATS(_tgtobj, _srcobj) \ 1968 do { \ 1969 _tgtobj->tx.comp_pkt.num += _srcobj->tx.comp_pkt.num; \ 1970 _tgtobj->tx.comp_pkt.bytes += _srcobj->tx.comp_pkt.bytes; \ 1971 _tgtobj->tx.tx_failed += _srcobj->tx.tx_failed; \ 1972 _tgtobj->rx.to_stack.num += _srcobj->rx.to_stack.num; \ 1973 _tgtobj->rx.to_stack.bytes += _srcobj->rx.to_stack.bytes; \ 1974 } while (0) 1975 1976 #define DP_UPDATE_PER_PKT_STATS(_tgtobj, _srcobj) \ 1977 do { \ 1978 uint8_t i; \ 1979 _tgtobj->tx.ucast.num += _srcobj->tx.ucast.num; \ 1980 _tgtobj->tx.ucast.bytes += _srcobj->tx.ucast.bytes; \ 1981 _tgtobj->tx.mcast.num += _srcobj->tx.mcast.num; \ 1982 _tgtobj->tx.mcast.bytes += _srcobj->tx.mcast.bytes; \ 1983 _tgtobj->tx.bcast.num += _srcobj->tx.bcast.num; \ 1984 _tgtobj->tx.bcast.bytes += _srcobj->tx.bcast.bytes; \ 1985 _tgtobj->tx.nawds_mcast.num += _srcobj->tx.nawds_mcast.num; \ 1986 _tgtobj->tx.nawds_mcast.bytes += \ 1987 _srcobj->tx.nawds_mcast.bytes; \ 1988 _tgtobj->tx.tx_success.num += _srcobj->tx.tx_success.num; \ 1989 _tgtobj->tx.tx_success.bytes += _srcobj->tx.tx_success.bytes; \ 1990 _tgtobj->tx.nawds_mcast_drop += _srcobj->tx.nawds_mcast_drop; \ 1991 _tgtobj->tx.ofdma += _srcobj->tx.ofdma; \ 1992 _tgtobj->tx.non_amsdu_cnt += _srcobj->tx.non_amsdu_cnt; \ 1993 _tgtobj->tx.amsdu_cnt += _srcobj->tx.amsdu_cnt; \ 1994 _tgtobj->tx.dropped.fw_rem.num += \ 1995 _srcobj->tx.dropped.fw_rem.num; \ 1996 _tgtobj->tx.dropped.fw_rem.bytes += \ 1997 _srcobj->tx.dropped.fw_rem.bytes; \ 1998 _tgtobj->tx.dropped.fw_rem_notx += \ 1999 _srcobj->tx.dropped.fw_rem_notx; \ 2000 _tgtobj->tx.dropped.fw_rem_tx += \ 2001 _srcobj->tx.dropped.fw_rem_tx; \ 2002 _tgtobj->tx.dropped.age_out += _srcobj->tx.dropped.age_out; \ 2003 _tgtobj->tx.dropped.fw_reason1 += \ 2004 _srcobj->tx.dropped.fw_reason1; \ 2005 _tgtobj->tx.dropped.fw_reason2 += \ 2006 _srcobj->tx.dropped.fw_reason2; \ 2007 _tgtobj->tx.dropped.fw_reason3 += \ 2008 _srcobj->tx.dropped.fw_reason3; \ 2009 _tgtobj->tx.dropped.fw_rem_queue_disable += \ 2010 _srcobj->tx.dropped.fw_rem_queue_disable; \ 2011 _tgtobj->tx.dropped.fw_rem_no_match += \ 2012 _srcobj->tx.dropped.fw_rem_no_match; \ 2013 _tgtobj->tx.dropped.drop_threshold += \ 2014 _srcobj->tx.dropped.drop_threshold; \ 2015 _tgtobj->tx.dropped.drop_link_desc_na += \ 2016 _srcobj->tx.dropped.drop_link_desc_na; \ 2017 _tgtobj->tx.dropped.invalid_drop += \ 2018 _srcobj->tx.dropped.invalid_drop; \ 2019 _tgtobj->tx.dropped.mcast_vdev_drop += \ 2020 _srcobj->tx.dropped.mcast_vdev_drop; \ 2021 _tgtobj->tx.dropped.invalid_rr += \ 2022 _srcobj->tx.dropped.invalid_rr; \ 2023 _tgtobj->tx.failed_retry_count += \ 2024 _srcobj->tx.failed_retry_count; \ 2025 _tgtobj->tx.retry_count += _srcobj->tx.retry_count; \ 2026 _tgtobj->tx.multiple_retry_count += \ 2027 _srcobj->tx.multiple_retry_count; \ 2028 _tgtobj->tx.tx_success_twt.num += \ 2029 _srcobj->tx.tx_success_twt.num; \ 2030 _tgtobj->tx.tx_success_twt.bytes += \ 2031 _srcobj->tx.tx_success_twt.bytes; \ 2032 _tgtobj->tx.last_tx_ts = _srcobj->tx.last_tx_ts; \ 2033 _tgtobj->tx.release_src_not_tqm += \ 2034 _srcobj->tx.release_src_not_tqm; \ 2035 for (i = 0; i < QDF_PROTO_SUBTYPE_MAX; i++) { \ 2036 _tgtobj->tx.no_ack_count[i] += \ 2037 _srcobj->tx.no_ack_count[i];\ 2038 } \ 2039 \ 2040 _tgtobj->rx.multicast.num += _srcobj->rx.multicast.num; \ 2041 _tgtobj->rx.multicast.bytes += _srcobj->rx.multicast.bytes; \ 2042 _tgtobj->rx.rx_success.num += _srcobj->rx.rx_success.num;\ 2043 _tgtobj->rx.rx_success.bytes += _srcobj->rx.rx_success.bytes;\ 2044 _tgtobj->rx.bcast.num += _srcobj->rx.bcast.num; \ 2045 _tgtobj->rx.bcast.bytes += _srcobj->rx.bcast.bytes; \ 2046 _tgtobj->rx.unicast.num += _srcobj->rx.unicast.num; \ 2047 _tgtobj->rx.unicast.bytes += _srcobj->rx.unicast.bytes; \ 2048 _tgtobj->rx.raw.num += _srcobj->rx.raw.num; \ 2049 _tgtobj->rx.raw.bytes += _srcobj->rx.raw.bytes; \ 2050 _tgtobj->rx.nawds_mcast_drop += _srcobj->rx.nawds_mcast_drop; \ 2051 _tgtobj->rx.mcast_3addr_drop += _srcobj->rx.mcast_3addr_drop; \ 2052 _tgtobj->rx.mec_drop.num += _srcobj->rx.mec_drop.num; \ 2053 _tgtobj->rx.mec_drop.bytes += _srcobj->rx.mec_drop.bytes; \ 2054 _tgtobj->rx.ppeds_drop.num += _srcobj->rx.ppeds_drop.num; \ 2055 _tgtobj->rx.ppeds_drop.bytes += _srcobj->rx.ppeds_drop.bytes; \ 2056 _tgtobj->rx.intra_bss.pkts.num += \ 2057 _srcobj->rx.intra_bss.pkts.num; \ 2058 _tgtobj->rx.intra_bss.pkts.bytes += \ 2059 _srcobj->rx.intra_bss.pkts.bytes; \ 2060 _tgtobj->rx.intra_bss.fail.num += \ 2061 _srcobj->rx.intra_bss.fail.num; \ 2062 _tgtobj->rx.intra_bss.fail.bytes += \ 2063 _srcobj->rx.intra_bss.fail.bytes; \ 2064 _tgtobj->rx.intra_bss.mdns_no_fwd += \ 2065 _srcobj->rx.intra_bss.mdns_no_fwd; \ 2066 _tgtobj->rx.err.mic_err += _srcobj->rx.err.mic_err; \ 2067 _tgtobj->rx.err.decrypt_err += _srcobj->rx.err.decrypt_err; \ 2068 _tgtobj->rx.err.fcserr += _srcobj->rx.err.fcserr; \ 2069 _tgtobj->rx.err.pn_err += _srcobj->rx.err.pn_err; \ 2070 _tgtobj->rx.err.oor_err += _srcobj->rx.err.oor_err; \ 2071 _tgtobj->rx.err.jump_2k_err += _srcobj->rx.err.jump_2k_err; \ 2072 _tgtobj->rx.err.rxdma_wifi_parse_err += \ 2073 _srcobj->rx.err.rxdma_wifi_parse_err; \ 2074 _tgtobj->rx.non_amsdu_cnt += _srcobj->rx.non_amsdu_cnt; \ 2075 _tgtobj->rx.amsdu_cnt += _srcobj->rx.amsdu_cnt; \ 2076 _tgtobj->rx.rx_retries += _srcobj->rx.rx_retries; \ 2077 _tgtobj->rx.multipass_rx_pkt_drop += \ 2078 _srcobj->rx.multipass_rx_pkt_drop; \ 2079 _tgtobj->rx.peer_unauth_rx_pkt_drop += \ 2080 _srcobj->rx.peer_unauth_rx_pkt_drop; \ 2081 _tgtobj->rx.policy_check_drop += \ 2082 _srcobj->rx.policy_check_drop; \ 2083 _tgtobj->rx.to_stack_twt.num += _srcobj->rx.to_stack_twt.num; \ 2084 _tgtobj->rx.to_stack_twt.bytes += \ 2085 _srcobj->rx.to_stack_twt.bytes; \ 2086 _tgtobj->rx.last_rx_ts = _srcobj->rx.last_rx_ts; \ 2087 for (i = 0; i < CDP_MAX_RX_RINGS; i++) { \ 2088 _tgtobj->rx.rcvd_reo[i].num += \ 2089 _srcobj->rx.rcvd_reo[i].num; \ 2090 _tgtobj->rx.rcvd_reo[i].bytes += \ 2091 _srcobj->rx.rcvd_reo[i].bytes; \ 2092 _tgtobj->rx.rcvd.num += \ 2093 _srcobj->rx.rcvd_reo[i].num; \ 2094 _tgtobj->rx.rcvd.bytes += \ 2095 _srcobj->rx.rcvd_reo[i].bytes; \ 2096 } \ 2097 for (i = 0; i < CDP_MAX_LMACS; i++) { \ 2098 _tgtobj->rx.rx_lmac[i].num += \ 2099 _srcobj->rx.rx_lmac[i].num; \ 2100 _tgtobj->rx.rx_lmac[i].bytes += \ 2101 _srcobj->rx.rx_lmac[i].bytes; \ 2102 } \ 2103 DP_IPA_UPDATE_PER_PKT_RX_STATS(_tgtobj, _srcobj); \ 2104 DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj); \ 2105 } while (0) 2106 2107 #define DP_UPDATE_EXTD_STATS(_tgtobj, _srcobj) \ 2108 do { \ 2109 uint8_t i, pream_type, mu_type; \ 2110 _tgtobj->tx.stbc += _srcobj->tx.stbc; \ 2111 _tgtobj->tx.ldpc += _srcobj->tx.ldpc; \ 2112 _tgtobj->tx.retries += _srcobj->tx.retries; \ 2113 _tgtobj->tx.ampdu_cnt += _srcobj->tx.ampdu_cnt; \ 2114 _tgtobj->tx.non_ampdu_cnt += _srcobj->tx.non_ampdu_cnt; \ 2115 _tgtobj->tx.num_ppdu_cookie_valid += \ 2116 _srcobj->tx.num_ppdu_cookie_valid; \ 2117 _tgtobj->tx.tx_ppdus += _srcobj->tx.tx_ppdus; \ 2118 _tgtobj->tx.tx_mpdus_success += _srcobj->tx.tx_mpdus_success; \ 2119 _tgtobj->tx.tx_mpdus_tried += _srcobj->tx.tx_mpdus_tried; \ 2120 _tgtobj->tx.tx_rate = _srcobj->tx.tx_rate; \ 2121 _tgtobj->tx.last_tx_rate = _srcobj->tx.last_tx_rate; \ 2122 _tgtobj->tx.last_tx_rate_mcs = _srcobj->tx.last_tx_rate_mcs; \ 2123 _tgtobj->tx.mcast_last_tx_rate = \ 2124 _srcobj->tx.mcast_last_tx_rate; \ 2125 _tgtobj->tx.mcast_last_tx_rate_mcs = \ 2126 _srcobj->tx.mcast_last_tx_rate_mcs; \ 2127 _tgtobj->tx.rnd_avg_tx_rate = _srcobj->tx.rnd_avg_tx_rate; \ 2128 _tgtobj->tx.avg_tx_rate = _srcobj->tx.avg_tx_rate; \ 2129 _tgtobj->tx.tx_ratecode = _srcobj->tx.tx_ratecode; \ 2130 _tgtobj->tx.pream_punct_cnt += _srcobj->tx.pream_punct_cnt; \ 2131 _tgtobj->tx.ru_start = _srcobj->tx.ru_start; \ 2132 _tgtobj->tx.ru_tones = _srcobj->tx.ru_tones; \ 2133 _tgtobj->tx.last_ack_rssi = _srcobj->tx.last_ack_rssi; \ 2134 _tgtobj->tx.nss_info = _srcobj->tx.nss_info; \ 2135 _tgtobj->tx.mcs_info = _srcobj->tx.mcs_info; \ 2136 _tgtobj->tx.bw_info = _srcobj->tx.bw_info; \ 2137 _tgtobj->tx.gi_info = _srcobj->tx.gi_info; \ 2138 _tgtobj->tx.preamble_info = _srcobj->tx.preamble_info; \ 2139 _tgtobj->tx.retries_mpdu += _srcobj->tx.retries_mpdu; \ 2140 _tgtobj->tx.mpdu_success_with_retries += \ 2141 _srcobj->tx.mpdu_success_with_retries; \ 2142 _tgtobj->tx.rts_success = _srcobj->tx.rts_success; \ 2143 _tgtobj->tx.rts_failure = _srcobj->tx.rts_failure; \ 2144 _tgtobj->tx.bar_cnt = _srcobj->tx.bar_cnt; \ 2145 _tgtobj->tx.ndpa_cnt = _srcobj->tx.ndpa_cnt; \ 2146 for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \ 2147 for (i = 0; i < MAX_MCS; i++) \ 2148 _tgtobj->tx.pkt_type[pream_type].mcs_count[i] += \ 2149 _srcobj->tx.pkt_type[pream_type].mcs_count[i]; \ 2150 } \ 2151 for (i = 0; i < WME_AC_MAX; i++) { \ 2152 _tgtobj->tx.wme_ac_type[i] += _srcobj->tx.wme_ac_type[i]; \ 2153 _tgtobj->tx.wme_ac_type_bytes[i] += \ 2154 _srcobj->tx.wme_ac_type_bytes[i]; \ 2155 _tgtobj->tx.excess_retries_per_ac[i] += \ 2156 _srcobj->tx.excess_retries_per_ac[i]; \ 2157 } \ 2158 for (i = 0; i < MAX_GI; i++) { \ 2159 _tgtobj->tx.sgi_count[i] += _srcobj->tx.sgi_count[i]; \ 2160 } \ 2161 for (i = 0; i < SS_COUNT; i++) { \ 2162 _tgtobj->tx.nss[i] += _srcobj->tx.nss[i]; \ 2163 } \ 2164 for (i = 0; i < MAX_BW; i++) { \ 2165 _tgtobj->tx.bw[i] += _srcobj->tx.bw[i]; \ 2166 } \ 2167 for (i = 0; i < MAX_RU_LOCATIONS; i++) { \ 2168 _tgtobj->tx.ru_loc[i].num_msdu += \ 2169 _srcobj->tx.ru_loc[i].num_msdu; \ 2170 _tgtobj->tx.ru_loc[i].num_mpdu += \ 2171 _srcobj->tx.ru_loc[i].num_mpdu; \ 2172 _tgtobj->tx.ru_loc[i].mpdu_tried += \ 2173 _srcobj->tx.ru_loc[i].mpdu_tried; \ 2174 } \ 2175 for (i = 0; i < MAX_TRANSMIT_TYPES; i++) { \ 2176 _tgtobj->tx.transmit_type[i].num_msdu += \ 2177 _srcobj->tx.transmit_type[i].num_msdu; \ 2178 _tgtobj->tx.transmit_type[i].num_mpdu += \ 2179 _srcobj->tx.transmit_type[i].num_mpdu; \ 2180 _tgtobj->tx.transmit_type[i].mpdu_tried += \ 2181 _srcobj->tx.transmit_type[i].mpdu_tried; \ 2182 } \ 2183 for (i = 0; i < MAX_MU_GROUP_ID; i++) { \ 2184 _tgtobj->tx.mu_group_id[i] = _srcobj->tx.mu_group_id[i]; \ 2185 } \ 2186 _tgtobj->tx.tx_ucast_total.num += \ 2187 _srcobj->tx.tx_ucast_total.num;\ 2188 _tgtobj->tx.tx_ucast_total.bytes += \ 2189 _srcobj->tx.tx_ucast_total.bytes;\ 2190 _tgtobj->tx.tx_ucast_success.num += \ 2191 _srcobj->tx.tx_ucast_success.num; \ 2192 _tgtobj->tx.tx_ucast_success.bytes += \ 2193 _srcobj->tx.tx_ucast_success.bytes; \ 2194 \ 2195 for (i = 0; i < CDP_RSSI_CHAIN_LEN; i++) \ 2196 _tgtobj->tx.rssi_chain[i] = _srcobj->tx.rssi_chain[i]; \ 2197 _tgtobj->rx.mpdu_cnt_fcs_ok += _srcobj->rx.mpdu_cnt_fcs_ok; \ 2198 _tgtobj->rx.mpdu_cnt_fcs_err += _srcobj->rx.mpdu_cnt_fcs_err; \ 2199 _tgtobj->rx.non_ampdu_cnt += _srcobj->rx.non_ampdu_cnt; \ 2200 _tgtobj->rx.ampdu_cnt += _srcobj->rx.ampdu_cnt; \ 2201 _tgtobj->rx.rx_mpdus += _srcobj->rx.rx_mpdus; \ 2202 _tgtobj->rx.rx_ppdus += _srcobj->rx.rx_ppdus; \ 2203 _tgtobj->rx.rx_rate = _srcobj->rx.rx_rate; \ 2204 _tgtobj->rx.last_rx_rate = _srcobj->rx.last_rx_rate; \ 2205 _tgtobj->rx.rnd_avg_rx_rate = _srcobj->rx.rnd_avg_rx_rate; \ 2206 _tgtobj->rx.avg_rx_rate = _srcobj->rx.avg_rx_rate; \ 2207 _tgtobj->rx.rx_ratecode = _srcobj->rx.rx_ratecode; \ 2208 _tgtobj->rx.avg_snr = _srcobj->rx.avg_snr; \ 2209 _tgtobj->rx.rx_snr_measured_time = \ 2210 _srcobj->rx.rx_snr_measured_time; \ 2211 _tgtobj->rx.snr = _srcobj->rx.snr; \ 2212 _tgtobj->rx.last_snr = _srcobj->rx.last_snr; \ 2213 _tgtobj->rx.nss_info = _srcobj->rx.nss_info; \ 2214 _tgtobj->rx.mcs_info = _srcobj->rx.mcs_info; \ 2215 _tgtobj->rx.bw_info = _srcobj->rx.bw_info; \ 2216 _tgtobj->rx.gi_info = _srcobj->rx.gi_info; \ 2217 _tgtobj->rx.preamble_info = _srcobj->rx.preamble_info; \ 2218 _tgtobj->rx.mpdu_retry_cnt += _srcobj->rx.mpdu_retry_cnt; \ 2219 _tgtobj->rx.bar_cnt = _srcobj->rx.bar_cnt; \ 2220 _tgtobj->rx.ndpa_cnt = _srcobj->rx.ndpa_cnt; \ 2221 for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \ 2222 for (i = 0; i < MAX_MCS; i++) { \ 2223 _tgtobj->rx.pkt_type[pream_type].mcs_count[i] += \ 2224 _srcobj->rx.pkt_type[pream_type].mcs_count[i]; \ 2225 } \ 2226 } \ 2227 for (i = 0; i < WME_AC_MAX; i++) { \ 2228 _tgtobj->rx.wme_ac_type[i] += _srcobj->rx.wme_ac_type[i]; \ 2229 _tgtobj->rx.wme_ac_type_bytes[i] += \ 2230 _srcobj->rx.wme_ac_type_bytes[i]; \ 2231 } \ 2232 for (i = 0; i < MAX_MCS; i++) { \ 2233 _tgtobj->rx.su_ax_ppdu_cnt.mcs_count[i] += \ 2234 _srcobj->rx.su_ax_ppdu_cnt.mcs_count[i]; \ 2235 _tgtobj->rx.rx_mpdu_cnt[i] += _srcobj->rx.rx_mpdu_cnt[i]; \ 2236 } \ 2237 for (mu_type = 0 ; mu_type < TXRX_TYPE_MU_MAX; mu_type++) { \ 2238 _tgtobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_ok += \ 2239 _srcobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_ok; \ 2240 _tgtobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_err += \ 2241 _srcobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_err; \ 2242 for (i = 0; i < SS_COUNT; i++) \ 2243 _tgtobj->rx.rx_mu[mu_type].ppdu_nss[i] += \ 2244 _srcobj->rx.rx_mu[mu_type].ppdu_nss[i]; \ 2245 for (i = 0; i < MAX_MCS; i++) \ 2246 _tgtobj->rx.rx_mu[mu_type].ppdu.mcs_count[i] += \ 2247 _srcobj->rx.rx_mu[mu_type].ppdu.mcs_count[i]; \ 2248 } \ 2249 for (i = 0; i < MAX_RECEPTION_TYPES; i++) { \ 2250 _tgtobj->rx.reception_type[i] += \ 2251 _srcobj->rx.reception_type[i]; \ 2252 _tgtobj->rx.ppdu_cnt[i] += _srcobj->rx.ppdu_cnt[i]; \ 2253 } \ 2254 for (i = 0; i < MAX_GI; i++) { \ 2255 _tgtobj->rx.sgi_count[i] += _srcobj->rx.sgi_count[i]; \ 2256 } \ 2257 for (i = 0; i < SS_COUNT; i++) { \ 2258 _tgtobj->rx.nss[i] += _srcobj->rx.nss[i]; \ 2259 _tgtobj->rx.ppdu_nss[i] += _srcobj->rx.ppdu_nss[i]; \ 2260 } \ 2261 for (i = 0; i < MAX_BW; i++) { \ 2262 _tgtobj->rx.bw[i] += _srcobj->rx.bw[i]; \ 2263 } \ 2264 DP_UPDATE_11BE_STATS(_tgtobj, _srcobj); \ 2265 } while (0) 2266 2267 #define DP_UPDATE_VDEV_STATS_FOR_UNMAPPED_PEERS(_tgtobj, _srcobj) \ 2268 do { \ 2269 DP_UPDATE_BASIC_STATS(_tgtobj, _srcobj); \ 2270 DP_UPDATE_PER_PKT_STATS(_tgtobj, _srcobj); \ 2271 DP_UPDATE_EXTD_STATS(_tgtobj, _srcobj); \ 2272 } while (0) 2273 2274 #define DP_UPDATE_RX_INGRESS_STATS(_tgtobj, _srcobj) \ 2275 do { \ 2276 _tgtobj->rx_i.reo_rcvd_pkt.num += \ 2277 _srcobj->rx_i.reo_rcvd_pkt.num; \ 2278 _tgtobj->rx_i.reo_rcvd_pkt.bytes += \ 2279 _srcobj->rx_i.reo_rcvd_pkt.bytes; \ 2280 _tgtobj->rx_i.null_q_desc_pkt.num += \ 2281 _srcobj->rx_i.null_q_desc_pkt.num; \ 2282 _tgtobj->rx_i.null_q_desc_pkt.bytes += \ 2283 _srcobj->rx_i.null_q_desc_pkt.bytes; \ 2284 _tgtobj->rx_i.routed_eapol_pkt.num += \ 2285 _srcobj->rx_i.routed_eapol_pkt.num; \ 2286 _tgtobj->rx_i.routed_eapol_pkt.bytes += \ 2287 _srcobj->rx_i.routed_eapol_pkt.bytes; \ 2288 } while (0) 2289 2290 #define DP_UPDATE_LINK_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type) \ 2291 do { \ 2292 uint8_t i = 0; \ 2293 uint8_t idx = 0; \ 2294 enum dp_pkt_xmit_type temp_xmit_type = _xmit_type; \ 2295 if (temp_xmit_type == DP_XMIT_MLD) { \ 2296 idx = DP_VDEV_XMIT_TYPE; \ 2297 temp_xmit_type = DP_VDEV_XMIT_TYPE; \ 2298 } else if (temp_xmit_type == DP_XMIT_TOTAL) { \ 2299 temp_xmit_type = DP_VDEV_XMIT_TYPE; \ 2300 } \ 2301 for (; idx <= temp_xmit_type; idx++) { \ 2302 _tgtobj->tx_i.rcvd.num += _srcobj->tx_i[idx].rcvd.num; \ 2303 _tgtobj->tx_i.rcvd.bytes += \ 2304 _srcobj->tx_i[idx].rcvd.bytes; \ 2305 _tgtobj->tx_i.rcvd_in_fast_xmit_flow += \ 2306 _srcobj->tx_i[idx].rcvd_in_fast_xmit_flow; \ 2307 for (i = 0; i < CDP_MAX_TX_DATA_RINGS; i++) { \ 2308 _tgtobj->tx_i.rcvd_per_core[i] += \ 2309 _srcobj->tx_i[idx].rcvd_per_core[i]; \ 2310 } \ 2311 _tgtobj->tx_i.processed.num += \ 2312 _srcobj->tx_i[idx].processed.num; \ 2313 _tgtobj->tx_i.processed.bytes += \ 2314 _srcobj->tx_i[idx].processed.bytes; \ 2315 _tgtobj->tx_i.reinject_pkts.num += \ 2316 _srcobj->tx_i[idx].reinject_pkts.num; \ 2317 _tgtobj->tx_i.reinject_pkts.bytes += \ 2318 _srcobj->tx_i[idx].reinject_pkts.bytes; \ 2319 _tgtobj->tx_i.inspect_pkts.num += \ 2320 _srcobj->tx_i[idx].inspect_pkts.num; \ 2321 _tgtobj->tx_i.inspect_pkts.bytes += \ 2322 _srcobj->tx_i[idx].inspect_pkts.bytes; \ 2323 _tgtobj->tx_i.nawds_mcast.num += \ 2324 _srcobj->tx_i[idx].nawds_mcast.num; \ 2325 _tgtobj->tx_i.nawds_mcast.bytes += \ 2326 _srcobj->tx_i[idx].nawds_mcast.bytes; \ 2327 _tgtobj->tx_i.bcast.num += \ 2328 _srcobj->tx_i[idx].bcast.num; \ 2329 _tgtobj->tx_i.bcast.bytes += \ 2330 _srcobj->tx_i[idx].bcast.bytes; \ 2331 _tgtobj->tx_i.raw.raw_pkt.num += \ 2332 _srcobj->tx_i[idx].raw.raw_pkt.num; \ 2333 _tgtobj->tx_i.raw.raw_pkt.bytes += \ 2334 _srcobj->tx_i[idx].raw.raw_pkt.bytes; \ 2335 _tgtobj->tx_i.raw.dma_map_error += \ 2336 _srcobj->tx_i[idx].raw.dma_map_error; \ 2337 _tgtobj->tx_i.raw.invalid_raw_pkt_datatype += \ 2338 _srcobj->tx_i[idx].raw.invalid_raw_pkt_datatype; \ 2339 _tgtobj->tx_i.raw.num_frags_overflow_err += \ 2340 _srcobj->tx_i[idx].raw.num_frags_overflow_err; \ 2341 _tgtobj->tx_i.sg.sg_pkt.num += \ 2342 _srcobj->tx_i[idx].sg.sg_pkt.num; \ 2343 _tgtobj->tx_i.sg.sg_pkt.bytes += \ 2344 _srcobj->tx_i[idx].sg.sg_pkt.bytes; \ 2345 _tgtobj->tx_i.sg.non_sg_pkts.num += \ 2346 _srcobj->tx_i[idx].sg.non_sg_pkts.num; \ 2347 _tgtobj->tx_i.sg.non_sg_pkts.bytes += \ 2348 _srcobj->tx_i[idx].sg.non_sg_pkts.bytes; \ 2349 _tgtobj->tx_i.sg.dropped_host.num += \ 2350 _srcobj->tx_i[idx].sg.dropped_host.num; \ 2351 _tgtobj->tx_i.sg.dropped_host.bytes += \ 2352 _srcobj->tx_i[idx].sg.dropped_host.bytes; \ 2353 _tgtobj->tx_i.sg.dropped_target += \ 2354 _srcobj->tx_i[idx].sg.dropped_target; \ 2355 _tgtobj->tx_i.sg.dma_map_error += \ 2356 _srcobj->tx_i[idx].sg.dma_map_error; \ 2357 _tgtobj->tx_i.mcast_en.mcast_pkt.num += \ 2358 _srcobj->tx_i[idx].mcast_en.mcast_pkt.num; \ 2359 _tgtobj->tx_i.mcast_en.mcast_pkt.bytes += \ 2360 _srcobj->tx_i[idx].mcast_en.mcast_pkt.bytes; \ 2361 _tgtobj->tx_i.mcast_en.dropped_map_error += \ 2362 _srcobj->tx_i[idx].mcast_en.dropped_map_error; \ 2363 _tgtobj->tx_i.mcast_en.dropped_self_mac += \ 2364 _srcobj->tx_i[idx].mcast_en.dropped_self_mac; \ 2365 _tgtobj->tx_i.mcast_en.dropped_send_fail += \ 2366 _srcobj->tx_i[idx].mcast_en.dropped_send_fail; \ 2367 _tgtobj->tx_i.mcast_en.ucast += \ 2368 _srcobj->tx_i[idx].mcast_en.ucast; \ 2369 _tgtobj->tx_i.mcast_en.fail_seg_alloc += \ 2370 _srcobj->tx_i[idx].mcast_en.fail_seg_alloc; \ 2371 _tgtobj->tx_i.mcast_en.clone_fail += \ 2372 _srcobj->tx_i[idx].mcast_en.clone_fail; \ 2373 _tgtobj->tx_i.igmp_mcast_en.igmp_rcvd += \ 2374 _srcobj->tx_i[idx].igmp_mcast_en.igmp_rcvd; \ 2375 _tgtobj->tx_i.igmp_mcast_en.igmp_ucast_converted += \ 2376 _srcobj->tx_i[idx].igmp_mcast_en.igmp_ucast_converted; \ 2377 _tgtobj->tx_i.dropped.desc_na.num += \ 2378 _srcobj->tx_i[idx].dropped.desc_na.num; \ 2379 _tgtobj->tx_i.dropped.desc_na.bytes += \ 2380 _srcobj->tx_i[idx].dropped.desc_na.bytes; \ 2381 _tgtobj->tx_i.dropped.desc_na_exc_alloc_fail.num += \ 2382 _srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.num; \ 2383 _tgtobj->tx_i.dropped.desc_na_exc_alloc_fail.bytes += \ 2384 _srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.bytes; \ 2385 _tgtobj->tx_i.dropped.desc_na_exc_outstand.num += \ 2386 _srcobj->tx_i[idx].dropped.desc_na_exc_outstand.num; \ 2387 _tgtobj->tx_i.dropped.desc_na_exc_outstand.bytes += \ 2388 _srcobj->tx_i[idx].dropped.desc_na_exc_outstand.bytes; \ 2389 _tgtobj->tx_i.dropped.exc_desc_na.num += \ 2390 _srcobj->tx_i[idx].dropped.exc_desc_na.num; \ 2391 _tgtobj->tx_i.dropped.exc_desc_na.bytes += \ 2392 _srcobj->tx_i[idx].dropped.exc_desc_na.bytes; \ 2393 _tgtobj->tx_i.dropped.ring_full += \ 2394 _srcobj->tx_i[idx].dropped.ring_full; \ 2395 _tgtobj->tx_i.dropped.enqueue_fail += \ 2396 _srcobj->tx_i[idx].dropped.enqueue_fail; \ 2397 _tgtobj->tx_i.dropped.dma_error += \ 2398 _srcobj->tx_i[idx].dropped.dma_error; \ 2399 _tgtobj->tx_i.dropped.res_full += \ 2400 _srcobj->tx_i[idx].dropped.res_full; \ 2401 _tgtobj->tx_i.dropped.headroom_insufficient += \ 2402 _srcobj->tx_i[idx].dropped.headroom_insufficient; \ 2403 _tgtobj->tx_i.dropped.fail_per_pkt_vdev_id_check += \ 2404 _srcobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check; \ 2405 _tgtobj->tx_i.dropped.drop_ingress += \ 2406 _srcobj->tx_i[idx].dropped.drop_ingress; \ 2407 _tgtobj->tx_i.dropped.invalid_peer_id_in_exc_path += \ 2408 _srcobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path; \ 2409 _tgtobj->tx_i.dropped.tx_mcast_drop += \ 2410 _srcobj->tx_i[idx].dropped.tx_mcast_drop; \ 2411 _tgtobj->tx_i.dropped.fw2wbm_tx_drop += \ 2412 _srcobj->tx_i[idx].dropped.fw2wbm_tx_drop; \ 2413 _tgtobj->tx_i.dropped.dropped_pkt.bytes += \ 2414 _srcobj->tx_i[idx].dropped.dropped_pkt.bytes; \ 2415 _tgtobj->tx_i.mesh.exception_fw += \ 2416 _srcobj->tx_i[idx].mesh.exception_fw; \ 2417 _tgtobj->tx_i.mesh.completion_fw += \ 2418 _srcobj->tx_i[idx].mesh.completion_fw; \ 2419 _tgtobj->tx_i.cce_classified += \ 2420 _srcobj->tx_i[idx].cce_classified; \ 2421 _tgtobj->tx_i.cce_classified_raw += \ 2422 _srcobj->tx_i[idx].cce_classified_raw; \ 2423 _tgtobj->tx_i.sniffer_rcvd.num += \ 2424 _srcobj->tx_i[idx].sniffer_rcvd.num; \ 2425 _tgtobj->tx_i.sniffer_rcvd.bytes += \ 2426 _srcobj->tx_i[idx].sniffer_rcvd.bytes; \ 2427 } \ 2428 _tgtobj->tx_i.dropped.dropped_pkt.num = \ 2429 _tgtobj->tx_i.dropped.dma_error + \ 2430 _tgtobj->tx_i.dropped.ring_full + \ 2431 _tgtobj->tx_i.dropped.enqueue_fail + \ 2432 _tgtobj->tx_i.dropped.fail_per_pkt_vdev_id_check + \ 2433 _tgtobj->tx_i.dropped.desc_na.num + \ 2434 _tgtobj->tx_i.dropped.res_full + \ 2435 _tgtobj->tx_i.dropped.drop_ingress + \ 2436 _tgtobj->tx_i.dropped.headroom_insufficient + \ 2437 _tgtobj->tx_i.dropped.invalid_peer_id_in_exc_path + \ 2438 _tgtobj->tx_i.dropped.tx_mcast_drop + \ 2439 _tgtobj->tx_i.dropped.fw2wbm_tx_drop; \ 2440 DP_UPDATE_RX_INGRESS_STATS(_tgtobj, _srcobj); \ 2441 } while (0) 2442 2443 #define DP_UPDATE_MLD_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type) \ 2444 do { \ 2445 uint8_t i = 0; \ 2446 uint8_t idx = 0; \ 2447 enum dp_pkt_xmit_type temp_xmit_type = _xmit_type; \ 2448 if (temp_xmit_type == DP_XMIT_MLD) { \ 2449 idx = DP_VDEV_XMIT_TYPE; \ 2450 temp_xmit_type = DP_VDEV_XMIT_TYPE; \ 2451 } else if (temp_xmit_type == DP_XMIT_TOTAL) { \ 2452 temp_xmit_type = DP_VDEV_XMIT_TYPE; \ 2453 } \ 2454 for (; idx <= temp_xmit_type; idx++) { \ 2455 _tgtobj->tx_i[idx].rcvd.num += _srcobj->tx_i[idx].rcvd.num; \ 2456 _tgtobj->tx_i[idx].rcvd.bytes += \ 2457 _srcobj->tx_i[idx].rcvd.bytes; \ 2458 _tgtobj->tx_i[idx].rcvd_in_fast_xmit_flow += \ 2459 _srcobj->tx_i[idx].rcvd_in_fast_xmit_flow; \ 2460 for (i = 0; i < CDP_MAX_TX_DATA_RINGS; i++) { \ 2461 _tgtobj->tx_i[idx].rcvd_per_core[i] += \ 2462 _srcobj->tx_i[idx].rcvd_per_core[i]; \ 2463 } \ 2464 _tgtobj->tx_i[idx].processed.num += \ 2465 _srcobj->tx_i[idx].processed.num; \ 2466 _tgtobj->tx_i[idx].processed.bytes += \ 2467 _srcobj->tx_i[idx].processed.bytes; \ 2468 _tgtobj->tx_i[idx].reinject_pkts.num += \ 2469 _srcobj->tx_i[idx].reinject_pkts.num; \ 2470 _tgtobj->tx_i[idx].reinject_pkts.bytes += \ 2471 _srcobj->tx_i[idx].reinject_pkts.bytes; \ 2472 _tgtobj->tx_i[idx].inspect_pkts.num += \ 2473 _srcobj->tx_i[idx].inspect_pkts.num; \ 2474 _tgtobj->tx_i[idx].inspect_pkts.bytes += \ 2475 _srcobj->tx_i[idx].inspect_pkts.bytes; \ 2476 _tgtobj->tx_i[idx].nawds_mcast.num += \ 2477 _srcobj->tx_i[idx].nawds_mcast.num; \ 2478 _tgtobj->tx_i[idx].nawds_mcast.bytes += \ 2479 _srcobj->tx_i[idx].nawds_mcast.bytes; \ 2480 _tgtobj->tx_i[idx].bcast.num += \ 2481 _srcobj->tx_i[idx].bcast.num; \ 2482 _tgtobj->tx_i[idx].bcast.bytes += \ 2483 _srcobj->tx_i[idx].bcast.bytes; \ 2484 _tgtobj->tx_i[idx].raw.raw_pkt.num += \ 2485 _srcobj->tx_i[idx].raw.raw_pkt.num; \ 2486 _tgtobj->tx_i[idx].raw.raw_pkt.bytes += \ 2487 _srcobj->tx_i[idx].raw.raw_pkt.bytes; \ 2488 _tgtobj->tx_i[idx].raw.dma_map_error += \ 2489 _srcobj->tx_i[idx].raw.dma_map_error; \ 2490 _tgtobj->tx_i[idx].raw.invalid_raw_pkt_datatype += \ 2491 _srcobj->tx_i[idx].raw.invalid_raw_pkt_datatype; \ 2492 _tgtobj->tx_i[idx].raw.num_frags_overflow_err += \ 2493 _srcobj->tx_i[idx].raw.num_frags_overflow_err; \ 2494 _tgtobj->tx_i[idx].sg.sg_pkt.num += \ 2495 _srcobj->tx_i[idx].sg.sg_pkt.num; \ 2496 _tgtobj->tx_i[idx].sg.sg_pkt.bytes += \ 2497 _srcobj->tx_i[idx].sg.sg_pkt.bytes; \ 2498 _tgtobj->tx_i[idx].sg.non_sg_pkts.num += \ 2499 _srcobj->tx_i[idx].sg.non_sg_pkts.num; \ 2500 _tgtobj->tx_i[idx].sg.non_sg_pkts.bytes += \ 2501 _srcobj->tx_i[idx].sg.non_sg_pkts.bytes; \ 2502 _tgtobj->tx_i[idx].sg.dropped_host.num += \ 2503 _srcobj->tx_i[idx].sg.dropped_host.num; \ 2504 _tgtobj->tx_i[idx].sg.dropped_host.bytes += \ 2505 _srcobj->tx_i[idx].sg.dropped_host.bytes; \ 2506 _tgtobj->tx_i[idx].sg.dropped_target += \ 2507 _srcobj->tx_i[idx].sg.dropped_target; \ 2508 _tgtobj->tx_i[idx].sg.dma_map_error += \ 2509 _srcobj->tx_i[idx].sg.dma_map_error; \ 2510 _tgtobj->tx_i[idx].mcast_en.mcast_pkt.num += \ 2511 _srcobj->tx_i[idx].mcast_en.mcast_pkt.num; \ 2512 _tgtobj->tx_i[idx].mcast_en.mcast_pkt.bytes += \ 2513 _srcobj->tx_i[idx].mcast_en.mcast_pkt.bytes; \ 2514 _tgtobj->tx_i[idx].mcast_en.dropped_map_error += \ 2515 _srcobj->tx_i[idx].mcast_en.dropped_map_error; \ 2516 _tgtobj->tx_i[idx].mcast_en.dropped_self_mac += \ 2517 _srcobj->tx_i[idx].mcast_en.dropped_self_mac; \ 2518 _tgtobj->tx_i[idx].mcast_en.dropped_send_fail += \ 2519 _srcobj->tx_i[idx].mcast_en.dropped_send_fail; \ 2520 _tgtobj->tx_i[idx].mcast_en.ucast += \ 2521 _srcobj->tx_i[idx].mcast_en.ucast; \ 2522 _tgtobj->tx_i[idx].mcast_en.fail_seg_alloc += \ 2523 _srcobj->tx_i[idx].mcast_en.fail_seg_alloc; \ 2524 _tgtobj->tx_i[idx].mcast_en.clone_fail += \ 2525 _srcobj->tx_i[idx].mcast_en.clone_fail; \ 2526 _tgtobj->tx_i[idx].igmp_mcast_en.igmp_rcvd += \ 2527 _srcobj->tx_i[idx].igmp_mcast_en.igmp_rcvd; \ 2528 _tgtobj->tx_i[idx].igmp_mcast_en.igmp_ucast_converted += \ 2529 _srcobj->tx_i[idx].igmp_mcast_en.igmp_ucast_converted; \ 2530 _tgtobj->tx_i[idx].dropped.desc_na.num += \ 2531 _srcobj->tx_i[idx].dropped.desc_na.num; \ 2532 _tgtobj->tx_i[idx].dropped.desc_na.bytes += \ 2533 _srcobj->tx_i[idx].dropped.desc_na.bytes; \ 2534 _tgtobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.num += \ 2535 _srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.num; \ 2536 _tgtobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.bytes += \ 2537 _srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.bytes; \ 2538 _tgtobj->tx_i[idx].dropped.desc_na_exc_outstand.num += \ 2539 _srcobj->tx_i[idx].dropped.desc_na_exc_outstand.num; \ 2540 _tgtobj->tx_i[idx].dropped.desc_na_exc_outstand.bytes += \ 2541 _srcobj->tx_i[idx].dropped.desc_na_exc_outstand.bytes; \ 2542 _tgtobj->tx_i[idx].dropped.exc_desc_na.num += \ 2543 _srcobj->tx_i[idx].dropped.exc_desc_na.num; \ 2544 _tgtobj->tx_i[idx].dropped.exc_desc_na.bytes += \ 2545 _srcobj->tx_i[idx].dropped.exc_desc_na.bytes; \ 2546 _tgtobj->tx_i[idx].dropped.ring_full += \ 2547 _srcobj->tx_i[idx].dropped.ring_full; \ 2548 _tgtobj->tx_i[idx].dropped.enqueue_fail += \ 2549 _srcobj->tx_i[idx].dropped.enqueue_fail; \ 2550 _tgtobj->tx_i[idx].dropped.dma_error += \ 2551 _srcobj->tx_i[idx].dropped.dma_error; \ 2552 _tgtobj->tx_i[idx].dropped.res_full += \ 2553 _srcobj->tx_i[idx].dropped.res_full; \ 2554 _tgtobj->tx_i[idx].dropped.headroom_insufficient += \ 2555 _srcobj->tx_i[idx].dropped.headroom_insufficient; \ 2556 _tgtobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check += \ 2557 _srcobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check; \ 2558 _tgtobj->tx_i[idx].dropped.drop_ingress += \ 2559 _srcobj->tx_i[idx].dropped.drop_ingress; \ 2560 _tgtobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path += \ 2561 _srcobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path; \ 2562 _tgtobj->tx_i[idx].dropped.tx_mcast_drop += \ 2563 _srcobj->tx_i[idx].dropped.tx_mcast_drop; \ 2564 _tgtobj->tx_i[idx].dropped.fw2wbm_tx_drop += \ 2565 _srcobj->tx_i[idx].dropped.fw2wbm_tx_drop; \ 2566 _tgtobj->tx_i[idx].dropped.dropped_pkt.bytes += \ 2567 _srcobj->tx_i[idx].dropped.dropped_pkt.bytes; \ 2568 _tgtobj->tx_i[idx].mesh.exception_fw += \ 2569 _srcobj->tx_i[idx].mesh.exception_fw; \ 2570 _tgtobj->tx_i[idx].mesh.completion_fw += \ 2571 _srcobj->tx_i[idx].mesh.completion_fw; \ 2572 _tgtobj->tx_i[idx].cce_classified += \ 2573 _srcobj->tx_i[idx].cce_classified; \ 2574 _tgtobj->tx_i[idx].cce_classified_raw += \ 2575 _srcobj->tx_i[idx].cce_classified_raw; \ 2576 _tgtobj->tx_i[idx].sniffer_rcvd.num += \ 2577 _srcobj->tx_i[idx].sniffer_rcvd.num; \ 2578 _tgtobj->tx_i[idx].sniffer_rcvd.bytes += \ 2579 _srcobj->tx_i[idx].sniffer_rcvd.bytes; \ 2580 _tgtobj->tx_i[idx].dropped.dropped_pkt.num = \ 2581 _tgtobj->tx_i[idx].dropped.dma_error + \ 2582 _tgtobj->tx_i[idx].dropped.ring_full + \ 2583 _tgtobj->tx_i[idx].dropped.enqueue_fail + \ 2584 _tgtobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check + \ 2585 _tgtobj->tx_i[idx].dropped.desc_na.num + \ 2586 _tgtobj->tx_i[idx].dropped.res_full + \ 2587 _tgtobj->tx_i[idx].dropped.drop_ingress + \ 2588 _tgtobj->tx_i[idx].dropped.headroom_insufficient + \ 2589 _tgtobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path + \ 2590 _tgtobj->tx_i[idx].dropped.tx_mcast_drop + \ 2591 _tgtobj->tx_i[idx].dropped.fw2wbm_tx_drop; \ 2592 } \ 2593 DP_UPDATE_RX_INGRESS_STATS(_tgtobj, _srcobj); \ 2594 } while (0) 2595 2596 #define DP_UPDATE_TO_MLD_VDEV_STATS(_tgtobj, _srcobj, _xmit_type) \ 2597 do { \ 2598 DP_UPDATE_MLD_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type); \ 2599 DP_UPDATE_VDEV_STATS_FOR_UNMAPPED_PEERS(_tgtobj, _srcobj); \ 2600 } while (0) 2601 2602 #define DP_UPDATE_TO_LINK_VDEV_STATS(_tgtobj, _srcobj, _xmit_type) \ 2603 do { \ 2604 DP_UPDATE_LINK_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type); \ 2605 DP_UPDATE_VDEV_STATS_FOR_UNMAPPED_PEERS(_tgtobj, _srcobj); \ 2606 } while (0) 2607 /** 2608 * dp_peer_find_attach() - Allocates memory for peer objects 2609 * @soc: SoC handle 2610 * 2611 * Return: QDF_STATUS 2612 */ 2613 QDF_STATUS dp_peer_find_attach(struct dp_soc *soc); 2614 2615 /** 2616 * dp_peer_find_detach() - Frees memory for peer objects 2617 * @soc: SoC handle 2618 * 2619 * Return: none 2620 */ 2621 void dp_peer_find_detach(struct dp_soc *soc); 2622 2623 /** 2624 * dp_peer_find_hash_add() - add peer to peer_hash_table 2625 * @soc: soc handle 2626 * @peer: peer handle 2627 * 2628 * Return: none 2629 */ 2630 void dp_peer_find_hash_add(struct dp_soc *soc, struct dp_peer *peer); 2631 2632 /** 2633 * dp_peer_find_hash_remove() - remove peer from peer_hash_table 2634 * @soc: soc handle 2635 * @peer: peer handle 2636 * 2637 * Return: none 2638 */ 2639 void dp_peer_find_hash_remove(struct dp_soc *soc, struct dp_peer *peer); 2640 2641 /* unused?? */ 2642 void dp_peer_find_hash_erase(struct dp_soc *soc); 2643 2644 /** 2645 * dp_peer_vdev_list_add() - add peer into vdev's peer list 2646 * @soc: soc handle 2647 * @vdev: vdev handle 2648 * @peer: peer handle 2649 * 2650 * Return: none 2651 */ 2652 void dp_peer_vdev_list_add(struct dp_soc *soc, struct dp_vdev *vdev, 2653 struct dp_peer *peer); 2654 2655 /** 2656 * dp_peer_vdev_list_remove() - remove peer from vdev's peer list 2657 * @soc: SoC handle 2658 * @vdev: VDEV handle 2659 * @peer: peer handle 2660 * 2661 * Return: none 2662 */ 2663 void dp_peer_vdev_list_remove(struct dp_soc *soc, struct dp_vdev *vdev, 2664 struct dp_peer *peer); 2665 2666 /** 2667 * dp_peer_find_id_to_obj_add() - Add peer into peer_id table 2668 * @soc: SoC handle 2669 * @peer: peer handle 2670 * @peer_id: peer_id 2671 * 2672 * Return: None 2673 */ 2674 void dp_peer_find_id_to_obj_add(struct dp_soc *soc, 2675 struct dp_peer *peer, 2676 uint16_t peer_id); 2677 2678 /** 2679 * dp_txrx_peer_attach_add() - Attach txrx_peer and add it to peer_id table 2680 * @soc: SoC handle 2681 * @peer: peer handle 2682 * @txrx_peer: txrx peer handle 2683 * 2684 * Return: None 2685 */ 2686 void dp_txrx_peer_attach_add(struct dp_soc *soc, 2687 struct dp_peer *peer, 2688 struct dp_txrx_peer *txrx_peer); 2689 2690 /** 2691 * dp_peer_find_id_to_obj_remove() - remove peer from peer_id table 2692 * @soc: SoC handle 2693 * @peer_id: peer_id 2694 * 2695 * Return: None 2696 */ 2697 void dp_peer_find_id_to_obj_remove(struct dp_soc *soc, 2698 uint16_t peer_id); 2699 2700 /** 2701 * dp_vdev_unref_delete() - check and process vdev delete 2702 * @soc: DP specific soc pointer 2703 * @vdev: DP specific vdev pointer 2704 * @mod_id: module id 2705 * 2706 */ 2707 void dp_vdev_unref_delete(struct dp_soc *soc, struct dp_vdev *vdev, 2708 enum dp_mod_id mod_id); 2709 2710 /** 2711 * dp_peer_ppdu_delayed_ba_cleanup() - free ppdu allocated in peer 2712 * @peer: Datapath peer 2713 * 2714 * Return: void 2715 */ 2716 void dp_peer_ppdu_delayed_ba_cleanup(struct dp_peer *peer); 2717 2718 /** 2719 * dp_peer_rx_init() - Initialize receive TID state 2720 * @pdev: Datapath pdev 2721 * @peer: Datapath peer 2722 * 2723 */ 2724 void dp_peer_rx_init(struct dp_pdev *pdev, struct dp_peer *peer); 2725 2726 /** 2727 * dp_peer_rx_init_wrapper() - Initialize receive TID state, based on peer type 2728 * @pdev: Datapath pdev 2729 * @peer: Datapath peer 2730 * @setup_info: setup info received for setting up the peer 2731 * 2732 * Return: None 2733 */ 2734 void dp_peer_rx_init_wrapper(struct dp_pdev *pdev, struct dp_peer *peer, 2735 struct cdp_peer_setup_info *setup_info); 2736 2737 /** 2738 * dp_peer_cleanup() - Cleanup peer information 2739 * @vdev: Datapath vdev 2740 * @peer: Datapath peer 2741 * 2742 */ 2743 void dp_peer_cleanup(struct dp_vdev *vdev, struct dp_peer *peer); 2744 2745 #ifdef DP_PEER_EXTENDED_API 2746 /** 2747 * dp_register_peer() - Register peer into physical device 2748 * @soc_hdl: data path soc handle 2749 * @pdev_id: device instance id 2750 * @sta_desc: peer description 2751 * 2752 * Register peer into physical device 2753 * 2754 * Return: QDF_STATUS_SUCCESS registration success 2755 * QDF_STATUS_E_FAULT peer not found 2756 */ 2757 QDF_STATUS dp_register_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 2758 struct ol_txrx_desc_type *sta_desc); 2759 2760 /** 2761 * dp_clear_peer() - remove peer from physical device 2762 * @soc_hdl: data path soc handle 2763 * @pdev_id: device instance id 2764 * @peer_addr: peer mac address 2765 * 2766 * remove peer from physical device 2767 * 2768 * Return: QDF_STATUS_SUCCESS registration success 2769 * QDF_STATUS_E_FAULT peer not found 2770 */ 2771 QDF_STATUS dp_clear_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 2772 struct qdf_mac_addr peer_addr); 2773 2774 /** 2775 * dp_find_peer_exist_on_vdev - find if peer exists on the given vdev 2776 * @soc_hdl: datapath soc handle 2777 * @vdev_id: vdev instance id 2778 * @peer_addr: peer mac address 2779 * 2780 * Return: true or false 2781 */ 2782 bool dp_find_peer_exist_on_vdev(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 2783 uint8_t *peer_addr); 2784 2785 /** 2786 * dp_find_peer_exist_on_other_vdev - find if peer exists 2787 * on other than the given vdev 2788 * @soc_hdl: datapath soc handle 2789 * @vdev_id: vdev instance id 2790 * @peer_addr: peer mac address 2791 * @max_bssid: max number of bssids 2792 * 2793 * Return: true or false 2794 */ 2795 bool dp_find_peer_exist_on_other_vdev(struct cdp_soc_t *soc_hdl, 2796 uint8_t vdev_id, uint8_t *peer_addr, 2797 uint16_t max_bssid); 2798 2799 /** 2800 * dp_peer_state_update() - update peer local state 2801 * @soc: datapath soc handle 2802 * @peer_mac: peer mac address 2803 * @state: new peer local state 2804 * 2805 * update peer local state 2806 * 2807 * Return: QDF_STATUS_SUCCESS registration success 2808 */ 2809 QDF_STATUS dp_peer_state_update(struct cdp_soc_t *soc, uint8_t *peer_mac, 2810 enum ol_txrx_peer_state state); 2811 2812 /** 2813 * dp_get_vdevid() - Get virtual interface id which peer registered 2814 * @soc_hdl: datapath soc handle 2815 * @peer_mac: peer mac address 2816 * @vdev_id: virtual interface id which peer registered 2817 * 2818 * Get virtual interface id which peer registered 2819 * 2820 * Return: QDF_STATUS_SUCCESS registration success 2821 */ 2822 QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac, 2823 uint8_t *vdev_id); 2824 2825 struct cdp_vdev *dp_get_vdev_by_peer_addr(struct cdp_pdev *pdev_handle, 2826 struct qdf_mac_addr peer_addr); 2827 2828 /** 2829 * dp_get_vdev_for_peer() - Get virtual interface instance which peer belongs 2830 * @peer: peer instance 2831 * 2832 * Get virtual interface instance which peer belongs 2833 * 2834 * Return: virtual interface instance pointer 2835 * NULL in case cannot find 2836 */ 2837 struct cdp_vdev *dp_get_vdev_for_peer(void *peer); 2838 2839 /** 2840 * dp_peer_get_peer_mac_addr() - Get peer mac address 2841 * @peer: peer instance 2842 * 2843 * Get peer mac address 2844 * 2845 * Return: peer mac address pointer 2846 * NULL in case cannot find 2847 */ 2848 uint8_t *dp_peer_get_peer_mac_addr(void *peer); 2849 2850 /** 2851 * dp_get_peer_state() - Get local peer state 2852 * @soc: datapath soc handle 2853 * @vdev_id: vdev id 2854 * @peer_mac: peer mac addr 2855 * @slowpath: call from slowpath or not 2856 * 2857 * Get local peer state 2858 * 2859 * Return: peer status 2860 */ 2861 int dp_get_peer_state(struct cdp_soc_t *soc, uint8_t vdev_id, 2862 uint8_t *peer_mac, bool slowpath); 2863 2864 /** 2865 * dp_local_peer_id_pool_init() - local peer id pool alloc for physical device 2866 * @pdev: data path device instance 2867 * 2868 * local peer id pool alloc for physical device 2869 * 2870 * Return: none 2871 */ 2872 void dp_local_peer_id_pool_init(struct dp_pdev *pdev); 2873 2874 /** 2875 * dp_local_peer_id_alloc() - allocate local peer id 2876 * @pdev: data path device instance 2877 * @peer: new peer instance 2878 * 2879 * allocate local peer id 2880 * 2881 * Return: none 2882 */ 2883 void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer); 2884 2885 /** 2886 * dp_local_peer_id_free() - remove local peer id 2887 * @pdev: data path device instance 2888 * @peer: peer instance should be removed 2889 * 2890 * remove local peer id 2891 * 2892 * Return: none 2893 */ 2894 void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer); 2895 2896 /** 2897 * dp_set_peer_as_tdls_peer() - set tdls peer flag to peer 2898 * @soc_hdl: datapath soc handle 2899 * @vdev_id: vdev_id 2900 * @peer_mac: peer mac addr 2901 * @val: tdls peer flag 2902 * 2903 * Return: none 2904 */ 2905 void dp_set_peer_as_tdls_peer(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 2906 uint8_t *peer_mac, bool val); 2907 #else 2908 static inline 2909 QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac, 2910 uint8_t *vdev_id) 2911 { 2912 return QDF_STATUS_E_NOSUPPORT; 2913 } 2914 2915 static inline void dp_local_peer_id_pool_init(struct dp_pdev *pdev) 2916 { 2917 } 2918 2919 static inline 2920 void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer) 2921 { 2922 } 2923 2924 static inline 2925 void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer) 2926 { 2927 } 2928 2929 static inline 2930 void dp_set_peer_as_tdls_peer(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 2931 uint8_t *peer_mac, bool val) 2932 { 2933 } 2934 #endif 2935 2936 /** 2937 * dp_find_peer_exist - find peer if already exists 2938 * @soc_hdl: datapath soc handle 2939 * @pdev_id: physical device instance id 2940 * @peer_addr: peer mac address 2941 * 2942 * Return: true or false 2943 */ 2944 bool dp_find_peer_exist(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 2945 uint8_t *peer_addr); 2946 2947 #ifdef DP_UMAC_HW_RESET_SUPPORT 2948 /** 2949 * dp_pause_reo_send_cmd() - Pause Reo send commands. 2950 * @soc: dp soc 2951 * 2952 * Return: none 2953 */ 2954 void dp_pause_reo_send_cmd(struct dp_soc *soc); 2955 2956 /** 2957 * dp_resume_reo_send_cmd() - Resume Reo send commands. 2958 * @soc: dp soc 2959 * 2960 * Return: none 2961 */ 2962 void dp_resume_reo_send_cmd(struct dp_soc *soc); 2963 2964 /** 2965 * dp_cleanup_reo_cmd_module - Clean up the reo cmd module 2966 * @soc: DP SoC handle 2967 * 2968 * Return: none 2969 */ 2970 void dp_cleanup_reo_cmd_module(struct dp_soc *soc); 2971 2972 /** 2973 * dp_reo_desc_freelist_destroy() - Flush REO descriptors from deferred freelist 2974 * @soc: DP SOC handle 2975 * 2976 * Return: none 2977 */ 2978 void dp_reo_desc_freelist_destroy(struct dp_soc *soc); 2979 2980 /** 2981 * dp_reset_rx_reo_tid_queue() - Reset the reo tid queues 2982 * @soc: dp soc 2983 * @hw_qdesc_vaddr: starting address of the tid queues 2984 * @size: size of the memory pointed to by hw_qdesc_vaddr 2985 * 2986 * Return: none 2987 */ 2988 void dp_reset_rx_reo_tid_queue(struct dp_soc *soc, void *hw_qdesc_vaddr, 2989 uint32_t size); 2990 2991 2992 static inline void dp_umac_reset_trigger_pre_reset_notify_cb(struct dp_soc *soc) 2993 { 2994 notify_pre_reset_fw_callback callback = soc->notify_fw_callback; 2995 2996 if (callback) 2997 callback(soc); 2998 } 2999 3000 /** 3001 * dp_reset_global_tx_desc_cleanup_flag() - Reset cleanup needed flag 3002 * @soc: dp soc handle 3003 * 3004 * Return: None 3005 */ 3006 void dp_reset_global_tx_desc_cleanup_flag(struct dp_soc *soc); 3007 3008 /** 3009 * dp_get_global_tx_desc_cleanup_flag() - Get cleanup needed flag 3010 * @soc: dp soc handle 3011 * 3012 * Return: cleanup needed/ not needed 3013 */ 3014 bool dp_get_global_tx_desc_cleanup_flag(struct dp_soc *soc); 3015 3016 3017 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 3018 /** 3019 * dp_umac_reset_complete_umac_recovery() - Complete Umac reset session 3020 * @soc: dp soc handle 3021 * 3022 * Return: void 3023 */ 3024 void dp_umac_reset_complete_umac_recovery(struct dp_soc *soc); 3025 3026 /** 3027 * dp_umac_reset_initiate_umac_recovery() - Initiate Umac reset session 3028 * @soc: dp soc handle 3029 * @umac_reset_ctx: Umac reset context 3030 * @rx_event: Rx event received 3031 * @is_target_recovery: Flag to indicate if it is triggered for target recovery 3032 * 3033 * Return: status 3034 */ 3035 QDF_STATUS dp_umac_reset_initiate_umac_recovery(struct dp_soc *soc, 3036 struct dp_soc_umac_reset_ctx *umac_reset_ctx, 3037 enum umac_reset_rx_event rx_event, 3038 bool is_target_recovery); 3039 3040 /** 3041 * dp_umac_reset_handle_action_cb() - Function to call action callback 3042 * @soc: dp soc handle 3043 * @umac_reset_ctx: Umac reset context 3044 * @action: Action to call the callback for 3045 * 3046 * Return: QDF_STATUS status 3047 */ 3048 QDF_STATUS dp_umac_reset_handle_action_cb(struct dp_soc *soc, 3049 struct dp_soc_umac_reset_ctx *umac_reset_ctx, 3050 enum umac_reset_action action); 3051 3052 /** 3053 * dp_umac_reset_post_tx_cmd() - Iterate partner socs and post Tx command 3054 * @umac_reset_ctx: UMAC reset context 3055 * @tx_cmd: Tx command to be posted 3056 * 3057 * Return: QDF status of operation 3058 */ 3059 QDF_STATUS 3060 dp_umac_reset_post_tx_cmd(struct dp_soc_umac_reset_ctx *umac_reset_ctx, 3061 enum umac_reset_tx_cmd tx_cmd); 3062 3063 /** 3064 * dp_umac_reset_initiator_check() - Check if soc is the Umac reset initiator 3065 * @soc: dp soc handle 3066 * 3067 * Return: true if the soc is initiator or false otherwise 3068 */ 3069 bool dp_umac_reset_initiator_check(struct dp_soc *soc); 3070 3071 /** 3072 * dp_umac_reset_target_recovery_check() - Check if this is for target recovery 3073 * @soc: dp soc handle 3074 * 3075 * Return: true if the session is for target recovery or false otherwise 3076 */ 3077 bool dp_umac_reset_target_recovery_check(struct dp_soc *soc); 3078 3079 /** 3080 * dp_umac_reset_is_soc_ignored() - Check if this soc is to be ignored 3081 * @soc: dp soc handle 3082 * 3083 * Return: true if the soc is ignored or false otherwise 3084 */ 3085 bool dp_umac_reset_is_soc_ignored(struct dp_soc *soc); 3086 3087 /** 3088 * dp_mlo_umac_reset_stats_print() - API to print MLO umac reset stats 3089 * @soc: dp soc handle 3090 * 3091 * Return: QDF_STATUS 3092 */ 3093 QDF_STATUS dp_mlo_umac_reset_stats_print(struct dp_soc *soc); 3094 #else 3095 static inline 3096 QDF_STATUS dp_mlo_umac_reset_stats_print(struct dp_soc *soc) 3097 { 3098 return QDF_STATUS_SUCCESS; 3099 } 3100 #endif 3101 #else 3102 static inline void dp_umac_reset_trigger_pre_reset_notify_cb(struct dp_soc *soc) 3103 { 3104 } 3105 #endif 3106 3107 #if defined(DP_UMAC_HW_RESET_SUPPORT) && defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 3108 /** 3109 * dp_umac_reset_notify_asserted_soc() - API to notify the asserted SOC 3110 * @soc: dp soc 3111 * 3112 * Return: QDF_STATUS 3113 */ 3114 QDF_STATUS dp_umac_reset_notify_asserted_soc(struct dp_soc *soc); 3115 3116 /** 3117 * dp_get_umac_reset_in_progress_state() - API to check umac reset in progress 3118 * state 3119 * @psoc: dp soc handle 3120 * 3121 * Return: umac reset state 3122 */ 3123 enum cdp_umac_reset_state 3124 dp_get_umac_reset_in_progress_state(struct cdp_soc_t *psoc); 3125 #else 3126 static inline 3127 QDF_STATUS dp_umac_reset_notify_asserted_soc(struct dp_soc *soc) 3128 { 3129 return QDF_STATUS_SUCCESS; 3130 } 3131 3132 static inline enum cdp_umac_reset_state 3133 dp_get_umac_reset_in_progress_state(struct cdp_soc_t *psoc) 3134 { 3135 return CDP_UMAC_RESET_NOT_IN_PROGRESS; 3136 } 3137 #endif 3138 3139 #ifndef WLAN_SOFTUMAC_SUPPORT 3140 QDF_STATUS dp_reo_send_cmd(struct dp_soc *soc, enum hal_reo_cmd_type type, 3141 struct hal_reo_cmd_params *params, 3142 void (*callback_fn), void *data); 3143 3144 /** 3145 * dp_reo_cmdlist_destroy() - Free REO commands in the queue 3146 * @soc: DP SoC handle 3147 * 3148 * Return: none 3149 */ 3150 void dp_reo_cmdlist_destroy(struct dp_soc *soc); 3151 3152 /** 3153 * dp_reo_status_ring_handler() - Handler for REO Status ring 3154 * @int_ctx: pointer to DP interrupt context 3155 * @soc: DP Soc handle 3156 * 3157 * Return: Number of descriptors reaped 3158 */ 3159 uint32_t dp_reo_status_ring_handler(struct dp_intr *int_ctx, 3160 struct dp_soc *soc); 3161 #endif 3162 3163 /** 3164 * dp_aggregate_vdev_stats() - Consolidate stats at VDEV level 3165 * @vdev: DP VDEV handle 3166 * @vdev_stats: aggregate statistics 3167 * @xmit_type: xmit type of packet - MLD/Link 3168 * return: void 3169 */ 3170 void dp_aggregate_vdev_stats(struct dp_vdev *vdev, 3171 struct cdp_vdev_stats *vdev_stats, 3172 enum dp_pkt_xmit_type xmit_type); 3173 3174 /** 3175 * dp_txrx_get_vdev_stats() - Update buffer with cdp_vdev_stats 3176 * @soc_hdl: CDP SoC handle 3177 * @vdev_id: vdev Id 3178 * @buf: buffer for vdev stats 3179 * @is_aggregate: are aggregate stats being collected 3180 * 3181 * Return: QDF_STATUS 3182 */ 3183 QDF_STATUS 3184 dp_txrx_get_vdev_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 3185 void *buf, bool is_aggregate); 3186 3187 /** 3188 * dp_rx_bar_stats_cb() - BAR received stats callback 3189 * @soc: SOC handle 3190 * @cb_ctxt: Call back context 3191 * @reo_status: Reo status 3192 * 3193 * Return: void 3194 */ 3195 void dp_rx_bar_stats_cb(struct dp_soc *soc, void *cb_ctxt, 3196 union hal_reo_status *reo_status); 3197 3198 uint16_t dp_tx_me_send_convert_ucast(struct cdp_soc_t *soc, uint8_t vdev_id, 3199 qdf_nbuf_t nbuf, 3200 uint8_t newmac[][QDF_MAC_ADDR_SIZE], 3201 uint8_t new_mac_cnt, uint8_t tid, 3202 bool is_igmp, bool is_dms_pkt); 3203 void dp_tx_me_alloc_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id); 3204 3205 void dp_tx_me_free_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id); 3206 3207 /** 3208 * dp_h2t_ext_stats_msg_send(): function to construct HTT message to pass to FW 3209 * @pdev: DP PDEV handle 3210 * @stats_type_upload_mask: stats type requested by user 3211 * @config_param_0: extra configuration parameters 3212 * @config_param_1: extra configuration parameters 3213 * @config_param_2: extra configuration parameters 3214 * @config_param_3: extra configuration parameters 3215 * @cookie: 3216 * @cookie_msb: 3217 * @mac_id: mac number 3218 * 3219 * Return: QDF STATUS 3220 */ 3221 QDF_STATUS dp_h2t_ext_stats_msg_send(struct dp_pdev *pdev, 3222 uint32_t stats_type_upload_mask, uint32_t config_param_0, 3223 uint32_t config_param_1, uint32_t config_param_2, 3224 uint32_t config_param_3, int cookie, int cookie_msb, 3225 uint8_t mac_id); 3226 3227 /** 3228 * dp_htt_stats_print_tag() - function to select the tag type and 3229 * print the corresponding tag structure 3230 * @pdev: pdev pointer 3231 * @tag_type: tag type that is to be printed 3232 * @tag_buf: pointer to the tag structure 3233 * 3234 * Return: void 3235 */ 3236 void dp_htt_stats_print_tag(struct dp_pdev *pdev, 3237 uint8_t tag_type, uint32_t *tag_buf); 3238 3239 /** 3240 * dp_htt_stats_copy_tag() - function to select the tag type and 3241 * copy the corresponding tag structure 3242 * @pdev: DP_PDEV handle 3243 * @tag_type: tag type that is to be printed 3244 * @tag_buf: pointer to the tag structure 3245 * 3246 * Return: void 3247 */ 3248 void dp_htt_stats_copy_tag(struct dp_pdev *pdev, uint8_t tag_type, uint32_t *tag_buf); 3249 3250 /** 3251 * dp_h2t_3tuple_config_send(): function to construct 3 tuple configuration 3252 * HTT message to pass to FW 3253 * @pdev: DP PDEV handle 3254 * @tuple_mask: tuple configuration to report 3 tuple hash value in either 3255 * toeplitz_2_or_4 or flow_id_toeplitz in MSDU START TLV. 3256 * 3257 * tuple_mask[1:0]: 3258 * 00 - Do not report 3 tuple hash value 3259 * 10 - Report 3 tuple hash value in toeplitz_2_or_4 3260 * 01 - Report 3 tuple hash value in flow_id_toeplitz 3261 * 11 - Report 3 tuple hash value in both toeplitz_2_or_4 & flow_id_toeplitz 3262 * @mac_id: MAC ID 3263 * 3264 * Return: QDF STATUS 3265 */ 3266 QDF_STATUS dp_h2t_3tuple_config_send(struct dp_pdev *pdev, uint32_t tuple_mask, 3267 uint8_t mac_id); 3268 3269 #ifdef IPA_OFFLOAD 3270 /** 3271 * dp_peer_update_tid_stats_from_reo() - update rx pkt and byte count from reo 3272 * @soc: soc handle 3273 * @cb_ctxt: combination of peer_id and tid 3274 * @reo_status: reo status 3275 * 3276 * Return: void 3277 */ 3278 void dp_peer_update_tid_stats_from_reo(struct dp_soc *soc, void *cb_ctxt, 3279 union hal_reo_status *reo_status); 3280 3281 int dp_peer_get_rxtid_stats_ipa(struct dp_peer *peer, 3282 dp_rxtid_stats_cmd_cb dp_stats_cmd_cb); 3283 #ifdef IPA_OPT_WIFI_DP 3284 void dp_ipa_wdi_opt_dpath_notify_flt_rlsd(int flt0_rslt, 3285 int flt1_rslt); 3286 void dp_ipa_wdi_opt_dpath_notify_flt_add_rem_cb(int flt0_rslt, int flt1_rslt); 3287 void dp_ipa_wdi_opt_dpath_notify_flt_rsvd(bool is_success); 3288 #endif 3289 #ifdef QCA_ENHANCED_STATS_SUPPORT 3290 /** 3291 * dp_peer_aggregate_tid_stats - aggregate rx tid stats 3292 * @peer: Data Path peer 3293 * 3294 * Return: void 3295 */ 3296 void dp_peer_aggregate_tid_stats(struct dp_peer *peer); 3297 #endif 3298 #else 3299 static inline void dp_peer_aggregate_tid_stats(struct dp_peer *peer) 3300 { 3301 } 3302 #endif 3303 3304 /** 3305 * dp_set_key_sec_type_wifi3() - set security mode of key 3306 * @soc: Datapath soc handle 3307 * @vdev_id: id of atapath vdev 3308 * @peer_mac: Datapath peer mac address 3309 * @sec_type: security type 3310 * @is_unicast: key type 3311 * 3312 */ 3313 QDF_STATUS 3314 dp_set_key_sec_type_wifi3(struct cdp_soc_t *soc, uint8_t vdev_id, 3315 uint8_t *peer_mac, enum cdp_sec_type sec_type, 3316 bool is_unicast); 3317 3318 /** 3319 * dp_get_pdev_for_mac_id() - Return pdev for mac_id 3320 * @soc: handle to DP soc 3321 * @mac_id: MAC id 3322 * 3323 * Return: Return pdev corresponding to MAC 3324 */ 3325 void *dp_get_pdev_for_mac_id(struct dp_soc *soc, uint32_t mac_id); 3326 3327 QDF_STATUS 3328 dp_set_michael_key(struct cdp_soc_t *soc, uint8_t vdev_id, 3329 uint8_t *peer_mac, 3330 bool is_unicast, uint32_t *key); 3331 3332 /** 3333 * dp_check_pdev_exists() - Validate pdev before use 3334 * @soc: dp soc handle 3335 * @data: pdev handle 3336 * 3337 * Return: 0 - success/invalid - failure 3338 */ 3339 bool dp_check_pdev_exists(struct dp_soc *soc, struct dp_pdev *data); 3340 3341 /** 3342 * dp_update_delay_stats() - Update delay statistics in structure 3343 * and fill min, max and avg delay 3344 * @tstats: tid tx stats 3345 * @rstats: tid rx stats 3346 * @delay: delay in ms 3347 * @tid: tid value 3348 * @mode: type of tx delay mode 3349 * @ring_id: ring number 3350 * @delay_in_us: flag to indicate whether the delay is in ms or us 3351 * 3352 * Return: none 3353 */ 3354 void dp_update_delay_stats(struct cdp_tid_tx_stats *tstats, 3355 struct cdp_tid_rx_stats *rstats, uint32_t delay, 3356 uint8_t tid, uint8_t mode, uint8_t ring_id, 3357 bool delay_in_us); 3358 3359 /** 3360 * dp_print_ring_stats(): Print tail and head pointer 3361 * @pdev: DP_PDEV handle 3362 * 3363 * Return: void 3364 */ 3365 void dp_print_ring_stats(struct dp_pdev *pdev); 3366 3367 /** 3368 * dp_print_ring_stat_from_hal(): Print tail and head pointer through hal 3369 * @soc: soc handle 3370 * @srng: srng handle 3371 * @ring_type: ring type 3372 * 3373 * Return: void 3374 */ 3375 void 3376 dp_print_ring_stat_from_hal(struct dp_soc *soc, struct dp_srng *srng, 3377 enum hal_ring_type ring_type); 3378 3379 /** 3380 * dp_print_pdev_cfg_params() - Print the pdev cfg parameters 3381 * @pdev: DP pdev handle 3382 * 3383 * Return: void 3384 */ 3385 void dp_print_pdev_cfg_params(struct dp_pdev *pdev); 3386 3387 /** 3388 * dp_print_soc_cfg_params()- Dump soc wlan config parameters 3389 * @soc: Soc handle 3390 * 3391 * Return: void 3392 */ 3393 void dp_print_soc_cfg_params(struct dp_soc *soc); 3394 3395 /** 3396 * dp_srng_get_str_from_hal_ring_type() - Return string name for a ring 3397 * @ring_type: Ring 3398 * 3399 * Return: char const pointer 3400 */ 3401 const 3402 char *dp_srng_get_str_from_hal_ring_type(enum hal_ring_type ring_type); 3403 3404 /** 3405 * dp_txrx_path_stats() - Function to display dump stats 3406 * @soc: soc handle 3407 * 3408 * Return: none 3409 */ 3410 void dp_txrx_path_stats(struct dp_soc *soc); 3411 3412 /** 3413 * dp_print_per_ring_stats(): Packet count per ring 3414 * @soc: soc handle 3415 * 3416 * Return: None 3417 */ 3418 void dp_print_per_ring_stats(struct dp_soc *soc); 3419 3420 /** 3421 * dp_aggregate_pdev_stats(): Consolidate stats at PDEV level 3422 * @pdev: DP PDEV handle 3423 * 3424 * Return: void 3425 */ 3426 void dp_aggregate_pdev_stats(struct dp_pdev *pdev); 3427 3428 /** 3429 * dp_print_rx_rates(): Print Rx rate stats 3430 * @vdev: DP_VDEV handle 3431 * 3432 * Return:void 3433 */ 3434 void dp_print_rx_rates(struct dp_vdev *vdev); 3435 3436 /** 3437 * dp_print_tx_rates(): Print tx rates 3438 * @vdev: DP_VDEV handle 3439 * 3440 * Return:void 3441 */ 3442 void dp_print_tx_rates(struct dp_vdev *vdev); 3443 3444 /** 3445 * dp_print_peer_stats():print peer stats 3446 * @peer: DP_PEER handle 3447 * @peer_stats: buffer holding peer stats 3448 * 3449 * return void 3450 */ 3451 void dp_print_peer_stats(struct dp_peer *peer, 3452 struct cdp_peer_stats *peer_stats); 3453 3454 /** 3455 * dp_print_pdev_tx_stats(): Print Pdev level TX stats 3456 * @pdev: DP_PDEV Handle 3457 * 3458 * Return:void 3459 */ 3460 void 3461 dp_print_pdev_tx_stats(struct dp_pdev *pdev); 3462 3463 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MCAST_MLO) 3464 /** 3465 * dp_print_vdev_mlo_mcast_tx_stats(): Print vdev level mlo mcast tx stats 3466 * @vdev: DP_VDEV Handle 3467 * 3468 * Return:void 3469 */ 3470 void 3471 dp_print_vdev_mlo_mcast_tx_stats(struct dp_vdev *vdev); 3472 #else 3473 /** 3474 * dp_print_vdev_mlo_mcast_tx_stats(): Print vdev level mlo mcast tx stats 3475 * @vdev: DP_VDEV Handle 3476 * 3477 * Return:void 3478 */ 3479 static inline 3480 void dp_print_vdev_mlo_mcast_tx_stats(struct dp_vdev *vdev) 3481 { 3482 } 3483 #endif 3484 3485 /** 3486 * dp_print_pdev_rx_stats(): Print Pdev level RX stats 3487 * @pdev: DP_PDEV Handle 3488 * 3489 * Return: void 3490 */ 3491 void 3492 dp_print_pdev_rx_stats(struct dp_pdev *pdev); 3493 3494 /** 3495 * dp_print_soc_tx_stats(): Print SOC level stats 3496 * @soc: DP_SOC Handle 3497 * 3498 * Return: void 3499 */ 3500 void dp_print_soc_tx_stats(struct dp_soc *soc); 3501 3502 #ifdef QCA_SUPPORT_DP_GLOBAL_CTX 3503 /** 3504 * dp_print_global_desc_count(): Print global desc in use 3505 * 3506 * Return: void 3507 */ 3508 void dp_print_global_desc_count(void); 3509 #else 3510 /** 3511 * dp_print_global_desc_count(): Print global desc in use 3512 * 3513 * Return: void 3514 */ 3515 static inline 3516 void dp_print_global_desc_count(void) 3517 { 3518 } 3519 #endif 3520 3521 /** 3522 * dp_print_soc_interrupt_stats() - Print interrupt stats for the soc 3523 * @soc: dp_soc handle 3524 * 3525 * Return: None 3526 */ 3527 void dp_print_soc_interrupt_stats(struct dp_soc *soc); 3528 3529 /** 3530 * dp_print_tx_ppeds_stats() - Print Tx in use stats for the soc in DS 3531 * @soc: dp_soc handle 3532 * 3533 * Return: None 3534 */ 3535 3536 void dp_print_tx_ppeds_stats(struct dp_soc *soc); 3537 3538 /* REO destination ring's watermark mask */ 3539 #define DP_SRNG_WM_MASK_REO_DST BIT(REO_DST) 3540 /* TX completion ring's watermark mask */ 3541 #define DP_SRNG_WM_MASK_TX_COMP BIT(WBM2SW_RELEASE) 3542 /* All srng's watermark mask */ 3543 #define DP_SRNG_WM_MASK_ALL 0xFFFFFFFF 3544 3545 #ifdef WLAN_DP_SRNG_USAGE_WM_TRACKING 3546 /** 3547 * dp_dump_srng_high_wm_stats() - Print the ring usage high watermark stats 3548 * for all SRNGs 3549 * @soc: DP soc handle 3550 * @srng_mask: SRNGs mask for dumping usage watermark stats 3551 * 3552 * Return: None 3553 */ 3554 void dp_dump_srng_high_wm_stats(struct dp_soc *soc, uint64_t srng_mask); 3555 #else 3556 static inline 3557 void dp_dump_srng_high_wm_stats(struct dp_soc *soc, uint64_t srng_mask) 3558 { 3559 } 3560 #endif 3561 3562 /** 3563 * dp_print_soc_rx_stats() - Print SOC level Rx stats 3564 * @soc: DP_SOC Handle 3565 * 3566 * Return: void 3567 */ 3568 void dp_print_soc_rx_stats(struct dp_soc *soc); 3569 3570 /** 3571 * dp_get_mac_id_for_pdev() - Return mac corresponding to pdev for mac 3572 * 3573 * @mac_id: MAC id 3574 * @pdev_id: pdev_id corresponding to pdev, 0 for MCL 3575 * 3576 * Single pdev using both MACs will operate on both MAC rings, 3577 * which is the case for MCL. 3578 * For WIN each PDEV will operate one ring, so index is zero. 3579 * 3580 */ 3581 static inline int dp_get_mac_id_for_pdev(uint32_t mac_id, uint32_t pdev_id) 3582 { 3583 if (mac_id && pdev_id) { 3584 qdf_print("Both mac_id and pdev_id cannot be non zero"); 3585 QDF_BUG(0); 3586 return 0; 3587 } 3588 return (mac_id + pdev_id); 3589 } 3590 3591 /** 3592 * dp_get_lmac_id_for_pdev_id() - Return lmac id corresponding to host pdev id 3593 * @soc: soc pointer 3594 * @mac_id: MAC id 3595 * @pdev_id: pdev_id corresponding to pdev, 0 for MCL 3596 * 3597 * For MCL, Single pdev using both MACs will operate on both MAC rings. 3598 * 3599 * For WIN, each PDEV will operate one ring. 3600 * 3601 */ 3602 static inline int 3603 dp_get_lmac_id_for_pdev_id 3604 (struct dp_soc *soc, uint32_t mac_id, uint32_t pdev_id) 3605 { 3606 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) { 3607 if (mac_id && pdev_id) { 3608 qdf_print("Both mac_id and pdev_id cannot be non zero"); 3609 QDF_BUG(0); 3610 return 0; 3611 } 3612 return (mac_id + pdev_id); 3613 } 3614 3615 return soc->pdev_list[pdev_id]->lmac_id; 3616 } 3617 3618 /** 3619 * dp_get_pdev_for_lmac_id() - Return pdev pointer corresponding to lmac id 3620 * @soc: soc pointer 3621 * @lmac_id: LMAC id 3622 * 3623 * For MCL, Single pdev exists 3624 * 3625 * For WIN, each PDEV will operate one ring. 3626 * 3627 */ 3628 static inline struct dp_pdev * 3629 dp_get_pdev_for_lmac_id(struct dp_soc *soc, uint32_t lmac_id) 3630 { 3631 uint8_t i = 0; 3632 3633 if (wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) { 3634 i = wlan_cfg_get_pdev_idx(soc->wlan_cfg_ctx, lmac_id); 3635 return ((i < MAX_PDEV_CNT) ? soc->pdev_list[i] : NULL); 3636 } 3637 3638 /* Typically for MCL as there only 1 PDEV*/ 3639 return soc->pdev_list[0]; 3640 } 3641 3642 /** 3643 * dp_calculate_target_pdev_id_from_host_pdev_id() - Return target pdev 3644 * corresponding to host pdev id 3645 * @soc: soc pointer 3646 * @mac_for_pdev: pdev_id corresponding to host pdev for WIN, mac id for MCL 3647 * 3648 * Return: target pdev_id for host pdev id. For WIN, this is derived through 3649 * a two step process: 3650 * 1. Get lmac_id corresponding to host pdev_id (lmac_id can change 3651 * during mode switch) 3652 * 2. Get target pdev_id (set up during WMI ready) from lmac_id 3653 * 3654 * For MCL, return the offset-1 translated mac_id 3655 */ 3656 static inline int 3657 dp_calculate_target_pdev_id_from_host_pdev_id 3658 (struct dp_soc *soc, uint32_t mac_for_pdev) 3659 { 3660 struct dp_pdev *pdev; 3661 3662 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) 3663 return DP_SW2HW_MACID(mac_for_pdev); 3664 3665 pdev = soc->pdev_list[mac_for_pdev]; 3666 3667 /*non-MCL case, get original target_pdev mapping*/ 3668 return wlan_cfg_get_target_pdev_id(soc->wlan_cfg_ctx, pdev->lmac_id); 3669 } 3670 3671 /** 3672 * dp_get_target_pdev_id_for_host_pdev_id() - Return target pdev corresponding 3673 * to host pdev id 3674 * @soc: soc pointer 3675 * @mac_for_pdev: pdev_id corresponding to host pdev for WIN, mac id for MCL 3676 * 3677 * Return: target pdev_id for host pdev id. 3678 * For WIN, return the value stored in pdev object. 3679 * For MCL, return the offset-1 translated mac_id. 3680 */ 3681 static inline int 3682 dp_get_target_pdev_id_for_host_pdev_id 3683 (struct dp_soc *soc, uint32_t mac_for_pdev) 3684 { 3685 struct dp_pdev *pdev; 3686 3687 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) 3688 return DP_SW2HW_MACID(mac_for_pdev); 3689 3690 pdev = soc->pdev_list[mac_for_pdev]; 3691 3692 return pdev->target_pdev_id; 3693 } 3694 3695 /** 3696 * dp_get_host_pdev_id_for_target_pdev_id() - Return host pdev corresponding 3697 * to target pdev id 3698 * @soc: soc pointer 3699 * @pdev_id: pdev_id corresponding to target pdev 3700 * 3701 * Return: host pdev_id for target pdev id. For WIN, this is derived through 3702 * a two step process: 3703 * 1. Get lmac_id corresponding to target pdev_id 3704 * 2. Get host pdev_id (set up during WMI ready) from lmac_id 3705 * 3706 * For MCL, return the 0-offset pdev_id 3707 */ 3708 static inline int 3709 dp_get_host_pdev_id_for_target_pdev_id 3710 (struct dp_soc *soc, uint32_t pdev_id) 3711 { 3712 struct dp_pdev *pdev; 3713 int lmac_id; 3714 3715 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) 3716 return DP_HW2SW_MACID(pdev_id); 3717 3718 /*non-MCL case, get original target_lmac mapping from target pdev*/ 3719 lmac_id = wlan_cfg_get_hw_mac_idx(soc->wlan_cfg_ctx, 3720 DP_HW2SW_MACID(pdev_id)); 3721 3722 /*Get host pdev from lmac*/ 3723 pdev = dp_get_pdev_for_lmac_id(soc, lmac_id); 3724 3725 return pdev ? pdev->pdev_id : INVALID_PDEV_ID; 3726 } 3727 3728 /** 3729 * dp_get_mac_id_for_mac() - Return mac corresponding WIN and MCL mac_ids 3730 * 3731 * @soc: handle to DP soc 3732 * @mac_id: MAC id 3733 * 3734 * Single pdev using both MACs will operate on both MAC rings, 3735 * which is the case for MCL. 3736 * For WIN each PDEV will operate one ring, so index is zero. 3737 * 3738 */ 3739 static inline int dp_get_mac_id_for_mac(struct dp_soc *soc, uint32_t mac_id) 3740 { 3741 /* 3742 * Single pdev using both MACs will operate on both MAC rings, 3743 * which is the case for MCL. 3744 */ 3745 if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) 3746 return mac_id; 3747 3748 /* For WIN each PDEV will operate one ring, so index is zero. */ 3749 return 0; 3750 } 3751 3752 /** 3753 * dp_is_subtype_data() - check if the frame subtype is data 3754 * 3755 * @frame_ctrl: Frame control field 3756 * 3757 * check the frame control field and verify if the packet 3758 * is a data packet. 3759 * 3760 * Return: true or false 3761 */ 3762 static inline bool dp_is_subtype_data(uint16_t frame_ctrl) 3763 { 3764 if (((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_TYPE_MASK) == 3765 QDF_IEEE80211_FC0_TYPE_DATA) && 3766 (((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_SUBTYPE_MASK) == 3767 QDF_IEEE80211_FC0_SUBTYPE_DATA) || 3768 ((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_SUBTYPE_MASK) == 3769 QDF_IEEE80211_FC0_SUBTYPE_QOS))) { 3770 return true; 3771 } 3772 3773 return false; 3774 } 3775 3776 #ifdef WDI_EVENT_ENABLE 3777 /** 3778 * dp_h2t_cfg_stats_msg_send(): function to construct HTT message to pass to FW 3779 * @pdev: DP PDEV handle 3780 * @stats_type_upload_mask: stats type requested by user 3781 * @mac_id: Mac id number 3782 * 3783 * return: QDF STATUS 3784 */ 3785 QDF_STATUS dp_h2t_cfg_stats_msg_send(struct dp_pdev *pdev, 3786 uint32_t stats_type_upload_mask, 3787 uint8_t mac_id); 3788 3789 /** 3790 * dp_wdi_event_unsub() - WDI event unsubscribe 3791 * @soc: soc handle 3792 * @pdev_id: id of pdev 3793 * @event_cb_sub_handle: subscribed event handle 3794 * @event: Event to be unsubscribe 3795 * 3796 * Return: 0 for success. nonzero for failure. 3797 */ 3798 int dp_wdi_event_unsub(struct cdp_soc_t *soc, uint8_t pdev_id, 3799 wdi_event_subscribe *event_cb_sub_handle, 3800 uint32_t event); 3801 3802 /** 3803 * dp_wdi_event_sub() - Subscribe WDI event 3804 * @soc: soc handle 3805 * @pdev_id: id of pdev 3806 * @event_cb_sub_handle: subscribe event handle 3807 * @event: Event to be subscribe 3808 * 3809 * Return: 0 for success. nonzero for failure. 3810 */ 3811 int dp_wdi_event_sub(struct cdp_soc_t *soc, uint8_t pdev_id, 3812 wdi_event_subscribe *event_cb_sub_handle, 3813 uint32_t event); 3814 3815 /** 3816 * dp_wdi_event_handler() - Event handler for WDI event 3817 * @event: wdi event number 3818 * @soc: soc handle 3819 * @data: pointer to data 3820 * @peer_id: peer id number 3821 * @status: HTT rx status 3822 * @pdev_id: id of pdev 3823 * 3824 * It will be called to register WDI event 3825 * 3826 * Return: None 3827 */ 3828 void dp_wdi_event_handler(enum WDI_EVENT event, struct dp_soc *soc, 3829 void *data, u_int16_t peer_id, 3830 int status, u_int8_t pdev_id); 3831 3832 /** 3833 * dp_wdi_event_attach() - Attach wdi event 3834 * @txrx_pdev: DP pdev handle 3835 * 3836 * Return: 0 for success. nonzero for failure. 3837 */ 3838 int dp_wdi_event_attach(struct dp_pdev *txrx_pdev); 3839 3840 /** 3841 * dp_wdi_event_detach() - Detach WDI event 3842 * @txrx_pdev: DP pdev handle 3843 * 3844 * Return: 0 for success. nonzero for failure. 3845 */ 3846 int dp_wdi_event_detach(struct dp_pdev *txrx_pdev); 3847 3848 static inline void 3849 dp_hif_update_pipe_callback(struct dp_soc *dp_soc, 3850 void *cb_context, 3851 QDF_STATUS (*callback)(void *, qdf_nbuf_t, uint8_t), 3852 uint8_t pipe_id) 3853 { 3854 struct hif_msg_callbacks hif_pipe_callbacks = { 0 }; 3855 3856 /* TODO: Temporary change to bypass HTC connection for this new 3857 * HIF pipe, which will be used for packet log and other high- 3858 * priority HTT messages. Proper HTC connection to be added 3859 * later once required FW changes are available 3860 */ 3861 hif_pipe_callbacks.rxCompletionHandler = callback; 3862 hif_pipe_callbacks.Context = cb_context; 3863 hif_update_pipe_callback(dp_soc->hif_handle, 3864 DP_HTT_T2H_HP_PIPE, &hif_pipe_callbacks); 3865 } 3866 #else 3867 static inline int dp_wdi_event_unsub(struct cdp_soc_t *soc, uint8_t pdev_id, 3868 wdi_event_subscribe *event_cb_sub_handle, 3869 uint32_t event) 3870 { 3871 return 0; 3872 } 3873 3874 static inline int dp_wdi_event_sub(struct cdp_soc_t *soc, uint8_t pdev_id, 3875 wdi_event_subscribe *event_cb_sub_handle, 3876 uint32_t event) 3877 { 3878 return 0; 3879 } 3880 3881 static inline 3882 void dp_wdi_event_handler(enum WDI_EVENT event, 3883 struct dp_soc *soc, 3884 void *data, u_int16_t peer_id, 3885 int status, u_int8_t pdev_id) 3886 { 3887 } 3888 3889 static inline int dp_wdi_event_attach(struct dp_pdev *txrx_pdev) 3890 { 3891 return 0; 3892 } 3893 3894 static inline int dp_wdi_event_detach(struct dp_pdev *txrx_pdev) 3895 { 3896 return 0; 3897 } 3898 3899 static inline QDF_STATUS dp_h2t_cfg_stats_msg_send(struct dp_pdev *pdev, 3900 uint32_t stats_type_upload_mask, uint8_t mac_id) 3901 { 3902 return 0; 3903 } 3904 3905 static inline void 3906 dp_hif_update_pipe_callback(struct dp_soc *dp_soc, void *cb_context, 3907 QDF_STATUS (*callback)(void *, qdf_nbuf_t, uint8_t), 3908 uint8_t pipe_id) 3909 { 3910 } 3911 #endif 3912 3913 #ifdef VDEV_PEER_PROTOCOL_COUNT 3914 /** 3915 * dp_vdev_peer_stats_update_protocol_cnt() - update per-peer protocol counters 3916 * @vdev: VDEV DP object 3917 * @nbuf: data packet 3918 * @txrx_peer: DP TXRX Peer object 3919 * @is_egress: whether egress or ingress 3920 * @is_rx: whether rx or tx 3921 * 3922 * This function updates the per-peer protocol counters 3923 * Return: void 3924 */ 3925 void dp_vdev_peer_stats_update_protocol_cnt(struct dp_vdev *vdev, 3926 qdf_nbuf_t nbuf, 3927 struct dp_txrx_peer *txrx_peer, 3928 bool is_egress, 3929 bool is_rx); 3930 3931 /** 3932 * dp_peer_stats_update_protocol_cnt() - update per-peer protocol counters 3933 * @soc: SOC DP object 3934 * @vdev_id: vdev_id 3935 * @nbuf: data packet 3936 * @is_egress: whether egress or ingress 3937 * @is_rx: whether rx or tx 3938 * 3939 * This function updates the per-peer protocol counters 3940 * 3941 * Return: void 3942 */ 3943 void dp_peer_stats_update_protocol_cnt(struct cdp_soc_t *soc, 3944 int8_t vdev_id, 3945 qdf_nbuf_t nbuf, 3946 bool is_egress, 3947 bool is_rx); 3948 3949 void dp_vdev_peer_stats_update_protocol_cnt_tx(struct dp_vdev *vdev_hdl, 3950 qdf_nbuf_t nbuf); 3951 3952 #else 3953 #define dp_vdev_peer_stats_update_protocol_cnt(vdev, nbuf, txrx_peer, \ 3954 is_egress, is_rx) 3955 3956 static inline 3957 void dp_vdev_peer_stats_update_protocol_cnt_tx(struct dp_vdev *vdev_hdl, 3958 qdf_nbuf_t nbuf) 3959 { 3960 } 3961 3962 #endif 3963 3964 #ifdef QCA_LL_TX_FLOW_CONTROL_V2 3965 /** 3966 * dp_tx_dump_flow_pool_info() - dump global_pool and flow_pool info 3967 * @soc_hdl: Handle to struct cdp_soc 3968 * 3969 * Return: none 3970 */ 3971 void dp_tx_dump_flow_pool_info(struct cdp_soc_t *soc_hdl); 3972 3973 /** 3974 * dp_tx_dump_flow_pool_info_compact() - dump flow pool info 3975 * @soc: DP soc context 3976 * 3977 * Return: none 3978 */ 3979 void dp_tx_dump_flow_pool_info_compact(struct dp_soc *soc); 3980 int dp_tx_delete_flow_pool(struct dp_soc *soc, struct dp_tx_desc_pool_s *pool, 3981 bool force); 3982 #else 3983 static inline void dp_tx_dump_flow_pool_info_compact(struct dp_soc *soc) 3984 { 3985 } 3986 #endif /* QCA_LL_TX_FLOW_CONTROL_V2 */ 3987 3988 #ifdef QCA_OL_DP_SRNG_LOCK_LESS_ACCESS 3989 static inline int 3990 dp_hal_srng_access_start(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) 3991 { 3992 return hal_srng_access_start_unlocked(soc, hal_ring_hdl); 3993 } 3994 3995 static inline void 3996 dp_hal_srng_access_end(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) 3997 { 3998 hal_srng_access_end_unlocked(soc, hal_ring_hdl); 3999 } 4000 4001 #else 4002 static inline int 4003 dp_hal_srng_access_start(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) 4004 { 4005 return hal_srng_access_start(soc, hal_ring_hdl); 4006 } 4007 4008 static inline void 4009 dp_hal_srng_access_end(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) 4010 { 4011 hal_srng_access_end(soc, hal_ring_hdl); 4012 } 4013 #endif 4014 4015 #ifdef WLAN_FEATURE_DP_EVENT_HISTORY 4016 /** 4017 * dp_srng_access_start() - Wrapper function to log access start of a hal ring 4018 * @int_ctx: pointer to DP interrupt context. This should not be NULL 4019 * @dp_soc: DP Soc handle 4020 * @hal_ring_hdl: opaque pointer to the HAL Rx Error Ring, which will be 4021 * serviced 4022 * 4023 * Return: 0 on success; error on failure 4024 */ 4025 int dp_srng_access_start(struct dp_intr *int_ctx, struct dp_soc *dp_soc, 4026 hal_ring_handle_t hal_ring_hdl); 4027 4028 /** 4029 * dp_srng_access_end() - Wrapper function to log access end of a hal ring 4030 * @int_ctx: pointer to DP interrupt context. This should not be NULL 4031 * @dp_soc: DP Soc handle 4032 * @hal_ring_hdl: opaque pointer to the HAL Rx Error Ring, which will be 4033 * serviced 4034 * 4035 * Return: void 4036 */ 4037 void dp_srng_access_end(struct dp_intr *int_ctx, struct dp_soc *dp_soc, 4038 hal_ring_handle_t hal_ring_hdl); 4039 4040 #else 4041 static inline int dp_srng_access_start(struct dp_intr *int_ctx, 4042 struct dp_soc *dp_soc, 4043 hal_ring_handle_t hal_ring_hdl) 4044 { 4045 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 4046 4047 return dp_hal_srng_access_start(hal_soc, hal_ring_hdl); 4048 } 4049 4050 static inline void dp_srng_access_end(struct dp_intr *int_ctx, 4051 struct dp_soc *dp_soc, 4052 hal_ring_handle_t hal_ring_hdl) 4053 { 4054 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 4055 4056 return dp_hal_srng_access_end(hal_soc, hal_ring_hdl); 4057 } 4058 #endif /* WLAN_FEATURE_DP_EVENT_HISTORY */ 4059 4060 #ifdef QCA_CACHED_RING_DESC 4061 /** 4062 * dp_srng_dst_get_next() - Wrapper function to get next ring desc 4063 * @dp_soc: DP Soc handle 4064 * @hal_ring_hdl: opaque pointer to the HAL Destination Ring 4065 * 4066 * Return: HAL ring descriptor 4067 */ 4068 static inline void *dp_srng_dst_get_next(struct dp_soc *dp_soc, 4069 hal_ring_handle_t hal_ring_hdl) 4070 { 4071 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 4072 4073 return hal_srng_dst_get_next_cached(hal_soc, hal_ring_hdl); 4074 } 4075 4076 /** 4077 * dp_srng_dst_inv_cached_descs() - Wrapper function to invalidate cached 4078 * descriptors 4079 * @dp_soc: DP Soc handle 4080 * @hal_ring_hdl: opaque pointer to the HAL Rx Destination ring 4081 * @num_entries: Entry count 4082 * 4083 * Return: None 4084 */ 4085 static inline void dp_srng_dst_inv_cached_descs(struct dp_soc *dp_soc, 4086 hal_ring_handle_t hal_ring_hdl, 4087 uint32_t num_entries) 4088 { 4089 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 4090 4091 hal_srng_dst_inv_cached_descs(hal_soc, hal_ring_hdl, num_entries); 4092 } 4093 #else 4094 static inline void *dp_srng_dst_get_next(struct dp_soc *dp_soc, 4095 hal_ring_handle_t hal_ring_hdl) 4096 { 4097 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 4098 4099 return hal_srng_dst_get_next(hal_soc, hal_ring_hdl); 4100 } 4101 4102 static inline void dp_srng_dst_inv_cached_descs(struct dp_soc *dp_soc, 4103 hal_ring_handle_t hal_ring_hdl, 4104 uint32_t num_entries) 4105 { 4106 } 4107 #endif /* QCA_CACHED_RING_DESC */ 4108 4109 #if defined(QCA_CACHED_RING_DESC) && \ 4110 (defined(QCA_DP_RX_HW_SW_NBUF_DESC_PREFETCH) || \ 4111 defined(QCA_DP_TX_HW_SW_NBUF_DESC_PREFETCH)) 4112 /** 4113 * dp_srng_dst_prefetch() - Wrapper function to prefetch descs from dest ring 4114 * @hal_soc: HAL SOC handle 4115 * @hal_ring_hdl: opaque pointer to the HAL Rx Destination ring 4116 * @num_entries: Entry count 4117 * 4118 * Return: None 4119 */ 4120 static inline void *dp_srng_dst_prefetch(hal_soc_handle_t hal_soc, 4121 hal_ring_handle_t hal_ring_hdl, 4122 uint32_t num_entries) 4123 { 4124 return hal_srng_dst_prefetch(hal_soc, hal_ring_hdl, num_entries); 4125 } 4126 4127 /** 4128 * dp_srng_dst_prefetch_32_byte_desc() - Wrapper function to prefetch 4129 * 32 byte descriptor starting at 4130 * 64 byte offset 4131 * @hal_soc: HAL SOC handle 4132 * @hal_ring_hdl: opaque pointer to the HAL Rx Destination ring 4133 * @num_entries: Entry count 4134 * 4135 * Return: None 4136 */ 4137 static inline 4138 void *dp_srng_dst_prefetch_32_byte_desc(hal_soc_handle_t hal_soc, 4139 hal_ring_handle_t hal_ring_hdl, 4140 uint32_t num_entries) 4141 { 4142 return hal_srng_dst_prefetch_32_byte_desc(hal_soc, hal_ring_hdl, 4143 num_entries); 4144 } 4145 #else 4146 static inline void *dp_srng_dst_prefetch(hal_soc_handle_t hal_soc, 4147 hal_ring_handle_t hal_ring_hdl, 4148 uint32_t num_entries) 4149 { 4150 return NULL; 4151 } 4152 4153 static inline 4154 void *dp_srng_dst_prefetch_32_byte_desc(hal_soc_handle_t hal_soc, 4155 hal_ring_handle_t hal_ring_hdl, 4156 uint32_t num_entries) 4157 { 4158 return NULL; 4159 } 4160 #endif 4161 4162 #ifdef QCA_ENH_V3_STATS_SUPPORT 4163 /** 4164 * dp_pdev_print_delay_stats(): Print pdev level delay stats 4165 * @pdev: DP_PDEV handle 4166 * 4167 * Return:void 4168 */ 4169 void dp_pdev_print_delay_stats(struct dp_pdev *pdev); 4170 4171 /** 4172 * dp_pdev_print_tid_stats(): Print pdev level tid stats 4173 * @pdev: DP_PDEV handle 4174 * 4175 * Return:void 4176 */ 4177 void dp_pdev_print_tid_stats(struct dp_pdev *pdev); 4178 4179 /** 4180 * dp_pdev_print_rx_error_stats(): Print pdev level rx error stats 4181 * @pdev: DP_PDEV handle 4182 * 4183 * Return:void 4184 */ 4185 void dp_pdev_print_rx_error_stats(struct dp_pdev *pdev); 4186 #endif /* QCA_ENH_V3_STATS_SUPPORT */ 4187 4188 /** 4189 * dp_pdev_get_tid_stats(): Get accumulated pdev level tid_stats 4190 * @soc_hdl: soc handle 4191 * @pdev_id: id of dp_pdev handle 4192 * @tid_stats: Pointer for cdp_tid_stats_intf 4193 * 4194 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_E_INVAL 4195 */ 4196 QDF_STATUS dp_pdev_get_tid_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 4197 struct cdp_tid_stats_intf *tid_stats); 4198 4199 /** 4200 * dp_soc_set_txrx_ring_map() 4201 * @soc: DP handler for soc 4202 * 4203 * Return: Void 4204 */ 4205 void dp_soc_set_txrx_ring_map(struct dp_soc *soc); 4206 4207 /** 4208 * dp_vdev_to_cdp_vdev() - typecast dp vdev to cdp vdev 4209 * @vdev: DP vdev handle 4210 * 4211 * Return: struct cdp_vdev pointer 4212 */ 4213 static inline 4214 struct cdp_vdev *dp_vdev_to_cdp_vdev(struct dp_vdev *vdev) 4215 { 4216 return (struct cdp_vdev *)vdev; 4217 } 4218 4219 /** 4220 * dp_pdev_to_cdp_pdev() - typecast dp pdev to cdp pdev 4221 * @pdev: DP pdev handle 4222 * 4223 * Return: struct cdp_pdev pointer 4224 */ 4225 static inline 4226 struct cdp_pdev *dp_pdev_to_cdp_pdev(struct dp_pdev *pdev) 4227 { 4228 return (struct cdp_pdev *)pdev; 4229 } 4230 4231 /** 4232 * dp_soc_to_cdp_soc() - typecast dp psoc to cdp psoc 4233 * @psoc: DP psoc handle 4234 * 4235 * Return: struct cdp_soc pointer 4236 */ 4237 static inline 4238 struct cdp_soc *dp_soc_to_cdp_soc(struct dp_soc *psoc) 4239 { 4240 return (struct cdp_soc *)psoc; 4241 } 4242 4243 /** 4244 * dp_soc_to_cdp_soc_t() - typecast dp psoc to ol txrx soc handle 4245 * @psoc: DP psoc handle 4246 * 4247 * Return: struct cdp_soc_t pointer 4248 */ 4249 static inline 4250 struct cdp_soc_t *dp_soc_to_cdp_soc_t(struct dp_soc *psoc) 4251 { 4252 return (struct cdp_soc_t *)psoc; 4253 } 4254 4255 #if defined(WLAN_SUPPORT_RX_FLOW_TAG) 4256 /** 4257 * dp_rx_flow_get_fse_stats() - Retrieve a flow's statistics 4258 * @pdev: pdev handle 4259 * @rx_flow_info: flow information in the Rx FST 4260 * @stats: stats to update 4261 * 4262 * Return: Success when flow statistcs is updated, error on failure 4263 */ 4264 QDF_STATUS dp_rx_flow_get_fse_stats(struct dp_pdev *pdev, 4265 struct cdp_rx_flow_info *rx_flow_info, 4266 struct cdp_flow_stats *stats); 4267 4268 /** 4269 * dp_rx_flow_delete_entry() - Delete a flow entry from flow search table 4270 * @pdev: pdev handle 4271 * @rx_flow_info: DP flow parameters 4272 * 4273 * Return: Success when flow is deleted, error on failure 4274 */ 4275 QDF_STATUS dp_rx_flow_delete_entry(struct dp_pdev *pdev, 4276 struct cdp_rx_flow_info *rx_flow_info); 4277 4278 /** 4279 * dp_rx_flow_add_entry() - Add a flow entry to flow search table 4280 * @pdev: DP pdev instance 4281 * @rx_flow_info: DP flow parameters 4282 * 4283 * Return: Success when flow is added, no-memory or already exists on error 4284 */ 4285 QDF_STATUS dp_rx_flow_add_entry(struct dp_pdev *pdev, 4286 struct cdp_rx_flow_info *rx_flow_info); 4287 4288 /** 4289 * dp_rx_fst_attach() - Initialize Rx FST and setup necessary parameters 4290 * @soc: SoC handle 4291 * @pdev: Pdev handle 4292 * 4293 * Return: Handle to flow search table entry 4294 */ 4295 QDF_STATUS dp_rx_fst_attach(struct dp_soc *soc, struct dp_pdev *pdev); 4296 4297 /** 4298 * dp_rx_fst_detach() - De-initialize Rx FST 4299 * @soc: SoC handle 4300 * @pdev: Pdev handle 4301 * 4302 * Return: None 4303 */ 4304 void dp_rx_fst_detach(struct dp_soc *soc, struct dp_pdev *pdev); 4305 4306 /** 4307 * dp_mon_rx_update_rx_flow_tag_stats() - Update a mon flow's statistics 4308 * @pdev: pdev handle 4309 * @flow_id: flow index (truncated hash) in the Rx FST 4310 * 4311 * Return: Success when flow statistcs is updated, error on failure 4312 */ 4313 QDF_STATUS 4314 dp_mon_rx_update_rx_flow_tag_stats(struct dp_pdev *pdev, uint32_t flow_id); 4315 #endif 4316 4317 #ifdef WLAN_SUPPORT_RX_FLOW_TAG 4318 /** 4319 * dp_rx_flow_send_fst_fw_setup() - Program FST parameters in FW/HW post-attach 4320 * @soc: SoC handle 4321 * @pdev: Pdev handle 4322 * 4323 * Return: Success when fst parameters are programmed in FW, error otherwise 4324 */ 4325 QDF_STATUS dp_rx_flow_send_fst_fw_setup(struct dp_soc *soc, 4326 struct dp_pdev *pdev); 4327 #endif 4328 4329 /** 4330 * dp_rx_fst_attach_wrapper() - wrapper API for dp_rx_fst_attach 4331 * @soc: SoC handle 4332 * @pdev: Pdev handle 4333 * 4334 * Return: Handle to flow search table entry 4335 */ 4336 extern QDF_STATUS 4337 dp_rx_fst_attach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev); 4338 4339 /** 4340 * dp_rx_fst_detach_wrapper() - wrapper API for dp_rx_fst_detach 4341 * @soc: SoC handle 4342 * @pdev: Pdev handle 4343 * 4344 * Return: None 4345 */ 4346 extern void 4347 dp_rx_fst_detach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev); 4348 4349 /** 4350 * dp_vdev_get_ref() - API to take a reference for VDEV object 4351 * 4352 * @soc : core DP soc context 4353 * @vdev : DP vdev 4354 * @mod_id : module id 4355 * 4356 * Return: QDF_STATUS_SUCCESS if reference held successfully 4357 * else QDF_STATUS_E_INVAL 4358 */ 4359 static inline 4360 QDF_STATUS dp_vdev_get_ref(struct dp_soc *soc, struct dp_vdev *vdev, 4361 enum dp_mod_id mod_id) 4362 { 4363 if (!qdf_atomic_inc_not_zero(&vdev->ref_cnt)) 4364 return QDF_STATUS_E_INVAL; 4365 4366 qdf_atomic_inc(&vdev->mod_refs[mod_id]); 4367 4368 return QDF_STATUS_SUCCESS; 4369 } 4370 4371 /** 4372 * dp_vdev_get_ref_by_id() - Returns vdev object given the vdev id 4373 * @soc: core DP soc context 4374 * @vdev_id: vdev id from vdev object can be retrieved 4375 * @mod_id: module id which is requesting the reference 4376 * 4377 * Return: struct dp_vdev*: Pointer to DP vdev object 4378 */ 4379 static inline struct dp_vdev * 4380 dp_vdev_get_ref_by_id(struct dp_soc *soc, uint8_t vdev_id, 4381 enum dp_mod_id mod_id) 4382 { 4383 struct dp_vdev *vdev = NULL; 4384 if (qdf_unlikely(vdev_id >= MAX_VDEV_CNT)) 4385 return NULL; 4386 4387 qdf_spin_lock_bh(&soc->vdev_map_lock); 4388 vdev = soc->vdev_id_map[vdev_id]; 4389 4390 if (!vdev || dp_vdev_get_ref(soc, vdev, mod_id) != QDF_STATUS_SUCCESS) { 4391 qdf_spin_unlock_bh(&soc->vdev_map_lock); 4392 return NULL; 4393 } 4394 qdf_spin_unlock_bh(&soc->vdev_map_lock); 4395 4396 return vdev; 4397 } 4398 4399 /** 4400 * dp_get_pdev_from_soc_pdev_id_wifi3() - Returns pdev object given the pdev id 4401 * @soc: core DP soc context 4402 * @pdev_id: pdev id from pdev object can be retrieved 4403 * 4404 * Return: struct dp_pdev*: Pointer to DP pdev object 4405 */ 4406 static inline struct dp_pdev * 4407 dp_get_pdev_from_soc_pdev_id_wifi3(struct dp_soc *soc, 4408 uint8_t pdev_id) 4409 { 4410 if (qdf_unlikely(pdev_id >= MAX_PDEV_CNT)) 4411 return NULL; 4412 4413 return soc->pdev_list[pdev_id]; 4414 } 4415 4416 /** 4417 * dp_get_peer_mac_list(): function to get peer mac list of vdev 4418 * @soc: Datapath soc handle 4419 * @vdev_id: vdev id 4420 * @newmac: Table of the clients mac 4421 * @mac_cnt: No. of MACs required 4422 * @limit: Limit the number of clients 4423 * 4424 * Return: no of clients 4425 */ 4426 uint16_t dp_get_peer_mac_list(ol_txrx_soc_handle soc, uint8_t vdev_id, 4427 u_int8_t newmac[][QDF_MAC_ADDR_SIZE], 4428 u_int16_t mac_cnt, bool limit); 4429 4430 /** 4431 * dp_update_num_mac_rings_for_dbs() - Update No of MAC rings based on 4432 * DBS check 4433 * @soc: DP SoC context 4434 * @max_mac_rings: Pointer to variable for No of MAC rings 4435 * 4436 * Return: None 4437 */ 4438 void dp_update_num_mac_rings_for_dbs(struct dp_soc *soc, 4439 int *max_mac_rings); 4440 4441 4442 #if defined(WLAN_SUPPORT_RX_FISA) 4443 /** 4444 * dp_rx_fst_update_cmem_params() - Update CMEM FST params 4445 * @soc: DP SoC context 4446 * @num_entries: Number of flow search entries 4447 * @cmem_ba_lo: CMEM base address low 4448 * @cmem_ba_hi: CMEM base address high 4449 * 4450 * Return: None 4451 */ 4452 void dp_rx_fst_update_cmem_params(struct dp_soc *soc, uint16_t num_entries, 4453 uint32_t cmem_ba_lo, uint32_t cmem_ba_hi); 4454 4455 /** 4456 * dp_fisa_config() - FISA config handler 4457 * @cdp_soc: CDP SoC handle 4458 * @pdev_id: PDEV ID 4459 * @config_id: FISA config ID 4460 * @cfg: FISA config msg data 4461 */ 4462 QDF_STATUS dp_fisa_config(ol_txrx_soc_handle cdp_soc, uint8_t pdev_id, 4463 enum cdp_fisa_config_id config_id, 4464 union cdp_fisa_config *cfg); 4465 #else 4466 static inline void 4467 dp_rx_fst_update_cmem_params(struct dp_soc *soc, uint16_t num_entries, 4468 uint32_t cmem_ba_lo, uint32_t cmem_ba_hi) 4469 { 4470 } 4471 #endif /* WLAN_SUPPORT_RX_FISA */ 4472 4473 #ifdef MAX_ALLOC_PAGE_SIZE 4474 /** 4475 * dp_set_max_page_size() - Set the max page size for hw link desc. 4476 * @pages: link desc page handle 4477 * @max_alloc_size: max_alloc_size 4478 * 4479 * For MCL the page size is set to OS defined value and for WIN 4480 * the page size is set to the max_alloc_size cfg ini 4481 * param. 4482 * This is to ensure that WIN gets contiguous memory allocations 4483 * as per requirement. 4484 * 4485 * Return: None 4486 */ 4487 static inline 4488 void dp_set_max_page_size(struct qdf_mem_multi_page_t *pages, 4489 uint32_t max_alloc_size) 4490 { 4491 pages->page_size = qdf_page_size; 4492 } 4493 4494 #else 4495 static inline 4496 void dp_set_max_page_size(struct qdf_mem_multi_page_t *pages, 4497 uint32_t max_alloc_size) 4498 { 4499 pages->page_size = max_alloc_size; 4500 } 4501 #endif /* MAX_ALLOC_PAGE_SIZE */ 4502 4503 /** 4504 * dp_get_next_index() - get the next entry to record an entry 4505 * in the history. 4506 * @curr_idx: Current index where the last entry is written. 4507 * @max_entries: Max number of entries in the history 4508 * 4509 * This function assumes that the max number os entries is a power of 2. 4510 * 4511 * Return: The index where the next entry is to be written. 4512 */ 4513 4514 static inline uint32_t dp_get_next_index(qdf_atomic_t *curr_idx, 4515 uint32_t max_entries) 4516 { 4517 uint32_t idx = qdf_atomic_inc_return(curr_idx); 4518 4519 return idx & (max_entries - 1); 4520 } 4521 4522 /** 4523 * dp_history_get_next_index() - get the next entry to record an entry 4524 * in the history. 4525 * @curr_idx: Current index where the last entry is written. 4526 * @max_entries: Max number of entries in the history 4527 * 4528 * This function assumes that the max number os entries is a power of 2. 4529 * 4530 * Return: The index where the next entry is to be written. 4531 */ 4532 static inline uint32_t dp_history_get_next_index(qdf_atomic_t *curr_idx, 4533 uint32_t max_entries) 4534 { 4535 return dp_get_next_index(curr_idx, max_entries); 4536 } 4537 4538 /** 4539 * dp_rx_skip_tlvs() - Skip TLVs len + L3 padding, save in nbuf->cb 4540 * @soc: Datapath soc handle 4541 * @nbuf: nbuf cb to be updated 4542 * @l3_padding: L3 padding 4543 * 4544 * Return: None 4545 */ 4546 void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding); 4547 4548 #ifndef FEATURE_WDS 4549 static inline void 4550 dp_hmwds_ast_add_notify(struct dp_peer *peer, 4551 uint8_t *mac_addr, 4552 enum cdp_txrx_ast_entry_type type, 4553 QDF_STATUS err, 4554 bool is_peer_map) 4555 { 4556 } 4557 #endif 4558 4559 #ifdef HTT_STATS_DEBUGFS_SUPPORT 4560 /** 4561 * dp_pdev_htt_stats_dbgfs_init() - Function to allocate memory and initialize 4562 * debugfs for HTT stats 4563 * @pdev: dp pdev handle 4564 * 4565 * Return: QDF_STATUS 4566 */ 4567 QDF_STATUS dp_pdev_htt_stats_dbgfs_init(struct dp_pdev *pdev); 4568 4569 /** 4570 * dp_pdev_htt_stats_dbgfs_deinit() - Function to remove debugfs entry for 4571 * HTT stats 4572 * @pdev: dp pdev handle 4573 * 4574 * Return: none 4575 */ 4576 void dp_pdev_htt_stats_dbgfs_deinit(struct dp_pdev *pdev); 4577 #else 4578 4579 /** 4580 * dp_pdev_htt_stats_dbgfs_init() - Function to allocate memory and initialize 4581 * debugfs for HTT stats 4582 * @pdev: dp pdev handle 4583 * 4584 * Return: QDF_STATUS 4585 */ 4586 static inline QDF_STATUS 4587 dp_pdev_htt_stats_dbgfs_init(struct dp_pdev *pdev) 4588 { 4589 return QDF_STATUS_SUCCESS; 4590 } 4591 4592 /** 4593 * dp_pdev_htt_stats_dbgfs_deinit() - Function to remove debugfs entry for 4594 * HTT stats 4595 * @pdev: dp pdev handle 4596 * 4597 * Return: none 4598 */ 4599 static inline void 4600 dp_pdev_htt_stats_dbgfs_deinit(struct dp_pdev *pdev) 4601 { 4602 } 4603 #endif /* HTT_STATS_DEBUGFS_SUPPORT */ 4604 4605 #ifndef WLAN_DP_FEATURE_SW_LATENCY_MGR 4606 /** 4607 * dp_soc_swlm_attach() - attach the software latency manager resources 4608 * @soc: Datapath global soc handle 4609 * 4610 * Return: QDF_STATUS 4611 */ 4612 static inline QDF_STATUS dp_soc_swlm_attach(struct dp_soc *soc) 4613 { 4614 return QDF_STATUS_SUCCESS; 4615 } 4616 4617 /** 4618 * dp_soc_swlm_detach() - detach the software latency manager resources 4619 * @soc: Datapath global soc handle 4620 * 4621 * Return: QDF_STATUS 4622 */ 4623 static inline QDF_STATUS dp_soc_swlm_detach(struct dp_soc *soc) 4624 { 4625 return QDF_STATUS_SUCCESS; 4626 } 4627 #endif /* !WLAN_DP_FEATURE_SW_LATENCY_MGR */ 4628 4629 #ifndef WLAN_DP_PROFILE_SUPPORT 4630 static inline void wlan_dp_soc_cfg_sync_profile(struct cdp_soc_t *cdp_soc) {} 4631 4632 static inline void wlan_dp_pdev_cfg_sync_profile(struct cdp_soc_t *cdp_soc, 4633 uint8_t pdev_id) {} 4634 #endif 4635 4636 /** 4637 * dp_get_peer_id(): function to get peer id by mac 4638 * @soc: Datapath soc handle 4639 * @vdev_id: vdev id 4640 * @mac: Peer mac address 4641 * 4642 * Return: valid peer id on success 4643 * HTT_INVALID_PEER on failure 4644 */ 4645 uint16_t dp_get_peer_id(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac); 4646 4647 #ifdef QCA_SUPPORT_WDS_EXTENDED 4648 /** 4649 * dp_wds_ext_set_peer_rx(): function to set peer rx handler 4650 * @soc: Datapath soc handle 4651 * @vdev_id: vdev id 4652 * @mac: Peer mac address 4653 * @rx: rx function pointer 4654 * @osif_peer: OSIF peer handle 4655 * 4656 * Return: QDF_STATUS_SUCCESS on success 4657 * QDF_STATUS_E_INVAL if peer is not found 4658 * QDF_STATUS_E_ALREADY if rx is already set/unset 4659 */ 4660 QDF_STATUS dp_wds_ext_set_peer_rx(ol_txrx_soc_handle soc, 4661 uint8_t vdev_id, 4662 uint8_t *mac, 4663 ol_txrx_rx_fp rx, 4664 ol_osif_peer_handle osif_peer); 4665 4666 /** 4667 * dp_wds_ext_get_peer_osif_handle(): function to get peer osif handle 4668 * @soc: Datapath soc handle 4669 * @vdev_id: vdev id 4670 * @mac: Peer mac address 4671 * @osif_peer: OSIF peer handle 4672 * 4673 * Return: QDF_STATUS_SUCCESS on success 4674 * QDF_STATUS_E_INVAL if peer is not found 4675 */ 4676 QDF_STATUS dp_wds_ext_get_peer_osif_handle( 4677 ol_txrx_soc_handle soc, 4678 uint8_t vdev_id, 4679 uint8_t *mac, 4680 ol_osif_peer_handle *osif_peer); 4681 4682 /** 4683 * dp_wds_ext_set_peer_bit(): function to set wds-ext peer bit 4684 * @soc: Datapath soc handle 4685 * @mac: Peer mac address 4686 * 4687 * Return: QDF_STATUS_SUCCESS on success 4688 * QDF_STATUS_E_INVAL if peer is not found 4689 */ 4690 QDF_STATUS dp_wds_ext_set_peer_bit(ol_txrx_soc_handle soc, uint8_t *mac); 4691 4692 #endif /* QCA_SUPPORT_WDS_EXTENDED */ 4693 4694 #ifdef DP_MEM_PRE_ALLOC 4695 4696 /** 4697 * dp_context_alloc_mem() - allocate memory for DP context 4698 * @soc: datapath soc handle 4699 * @ctxt_type: DP context type 4700 * @ctxt_size: DP context size 4701 * 4702 * Return: DP context address 4703 */ 4704 void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 4705 size_t ctxt_size); 4706 4707 /** 4708 * dp_context_free_mem() - Free memory of DP context 4709 * @soc: datapath soc handle 4710 * @ctxt_type: DP context type 4711 * @vaddr: Address of context memory 4712 * 4713 * Return: None 4714 */ 4715 void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 4716 void *vaddr); 4717 4718 /** 4719 * dp_desc_multi_pages_mem_alloc() - alloc memory over multiple pages 4720 * @soc: datapath soc handle 4721 * @desc_type: memory request source type 4722 * @pages: multi page information storage 4723 * @element_size: each element size 4724 * @element_num: total number of elements should be allocated 4725 * @memctxt: memory context 4726 * @cacheable: coherent memory or cacheable memory 4727 * 4728 * This function is a wrapper for memory allocation over multiple 4729 * pages, if dp prealloc method is registered, then will try prealloc 4730 * firstly. if prealloc failed, fall back to regular way over 4731 * qdf_mem_multi_pages_alloc(). 4732 * 4733 * Return: None 4734 */ 4735 void dp_desc_multi_pages_mem_alloc(struct dp_soc *soc, 4736 enum qdf_dp_desc_type desc_type, 4737 struct qdf_mem_multi_page_t *pages, 4738 size_t element_size, 4739 uint32_t element_num, 4740 qdf_dma_context_t memctxt, 4741 bool cacheable); 4742 4743 /** 4744 * dp_desc_multi_pages_mem_free() - free multiple pages memory 4745 * @soc: datapath soc handle 4746 * @desc_type: memory request source type 4747 * @pages: multi page information storage 4748 * @memctxt: memory context 4749 * @cacheable: coherent memory or cacheable memory 4750 * 4751 * This function is a wrapper for multiple pages memory free, 4752 * if memory is got from prealloc pool, put it back to pool. 4753 * otherwise free by qdf_mem_multi_pages_free(). 4754 * 4755 * Return: None 4756 */ 4757 void dp_desc_multi_pages_mem_free(struct dp_soc *soc, 4758 enum qdf_dp_desc_type desc_type, 4759 struct qdf_mem_multi_page_t *pages, 4760 qdf_dma_context_t memctxt, 4761 bool cacheable); 4762 4763 #else 4764 static inline 4765 void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 4766 size_t ctxt_size) 4767 { 4768 return qdf_mem_malloc(ctxt_size); 4769 } 4770 4771 static inline 4772 void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 4773 void *vaddr) 4774 { 4775 qdf_mem_free(vaddr); 4776 } 4777 4778 static inline 4779 void dp_desc_multi_pages_mem_alloc(struct dp_soc *soc, 4780 enum qdf_dp_desc_type desc_type, 4781 struct qdf_mem_multi_page_t *pages, 4782 size_t element_size, 4783 uint32_t element_num, 4784 qdf_dma_context_t memctxt, 4785 bool cacheable) 4786 { 4787 qdf_mem_multi_pages_alloc(soc->osdev, pages, element_size, 4788 element_num, memctxt, cacheable); 4789 } 4790 4791 static inline 4792 void dp_desc_multi_pages_mem_free(struct dp_soc *soc, 4793 enum qdf_dp_desc_type desc_type, 4794 struct qdf_mem_multi_page_t *pages, 4795 qdf_dma_context_t memctxt, 4796 bool cacheable) 4797 { 4798 qdf_mem_multi_pages_free(soc->osdev, pages, 4799 memctxt, cacheable); 4800 } 4801 #endif 4802 4803 /** 4804 * struct dp_frag_history_opaque_atomic - Opaque struct for adding a fragmented 4805 * history. 4806 * @index: atomic index 4807 * @num_entries_per_slot: Number of entries per slot 4808 * @allocated: is allocated or not 4809 * @entry: pointers to array of records 4810 */ 4811 struct dp_frag_history_opaque_atomic { 4812 qdf_atomic_t index; 4813 uint16_t num_entries_per_slot; 4814 uint16_t allocated; 4815 void *entry[0]; 4816 }; 4817 4818 static inline QDF_STATUS 4819 dp_soc_frag_history_attach(struct dp_soc *soc, void *history_hdl, 4820 uint32_t max_slots, uint32_t max_entries_per_slot, 4821 uint32_t entry_size, 4822 bool attempt_prealloc, enum dp_ctxt_type ctxt_type) 4823 { 4824 struct dp_frag_history_opaque_atomic *history = 4825 (struct dp_frag_history_opaque_atomic *)history_hdl; 4826 size_t alloc_size = max_entries_per_slot * entry_size; 4827 int i; 4828 4829 for (i = 0; i < max_slots; i++) { 4830 if (attempt_prealloc) 4831 history->entry[i] = dp_context_alloc_mem(soc, ctxt_type, 4832 alloc_size); 4833 else 4834 history->entry[i] = qdf_mem_malloc(alloc_size); 4835 4836 if (!history->entry[i]) 4837 goto exit; 4838 } 4839 4840 qdf_atomic_init(&history->index); 4841 history->allocated = 1; 4842 history->num_entries_per_slot = max_entries_per_slot; 4843 4844 return QDF_STATUS_SUCCESS; 4845 exit: 4846 for (i = i - 1; i >= 0; i--) { 4847 if (attempt_prealloc) 4848 dp_context_free_mem(soc, ctxt_type, history->entry[i]); 4849 else 4850 qdf_mem_free(history->entry[i]); 4851 } 4852 4853 return QDF_STATUS_E_NOMEM; 4854 } 4855 4856 static inline 4857 void dp_soc_frag_history_detach(struct dp_soc *soc, 4858 void *history_hdl, uint32_t max_slots, 4859 bool attempt_prealloc, 4860 enum dp_ctxt_type ctxt_type) 4861 { 4862 struct dp_frag_history_opaque_atomic *history = 4863 (struct dp_frag_history_opaque_atomic *)history_hdl; 4864 int i; 4865 4866 for (i = 0; i < max_slots; i++) { 4867 if (attempt_prealloc) 4868 dp_context_free_mem(soc, ctxt_type, history->entry[i]); 4869 else 4870 qdf_mem_free(history->entry[i]); 4871 } 4872 4873 history->allocated = 0; 4874 } 4875 4876 /** 4877 * dp_get_frag_hist_next_atomic_idx() - get the next entry index to record an 4878 * entry in a fragmented history with 4879 * index being atomic. 4880 * @curr_idx: address of the current index where the last entry was written 4881 * @next_idx: pointer to update the next index 4882 * @slot: pointer to update the history slot to be selected 4883 * @slot_shift: BITwise shift mask for slot (in index) 4884 * @max_entries_per_slot: Max number of entries in a slot of history 4885 * @max_entries: Total number of entries in the history (sum of all slots) 4886 * 4887 * This function assumes that the "max_entries_per_slot" and "max_entries" 4888 * are a power-of-2. 4889 * 4890 * Return: None 4891 */ 4892 static inline void 4893 dp_get_frag_hist_next_atomic_idx(qdf_atomic_t *curr_idx, uint32_t *next_idx, 4894 uint16_t *slot, uint32_t slot_shift, 4895 uint32_t max_entries_per_slot, 4896 uint32_t max_entries) 4897 { 4898 uint32_t idx; 4899 4900 idx = qdf_do_div_rem(qdf_atomic_inc_return(curr_idx), max_entries); 4901 4902 *slot = idx >> slot_shift; 4903 *next_idx = idx & (max_entries_per_slot - 1); 4904 } 4905 4906 #ifdef FEATURE_RUNTIME_PM 4907 /** 4908 * dp_runtime_get() - Get dp runtime refcount 4909 * @soc: Datapath soc handle 4910 * 4911 * Get dp runtime refcount by increment of an atomic variable, which can block 4912 * dp runtime resume to wait to flush pending tx by runtime suspend. 4913 * 4914 * Return: Current refcount 4915 */ 4916 static inline int32_t dp_runtime_get(struct dp_soc *soc) 4917 { 4918 return qdf_atomic_inc_return(&soc->dp_runtime_refcount); 4919 } 4920 4921 /** 4922 * dp_runtime_put() - Return dp runtime refcount 4923 * @soc: Datapath soc handle 4924 * 4925 * Return dp runtime refcount by decrement of an atomic variable, allow dp 4926 * runtime resume finish. 4927 * 4928 * Return: Current refcount 4929 */ 4930 static inline int32_t dp_runtime_put(struct dp_soc *soc) 4931 { 4932 return qdf_atomic_dec_return(&soc->dp_runtime_refcount); 4933 } 4934 4935 /** 4936 * dp_runtime_get_refcount() - Get dp runtime refcount 4937 * @soc: Datapath soc handle 4938 * 4939 * Get dp runtime refcount by returning an atomic variable 4940 * 4941 * Return: Current refcount 4942 */ 4943 static inline int32_t dp_runtime_get_refcount(struct dp_soc *soc) 4944 { 4945 return qdf_atomic_read(&soc->dp_runtime_refcount); 4946 } 4947 4948 /** 4949 * dp_runtime_init() - Init DP related runtime PM clients and runtime refcount 4950 * @soc: Datapath soc handle 4951 * 4952 * Return: QDF_STATUS 4953 */ 4954 static inline void dp_runtime_init(struct dp_soc *soc) 4955 { 4956 hif_rtpm_register(HIF_RTPM_ID_DP, NULL); 4957 hif_rtpm_register(HIF_RTPM_ID_DP_RING_STATS, NULL); 4958 qdf_atomic_init(&soc->dp_runtime_refcount); 4959 } 4960 4961 /** 4962 * dp_runtime_deinit() - Deinit DP related runtime PM clients 4963 * 4964 * Return: None 4965 */ 4966 static inline void dp_runtime_deinit(void) 4967 { 4968 hif_rtpm_deregister(HIF_RTPM_ID_DP); 4969 hif_rtpm_deregister(HIF_RTPM_ID_DP_RING_STATS); 4970 } 4971 4972 /** 4973 * dp_runtime_pm_mark_last_busy() - Mark last busy when rx path in use 4974 * @soc: Datapath soc handle 4975 * 4976 * Return: None 4977 */ 4978 static inline void dp_runtime_pm_mark_last_busy(struct dp_soc *soc) 4979 { 4980 soc->rx_last_busy = qdf_get_log_timestamp_usecs(); 4981 4982 hif_rtpm_mark_last_busy(HIF_RTPM_ID_DP); 4983 } 4984 #else 4985 static inline int32_t dp_runtime_get(struct dp_soc *soc) 4986 { 4987 return 0; 4988 } 4989 4990 static inline int32_t dp_runtime_put(struct dp_soc *soc) 4991 { 4992 return 0; 4993 } 4994 4995 static inline QDF_STATUS dp_runtime_init(struct dp_soc *soc) 4996 { 4997 return QDF_STATUS_SUCCESS; 4998 } 4999 5000 static inline void dp_runtime_deinit(void) 5001 { 5002 } 5003 5004 static inline void dp_runtime_pm_mark_last_busy(struct dp_soc *soc) 5005 { 5006 } 5007 #endif 5008 5009 static inline enum QDF_GLOBAL_MODE dp_soc_get_con_mode(struct dp_soc *soc) 5010 { 5011 if (soc->cdp_soc.ol_ops->get_con_mode) 5012 return soc->cdp_soc.ol_ops->get_con_mode(); 5013 5014 return QDF_GLOBAL_MAX_MODE; 5015 } 5016 5017 /** 5018 * dp_pdev_bkp_stats_detach() - detach resources for back pressure stats 5019 * processing 5020 * @pdev: Datapath PDEV handle 5021 * 5022 */ 5023 void dp_pdev_bkp_stats_detach(struct dp_pdev *pdev); 5024 5025 /** 5026 * dp_pdev_bkp_stats_attach() - attach resources for back pressure stats 5027 * processing 5028 * @pdev: Datapath PDEV handle 5029 * 5030 * Return: QDF_STATUS_SUCCESS: Success 5031 * QDF_STATUS_E_NOMEM: Error 5032 */ 5033 5034 QDF_STATUS dp_pdev_bkp_stats_attach(struct dp_pdev *pdev); 5035 5036 /** 5037 * dp_peer_flush_frags() - Flush all fragments for a particular 5038 * peer 5039 * @soc_hdl: data path soc handle 5040 * @vdev_id: vdev id 5041 * @peer_mac: peer mac address 5042 * 5043 * Return: None 5044 */ 5045 void dp_peer_flush_frags(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 5046 uint8_t *peer_mac); 5047 5048 /** 5049 * dp_soc_reset_mon_intr_mask() - reset mon intr mask 5050 * @soc: pointer to dp_soc handle 5051 * 5052 * Return: 5053 */ 5054 void dp_soc_reset_mon_intr_mask(struct dp_soc *soc); 5055 5056 /** 5057 * dp_txrx_get_soc_stats() - will return cdp_soc_stats 5058 * @soc_hdl: soc handle 5059 * @soc_stats: buffer to hold the values 5060 * 5061 * Return: QDF_STATUS_SUCCESS: Success 5062 * QDF_STATUS_E_FAILURE: Error 5063 */ 5064 QDF_STATUS dp_txrx_get_soc_stats(struct cdp_soc_t *soc_hdl, 5065 struct cdp_soc_stats *soc_stats); 5066 5067 /** 5068 * dp_txrx_get_peer_delay_stats() - to get peer delay stats per TIDs 5069 * @soc_hdl: soc handle 5070 * @vdev_id: id of vdev handle 5071 * @peer_mac: mac of DP_PEER handle 5072 * @delay_stats: pointer to delay stats array 5073 * 5074 * Return: QDF_STATUS_SUCCESS: Success 5075 * QDF_STATUS_E_FAILURE: Error 5076 */ 5077 QDF_STATUS 5078 dp_txrx_get_peer_delay_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 5079 uint8_t *peer_mac, 5080 struct cdp_delay_tid_stats *delay_stats); 5081 5082 /** 5083 * dp_txrx_get_peer_jitter_stats() - to get peer jitter stats per TIDs 5084 * @soc_hdl: soc handle 5085 * @pdev_id: id of pdev handle 5086 * @vdev_id: id of vdev handle 5087 * @peer_mac: mac of DP_PEER handle 5088 * @tid_stats: pointer to jitter stats array 5089 * 5090 * Return: QDF_STATUS_SUCCESS: Success 5091 * QDF_STATUS_E_FAILURE: Error 5092 */ 5093 QDF_STATUS 5094 dp_txrx_get_peer_jitter_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 5095 uint8_t vdev_id, uint8_t *peer_mac, 5096 struct cdp_peer_tid_stats *tid_stats); 5097 5098 /** 5099 * dp_peer_get_tx_capture_stats() - to get peer Tx Capture stats 5100 * @soc_hdl: soc handle 5101 * @vdev_id: id of vdev handle 5102 * @peer_mac: mac of DP_PEER handle 5103 * @stats: pointer to peer tx capture stats 5104 * 5105 * Return: QDF_STATUS_SUCCESS: Success 5106 * QDF_STATUS_E_FAILURE: Error 5107 */ 5108 QDF_STATUS 5109 dp_peer_get_tx_capture_stats(struct cdp_soc_t *soc_hdl, 5110 uint8_t vdev_id, uint8_t *peer_mac, 5111 struct cdp_peer_tx_capture_stats *stats); 5112 5113 /** 5114 * dp_pdev_get_tx_capture_stats() - to get pdev Tx Capture stats 5115 * @soc_hdl: soc handle 5116 * @pdev_id: id of pdev handle 5117 * @stats: pointer to pdev tx capture stats 5118 * 5119 * Return: QDF_STATUS_SUCCESS: Success 5120 * QDF_STATUS_E_FAILURE: Error 5121 */ 5122 QDF_STATUS 5123 dp_pdev_get_tx_capture_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 5124 struct cdp_pdev_tx_capture_stats *stats); 5125 5126 #ifdef HW_TX_DELAY_STATS_ENABLE 5127 /** 5128 * dp_is_vdev_tx_delay_stats_enabled(): Check if tx delay stats 5129 * is enabled for vdev 5130 * @vdev: dp vdev 5131 * 5132 * Return: true if tx delay stats is enabled for vdev else false 5133 */ 5134 static inline uint8_t dp_is_vdev_tx_delay_stats_enabled(struct dp_vdev *vdev) 5135 { 5136 return vdev->hw_tx_delay_stats_enabled; 5137 } 5138 5139 /** 5140 * dp_pdev_print_tx_delay_stats(): Print vdev tx delay stats 5141 * for pdev 5142 * @soc: dp soc 5143 * 5144 * Return: None 5145 */ 5146 void dp_pdev_print_tx_delay_stats(struct dp_soc *soc); 5147 5148 /** 5149 * dp_pdev_clear_tx_delay_stats() - clear tx delay stats 5150 * @soc: soc handle 5151 * 5152 * Return: None 5153 */ 5154 void dp_pdev_clear_tx_delay_stats(struct dp_soc *soc); 5155 #else 5156 static inline uint8_t dp_is_vdev_tx_delay_stats_enabled(struct dp_vdev *vdev) 5157 { 5158 return 0; 5159 } 5160 5161 static inline void dp_pdev_print_tx_delay_stats(struct dp_soc *soc) 5162 { 5163 } 5164 5165 static inline void dp_pdev_clear_tx_delay_stats(struct dp_soc *soc) 5166 { 5167 } 5168 #endif 5169 5170 static inline void 5171 dp_get_rx_hash_key_bytes(struct cdp_lro_hash_config *lro_hash) 5172 { 5173 qdf_get_random_bytes(lro_hash->toeplitz_hash_ipv4, 5174 (sizeof(lro_hash->toeplitz_hash_ipv4[0]) * 5175 LRO_IPV4_SEED_ARR_SZ)); 5176 qdf_get_random_bytes(lro_hash->toeplitz_hash_ipv6, 5177 (sizeof(lro_hash->toeplitz_hash_ipv6[0]) * 5178 LRO_IPV6_SEED_ARR_SZ)); 5179 } 5180 5181 #ifdef WLAN_CONFIG_TELEMETRY_AGENT 5182 /** 5183 * dp_get_pdev_telemetry_stats- API to get pdev telemetry stats 5184 * @soc_hdl: soc handle 5185 * @pdev_id: id of pdev handle 5186 * @stats: pointer to pdev telemetry stats 5187 * 5188 * Return: QDF_STATUS_SUCCESS: Success 5189 * QDF_STATUS_E_FAILURE: Error 5190 */ 5191 QDF_STATUS 5192 dp_get_pdev_telemetry_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 5193 struct cdp_pdev_telemetry_stats *stats); 5194 5195 /** 5196 * dp_get_peer_telemetry_stats() - API to get peer telemetry stats 5197 * @soc_hdl: soc handle 5198 * @addr: peer mac 5199 * @stats: pointer to peer telemetry stats 5200 * 5201 * Return: QDF_STATUS_SUCCESS: Success 5202 * QDF_STATUS_E_FAILURE: Error 5203 */ 5204 QDF_STATUS 5205 dp_get_peer_telemetry_stats(struct cdp_soc_t *soc_hdl, uint8_t *addr, 5206 struct cdp_peer_telemetry_stats *stats); 5207 5208 /** 5209 * dp_get_peer_deter_stats() - API to get peer deterministic stats 5210 * @soc_hdl: soc handle 5211 * @vdev_id: id of vdev handle 5212 * @addr: peer mac 5213 * @stats: pointer to peer deterministic stats 5214 * 5215 * Return: QDF_STATUS_SUCCESS: Success 5216 * QDF_STATUS_E_FAILURE: Error 5217 */ 5218 QDF_STATUS 5219 dp_get_peer_deter_stats(struct cdp_soc_t *soc_hdl, 5220 uint8_t vdev_id, 5221 uint8_t *addr, 5222 struct cdp_peer_deter_stats *stats); 5223 5224 /** 5225 * dp_get_pdev_deter_stats() - API to get pdev deterministic stats 5226 * @soc_hdl: soc handle 5227 * @pdev_id: id of pdev handle 5228 * @stats: pointer to pdev deterministic stats 5229 * 5230 * Return: QDF_STATUS_SUCCESS: Success 5231 * QDF_STATUS_E_FAILURE: Error 5232 */ 5233 QDF_STATUS 5234 dp_get_pdev_deter_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 5235 struct cdp_pdev_deter_stats *stats); 5236 5237 /** 5238 * dp_update_pdev_chan_util_stats() - API to update channel utilization stats 5239 * @soc_hdl: soc handle 5240 * @pdev_id: id of pdev handle 5241 * @ch_util: Pointer to channel util stats 5242 * 5243 * Return: QDF_STATUS_SUCCESS: Success 5244 * QDF_STATUS_E_FAILURE: Error 5245 */ 5246 QDF_STATUS 5247 dp_update_pdev_chan_util_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 5248 struct cdp_pdev_chan_util_stats *ch_util); 5249 #endif /* WLAN_CONFIG_TELEMETRY_AGENT */ 5250 5251 #ifdef CONNECTIVITY_PKTLOG 5252 /** 5253 * dp_tx_send_pktlog() - send tx packet log 5254 * @soc: soc handle 5255 * @pdev: pdev handle 5256 * @tx_desc: TX software descriptor 5257 * @nbuf: nbuf 5258 * @status: status of tx packet 5259 * 5260 * This function is used to send tx packet for logging 5261 * 5262 * Return: None 5263 * 5264 */ 5265 static inline 5266 void dp_tx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 5267 struct dp_tx_desc_s *tx_desc, 5268 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) 5269 { 5270 ol_txrx_pktdump_cb packetdump_cb = pdev->dp_tx_packetdump_cb; 5271 5272 if (qdf_unlikely(packetdump_cb) && 5273 dp_tx_frm_std == tx_desc->frm_type) { 5274 packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id, 5275 tx_desc->vdev_id, nbuf, status, QDF_TX_DATA_PKT); 5276 } 5277 } 5278 5279 /** 5280 * dp_rx_send_pktlog() - send rx packet log 5281 * @soc: soc handle 5282 * @pdev: pdev handle 5283 * @nbuf: nbuf 5284 * @status: status of rx packet 5285 * 5286 * This function is used to send rx packet for logging 5287 * 5288 * Return: None 5289 * 5290 */ 5291 static inline 5292 void dp_rx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 5293 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) 5294 { 5295 ol_txrx_pktdump_cb packetdump_cb = pdev->dp_rx_packetdump_cb; 5296 5297 if (qdf_unlikely(packetdump_cb)) { 5298 packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id, 5299 QDF_NBUF_CB_RX_VDEV_ID(nbuf), 5300 nbuf, status, QDF_RX_DATA_PKT); 5301 } 5302 } 5303 5304 /** 5305 * dp_rx_err_send_pktlog() - send rx error packet log 5306 * @soc: soc handle 5307 * @pdev: pdev handle 5308 * @mpdu_desc_info: MPDU descriptor info 5309 * @nbuf: nbuf 5310 * @status: status of rx packet 5311 * @set_pktlen: weither to set packet length 5312 * 5313 * This API should only be called when we have not removed 5314 * Rx TLV from head, and head is pointing to rx_tlv 5315 * 5316 * This function is used to send rx packet from error path 5317 * for logging for which rx packet tlv is not removed. 5318 * 5319 * Return: None 5320 * 5321 */ 5322 static inline 5323 void dp_rx_err_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 5324 struct hal_rx_mpdu_desc_info *mpdu_desc_info, 5325 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status, 5326 bool set_pktlen) 5327 { 5328 ol_txrx_pktdump_cb packetdump_cb = pdev->dp_rx_packetdump_cb; 5329 qdf_size_t skip_size; 5330 uint16_t msdu_len, nbuf_len; 5331 uint8_t *rx_tlv_hdr; 5332 struct hal_rx_msdu_metadata msdu_metadata; 5333 uint16_t buf_size; 5334 5335 buf_size = wlan_cfg_rx_buffer_size(soc->wlan_cfg_ctx); 5336 5337 if (qdf_unlikely(packetdump_cb)) { 5338 rx_tlv_hdr = qdf_nbuf_data(nbuf); 5339 nbuf_len = hal_rx_msdu_start_msdu_len_get(soc->hal_soc, 5340 rx_tlv_hdr); 5341 hal_rx_msdu_metadata_get(soc->hal_soc, rx_tlv_hdr, 5342 &msdu_metadata); 5343 5344 if (mpdu_desc_info->bar_frame || 5345 (mpdu_desc_info->mpdu_flags & HAL_MPDU_F_FRAGMENT)) 5346 skip_size = soc->rx_pkt_tlv_size; 5347 else 5348 skip_size = soc->rx_pkt_tlv_size + 5349 msdu_metadata.l3_hdr_pad; 5350 5351 if (set_pktlen) { 5352 msdu_len = nbuf_len + skip_size; 5353 qdf_nbuf_set_pktlen(nbuf, qdf_min(msdu_len, buf_size)); 5354 } 5355 5356 qdf_nbuf_pull_head(nbuf, skip_size); 5357 packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id, 5358 QDF_NBUF_CB_RX_VDEV_ID(nbuf), 5359 nbuf, status, QDF_RX_DATA_PKT); 5360 qdf_nbuf_push_head(nbuf, skip_size); 5361 } 5362 } 5363 5364 #else 5365 static inline 5366 void dp_tx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 5367 struct dp_tx_desc_s *tx_desc, 5368 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) 5369 { 5370 } 5371 5372 static inline 5373 void dp_rx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 5374 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) 5375 { 5376 } 5377 5378 static inline 5379 void dp_rx_err_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, 5380 struct hal_rx_mpdu_desc_info *mpdu_desc_info, 5381 qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status, 5382 bool set_pktlen) 5383 { 5384 } 5385 #endif 5386 5387 /** 5388 * dp_pdev_update_fast_rx_flag() - Update Fast rx flag for a PDEV 5389 * @soc : Data path soc handle 5390 * @pdev : PDEV handle 5391 * 5392 * Return: None 5393 */ 5394 void dp_pdev_update_fast_rx_flag(struct dp_soc *soc, struct dp_pdev *pdev); 5395 5396 #ifdef FEATURE_DIRECT_LINK 5397 /** 5398 * dp_setup_direct_link_refill_ring(): Setup direct link refill ring for pdev 5399 * @soc_hdl: DP SOC handle 5400 * @pdev_id: pdev id 5401 * 5402 * Return: Handle to SRNG 5403 */ 5404 struct dp_srng *dp_setup_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, 5405 uint8_t pdev_id); 5406 5407 /** 5408 * dp_destroy_direct_link_refill_ring(): Destroy direct link refill ring for 5409 * pdev 5410 * @soc_hdl: DP SOC handle 5411 * @pdev_id: pdev id 5412 * 5413 * Return: None 5414 */ 5415 void dp_destroy_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, 5416 uint8_t pdev_id); 5417 #else 5418 static inline 5419 struct dp_srng *dp_setup_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, 5420 uint8_t pdev_id) 5421 { 5422 return NULL; 5423 } 5424 5425 static inline 5426 void dp_destroy_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, 5427 uint8_t pdev_id) 5428 { 5429 } 5430 #endif 5431 5432 #ifdef WLAN_FEATURE_DP_CFG_EVENT_HISTORY 5433 static inline 5434 void dp_cfg_event_record(struct dp_soc *soc, 5435 enum dp_cfg_event_type event, 5436 union dp_cfg_event_desc *cfg_event_desc) 5437 { 5438 struct dp_cfg_event_history *cfg_event_history = 5439 &soc->cfg_event_history; 5440 struct dp_cfg_event *entry; 5441 uint32_t idx; 5442 uint16_t slot; 5443 5444 dp_get_frag_hist_next_atomic_idx(&cfg_event_history->index, &idx, 5445 &slot, 5446 DP_CFG_EVT_HIST_SLOT_SHIFT, 5447 DP_CFG_EVT_HIST_PER_SLOT_MAX, 5448 DP_CFG_EVT_HISTORY_SIZE); 5449 5450 entry = &cfg_event_history->entry[slot][idx]; 5451 5452 entry->timestamp = qdf_get_log_timestamp(); 5453 entry->type = event; 5454 qdf_mem_copy(&entry->event_desc, cfg_event_desc, 5455 sizeof(entry->event_desc)); 5456 } 5457 5458 static inline void 5459 dp_cfg_event_record_vdev_evt(struct dp_soc *soc, enum dp_cfg_event_type event, 5460 struct dp_vdev *vdev) 5461 { 5462 union dp_cfg_event_desc cfg_evt_desc = {0}; 5463 struct dp_vdev_attach_detach_desc *vdev_evt = 5464 &cfg_evt_desc.vdev_evt; 5465 5466 if (qdf_unlikely(event != DP_CFG_EVENT_VDEV_ATTACH && 5467 event != DP_CFG_EVENT_VDEV_UNREF_DEL && 5468 event != DP_CFG_EVENT_VDEV_DETACH)) { 5469 qdf_assert_always(0); 5470 return; 5471 } 5472 5473 vdev_evt->vdev = vdev; 5474 vdev_evt->vdev_id = vdev->vdev_id; 5475 vdev_evt->ref_count = qdf_atomic_read(&vdev->ref_cnt); 5476 vdev_evt->mac_addr = vdev->mac_addr; 5477 5478 dp_cfg_event_record(soc, event, &cfg_evt_desc); 5479 } 5480 5481 static inline void 5482 dp_cfg_event_record_peer_evt(struct dp_soc *soc, enum dp_cfg_event_type event, 5483 struct dp_peer *peer, struct dp_vdev *vdev, 5484 uint8_t is_reuse) 5485 { 5486 union dp_cfg_event_desc cfg_evt_desc = {0}; 5487 struct dp_peer_cmn_ops_desc *peer_evt = &cfg_evt_desc.peer_cmn_evt; 5488 5489 if (qdf_unlikely(event != DP_CFG_EVENT_PEER_CREATE && 5490 event != DP_CFG_EVENT_PEER_DELETE && 5491 event != DP_CFG_EVENT_PEER_UNREF_DEL)) { 5492 qdf_assert_always(0); 5493 return; 5494 } 5495 5496 peer_evt->peer = peer; 5497 peer_evt->vdev = vdev; 5498 peer_evt->vdev_id = vdev->vdev_id; 5499 peer_evt->is_reuse = is_reuse; 5500 peer_evt->peer_ref_count = qdf_atomic_read(&peer->ref_cnt); 5501 peer_evt->vdev_ref_count = qdf_atomic_read(&vdev->ref_cnt); 5502 peer_evt->mac_addr = peer->mac_addr; 5503 peer_evt->vdev_mac_addr = vdev->mac_addr; 5504 5505 dp_cfg_event_record(soc, event, &cfg_evt_desc); 5506 } 5507 5508 static inline void 5509 dp_cfg_event_record_mlo_link_delink_evt(struct dp_soc *soc, 5510 enum dp_cfg_event_type event, 5511 struct dp_peer *mld_peer, 5512 struct dp_peer *link_peer, 5513 uint8_t idx, uint8_t result) 5514 { 5515 union dp_cfg_event_desc cfg_evt_desc = {0}; 5516 struct dp_mlo_add_del_link_desc *mlo_link_delink_evt = 5517 &cfg_evt_desc.mlo_link_delink_evt; 5518 5519 if (qdf_unlikely(event != DP_CFG_EVENT_MLO_ADD_LINK && 5520 event != DP_CFG_EVENT_MLO_DEL_LINK)) { 5521 qdf_assert_always(0); 5522 return; 5523 } 5524 5525 mlo_link_delink_evt->link_peer = link_peer; 5526 mlo_link_delink_evt->mld_peer = mld_peer; 5527 mlo_link_delink_evt->link_mac_addr = link_peer->mac_addr; 5528 mlo_link_delink_evt->mld_mac_addr = mld_peer->mac_addr; 5529 mlo_link_delink_evt->num_links = mld_peer->num_links; 5530 mlo_link_delink_evt->action_result = result; 5531 mlo_link_delink_evt->idx = idx; 5532 5533 dp_cfg_event_record(soc, event, &cfg_evt_desc); 5534 } 5535 5536 static inline void 5537 dp_cfg_event_record_mlo_setup_vdev_update_evt(struct dp_soc *soc, 5538 struct dp_peer *mld_peer, 5539 struct dp_vdev *prev_vdev, 5540 struct dp_vdev *new_vdev) 5541 { 5542 union dp_cfg_event_desc cfg_evt_desc = {0}; 5543 struct dp_mlo_setup_vdev_update_desc *vdev_update_evt = 5544 &cfg_evt_desc.mlo_setup_vdev_update; 5545 5546 vdev_update_evt->mld_peer = mld_peer; 5547 vdev_update_evt->prev_vdev = prev_vdev; 5548 vdev_update_evt->new_vdev = new_vdev; 5549 5550 dp_cfg_event_record(soc, DP_CFG_EVENT_MLO_SETUP_VDEV_UPDATE, 5551 &cfg_evt_desc); 5552 } 5553 5554 static inline void 5555 dp_cfg_event_record_peer_map_unmap_evt(struct dp_soc *soc, 5556 enum dp_cfg_event_type event, 5557 struct dp_peer *peer, 5558 uint8_t *mac_addr, 5559 uint8_t is_ml_peer, 5560 uint16_t peer_id, uint16_t ml_peer_id, 5561 uint16_t hw_peer_id, uint8_t vdev_id) 5562 { 5563 union dp_cfg_event_desc cfg_evt_desc = {0}; 5564 struct dp_rx_peer_map_unmap_desc *peer_map_unmap_evt = 5565 &cfg_evt_desc.peer_map_unmap_evt; 5566 5567 if (qdf_unlikely(event != DP_CFG_EVENT_PEER_MAP && 5568 event != DP_CFG_EVENT_PEER_UNMAP && 5569 event != DP_CFG_EVENT_MLO_PEER_MAP && 5570 event != DP_CFG_EVENT_MLO_PEER_UNMAP)) { 5571 qdf_assert_always(0); 5572 return; 5573 } 5574 5575 peer_map_unmap_evt->peer_id = peer_id; 5576 peer_map_unmap_evt->ml_peer_id = ml_peer_id; 5577 peer_map_unmap_evt->hw_peer_id = hw_peer_id; 5578 peer_map_unmap_evt->vdev_id = vdev_id; 5579 /* Peer may be NULL at times, but its not an issue. */ 5580 peer_map_unmap_evt->peer = peer; 5581 peer_map_unmap_evt->is_ml_peer = is_ml_peer; 5582 qdf_mem_copy(&peer_map_unmap_evt->mac_addr.raw, mac_addr, 5583 QDF_MAC_ADDR_SIZE); 5584 5585 dp_cfg_event_record(soc, event, &cfg_evt_desc); 5586 } 5587 5588 static inline void 5589 dp_cfg_event_record_peer_setup_evt(struct dp_soc *soc, 5590 enum dp_cfg_event_type event, 5591 struct dp_peer *peer, 5592 struct dp_vdev *vdev, 5593 uint8_t vdev_id, 5594 struct cdp_peer_setup_info *peer_setup_info) 5595 { 5596 union dp_cfg_event_desc cfg_evt_desc = {0}; 5597 struct dp_peer_setup_desc *peer_setup_evt = 5598 &cfg_evt_desc.peer_setup_evt; 5599 5600 if (qdf_unlikely(event != DP_CFG_EVENT_PEER_SETUP && 5601 event != DP_CFG_EVENT_MLO_SETUP)) { 5602 qdf_assert_always(0); 5603 return; 5604 } 5605 5606 peer_setup_evt->peer = peer; 5607 peer_setup_evt->vdev = vdev; 5608 if (vdev) 5609 peer_setup_evt->vdev_ref_count = qdf_atomic_read(&vdev->ref_cnt); 5610 peer_setup_evt->mac_addr = peer->mac_addr; 5611 peer_setup_evt->vdev_id = vdev_id; 5612 if (peer_setup_info) { 5613 peer_setup_evt->is_first_link = peer_setup_info->is_first_link; 5614 peer_setup_evt->is_primary_link = peer_setup_info->is_primary_link; 5615 qdf_mem_copy(peer_setup_evt->mld_mac_addr.raw, 5616 peer_setup_info->mld_peer_mac, 5617 QDF_MAC_ADDR_SIZE); 5618 } 5619 5620 dp_cfg_event_record(soc, event, &cfg_evt_desc); 5621 } 5622 #else 5623 5624 static inline void 5625 dp_cfg_event_record_vdev_evt(struct dp_soc *soc, enum dp_cfg_event_type event, 5626 struct dp_vdev *vdev) 5627 { 5628 } 5629 5630 static inline void 5631 dp_cfg_event_record_peer_evt(struct dp_soc *soc, enum dp_cfg_event_type event, 5632 struct dp_peer *peer, struct dp_vdev *vdev, 5633 uint8_t is_reuse) 5634 { 5635 } 5636 5637 static inline void 5638 dp_cfg_event_record_mlo_link_delink_evt(struct dp_soc *soc, 5639 enum dp_cfg_event_type event, 5640 struct dp_peer *mld_peer, 5641 struct dp_peer *link_peer, 5642 uint8_t idx, uint8_t result) 5643 { 5644 } 5645 5646 static inline void 5647 dp_cfg_event_record_mlo_setup_vdev_update_evt(struct dp_soc *soc, 5648 struct dp_peer *mld_peer, 5649 struct dp_vdev *prev_vdev, 5650 struct dp_vdev *new_vdev) 5651 { 5652 } 5653 5654 static inline void 5655 dp_cfg_event_record_peer_map_unmap_evt(struct dp_soc *soc, 5656 enum dp_cfg_event_type event, 5657 struct dp_peer *peer, 5658 uint8_t *mac_addr, 5659 uint8_t is_ml_peer, 5660 uint16_t peer_id, uint16_t ml_peer_id, 5661 uint16_t hw_peer_id, uint8_t vdev_id) 5662 { 5663 } 5664 5665 static inline void 5666 dp_cfg_event_record_peer_setup_evt(struct dp_soc *soc, 5667 enum dp_cfg_event_type event, 5668 struct dp_peer *peer, 5669 struct dp_vdev *vdev, 5670 uint8_t vdev_id, 5671 struct cdp_peer_setup_info *peer_setup_info) 5672 { 5673 } 5674 #endif 5675 5676 #ifndef WLAN_SOFTUMAC_SUPPORT 5677 /** 5678 * dp_soc_interrupt_detach() - Deregister any allocations done for interrupts 5679 * @txrx_soc: DP SOC handle 5680 * 5681 * Return: none 5682 */ 5683 void dp_soc_interrupt_detach(struct cdp_soc_t *txrx_soc); 5684 #endif 5685 5686 /** 5687 * dp_get_peer_stats()- Get peer stats 5688 * @peer: Datapath peer 5689 * @peer_stats: buffer for peer stats 5690 * 5691 * Return: none 5692 */ 5693 void dp_get_peer_stats(struct dp_peer *peer, 5694 struct cdp_peer_stats *peer_stats); 5695 5696 /** 5697 * dp_get_per_link_peer_stats()- Get per link peer stats 5698 * @peer: Datapath peer 5699 * @peer_stats: buffer for peer stats 5700 * @peer_type: Peer type 5701 * @num_link: Number of ML links 5702 * 5703 * Return: status success/failure 5704 */ 5705 QDF_STATUS dp_get_per_link_peer_stats(struct dp_peer *peer, 5706 struct cdp_peer_stats *peer_stats, 5707 enum cdp_peer_type peer_type, 5708 uint8_t num_link); 5709 /** 5710 * dp_get_peer_hw_link_id() - get peer hardware link id 5711 * @soc: soc handle 5712 * @pdev: data path pdev 5713 * 5714 * Return: link_id 5715 */ 5716 static inline int 5717 dp_get_peer_hw_link_id(struct dp_soc *soc, 5718 struct dp_pdev *pdev) 5719 { 5720 if (wlan_cfg_is_peer_link_stats_enabled(soc->wlan_cfg_ctx)) 5721 return ((soc->arch_ops.get_hw_link_id(pdev)) + 1); 5722 5723 return 0; 5724 } 5725 5726 #ifdef QCA_MULTIPASS_SUPPORT 5727 /** 5728 * dp_tx_remove_vlan_tag() - Remove 4 bytes of vlan tag 5729 * @vdev: DP vdev handle 5730 * @nbuf: network buffer 5731 * 5732 * Return: void 5733 */ 5734 void dp_tx_remove_vlan_tag(struct dp_vdev *vdev, qdf_nbuf_t nbuf); 5735 #endif 5736 5737 /** 5738 * dp_print_per_link_stats() - Print per link peer stats. 5739 * @soc_hdl: soc handle. 5740 * @vdev_id: vdev_id. 5741 * 5742 * Return: None. 5743 */ 5744 void dp_print_per_link_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id); 5745 5746 /** 5747 * dp_get_ring_stats_from_hal(): get hal level ring pointer values 5748 * @soc: DP_SOC handle 5749 * @srng: DP_SRNG handle 5750 * @ring_type: srng src/dst ring 5751 * @_tailp: pointer to tail of ring 5752 * @_headp: pointer to head of ring 5753 * @_hw_headp: pointer to head of ring in HW 5754 * @_hw_tailp: pointer to tail of ring in HW 5755 * 5756 * Return: void 5757 */ 5758 static inline void 5759 dp_get_ring_stats_from_hal(struct dp_soc *soc, struct dp_srng *srng, 5760 enum hal_ring_type ring_type, 5761 uint32_t *_tailp, uint32_t *_headp, 5762 int32_t *_hw_headp, int32_t *_hw_tailp) 5763 { 5764 uint32_t tailp; 5765 uint32_t headp; 5766 int32_t hw_headp = -1; 5767 int32_t hw_tailp = -1; 5768 struct hal_soc *hal_soc; 5769 5770 if (soc && srng && srng->hal_srng) { 5771 hal_soc = (struct hal_soc *)soc->hal_soc; 5772 hal_get_sw_hptp(soc->hal_soc, srng->hal_srng, &tailp, &headp); 5773 *_headp = headp; 5774 *_tailp = tailp; 5775 5776 hal_get_hw_hptp(soc->hal_soc, srng->hal_srng, &hw_headp, 5777 &hw_tailp, ring_type); 5778 *_hw_headp = hw_headp; 5779 *_hw_tailp = hw_tailp; 5780 } 5781 } 5782 5783 /** 5784 * dp_update_vdev_be_basic_stats() - Update vdev basic stats 5785 * @txrx_peer: DP txrx_peer handle 5786 * @tgtobj: Pointer to buffer for be vdev stats 5787 * 5788 * Return: None 5789 */ 5790 void dp_update_vdev_be_basic_stats(struct dp_txrx_peer *txrx_peer, 5791 struct dp_vdev_stats *tgtobj); 5792 5793 /** 5794 * dp_update_vdev_basic_stats() - Update vdev basic stats 5795 * @txrx_peer: DP txrx_peer handle 5796 * @tgtobj: Pointer to buffer for vdev stats 5797 * 5798 * Return: None 5799 */ 5800 void dp_update_vdev_basic_stats(struct dp_txrx_peer *txrx_peer, 5801 struct cdp_vdev_stats *tgtobj); 5802 5803 /** 5804 * dp_get_vdev_stats_for_unmap_peer_legacy() - Update vdev basic stats 5805 * @vdev: vdev associated with the peer 5806 * @peer: unmapped peer 5807 * 5808 * Return: None 5809 */ 5810 void dp_get_vdev_stats_for_unmap_peer_legacy(struct dp_vdev *vdev, 5811 struct dp_peer *peer); 5812 5813 #ifdef WLAN_FEATURE_TX_LATENCY_STATS 5814 /** 5815 * dp_h2t_tx_latency_stats_cfg_msg_send(): send HTT message for tx latency 5816 * stats config to FW 5817 * @dp_soc: DP SOC handle 5818 * @vdev_id: vdev id 5819 * @enable: indicates enablement of the feature 5820 * @period: statistical period for transmit latency in terms of ms 5821 * @granularity: granularity for tx latency distribution 5822 * 5823 * return: QDF STATUS 5824 */ 5825 QDF_STATUS 5826 dp_h2t_tx_latency_stats_cfg_msg_send(struct dp_soc *dp_soc, uint16_t vdev_id, 5827 bool enable, uint32_t period, 5828 uint32_t granularity); 5829 5830 /** 5831 * dp_tx_latency_stats_update_cca() - update transmit latency statistics for 5832 * CCA 5833 * @soc: dp soc handle 5834 * @peer_id: peer id 5835 * @granularity: granularity of distribution 5836 * @distribution: distribution of transmit latency statistics 5837 * @avg: average of CCA latency(in microseconds) within a cycle 5838 * 5839 * Return: None 5840 */ 5841 void 5842 dp_tx_latency_stats_update_cca(struct dp_soc *soc, uint16_t peer_id, 5843 uint32_t granularity, uint32_t *distribution, 5844 uint32_t avg); 5845 5846 /** 5847 * dp_tx_latency_stats_report() - report transmit latency statistics for each 5848 * vdev of specified pdev 5849 * @soc: dp soc handle 5850 * @pdev: dp pdev Handle 5851 * 5852 * Return: None 5853 */ 5854 void dp_tx_latency_stats_report(struct dp_soc *soc, struct dp_pdev *pdev); 5855 #endif 5856 #ifdef WLAN_FEATURE_SSR_DRIVER_DUMP 5857 /** 5858 * dp_ssr_dump_srng_register() - Register DP ring with SSR dump. 5859 * @region_name: ring name to register. 5860 * @srng: dp srng handler. 5861 * @num: Ring number 5862 * 5863 * num = -1. If there is only single ring 5864 * num = ring number. If there are multiple rings pass ring number. 5865 * e.g. in case of REO pass reo number (0..n). 5866 * 5867 * Return: None. 5868 */ 5869 void 5870 dp_ssr_dump_srng_register(char *region_name, struct dp_srng *srng, int num); 5871 5872 /** 5873 * dp_ssr_dump_srng_unregister() - Unegister DP ring with SSR dump. 5874 * @region_name: ring name to unregister. 5875 * @num: Ring number 5876 * 5877 * num = -1. If there is only single ring 5878 * num = ring number. If there are multiple rings pass ring number. 5879 * e.g. in case of REO pass reo number (0..n). 5880 * 5881 * Return: None. 5882 */ 5883 void dp_ssr_dump_srng_unregister(char *region_name, int num); 5884 5885 /** 5886 * dp_ssr_dump_pdev_register() - Register DP Pdev with SSR dump. 5887 * @pdev: Pdev handle to register. 5888 * @pdev_id: Pdev ID. 5889 * 5890 * Return: None. 5891 */ 5892 void dp_ssr_dump_pdev_register(struct dp_pdev *pdev, uint8_t pdev_id); 5893 5894 /** 5895 * dp_ssr_dump_pdev_unregister() - Unregister DP Pdev with SSR dump. 5896 * @pdev_id: Pdev ID. 5897 * 5898 * Return: None. 5899 */ 5900 void dp_ssr_dump_pdev_unregister(uint8_t pdev_id); 5901 #else 5902 static inline 5903 void dp_ssr_dump_srng_register(char *region_name, struct dp_srng *srng, int num) 5904 { 5905 } 5906 5907 static inline 5908 void dp_ssr_dump_srng_unregister(char *region_name, int num) 5909 { 5910 } 5911 5912 static inline 5913 void dp_ssr_dump_pdev_register(struct dp_pdev *pdev, uint8_t pdev_id) 5914 { 5915 } 5916 5917 static inline 5918 void dp_ssr_dump_pdev_unregister(uint8_t pdev_id) 5919 { 5920 } 5921 #endif 5922 5923 /** 5924 * dp_get_peer_vdev_roaming_in_progress() - Check if peer's vdev is in roaming 5925 * state. 5926 * @peer: DP peer handle 5927 * 5928 * Return: true if the peer's vdev is in roaming state 5929 * else false. 5930 */ 5931 bool dp_get_peer_vdev_roaming_in_progress(struct dp_peer *peer); 5932 5933 #endif /* #ifndef _DP_INTERNAL_H_ */ 5934