1 /* 2 * Copyright (c) 2011-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 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 /** 21 * DOC: cdp_txrx_cmn.h 22 * Define the host data path converged API functions 23 * called by the host control SW and the OS interface module 24 */ 25 #ifndef _CDP_TXRX_CMN_H_ 26 #define _CDP_TXRX_CMN_H_ 27 28 #include "qdf_types.h" 29 #include "qdf_nbuf.h" 30 #include "cdp_txrx_ops.h" 31 #include "cdp_txrx_handle.h" 32 #include "cdp_txrx_cmn_struct.h" 33 #include "wlan_objmgr_global_obj.h" 34 35 #ifdef ENABLE_VERBOSE_DEBUG 36 extern bool is_dp_verbose_debug_enabled; 37 #endif 38 39 /****************************************************************************** 40 * 41 * Common Data Path Header File 42 * 43 *****************************************************************************/ 44 #define dp_alert(params...) QDF_TRACE_FATAL(QDF_MODULE_ID_DP, params) 45 #define dp_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_DP, params) 46 #define dp_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_DP, params) 47 #define dp_info(params...) \ 48 __QDF_TRACE_FL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_DP, ## params) 49 #define dp_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_DP, params) 50 51 #ifdef DP_PRINT_NO_CONSOLE 52 #define dp_err_log(params...) \ 53 __QDF_TRACE_FL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_DP, ## params) 54 #define dp_info_rl(params...) \ 55 __QDF_TRACE_RL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_DP, ## params) 56 #else 57 #define dp_err_log(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_DP, params) 58 #define dp_info_rl(params...) QDF_TRACE_INFO_RL(QDF_MODULE_ID_DP, params) 59 #endif /* DP_PRINT_NO_CONSOLE */ 60 61 #ifdef ENABLE_VERBOSE_DEBUG 62 /** 63 * enum verbose_debug_module - 64 * if INI "enable_verbose_debug" has to set following bit positions to enable 65 * respective module's excessive logging, 66 * 67 * @hif_verbose_debug_mask: 1st bit [0th index] is for HIF module 68 * @hal_verbose_debug_mask: 2nd bit [1st index] is for HAL module 69 * @dp_verbose_debug_mask: 3rd bit [2nd index] is for DP module 70 */ 71 enum verbose_debug_module { 72 hif_verbose_debug_mask = 1 << 0, 73 hal_verbose_debug_mask = 1 << 1, 74 dp_verbose_debug_mask = 1 << 2, 75 }; 76 77 /* legacy misspelled enumerator */ 78 #define hif_vebose_debug_mask hif_verbose_debug_mask 79 80 #define dp_verbose_debug(params...) \ 81 if (unlikely(is_dp_verbose_debug_enabled)) \ 82 do {\ 83 QDF_TRACE_DEBUG(QDF_MODULE_ID_DP, params); \ 84 } while (0) 85 #else 86 #define dp_verbose_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_DP, params) 87 #endif 88 89 #define dp_nofl_alert(params...) \ 90 QDF_TRACE_FATAL_NO_FL(QDF_MODULE_ID_DP, params) 91 #define dp_nofl_err(params...) \ 92 QDF_TRACE_ERROR_NO_FL(QDF_MODULE_ID_DP, params) 93 #define dp_nofl_warn(params...) \ 94 QDF_TRACE_WARN_NO_FL(QDF_MODULE_ID_DP, params) 95 #define dp_nofl_info(params...) \ 96 QDF_TRACE_INFO_NO_FL(QDF_MODULE_ID_DP, params) 97 #define dp_nofl_debug(params...) \ 98 QDF_TRACE_DEBUG_NO_FL(QDF_MODULE_ID_DP, params) 99 100 #define dp_alert_rl(params...) QDF_TRACE_FATAL_RL(QDF_MODULE_ID_DP, params) 101 #define dp_err_rl(params...) QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP, params) 102 #define dp_warn_rl(params...) QDF_TRACE_WARN_RL(QDF_MODULE_ID_DP, params) 103 #define dp_debug_rl(params...) QDF_TRACE_DEBUG_RL(QDF_MODULE_ID_DP, params) 104 105 #define dp_cdp_alert(params...) QDF_TRACE_FATAL(QDF_MODULE_ID_DP_CDP, params) 106 #define dp_cdp_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_DP_CDP, params) 107 #define dp_cdp_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_DP_CDP, params) 108 #define dp_cdp_info(params...) \ 109 __QDF_TRACE_FL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_DP_CDP, ## params) 110 #define dp_cdp_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_DP_CDP, params) 111 112 #define dp_cdp_nofl_alert(params...) \ 113 QDF_TRACE_FATAL_NO_FL(QDF_MODULE_ID_DP_CDP, params) 114 #define dp_cdp_nofl_err(params...) \ 115 QDF_TRACE_ERROR_NO_FL(QDF_MODULE_ID_DP_CDP, params) 116 #define dp_cdp_nofl_warn(params...) \ 117 QDF_TRACE_WARN_NO_FL(QDF_MODULE_ID_DP_CDP, params) 118 #define dp_cdp_nofl_info(params...) \ 119 QDF_TRACE_DEBUG_NO_FL(QDF_MODULE_ID_DP_CDP, params) 120 #define dp_cdp_nofl_debug(params...) \ 121 QDF_TRACE_DEBUG_NO_FL(QDF_MODULE_ID_DP_CDP, params) 122 123 #define DP_PEER_INFO_PARAMS_INIT(peer_info, _vdev_id, \ 124 _peer_mac, _addr_align, _peer_type) \ 125 ({ typeof(peer_info) _peer_info = (peer_info); \ 126 do { \ 127 (_peer_info)->vdev_id = (_vdev_id); \ 128 (_peer_info)->mac_addr = (_peer_mac); \ 129 (_peer_info)->mac_addr_is_aligned = (_addr_align); \ 130 (_peer_info)->peer_type = (_peer_type); \ 131 } while (0); }) 132 133 #ifdef WLAN_FEATURE_11BE_MLO 134 #define CDP_RX_ML_PEER_VALID_MASK (0x00002000) 135 #define CDP_RX_ML_PEER_VALID_SHIFT (13) 136 #define CDP_RX_GET_ML_PEER_VALID(skb) \ 137 ((QDF_NBUF_CB_RX_PEER_ID(skb) & \ 138 CDP_RX_ML_PEER_VALID_MASK) >> CDP_RX_ML_PEER_VALID_SHIFT) 139 #endif 140 141 /** 142 * enum vdev_host_stats_id - 143 * host stats update from CDP have to set one of the following stats ID 144 * 145 * @DP_VDEV_STATS_PKT_CNT_ONLY: update Tx packet count only 146 * @DP_VDEV_STATS_TX_ME: update Tx ingress stats 147 */ 148 enum vdev_host_stats_id { 149 DP_VDEV_STATS_PKT_CNT_ONLY, 150 DP_VDEV_STATS_TX_ME, 151 }; 152 153 /* 154 * BW types used for RX PPDU 155 */ 156 enum rx_tlv_bw { 157 RX_TLV_BW_20MHZ, 158 RX_TLV_BW_40MHZ, 159 RX_TLV_BW_80MHZ, 160 RX_TLV_BW_160MHZ, 161 RX_TLV_BW_320MHZ, 162 RX_TLV_BW_240MHZ, 163 RX_TLV_BW_CNT, 164 }; 165 166 /** 167 * typedef ipa_uc_op_cb_type() - Register OP handler function 168 * @op_msg: message 169 * @osif_ctxt: OSIF context 170 */ 171 typedef void (*ipa_uc_op_cb_type)(uint8_t *op_msg, 172 void *osif_ctxt); 173 174 #ifdef QCA_SUPPORT_DP_GLOBAL_CTX 175 /* Global level structure for win contexts */ 176 struct dp_global_context { 177 struct dp_rx_fst *fst_ctx; 178 struct dp_tx_desc_pool_s *tx_desc[2][4]; 179 struct dp_hw_cookie_conversion_t *tx_cc_ctx[4]; 180 struct dp_tx_desc_pool_s *spcl_tx_desc[2][4]; 181 struct dp_hw_cookie_conversion_t *spcl_tx_cc_ctx[4]; 182 qdf_atomic_t rx_fst_ref_cnt; 183 qdf_atomic_t global_descriptor_in_use; 184 int tx_cookie_ctx_alloc_cnt; 185 int tx_desc_pool_alloc_cnt[2]; 186 int tx_desc_pool_init_cnt[2]; 187 int spcl_tx_cookie_ctx_alloc_cnt; 188 int spcl_tx_desc_pool_alloc_cnt[2]; 189 int spcl_tx_desc_pool_init_cnt[2]; 190 }; 191 192 /** 193 * cdp_global_ctx_init() - to initialise global context for tx descriptors 194 * 195 * Return: QDF_STATUS on success 196 */ 197 static inline QDF_STATUS cdp_global_ctx_init(void) 198 { 199 struct dp_global_context *dp_global; 200 QDF_STATUS status = QDF_STATUS_SUCCESS; 201 202 if (wlan_objmgr_get_global_ctx()) { 203 dp_err("Global object is already created"); 204 return QDF_STATUS_SUCCESS; 205 } 206 207 dp_global = (struct dp_global_context *) 208 qdf_mem_malloc(sizeof(*dp_global)); 209 210 if (!dp_global) 211 return QDF_STATUS_E_FAILURE; 212 213 qdf_mem_zero(dp_global, sizeof(*dp_global)); 214 wlan_objmgr_set_global_ctx(dp_global); 215 qdf_atomic_set(&dp_global->global_descriptor_in_use, 0); 216 dp_global->fst_ctx = NULL; 217 qdf_atomic_set(&dp_global->rx_fst_ref_cnt, 0); 218 219 return status; 220 } 221 222 /** 223 * cdp_global_ctx_deinit() - to deinitialise global context for tx descriptors 224 * 225 * Return: SUCCESS status on success 226 */ 227 static inline QDF_STATUS cdp_global_ctx_deinit(void) 228 { 229 struct dp_global_context *dp_global = wlan_objmgr_get_global_ctx(); 230 QDF_STATUS status = QDF_STATUS_SUCCESS; 231 232 if (!dp_global) 233 return QDF_STATUS_SUCCESS; 234 235 qdf_mem_free(dp_global); 236 wlan_objmgr_set_global_ctx(NULL); 237 238 return status; 239 } 240 #else 241 static inline QDF_STATUS cdp_global_ctx_init(void) 242 { 243 return QDF_STATUS_SUCCESS; 244 } 245 246 static inline QDF_STATUS cdp_global_ctx_deinit(void) 247 { 248 return QDF_STATUS_SUCCESS; 249 } 250 #endif 251 252 static inline QDF_STATUS 253 cdp_soc_attach_target(ol_txrx_soc_handle soc) 254 { 255 if (!soc || !soc->ops) { 256 dp_cdp_debug("Invalid Instance:"); 257 QDF_BUG(0); 258 return QDF_STATUS_E_INVAL; 259 } 260 261 if (!soc->ops->cmn_drv_ops || 262 !soc->ops->cmn_drv_ops->txrx_soc_attach_target) 263 return QDF_STATUS_SUCCESS; 264 265 return soc->ops->cmn_drv_ops->txrx_soc_attach_target(soc); 266 267 } 268 269 static inline QDF_STATUS 270 cdp_vdev_attach(ol_txrx_soc_handle soc, uint8_t pdev_id, 271 struct cdp_vdev_info *vdev_info) 272 { 273 if (!soc || !soc->ops) { 274 dp_cdp_debug("Invalid Instance:"); 275 QDF_BUG(0); 276 return QDF_STATUS_E_FAILURE; 277 } 278 279 if (!soc->ops->cmn_drv_ops || 280 !soc->ops->cmn_drv_ops->txrx_vdev_attach) 281 return QDF_STATUS_E_FAILURE; 282 283 return soc->ops->cmn_drv_ops->txrx_vdev_attach(soc, pdev_id, vdev_info); 284 } 285 286 #ifdef DP_FLOW_CTL 287 /** 288 * cdp_flow_pool_map() - Create flow pool for vdev 289 * @soc: data path soc handle 290 * @pdev_id: id of dp pdev handle 291 * @vdev_id: vdev_id corresponding to vdev start 292 * 293 * Create per vdev flow pool. 294 * 295 * Return: QDF_STATUS 296 */ 297 static inline QDF_STATUS cdp_flow_pool_map(ol_txrx_soc_handle soc, 298 uint8_t pdev_id, uint8_t vdev_id) 299 { 300 if (!soc || !soc->ops) { 301 dp_cdp_debug("Invalid Instance:"); 302 QDF_BUG(0); 303 return QDF_STATUS_E_INVAL; 304 } 305 306 if (!soc->ops->flowctl_ops || 307 !soc->ops->flowctl_ops->flow_pool_map_handler) 308 return QDF_STATUS_E_INVAL; 309 310 return soc->ops->flowctl_ops->flow_pool_map_handler(soc, pdev_id, 311 vdev_id); 312 } 313 314 /** 315 * cdp_flow_pool_unmap() - Delete flow pool 316 * @soc: data path soc handle 317 * @pdev_id: id of dp pdev handle 318 * @vdev_id: vdev_id corresponding to vdev start 319 * 320 * Delete flow pool 321 * 322 * Return: none 323 */ 324 static inline void cdp_flow_pool_unmap(ol_txrx_soc_handle soc, 325 uint8_t pdev_id, uint8_t vdev_id) 326 { 327 if (!soc || !soc->ops) { 328 dp_cdp_debug("Invalid Instance:"); 329 QDF_BUG(0); 330 return; 331 } 332 333 if (!soc->ops->flowctl_ops || 334 !soc->ops->flowctl_ops->flow_pool_unmap_handler) 335 return; 336 337 return soc->ops->flowctl_ops->flow_pool_unmap_handler(soc, pdev_id, 338 vdev_id); 339 } 340 #endif 341 342 static inline QDF_STATUS 343 cdp_vdev_detach(ol_txrx_soc_handle soc, uint8_t vdev_id, 344 ol_txrx_vdev_delete_cb callback, void *cb_context) 345 { 346 if (!soc || !soc->ops) { 347 dp_cdp_debug("Invalid Instance:"); 348 QDF_BUG(0); 349 return QDF_STATUS_E_FAILURE; 350 } 351 352 if (!soc->ops->cmn_drv_ops || 353 !soc->ops->cmn_drv_ops->txrx_vdev_detach) 354 return QDF_STATUS_E_FAILURE; 355 356 return soc->ops->cmn_drv_ops->txrx_vdev_detach(soc, vdev_id, 357 callback, cb_context); 358 } 359 360 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 361 static inline void 362 cdp_vdev_recovery_flush_peers(ol_txrx_soc_handle soc, 363 uint8_t vdev_id, 364 bool mlo_peers_only) 365 { 366 if (!soc || !soc->ops) { 367 dp_cdp_debug("Invalid Instance:"); 368 QDF_BUG(0); 369 return; 370 } 371 372 if (!soc->ops->cmn_drv_ops || 373 !soc->ops->cmn_drv_ops->txrx_recovery_vdev_flush_peers) 374 return; 375 376 soc->ops->cmn_drv_ops->txrx_recovery_vdev_flush_peers(soc, 377 vdev_id, 378 mlo_peers_only); 379 } 380 #endif 381 382 static inline int 383 cdp_pdev_attach_target(ol_txrx_soc_handle soc, uint8_t pdev_id) 384 { 385 if (!soc || !soc->ops) { 386 dp_cdp_debug("Invalid Instance:"); 387 QDF_BUG(0); 388 return 0; 389 } 390 391 if (!soc->ops->cmn_drv_ops || 392 !soc->ops->cmn_drv_ops->txrx_pdev_attach_target) 393 return 0; 394 395 return soc->ops->cmn_drv_ops->txrx_pdev_attach_target(soc, pdev_id); 396 } 397 398 static inline QDF_STATUS cdp_pdev_attach 399 (ol_txrx_soc_handle soc, struct cdp_pdev_attach_params *params) 400 { 401 if (!soc || !soc->ops) { 402 dp_cdp_debug("Invalid Instance:"); 403 QDF_BUG(0); 404 return QDF_STATUS_E_FAILURE; 405 } 406 407 if (!soc->ops->cmn_drv_ops || 408 !soc->ops->cmn_drv_ops->txrx_pdev_attach) 409 return QDF_STATUS_E_FAILURE; 410 411 return soc->ops->cmn_drv_ops->txrx_pdev_attach(soc, params); 412 } 413 414 /** 415 * cdp_pdev_post_attach() - attach the data SW state 416 * @soc: datapath soc handle 417 * @pdev_id: the data physical device id being removed 418 * 419 * This function is used when the WLAN driver is being loaded to 420 * attach the host data component within the driver. 421 * 422 * Return: 0 for success or error code 423 */ 424 static inline int cdp_pdev_post_attach(ol_txrx_soc_handle soc, uint8_t pdev_id) 425 { 426 if (!soc || !soc->ops) { 427 dp_cdp_debug("Invalid Instance:"); 428 QDF_BUG(0); 429 return 0; 430 } 431 432 if (!soc->ops->cmn_drv_ops || 433 !soc->ops->cmn_drv_ops->txrx_pdev_post_attach) 434 return 0; 435 436 return soc->ops->cmn_drv_ops->txrx_pdev_post_attach(soc, pdev_id); 437 } 438 439 /** 440 * cdp_pdev_pre_detach() - detach the data SW state 441 * @soc: datapath soc handle 442 * @pdev_id: the data physical device id being removed 443 * @force: delete the pdev (and its vdevs and peers) even if 444 * there are outstanding references by the target to the vdevs 445 * and peers within the pdev 446 * 447 * This function is used when the WLAN driver is being removed to 448 * detach the host data component within the driver. 449 * 450 * Return: None 451 */ 452 static inline void 453 cdp_pdev_pre_detach(ol_txrx_soc_handle soc, uint8_t pdev_id, int force) 454 { 455 if (!soc || !soc->ops) { 456 dp_cdp_debug("Invalid Instance:"); 457 QDF_BUG(0); 458 return; 459 } 460 461 if (!soc->ops->cmn_drv_ops || 462 !soc->ops->cmn_drv_ops->txrx_pdev_pre_detach) 463 return; 464 465 soc->ops->cmn_drv_ops->txrx_pdev_pre_detach(soc, pdev_id, force); 466 } 467 468 static inline QDF_STATUS 469 cdp_pdev_detach(ol_txrx_soc_handle soc, uint8_t pdev_id, int force) 470 { 471 if (!soc || !soc->ops) { 472 dp_cdp_debug("Invalid Instance:"); 473 QDF_BUG(0); 474 return QDF_STATUS_E_FAILURE; 475 } 476 477 if (!soc->ops->cmn_drv_ops || 478 !soc->ops->cmn_drv_ops->txrx_pdev_detach) 479 return QDF_STATUS_E_FAILURE; 480 481 return soc->ops->cmn_drv_ops->txrx_pdev_detach(soc, pdev_id, force); 482 } 483 484 static inline void 485 cdp_pdev_deinit(ol_txrx_soc_handle soc, uint8_t pdev_id, int force) 486 { 487 if (!soc || !soc->ops) { 488 dp_cdp_debug("Invalid Instance:"); 489 QDF_BUG(0); 490 return; 491 } 492 493 if (!soc->ops->cmn_drv_ops || 494 !soc->ops->cmn_drv_ops->txrx_pdev_deinit) 495 return; 496 497 soc->ops->cmn_drv_ops->txrx_pdev_deinit(soc, pdev_id, force); 498 } 499 500 static inline QDF_STATUS cdp_peer_create 501 (ol_txrx_soc_handle soc, uint8_t vdev_id, 502 uint8_t *peer_mac_addr) 503 { 504 if (!soc || !soc->ops) { 505 dp_cdp_debug("Invalid Instance:"); 506 QDF_BUG(0); 507 return QDF_STATUS_E_FAILURE; 508 } 509 510 if (!soc->ops->cmn_drv_ops || 511 !soc->ops->cmn_drv_ops->txrx_peer_create) 512 return QDF_STATUS_E_FAILURE; 513 514 return soc->ops->cmn_drv_ops->txrx_peer_create(soc, vdev_id, 515 peer_mac_addr, CDP_LINK_PEER_TYPE); 516 } 517 518 static inline QDF_STATUS cdp_peer_setup 519 (ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *peer_mac, 520 struct cdp_peer_setup_info *setup_info) 521 { 522 if (!soc || !soc->ops) { 523 dp_cdp_debug("Invalid Instance:"); 524 QDF_BUG(0); 525 return QDF_STATUS_E_FAILURE; 526 } 527 528 if (!soc->ops->cmn_drv_ops || 529 !soc->ops->cmn_drv_ops->txrx_peer_setup) 530 return QDF_STATUS_E_FAILURE; 531 532 return soc->ops->cmn_drv_ops->txrx_peer_setup(soc, vdev_id, 533 peer_mac, setup_info); 534 } 535 536 /** 537 * cdp_cp_peer_del_response() - Call the peer delete response handler 538 * @soc: Datapath SOC handle 539 * @vdev_id: id of virtual device object 540 * @peer_mac_addr: Mac address of the peer 541 * 542 * Return: void 543 */ 544 static inline QDF_STATUS cdp_cp_peer_del_response 545 (ol_txrx_soc_handle soc, 546 uint8_t vdev_id, 547 uint8_t *peer_mac_addr) 548 { 549 if (!soc || !soc->ops) { 550 dp_cdp_debug("Invalid Instance:"); 551 QDF_BUG(0); 552 return QDF_STATUS_E_FAILURE; 553 } 554 555 if (!soc->ops->cmn_drv_ops || 556 !soc->ops->cmn_drv_ops->txrx_cp_peer_del_response) 557 return QDF_STATUS_E_FAILURE; 558 559 return soc->ops->cmn_drv_ops->txrx_cp_peer_del_response(soc, 560 vdev_id, 561 peer_mac_addr); 562 } 563 /** 564 * cdp_peer_get_ast_info_by_soc() - search the soc AST hash table 565 * and return ast entry information 566 * of first ast entry found in the 567 * table with given mac address 568 * 569 * @soc: data path soc handle 570 * @ast_mac_addr: AST entry mac address 571 * @ast_entry_info: ast entry information 572 * 573 * return: true if ast entry found with ast_mac_addr 574 * false if ast entry not found 575 */ 576 static inline bool cdp_peer_get_ast_info_by_soc 577 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr, 578 struct cdp_ast_entry_info *ast_entry_info) 579 { 580 if (!soc || !soc->ops) { 581 dp_cdp_debug("Invalid Instance:"); 582 QDF_BUG(0); 583 return false; 584 } 585 586 if (!soc->ops->cmn_drv_ops || 587 !soc->ops->cmn_drv_ops->txrx_peer_get_ast_info_by_soc) 588 return false; 589 590 return soc->ops->cmn_drv_ops->txrx_peer_get_ast_info_by_soc 591 (soc, ast_mac_addr, 592 ast_entry_info); 593 } 594 595 /** 596 * cdp_peer_get_ast_info_by_pdev() - search the soc AST hash table 597 * and return ast entry information 598 * if mac address and pdev_id matches 599 * 600 * @soc: data path soc handle 601 * @ast_mac_addr: AST entry mac address 602 * @pdev_id: pdev_id 603 * @ast_entry_info: ast entry information 604 * 605 * return: true if ast entry found with ast_mac_addr 606 * false if ast entry not found 607 */ 608 static inline bool cdp_peer_get_ast_info_by_pdev 609 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr, 610 uint8_t pdev_id, 611 struct cdp_ast_entry_info *ast_entry_info) 612 { 613 if (!soc || !soc->ops) { 614 dp_cdp_debug("Invalid Instance:"); 615 QDF_BUG(0); 616 return false; 617 } 618 619 if (!soc->ops->cmn_drv_ops || 620 !soc->ops->cmn_drv_ops->txrx_peer_get_ast_info_by_pdev) 621 return false; 622 623 return soc->ops->cmn_drv_ops->txrx_peer_get_ast_info_by_pdev 624 (soc, 625 ast_mac_addr, 626 pdev_id, 627 ast_entry_info); 628 } 629 630 /** 631 * cdp_peer_ast_delete_by_soc() - delete the ast entry from soc AST hash table 632 * with given mac address 633 * 634 * @soc: data path soc handle 635 * @ast_mac_addr: AST entry mac address 636 * @callback: callback function to called on ast delete response from FW 637 * @cookie: argument to be passed to callback 638 * 639 * return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete 640 * is sent 641 * QDF_STATUS_E_INVAL false if ast entry not found 642 */ 643 static inline QDF_STATUS cdp_peer_ast_delete_by_soc 644 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr, 645 txrx_ast_free_cb callback, 646 void *cookie) 647 { 648 if (!soc || !soc->ops) { 649 dp_cdp_debug("Invalid Instance:"); 650 QDF_BUG(0); 651 return QDF_STATUS_E_INVAL; 652 } 653 654 if (!soc->ops->cmn_drv_ops || 655 !soc->ops->cmn_drv_ops->txrx_peer_ast_delete_by_soc) 656 return QDF_STATUS_E_INVAL; 657 658 return soc->ops->cmn_drv_ops->txrx_peer_ast_delete_by_soc 659 (soc, 660 ast_mac_addr, 661 callback, 662 cookie); 663 } 664 665 /** 666 * cdp_peer_ast_delete_by_pdev() - delete the ast entry from soc AST hash table 667 * if mac address and pdev_id matches 668 * 669 * @soc: data path soc handle 670 * @ast_mac_addr: AST entry mac address 671 * @pdev_id: pdev id 672 * @callback: callback function to called on ast delete response from FW 673 * @cookie: argument to be passed to callback 674 * 675 * return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete 676 * is sent 677 * QDF_STATUS_E_INVAL false if ast entry not found 678 */ 679 static inline QDF_STATUS cdp_peer_ast_delete_by_pdev 680 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr, 681 uint8_t pdev_id, txrx_ast_free_cb callback, 682 void *cookie) 683 { 684 if (!soc || !soc->ops) { 685 dp_cdp_debug("Invalid Instance:"); 686 QDF_BUG(0); 687 return QDF_STATUS_E_INVAL; 688 } 689 690 if (!soc->ops->cmn_drv_ops || 691 !soc->ops->cmn_drv_ops->txrx_peer_ast_delete_by_pdev) 692 return QDF_STATUS_E_INVAL; 693 694 return soc->ops->cmn_drv_ops->txrx_peer_ast_delete_by_pdev 695 (soc, 696 ast_mac_addr, 697 pdev_id, 698 callback, 699 cookie); 700 } 701 702 /** 703 * cdp_peer_HMWDS_ast_delete() - delete the ast entry from soc AST hash table 704 * for HMWDS rem-addr command 705 * 706 * @soc: data path soc handle 707 * @vdev_id: vdev id 708 * @dest_mac: AST entry mac address to delete 709 * @type: cdp_txrx_ast_entry_type to send to FW 710 * @delete_in_fw: flag to indicate AST entry deletion in FW 711 * 712 * Return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete 713 * is sent 714 * QDF_STATUS_E_INVAL false if ast entry not found 715 */ 716 static inline QDF_STATUS cdp_peer_HMWDS_ast_delete 717 (ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *dest_mac, 718 uint8_t type, uint8_t delete_in_fw) 719 { 720 if (!soc || !soc->ops) { 721 dp_cdp_debug("Invalid Instance:"); 722 QDF_BUG(0); 723 return QDF_STATUS_E_INVAL; 724 } 725 726 if (!soc->ops->cmn_drv_ops || 727 !soc->ops->cmn_drv_ops->txrx_peer_HMWDS_ast_delete) 728 return QDF_STATUS_E_INVAL; 729 730 return soc->ops->cmn_drv_ops->txrx_peer_HMWDS_ast_delete 731 (soc, 732 vdev_id, 733 dest_mac, 734 type, 735 delete_in_fw); 736 } 737 738 static inline int cdp_peer_add_ast 739 (ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *peer_mac, 740 uint8_t *mac_addr, 741 enum cdp_txrx_ast_entry_type type, uint32_t flags) 742 { 743 if (!soc || !soc->ops) { 744 dp_cdp_debug("Invalid Instance:"); 745 QDF_BUG(0); 746 return 0; 747 } 748 749 if (!soc->ops->cmn_drv_ops || 750 !soc->ops->cmn_drv_ops->txrx_peer_add_ast) 751 return 0; 752 753 return soc->ops->cmn_drv_ops->txrx_peer_add_ast(soc, 754 vdev_id, 755 peer_mac, 756 mac_addr, 757 type, 758 flags); 759 } 760 761 static inline QDF_STATUS cdp_peer_reset_ast 762 (ol_txrx_soc_handle soc, uint8_t *wds_macaddr, uint8_t *peer_macaddr, 763 uint8_t vdev_id) 764 { 765 766 if (!soc || !soc->ops) { 767 dp_cdp_debug("Invalid Instance:"); 768 QDF_BUG(0); 769 return QDF_STATUS_E_FAILURE; 770 } 771 if (!soc->ops->cmn_drv_ops || 772 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast) 773 return QDF_STATUS_E_FAILURE; 774 775 return soc->ops->cmn_drv_ops->txrx_peer_reset_ast(soc, wds_macaddr, 776 peer_macaddr, vdev_id); 777 } 778 779 static inline QDF_STATUS cdp_peer_reset_ast_table 780 (ol_txrx_soc_handle soc, uint8_t vdev_id) 781 { 782 if (!soc || !soc->ops) { 783 dp_cdp_debug("Invalid Instance:"); 784 QDF_BUG(0); 785 return QDF_STATUS_E_FAILURE; 786 } 787 788 if (!soc->ops->cmn_drv_ops || 789 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table) 790 return QDF_STATUS_E_FAILURE; 791 792 return soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table(soc, vdev_id); 793 } 794 795 static inline void cdp_peer_flush_ast_table 796 (ol_txrx_soc_handle soc) 797 { 798 if (!soc || !soc->ops) { 799 dp_cdp_debug("Invalid Instance:"); 800 QDF_BUG(0); 801 return; 802 } 803 804 if (!soc->ops->cmn_drv_ops || 805 !soc->ops->cmn_drv_ops->txrx_peer_flush_ast_table) 806 return; 807 808 soc->ops->cmn_drv_ops->txrx_peer_flush_ast_table(soc); 809 } 810 811 static inline int cdp_peer_update_ast 812 (ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *peer_mac, 813 uint8_t *wds_macaddr, uint32_t flags) 814 { 815 if (!soc || !soc->ops) { 816 dp_cdp_debug("Invalid Instance:"); 817 QDF_BUG(0); 818 return 0; 819 } 820 821 if (!soc->ops->cmn_drv_ops || 822 !soc->ops->cmn_drv_ops->txrx_peer_update_ast) 823 return 0; 824 825 826 return soc->ops->cmn_drv_ops->txrx_peer_update_ast(soc, 827 vdev_id, 828 peer_mac, 829 wds_macaddr, 830 flags); 831 } 832 833 static inline void cdp_peer_teardown 834 (ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *peer_mac) 835 { 836 if (!soc || !soc->ops) { 837 dp_cdp_debug("Invalid Instance:"); 838 QDF_BUG(0); 839 return; 840 } 841 842 if (!soc->ops->cmn_drv_ops || 843 !soc->ops->cmn_drv_ops->txrx_peer_teardown) 844 return; 845 846 soc->ops->cmn_drv_ops->txrx_peer_teardown(soc, vdev_id, peer_mac); 847 } 848 849 static inline void 850 cdp_peer_delete(ol_txrx_soc_handle soc, uint8_t vdev_id, 851 uint8_t *peer_mac, uint32_t bitmap) 852 { 853 if (!soc || !soc->ops) { 854 dp_cdp_debug("Invalid Instance:"); 855 QDF_BUG(0); 856 return; 857 } 858 859 if (!soc->ops->cmn_drv_ops || 860 !soc->ops->cmn_drv_ops->txrx_peer_delete) 861 return; 862 863 soc->ops->cmn_drv_ops->txrx_peer_delete(soc, vdev_id, peer_mac, 864 bitmap, CDP_LINK_PEER_TYPE); 865 } 866 867 #ifdef DP_RX_UDP_OVER_PEER_ROAM 868 static inline void 869 cdp_update_roaming_peer_in_vdev(ol_txrx_soc_handle soc, uint8_t vdev_id, 870 uint8_t *peer_mac, uint32_t auth_status) 871 { 872 if (!soc || !soc->ops) { 873 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 874 "%s: Invalid Instance:", __func__); 875 QDF_BUG(0); 876 return; 877 } 878 879 if (!soc->ops->cmn_drv_ops || 880 !soc->ops->cmn_drv_ops->txrx_update_roaming_peer) 881 return; 882 883 soc->ops->cmn_drv_ops->txrx_update_roaming_peer(soc, vdev_id, 884 peer_mac, auth_status); 885 } 886 #else 887 static inline void 888 cdp_update_roaming_peer_in_vdev(ol_txrx_soc_handle soc, uint8_t vdev_id, 889 uint8_t *peer_mac, uint32_t auth_status) 890 { 891 } 892 #endif 893 /** 894 * cdp_peer_delete_sync() - peer delete sync callback 895 * @soc: datapath soc handle 896 * @vdev_id: virtual device/interface id 897 * @peer_mac: peer mac address 898 * @delete_cb: peer delete sync cb. 899 * @bitmap: bitmap indicating special handling of request. 900 * 901 * Return: None 902 */ 903 static inline void 904 cdp_peer_delete_sync(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *peer_mac, 905 QDF_STATUS(*delete_cb)( 906 uint8_t vdev_id, 907 uint32_t peerid_cnt, 908 uint16_t *peerid_list), 909 uint32_t bitmap) 910 { 911 if (!soc || !soc->ops) { 912 dp_cdp_debug("Invalid Instance:"); 913 QDF_BUG(0); 914 return; 915 } 916 917 if (!soc->ops->cmn_drv_ops || 918 !soc->ops->cmn_drv_ops->txrx_peer_delete_sync) 919 return; 920 921 soc->ops->cmn_drv_ops->txrx_peer_delete_sync(soc, vdev_id, peer_mac, 922 delete_cb, 923 bitmap); 924 } 925 926 static inline int 927 cdp_set_monitor_mode(ol_txrx_soc_handle soc, uint8_t vdev_id, 928 uint8_t smart_monitor) 929 { 930 if (!soc || !soc->ops) { 931 dp_cdp_debug("Invalid Instance:"); 932 QDF_BUG(0); 933 return 0; 934 } 935 936 if (!soc->ops->cmn_drv_ops || 937 !soc->ops->cmn_drv_ops->txrx_set_monitor_mode) 938 return 0; 939 940 return soc->ops->cmn_drv_ops->txrx_set_monitor_mode(soc, vdev_id, 941 smart_monitor); 942 } 943 944 static inline QDF_STATUS 945 cdp_set_curchan(ol_txrx_soc_handle soc, 946 uint8_t pdev_id, 947 uint32_t chan_mhz) 948 { 949 if (!soc || !soc->ops) { 950 dp_cdp_debug("Invalid Instance:"); 951 QDF_BUG(0); 952 return QDF_STATUS_E_FAILURE; 953 } 954 955 if (!soc->ops->cmn_drv_ops || 956 !soc->ops->cmn_drv_ops->txrx_set_curchan) 957 return QDF_STATUS_E_FAILURE; 958 959 return soc->ops->cmn_drv_ops->txrx_set_curchan(soc, pdev_id, chan_mhz); 960 } 961 962 static inline QDF_STATUS 963 cdp_set_privacy_filters(ol_txrx_soc_handle soc, uint8_t vdev_id, 964 void *filter, uint32_t num) 965 { 966 if (!soc || !soc->ops) { 967 dp_cdp_debug("Invalid Instance:"); 968 QDF_BUG(0); 969 return QDF_STATUS_E_FAILURE; 970 } 971 972 if (!soc->ops->cmn_drv_ops || 973 !soc->ops->cmn_drv_ops->txrx_set_privacy_filters) 974 return QDF_STATUS_E_FAILURE; 975 976 return soc->ops->cmn_drv_ops->txrx_set_privacy_filters(soc, vdev_id, 977 filter, num); 978 } 979 980 static inline int 981 cdp_set_monitor_filter(ol_txrx_soc_handle soc, uint8_t pdev_id, 982 struct cdp_monitor_filter *filter_val) 983 { 984 if (soc->ops->mon_ops->txrx_set_advance_monitor_filter) 985 return soc->ops->mon_ops->txrx_set_advance_monitor_filter(soc, 986 pdev_id, 987 filter_val); 988 return 0; 989 } 990 991 992 /****************************************************************************** 993 * Data Interface (B Interface) 994 *****************************************************************************/ 995 static inline void 996 cdp_vdev_register(ol_txrx_soc_handle soc, uint8_t vdev_id, 997 ol_osif_vdev_handle osif_vdev, 998 struct ol_txrx_ops *txrx_ops) 999 { 1000 if (!soc || !soc->ops) { 1001 dp_cdp_debug("Invalid Instance:"); 1002 QDF_BUG(0); 1003 return; 1004 } 1005 1006 if (!soc->ops->cmn_drv_ops || 1007 !soc->ops->cmn_drv_ops->txrx_vdev_register) 1008 return; 1009 1010 soc->ops->cmn_drv_ops->txrx_vdev_register(soc, vdev_id, 1011 osif_vdev, txrx_ops); 1012 } 1013 1014 static inline int 1015 cdp_mgmt_send(ol_txrx_soc_handle soc, uint8_t vdev_id, 1016 qdf_nbuf_t tx_mgmt_frm, uint8_t type) 1017 { 1018 if (!soc || !soc->ops) { 1019 dp_cdp_debug("Invalid Instance:"); 1020 QDF_BUG(0); 1021 return 0; 1022 } 1023 1024 if (!soc->ops->cmn_drv_ops || 1025 !soc->ops->cmn_drv_ops->txrx_mgmt_send) 1026 return 0; 1027 1028 return soc->ops->cmn_drv_ops->txrx_mgmt_send(soc, vdev_id, 1029 tx_mgmt_frm, type); 1030 } 1031 1032 static inline int 1033 cdp_mgmt_send_ext(ol_txrx_soc_handle soc, uint8_t vdev_id, 1034 qdf_nbuf_t tx_mgmt_frm, uint8_t type, 1035 uint8_t use_6mbps, uint16_t chanfreq) 1036 { 1037 if (!soc || !soc->ops) { 1038 dp_cdp_debug("Invalid Instance:"); 1039 QDF_BUG(0); 1040 return 0; 1041 } 1042 1043 if (!soc->ops->cmn_drv_ops || 1044 !soc->ops->cmn_drv_ops->txrx_mgmt_send_ext) 1045 return 0; 1046 1047 return soc->ops->cmn_drv_ops->txrx_mgmt_send_ext 1048 (soc, vdev_id, tx_mgmt_frm, type, use_6mbps, chanfreq); 1049 } 1050 1051 1052 static inline QDF_STATUS 1053 cdp_mgmt_tx_cb_set(ol_txrx_soc_handle soc, uint8_t pdev_id, 1054 uint8_t type, ol_txrx_mgmt_tx_cb download_cb, 1055 ol_txrx_mgmt_tx_cb ota_ack_cb, void *ctxt) 1056 { 1057 if (!soc || !soc->ops) { 1058 dp_cdp_debug("Invalid Instance:"); 1059 QDF_BUG(0); 1060 return QDF_STATUS_E_FAILURE; 1061 } 1062 1063 if (!soc->ops->cmn_drv_ops || 1064 !soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set) 1065 return QDF_STATUS_E_FAILURE; 1066 1067 return soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set 1068 (soc, pdev_id, type, download_cb, ota_ack_cb, ctxt); 1069 } 1070 1071 /** 1072 * cdp_peer_unmap_sync_cb_set() - set peer unmap sync callback 1073 * @soc: datapath soc handle 1074 * @pdev_id: physical device instance id 1075 * @unmap_resp_cb: peer unmap sync callback 1076 * 1077 * Return: None 1078 */ 1079 static inline void 1080 cdp_peer_unmap_sync_cb_set(ol_txrx_soc_handle soc, 1081 uint8_t pdev_id, 1082 QDF_STATUS(*unmap_resp_cb)( 1083 uint8_t vdev_id, 1084 uint32_t peerid_cnt, 1085 uint16_t *peerid_list)) 1086 { 1087 if (!soc || !soc->ops) { 1088 dp_cdp_debug("Invalid Instance:"); 1089 QDF_BUG(0); 1090 return; 1091 } 1092 1093 if (!soc->ops->cmn_drv_ops || 1094 !soc->ops->cmn_drv_ops->txrx_peer_unmap_sync_cb_set) 1095 return; 1096 1097 soc->ops->cmn_drv_ops->txrx_peer_unmap_sync_cb_set(soc, pdev_id, 1098 unmap_resp_cb); 1099 } 1100 1101 /** 1102 * cdp_data_tx_cb_set(): set the callback for non standard tx 1103 * @soc: datapath soc handle 1104 * @vdev_id: virtual device/interface id 1105 * @callback: callback function 1106 * @ctxt: callback context 1107 * 1108 */ 1109 static inline void 1110 cdp_data_tx_cb_set(ol_txrx_soc_handle soc, uint8_t vdev_id, 1111 ol_txrx_data_tx_cb callback, void *ctxt) 1112 { 1113 if (!soc || !soc->ops) { 1114 dp_cdp_debug("Invalid Instance:"); 1115 QDF_BUG(0); 1116 return; 1117 } 1118 1119 if (!soc->ops->cmn_drv_ops || 1120 !soc->ops->cmn_drv_ops->txrx_data_tx_cb_set) 1121 return; 1122 1123 soc->ops->cmn_drv_ops->txrx_data_tx_cb_set(soc, vdev_id, 1124 callback, ctxt); 1125 } 1126 1127 /****************************************************************************** 1128 * Statistics and Debugging Interface (C Interface) 1129 *****************************************************************************/ 1130 /* 1131 * External Device physical address types 1132 * 1133 * Currently, both MAC and IPA uController use the same size addresses 1134 * and descriptors are exchanged between these two depending on the mode. 1135 * 1136 * Rationale: qdf_dma_addr_t is the type used internally on the host for DMA 1137 * operations. However, external device physical address sizes 1138 * may be different from host-specific physical address sizes. 1139 * This calls for the following definitions for target devices 1140 * (MAC, IPA uc). 1141 */ 1142 #if HTT_PADDR64 1143 typedef uint64_t target_paddr_t; 1144 #else 1145 typedef uint32_t target_paddr_t; 1146 #endif /*HTT_PADDR64 */ 1147 1148 static inline int 1149 cdp_aggr_cfg(ol_txrx_soc_handle soc, uint8_t vdev_id, 1150 int max_subfrms_ampdu, 1151 int max_subfrms_amsdu) 1152 { 1153 if (!soc || !soc->ops) { 1154 dp_cdp_debug("Invalid Instance:"); 1155 QDF_BUG(0); 1156 return 0; 1157 } 1158 1159 if (!soc->ops->cmn_drv_ops || 1160 !soc->ops->cmn_drv_ops->txrx_aggr_cfg) 1161 return 0; 1162 1163 return soc->ops->cmn_drv_ops->txrx_aggr_cfg(soc, vdev_id, 1164 max_subfrms_ampdu, max_subfrms_amsdu); 1165 } 1166 1167 static inline int 1168 cdp_fw_stats_get(ol_txrx_soc_handle soc, uint8_t vdev_id, 1169 struct ol_txrx_stats_req *req, bool per_vdev, 1170 bool response_expected) 1171 { 1172 if (!soc || !soc->ops) { 1173 dp_cdp_debug("Invalid Instance:"); 1174 QDF_BUG(0); 1175 return 0; 1176 } 1177 1178 if (!soc->ops->cmn_drv_ops || 1179 !soc->ops->cmn_drv_ops->txrx_fw_stats_get) 1180 return 0; 1181 1182 return soc->ops->cmn_drv_ops->txrx_fw_stats_get(soc, vdev_id, req, 1183 per_vdev, response_expected); 1184 } 1185 1186 static inline int 1187 cdp_debug(ol_txrx_soc_handle soc, uint8_t vdev_id, int debug_specs) 1188 { 1189 if (!soc || !soc->ops) { 1190 dp_cdp_debug("Invalid Instance:"); 1191 QDF_BUG(0); 1192 return 0; 1193 } 1194 1195 if (!soc->ops->cmn_drv_ops || 1196 !soc->ops->cmn_drv_ops->txrx_debug) 1197 return 0; 1198 1199 return soc->ops->cmn_drv_ops->txrx_debug(soc, vdev_id, debug_specs); 1200 } 1201 1202 static inline QDF_STATUS 1203 cdp_fw_stats_cfg(ol_txrx_soc_handle soc, 1204 uint8_t vdev_id, uint8_t cfg_stats_type, uint32_t cfg_val) 1205 { 1206 if (!soc || !soc->ops) { 1207 dp_cdp_debug("Invalid Instance:"); 1208 QDF_BUG(0); 1209 return QDF_STATUS_E_FAILURE; 1210 } 1211 1212 if (!soc->ops->cmn_drv_ops || 1213 !soc->ops->cmn_drv_ops->txrx_fw_stats_cfg) 1214 return QDF_STATUS_E_FAILURE; 1215 1216 return soc->ops->cmn_drv_ops->txrx_fw_stats_cfg(soc, vdev_id, 1217 cfg_stats_type, cfg_val); 1218 } 1219 1220 static inline void cdp_print_level_set(ol_txrx_soc_handle soc, unsigned level) 1221 { 1222 if (!soc || !soc->ops) { 1223 dp_cdp_debug("Invalid Instance:"); 1224 QDF_BUG(0); 1225 return; 1226 } 1227 1228 if (!soc->ops->cmn_drv_ops || 1229 !soc->ops->cmn_drv_ops->txrx_print_level_set) 1230 return; 1231 1232 soc->ops->cmn_drv_ops->txrx_print_level_set(level); 1233 } 1234 1235 /** 1236 * cdp_get_vdev_mac_addr() - Detach txrx peer 1237 * @soc: Datapath soc handle 1238 * @vdev_id: virtual device/interface id 1239 * 1240 * Return: MAC address on success, NULL on failure. 1241 * 1242 */ 1243 static inline uint8_t * 1244 cdp_get_vdev_mac_addr(ol_txrx_soc_handle soc, uint8_t vdev_id) 1245 { 1246 if (!soc || !soc->ops) { 1247 dp_cdp_debug("Invalid Instance:"); 1248 QDF_BUG(0); 1249 return NULL; 1250 } 1251 1252 if (!soc->ops->cmn_drv_ops || 1253 !soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr) 1254 return NULL; 1255 1256 return soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr(soc, vdev_id); 1257 1258 } 1259 1260 /** 1261 * cdp_get_os_rx_handles_from_vdev() - Return os rx handles for a vdev 1262 * @soc: ol_txrx_soc_handle handle 1263 * @vdev_id: vdev id for which os rx handles are needed 1264 * @stack_fn_p: pointer to stack function pointer 1265 * @osif_handle_p: pointer to ol_osif_vdev_handle 1266 * 1267 * Return: void 1268 */ 1269 static inline 1270 void cdp_get_os_rx_handles_from_vdev(ol_txrx_soc_handle soc, 1271 uint8_t vdev_id, 1272 ol_txrx_rx_fp *stack_fn_p, 1273 ol_osif_vdev_handle *osif_handle_p) 1274 { 1275 if (!soc || !soc->ops) { 1276 dp_cdp_debug("Invalid Instance:"); 1277 QDF_BUG(0); 1278 return; 1279 } 1280 1281 if (!soc->ops->cmn_drv_ops || 1282 !soc->ops->cmn_drv_ops->txrx_get_os_rx_handles_from_vdev) 1283 return; 1284 1285 soc->ops->cmn_drv_ops->txrx_get_os_rx_handles_from_vdev(soc, vdev_id, 1286 stack_fn_p, 1287 osif_handle_p); 1288 } 1289 1290 /** 1291 * cdp_get_ctrl_pdev_from_vdev() - Return control pdev of vdev 1292 * @soc: datapath soc handle 1293 * @vdev_id: virtual device/interface id 1294 * 1295 * Return: Handle to control pdev 1296 */ 1297 static inline struct cdp_cfg * 1298 cdp_get_ctrl_pdev_from_vdev(ol_txrx_soc_handle soc, uint8_t vdev_id) 1299 { 1300 if (!soc || !soc->ops) { 1301 dp_cdp_debug("Invalid Instance:"); 1302 QDF_BUG(0); 1303 return NULL; 1304 } 1305 1306 if (!soc->ops->cmn_drv_ops || 1307 !soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev) 1308 return NULL; 1309 1310 return soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev(soc, 1311 vdev_id); 1312 } 1313 1314 /** 1315 * cdp_get_mon_vdev_from_pdev() - Get vdev handle of monitor mode 1316 * @soc: datapath soc handle 1317 * @pdev_id: physical device instance id 1318 * 1319 * Return: virtual interface id 1320 */ 1321 static inline uint8_t 1322 cdp_get_mon_vdev_from_pdev(ol_txrx_soc_handle soc, uint8_t pdev_id) 1323 { 1324 if (!soc || !soc->ops) { 1325 dp_cdp_debug("Invalid Instance:"); 1326 QDF_BUG(0); 1327 return -EINVAL; 1328 } 1329 1330 if (!soc->ops->cmn_drv_ops || 1331 !soc->ops->cmn_drv_ops->txrx_get_mon_vdev_from_pdev) 1332 return -EINVAL; 1333 1334 return soc->ops->cmn_drv_ops->txrx_get_mon_vdev_from_pdev(soc, pdev_id); 1335 } 1336 1337 static inline void 1338 cdp_soc_detach(ol_txrx_soc_handle soc) 1339 { 1340 if (!soc || !soc->ops) { 1341 dp_cdp_debug("Invalid Instance:"); 1342 QDF_BUG(0); 1343 return; 1344 } 1345 1346 if (!soc->ops->cmn_drv_ops || 1347 !soc->ops->cmn_drv_ops->txrx_soc_detach) 1348 return; 1349 1350 soc->ops->cmn_drv_ops->txrx_soc_detach(soc); 1351 } 1352 1353 /** 1354 * cdp_soc_init() - Initialize txrx SOC 1355 * @soc: ol_txrx_soc_handle handle 1356 * @devid: Device ID 1357 * @hif_handle: Opaque HIF handle 1358 * @psoc: Opaque Objmgr handle 1359 * @htc_handle: Opaque HTC handle 1360 * @qdf_dev: QDF device 1361 * @dp_ol_if_ops: Offload Operations 1362 * 1363 * Return: DP SOC handle on success, NULL on failure 1364 */ 1365 static inline ol_txrx_soc_handle 1366 cdp_soc_init(ol_txrx_soc_handle soc, u_int16_t devid, 1367 void *hif_handle, 1368 struct cdp_ctrl_objmgr_psoc *psoc, 1369 HTC_HANDLE htc_handle, qdf_device_t qdf_dev, 1370 struct ol_if_ops *dp_ol_if_ops) 1371 { 1372 if (!soc || !soc->ops) { 1373 dp_cdp_debug("Invalid Instance:"); 1374 QDF_BUG(0); 1375 return NULL; 1376 } 1377 1378 if (!soc->ops->cmn_drv_ops || 1379 !soc->ops->cmn_drv_ops->txrx_soc_init) 1380 return NULL; 1381 1382 return soc->ops->cmn_drv_ops->txrx_soc_init(soc, psoc, 1383 hif_handle, 1384 htc_handle, qdf_dev, 1385 dp_ol_if_ops, devid); 1386 } 1387 1388 /** 1389 * cdp_pdev_init() - Initialize txrx pdev 1390 * @soc: ol_txrx_soc_handle handle 1391 * @htc_handle: Opaque HTC handle 1392 * @qdf_dev: QDF device 1393 * @pdev_id: pdev id 1394 * 1395 * Return: DP SOC handle on success, NULL on failure 1396 */ 1397 static inline QDF_STATUS 1398 cdp_pdev_init(ol_txrx_soc_handle soc, 1399 HTC_HANDLE htc_handle, qdf_device_t qdf_dev, 1400 uint8_t pdev_id) 1401 { 1402 if (!soc || !soc->ops) { 1403 dp_cdp_debug("Invalid Instance:"); 1404 QDF_BUG(0); 1405 return 0; 1406 } 1407 1408 if (!soc->ops->cmn_drv_ops || 1409 !soc->ops->cmn_drv_ops->txrx_pdev_init) 1410 return 0; 1411 1412 return soc->ops->cmn_drv_ops->txrx_pdev_init(soc, 1413 htc_handle, qdf_dev, 1414 pdev_id); 1415 } 1416 1417 /** 1418 * cdp_soc_deinit() - Deinitialize txrx SOC 1419 * @soc: Opaque DP SOC handle 1420 * 1421 * Return: None 1422 */ 1423 static inline void 1424 cdp_soc_deinit(ol_txrx_soc_handle soc) 1425 { 1426 if (!soc || !soc->ops) { 1427 dp_cdp_debug("Invalid Instance:"); 1428 QDF_BUG(0); 1429 return; 1430 } 1431 1432 if (!soc->ops->cmn_drv_ops || 1433 !soc->ops->cmn_drv_ops->txrx_soc_deinit) 1434 return; 1435 1436 soc->ops->cmn_drv_ops->txrx_soc_deinit(soc); 1437 } 1438 1439 /** 1440 * cdp_tso_soc_attach() - TSO attach function 1441 * @soc: ol_txrx_soc_handle handle 1442 * 1443 * Reserve TSO descriptor buffers 1444 * 1445 * Return: QDF_STATUS_SUCCESS on Success or 1446 * QDF_STATUS_E_FAILURE on failure 1447 */ 1448 static inline QDF_STATUS 1449 cdp_tso_soc_attach(ol_txrx_soc_handle soc) 1450 { 1451 if (!soc || !soc->ops) { 1452 dp_cdp_debug("Invalid Instance:"); 1453 QDF_BUG(0); 1454 return 0; 1455 } 1456 1457 if (!soc->ops->cmn_drv_ops || 1458 !soc->ops->cmn_drv_ops->txrx_tso_soc_attach) 1459 return 0; 1460 1461 return soc->ops->cmn_drv_ops->txrx_tso_soc_attach(soc); 1462 } 1463 1464 /** 1465 * cdp_tso_soc_detach() - TSO detach function 1466 * @soc: ol_txrx_soc_handle handle 1467 * 1468 * Release TSO descriptor buffers 1469 * 1470 * Return: QDF_STATUS_SUCCESS on Success or 1471 * QDF_STATUS_E_FAILURE on failure 1472 */ 1473 static inline QDF_STATUS 1474 cdp_tso_soc_detach(ol_txrx_soc_handle soc) 1475 { 1476 if (!soc || !soc->ops) { 1477 dp_cdp_debug("Invalid Instance:"); 1478 QDF_BUG(0); 1479 return 0; 1480 } 1481 1482 if (!soc->ops->cmn_drv_ops || 1483 !soc->ops->cmn_drv_ops->txrx_tso_soc_detach) 1484 return 0; 1485 1486 return soc->ops->cmn_drv_ops->txrx_tso_soc_detach(soc); 1487 } 1488 1489 /** 1490 * cdp_tid_update_ba_win_size() - Update the DP tid BA window size 1491 * @soc: soc handle 1492 * @peer_mac: mac address of peer handle 1493 * @vdev_id: id of vdev handle 1494 * @tid: tid 1495 * @buffersize: BA window size 1496 * 1497 * Return: success/failure of tid update 1498 */ 1499 static inline QDF_STATUS 1500 cdp_tid_update_ba_win_size(ol_txrx_soc_handle soc, 1501 uint8_t *peer_mac, uint16_t vdev_id, uint8_t tid, 1502 uint16_t buffersize) 1503 { 1504 if (!soc || !soc->ops) { 1505 dp_cdp_debug("Invalid Instance:"); 1506 QDF_BUG(0); 1507 return 0; 1508 } 1509 1510 if (!soc->ops->cmn_drv_ops || 1511 !soc->ops->cmn_drv_ops->tid_update_ba_win_size) 1512 return 0; 1513 1514 return soc->ops->cmn_drv_ops->tid_update_ba_win_size(soc, peer_mac, 1515 vdev_id, tid, 1516 buffersize); 1517 } 1518 1519 /** 1520 * cdp_addba_resp_tx_completion() - Indicate addba response tx 1521 * completion to dp to change tid state. 1522 * @soc: soc handle 1523 * @peer_mac: mac address of peer handle 1524 * @vdev_id: id of vdev handle 1525 * @tid: tid 1526 * @status: Tx completion status 1527 * 1528 * Return: success/failure of tid update 1529 */ 1530 static inline int cdp_addba_resp_tx_completion(ol_txrx_soc_handle soc, 1531 uint8_t *peer_mac, 1532 uint16_t vdev_id, 1533 uint8_t tid, int status) 1534 { 1535 if (!soc || !soc->ops) { 1536 dp_cdp_debug("Invalid Instance:"); 1537 QDF_BUG(0); 1538 return 0; 1539 } 1540 1541 if (!soc->ops->cmn_drv_ops || 1542 !soc->ops->cmn_drv_ops->addba_resp_tx_completion) 1543 return 0; 1544 1545 return soc->ops->cmn_drv_ops->addba_resp_tx_completion(soc, peer_mac, 1546 vdev_id, tid, status); 1547 } 1548 1549 static inline int cdp_addba_requestprocess(ol_txrx_soc_handle soc, 1550 uint8_t *peer_mac, uint16_t vdev_id, uint8_t dialogtoken, uint16_t tid, 1551 uint16_t batimeout, uint16_t buffersize, uint16_t startseqnum) 1552 { 1553 if (!soc || !soc->ops) { 1554 dp_cdp_debug("Invalid Instance:"); 1555 QDF_BUG(0); 1556 return 0; 1557 } 1558 1559 if (!soc->ops->cmn_drv_ops || 1560 !soc->ops->cmn_drv_ops->addba_requestprocess) 1561 return 0; 1562 1563 return soc->ops->cmn_drv_ops->addba_requestprocess(soc, peer_mac, 1564 vdev_id, dialogtoken, tid, batimeout, buffersize, 1565 startseqnum); 1566 } 1567 1568 static inline QDF_STATUS 1569 cdp_addba_responsesetup(ol_txrx_soc_handle soc, 1570 uint8_t *peer_mac, uint16_t vdev_id, 1571 uint8_t tid, uint8_t *dialogtoken, 1572 uint16_t *statuscode, uint16_t *buffersize, 1573 uint16_t *batimeout) 1574 { 1575 if (!soc || !soc->ops) { 1576 dp_cdp_debug("Invalid Instance:"); 1577 QDF_BUG(0); 1578 return QDF_STATUS_E_FAILURE; 1579 } 1580 1581 if (!soc->ops->cmn_drv_ops || 1582 !soc->ops->cmn_drv_ops->addba_responsesetup) 1583 return QDF_STATUS_E_FAILURE; 1584 1585 return soc->ops->cmn_drv_ops->addba_responsesetup(soc, peer_mac, 1586 vdev_id, tid, dialogtoken, statuscode, buffersize, 1587 batimeout); 1588 } 1589 1590 static inline int cdp_delba_process(ol_txrx_soc_handle soc, uint8_t *peer_mac, 1591 uint16_t vdev_id, int tid, 1592 uint16_t reasoncode) 1593 { 1594 if (!soc || !soc->ops) { 1595 dp_cdp_debug("Invalid Instance:"); 1596 QDF_BUG(0); 1597 return 0; 1598 } 1599 1600 if (!soc->ops->cmn_drv_ops || 1601 !soc->ops->cmn_drv_ops->delba_process) 1602 return 0; 1603 1604 return soc->ops->cmn_drv_ops->delba_process(soc, peer_mac, 1605 vdev_id, tid, reasoncode); 1606 } 1607 1608 /** 1609 * cdp_delba_tx_completion() - Handle delba tx completion 1610 * to update stats and retry transmission if failed. 1611 * @soc: soc handle 1612 * @peer_mac: peer mac address 1613 * @vdev_id: id of vdev handle 1614 * @tid: Tid number 1615 * @status: Tx completion status 1616 * 1617 * Return: 0 on Success, 1 on failure 1618 */ 1619 1620 static inline int cdp_delba_tx_completion(ol_txrx_soc_handle soc, 1621 uint8_t *peer_mac, 1622 uint16_t vdev_id, 1623 uint8_t tid, int status) 1624 { 1625 if (!soc || !soc->ops) { 1626 dp_cdp_debug("Invalid Instance:"); 1627 QDF_BUG(0); 1628 return 0; 1629 } 1630 1631 if (!soc->ops->cmn_drv_ops || 1632 !soc->ops->cmn_drv_ops->delba_tx_completion) 1633 return 0; 1634 1635 return soc->ops->cmn_drv_ops->delba_tx_completion(soc, peer_mac, 1636 vdev_id, 1637 tid, status); 1638 } 1639 1640 static inline QDF_STATUS 1641 cdp_set_addbaresponse(ol_txrx_soc_handle soc, 1642 uint8_t *peer_mac, uint16_t vdev_id, int tid, 1643 uint16_t statuscode) 1644 { 1645 if (!soc || !soc->ops) { 1646 dp_cdp_debug("Invalid Instance:"); 1647 QDF_BUG(0); 1648 return QDF_STATUS_E_FAILURE; 1649 } 1650 1651 if (!soc->ops->cmn_drv_ops || 1652 !soc->ops->cmn_drv_ops->set_addba_response) 1653 return QDF_STATUS_E_FAILURE; 1654 1655 return soc->ops->cmn_drv_ops->set_addba_response(soc, peer_mac, vdev_id, 1656 tid, statuscode); 1657 } 1658 1659 /** 1660 * cdp_set_vdev_dscp_tid_map(): function to set DSCP-tid map in the vap 1661 * @soc : soc handle 1662 * @vdev_id: id of vdev handle 1663 * @map_id: id of the tid map 1664 * 1665 * Return: QDF_STATUS 1666 */ 1667 static inline QDF_STATUS 1668 cdp_set_vdev_dscp_tid_map(ol_txrx_soc_handle soc, 1669 uint8_t vdev_id, uint8_t map_id) 1670 { 1671 if (!soc || !soc->ops) { 1672 dp_cdp_debug("Invalid Instance:"); 1673 QDF_BUG(0); 1674 return QDF_STATUS_E_FAILURE; 1675 } 1676 1677 if (!soc->ops->cmn_drv_ops || 1678 !soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map) 1679 return QDF_STATUS_E_FAILURE; 1680 1681 return soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map(soc, vdev_id, 1682 map_id); 1683 } 1684 1685 #ifdef QCA_MULTIPASS_SUPPORT 1686 /** 1687 * cdp_set_vlan_groupkey(): function to set vlan ID - group key map in the vap 1688 * @soc : soc handle 1689 * @vdev_id: id of vdev handle 1690 * @vlan_id: vlan id 1691 * @group_key: corresponding group key to vlan ID 1692 * 1693 * Return: void 1694 */ 1695 static inline 1696 QDF_STATUS cdp_set_vlan_groupkey(ol_txrx_soc_handle soc, uint8_t vdev_id, 1697 uint16_t vlan_id, uint16_t group_key) 1698 { 1699 if (!soc || !soc->ops) { 1700 dp_cdp_debug("Invalid Instance:"); 1701 QDF_BUG(0); 1702 return 0; 1703 } 1704 1705 if (!soc->ops->cmn_drv_ops || 1706 !soc->ops->cmn_drv_ops->set_vlan_groupkey) 1707 return 0; 1708 1709 return soc->ops->cmn_drv_ops->set_vlan_groupkey(soc, vdev_id, vlan_id, 1710 group_key); 1711 } 1712 #endif 1713 1714 /** 1715 * cdp_ath_get_total_per(): function to get hw retries 1716 * @soc : soc handle 1717 * @pdev_id: id of pdev handle 1718 * 1719 * Return: get hw retries 1720 */ 1721 static inline 1722 int cdp_ath_get_total_per(ol_txrx_soc_handle soc, uint8_t pdev_id) 1723 { 1724 if (!soc || !soc->ops) { 1725 dp_cdp_debug("Invalid Instance:"); 1726 QDF_BUG(0); 1727 return 0; 1728 } 1729 1730 if (!soc->ops->cmn_drv_ops || 1731 !soc->ops->cmn_drv_ops->txrx_get_total_per) 1732 return 0; 1733 1734 return soc->ops->cmn_drv_ops->txrx_get_total_per(soc, pdev_id); 1735 } 1736 1737 /** 1738 * cdp_set_pdev_dscp_tid_map(): function to change tid values in DSCP-tid map 1739 * @soc: soc handle 1740 * @pdev_id: id of pdev handle 1741 * @map_id: id of the tid map 1742 * @tos: index value in map that needs to be changed 1743 * @tid: tid value passed by user 1744 * 1745 * Return: void 1746 */ 1747 static inline void cdp_set_pdev_dscp_tid_map(ol_txrx_soc_handle soc, 1748 uint8_t pdev_id, uint8_t map_id, uint8_t tos, uint8_t tid) 1749 { 1750 if (!soc || !soc->ops) { 1751 dp_cdp_debug("Invalid Instance:"); 1752 QDF_BUG(0); 1753 return; 1754 } 1755 1756 if (!soc->ops->cmn_drv_ops || 1757 !soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map) 1758 return; 1759 1760 soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map(soc, pdev_id, 1761 map_id, tos, tid); 1762 } 1763 1764 /** 1765 * cdp_flush_cache_rx_queue() - flush cache rx queue frame 1766 * @soc: soc handle 1767 * 1768 * Return: None 1769 */ 1770 static inline void cdp_flush_cache_rx_queue(ol_txrx_soc_handle soc) 1771 { 1772 if (!soc || !soc->ops) { 1773 dp_cdp_debug("Invalid Instance:"); 1774 QDF_BUG(0); 1775 return; 1776 } 1777 1778 if (!soc->ops->cmn_drv_ops || 1779 !soc->ops->cmn_drv_ops->flush_cache_rx_queue) 1780 return; 1781 soc->ops->cmn_drv_ops->flush_cache_rx_queue(); 1782 } 1783 1784 /** 1785 * cdp_txrx_stats_request(): function to map to host and firmware statistics 1786 * @soc: soc handle 1787 * @vdev_id: virtual device ID 1788 * @req: stats request container 1789 * 1790 * return: status 1791 */ 1792 static inline 1793 int cdp_txrx_stats_request(ol_txrx_soc_handle soc, uint8_t vdev_id, 1794 struct cdp_txrx_stats_req *req) 1795 { 1796 if (!soc || !soc->ops || !soc->ops->cmn_drv_ops || !req) { 1797 dp_cdp_debug("Invalid Instance:"); 1798 QDF_ASSERT(0); 1799 return 0; 1800 } 1801 1802 if (soc->ops->cmn_drv_ops->txrx_stats_request) 1803 return soc->ops->cmn_drv_ops->txrx_stats_request(soc, vdev_id, 1804 req); 1805 1806 return 0; 1807 } 1808 1809 /** 1810 * cdp_txrx_intr_attach(): function to attach and configure interrupt 1811 * @soc: soc handle 1812 */ 1813 static inline QDF_STATUS cdp_txrx_intr_attach(ol_txrx_soc_handle soc) 1814 { 1815 if (!soc || !soc->ops) { 1816 dp_cdp_debug("Invalid Instance:"); 1817 QDF_BUG(0); 1818 return 0; 1819 } 1820 1821 if (!soc->ops->cmn_drv_ops || 1822 !soc->ops->cmn_drv_ops->txrx_intr_attach) 1823 return 0; 1824 1825 return soc->ops->cmn_drv_ops->txrx_intr_attach(soc); 1826 } 1827 1828 /** 1829 * cdp_txrx_intr_detach(): function to detach interrupt 1830 * @soc: soc handle 1831 */ 1832 static inline void cdp_txrx_intr_detach(ol_txrx_soc_handle soc) 1833 { 1834 if (!soc || !soc->ops) { 1835 dp_cdp_debug("Invalid Instance:"); 1836 QDF_BUG(0); 1837 return; 1838 } 1839 1840 if (!soc->ops->cmn_drv_ops || 1841 !soc->ops->cmn_drv_ops->txrx_intr_detach) 1842 return; 1843 1844 soc->ops->cmn_drv_ops->txrx_intr_detach(soc); 1845 } 1846 1847 /** 1848 * cdp_txrx_ppeds_stop(): function to stop ppeds 1849 * @soc: soc handle 1850 */ 1851 static inline void cdp_txrx_ppeds_stop(ol_txrx_soc_handle soc) 1852 { 1853 if (!soc || !soc->ops) { 1854 dp_cdp_debug("Invalid Instance:"); 1855 QDF_BUG(0); 1856 return; 1857 } 1858 1859 if (!soc->ops->cmn_drv_ops || 1860 !soc->ops->cmn_drv_ops->txrx_ppeds_stop) 1861 return; 1862 1863 soc->ops->cmn_drv_ops->txrx_ppeds_stop(soc); 1864 } 1865 1866 /** 1867 * cdp_txrx_umac_reset_init(): De-initialize UMAC HW reset module 1868 * @soc: soc handle 1869 */ 1870 static inline void cdp_txrx_umac_reset_init(ol_txrx_soc_handle soc) 1871 { 1872 if (!soc || !soc->ops) { 1873 dp_cdp_debug("Invalid Instance:"); 1874 QDF_BUG(0); 1875 return; 1876 } 1877 1878 if (!soc->ops->cmn_drv_ops || 1879 !soc->ops->cmn_drv_ops->txrx_umac_reset_init) 1880 return; 1881 1882 soc->ops->cmn_drv_ops->txrx_umac_reset_init(soc); 1883 } 1884 1885 /** 1886 * cdp_txrx_umac_reset_deinit(): De-initialize UMAC HW reset module 1887 * @soc: soc handle 1888 */ 1889 static inline void cdp_txrx_umac_reset_deinit(ol_txrx_soc_handle soc) 1890 { 1891 if (!soc || !soc->ops) { 1892 dp_cdp_debug("Invalid Instance:"); 1893 QDF_BUG(0); 1894 return; 1895 } 1896 1897 if (!soc->ops->cmn_drv_ops || 1898 !soc->ops->cmn_drv_ops->txrx_umac_reset_deinit) 1899 return; 1900 1901 soc->ops->cmn_drv_ops->txrx_umac_reset_deinit(soc); 1902 } 1903 1904 /** 1905 * cdp_notify_asserted_soc(): function to notify asserted SoC 1906 * @soc: soc handle 1907 * 1908 * Return: QDF_STATUS 1909 */ 1910 static inline QDF_STATUS 1911 cdp_notify_asserted_soc(ol_txrx_soc_handle soc) 1912 { 1913 if (!soc || !soc->ops) { 1914 dp_cdp_debug("Invalid Instance:"); 1915 QDF_BUG(0); 1916 return QDF_STATUS_E_NULL_VALUE; 1917 } 1918 1919 if (!soc->ops->cmn_drv_ops || 1920 !soc->ops->cmn_drv_ops->notify_asserted_soc) 1921 return QDF_STATUS_E_NULL_VALUE; 1922 1923 return soc->ops->cmn_drv_ops->notify_asserted_soc(soc); 1924 } 1925 1926 /** 1927 * cdp_display_stats(): function to map to dump stats 1928 * @soc: soc handle 1929 * @value: statistics option 1930 * @level: verbosity level 1931 */ 1932 static inline QDF_STATUS 1933 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1934 enum qdf_stats_verbosity_level level) 1935 { 1936 if (!soc || !soc->ops) { 1937 dp_cdp_debug("Invalid Instance:"); 1938 QDF_BUG(0); 1939 return 0; 1940 } 1941 1942 if (!soc->ops->cmn_drv_ops || 1943 !soc->ops->cmn_drv_ops->display_stats) 1944 return 0; 1945 1946 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1947 } 1948 1949 1950 /** 1951 * cdp_set_pn_check(): function to set pn check 1952 * @soc: soc handle 1953 * @vdev_id: id of virtual device 1954 * @peer_mac: mac address of peer 1955 * @sec_type: security type 1956 * @rx_pn: receive pn 1957 */ 1958 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1959 uint8_t vdev_id, uint8_t *peer_mac, 1960 enum cdp_sec_type sec_type, uint32_t *rx_pn) 1961 { 1962 if (!soc || !soc->ops) { 1963 dp_cdp_debug("Invalid Instance:"); 1964 QDF_BUG(0); 1965 return 0; 1966 } 1967 1968 if (!soc->ops->cmn_drv_ops || 1969 !soc->ops->cmn_drv_ops->set_pn_check) 1970 return 0; 1971 1972 soc->ops->cmn_drv_ops->set_pn_check(soc, vdev_id, peer_mac, 1973 sec_type, rx_pn); 1974 return 0; 1975 } 1976 1977 /** 1978 * cdp_set_key_sec_type(): function to set sec mode of key 1979 * @soc: soc handle 1980 * @vdev_id: id of virtual device 1981 * @peer_mac: mac address of peer 1982 * @sec_type: security type 1983 * @is_unicast: ucast or mcast 1984 */ 1985 static inline int cdp_set_key_sec_type(ol_txrx_soc_handle soc, 1986 uint8_t vdev_id, 1987 uint8_t *peer_mac, 1988 enum cdp_sec_type sec_type, 1989 bool is_unicast) 1990 { 1991 if (!soc || !soc->ops) { 1992 dp_cdp_debug("Invalid Instance:"); 1993 QDF_BUG(0); 1994 return 0; 1995 } 1996 1997 if (!soc->ops->cmn_drv_ops || 1998 !soc->ops->cmn_drv_ops->set_key_sec_type) 1999 return 0; 2000 2001 soc->ops->cmn_drv_ops->set_key_sec_type(soc, vdev_id, 2002 peer_mac, sec_type, is_unicast); 2003 return 0; 2004 } 2005 2006 static inline QDF_STATUS 2007 cdp_set_key(ol_txrx_soc_handle soc, 2008 uint8_t vdev_id, 2009 uint8_t *mac, 2010 bool is_unicast, uint32_t *key) 2011 { 2012 if (!soc || !soc->ops) { 2013 dp_cdp_debug("Invalid Instance:"); 2014 QDF_BUG(0); 2015 return QDF_STATUS_E_FAILURE; 2016 } 2017 2018 if (!soc->ops->ctrl_ops || 2019 !soc->ops->ctrl_ops->set_key) 2020 return QDF_STATUS_E_FAILURE; 2021 2022 return soc->ops->ctrl_ops->set_key(soc, vdev_id, mac, 2023 is_unicast, key); 2024 } 2025 2026 /** 2027 * cdp_update_config_parameters(): function to propagate configuration 2028 * parameters to datapath 2029 * @soc: opaque soc handle 2030 * @cfg: configuration handle 2031 * 2032 * Return: status: 0 - Success, non-zero: Failure 2033 */ 2034 static inline 2035 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 2036 struct cdp_config_params *cfg) 2037 { 2038 struct cdp_soc *psoc = (struct cdp_soc *)soc; 2039 2040 if (!soc || !soc->ops) { 2041 dp_cdp_debug("Invalid Instance:"); 2042 QDF_BUG(0); 2043 return 0; 2044 } 2045 2046 if (!soc->ops->cmn_drv_ops || 2047 !soc->ops->cmn_drv_ops->update_config_parameters) 2048 return QDF_STATUS_SUCCESS; 2049 2050 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 2051 cfg); 2052 } 2053 2054 /** 2055 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 2056 * @soc: opaque soc handle 2057 * @pdev_id: id of data path pdev handle 2058 * 2059 * Return: opaque dp handle 2060 */ 2061 static inline void * 2062 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, uint8_t pdev_id) 2063 { 2064 if (!soc || !soc->ops) { 2065 dp_cdp_debug("Invalid Instance:"); 2066 QDF_BUG(0); 2067 return 0; 2068 } 2069 2070 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 2071 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(soc, pdev_id); 2072 2073 return 0; 2074 } 2075 2076 /** 2077 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 2078 * @soc: opaque soc handle 2079 * @pdev_id: id of data path pdev handle 2080 * @dp_hdl: opaque pointer for dp_txrx_handle 2081 * 2082 * Return: void 2083 */ 2084 static inline void 2085 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, uint8_t pdev_id, 2086 void *dp_hdl) 2087 { 2088 if (!soc || !soc->ops) { 2089 dp_cdp_debug("Invalid Instance:"); 2090 QDF_BUG(0); 2091 return; 2092 } 2093 2094 if (!soc->ops->cmn_drv_ops || 2095 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 2096 return; 2097 2098 soc->ops->cmn_drv_ops->set_dp_txrx_handle(soc, pdev_id, dp_hdl); 2099 } 2100 2101 /** 2102 * cdp_vdev_get_dp_ext_txrx_handle() - get extended dp handle from vdev 2103 * @soc: opaque soc handle 2104 * @vdev_id: vdev id 2105 * 2106 * Return: opaque dp handle 2107 */ 2108 static inline void * 2109 cdp_vdev_get_dp_ext_txrx_handle(ol_txrx_soc_handle soc, uint8_t vdev_id) 2110 { 2111 if (!soc || !soc->ops) { 2112 dp_cdp_debug("Invalid Instance:"); 2113 QDF_BUG(0); 2114 return 0; 2115 } 2116 2117 if (soc->ops->cmn_drv_ops->get_vdev_dp_ext_txrx_handle) 2118 return soc->ops->cmn_drv_ops->get_vdev_dp_ext_txrx_handle( 2119 soc, vdev_id); 2120 2121 return 0; 2122 } 2123 2124 /** 2125 * cdp_vdev_set_dp_ext_txrx_handle() - set extended dp handle in vdev 2126 * @soc: opaque soc handle 2127 * @vdev_id: vdev id 2128 * @size: size of the advance dp handle 2129 * 2130 * Return: QDF_STATUS 2131 */ 2132 static inline QDF_STATUS 2133 cdp_vdev_set_dp_ext_txrx_handle(ol_txrx_soc_handle soc, uint8_t vdev_id, 2134 uint16_t size) 2135 { 2136 if (!soc || !soc->ops) { 2137 dp_cdp_debug("Invalid Instance:"); 2138 QDF_BUG(0); 2139 return QDF_STATUS_E_FAILURE; 2140 } 2141 2142 if (!soc->ops->cmn_drv_ops || 2143 !soc->ops->cmn_drv_ops->set_vdev_dp_ext_txrx_handle) 2144 return QDF_STATUS_E_FAILURE; 2145 2146 return soc->ops->cmn_drv_ops->set_vdev_dp_ext_txrx_handle(soc, 2147 vdev_id, 2148 size); 2149 } 2150 2151 /** 2152 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 2153 * @soc: opaque soc handle 2154 * 2155 * Return: opaque extended dp handle 2156 */ 2157 static inline void * 2158 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 2159 { 2160 if (!soc || !soc->ops) { 2161 dp_cdp_debug("Invalid Instance:"); 2162 QDF_BUG(0); 2163 return NULL; 2164 } 2165 2166 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 2167 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 2168 (struct cdp_soc *) soc); 2169 2170 return NULL; 2171 } 2172 2173 /** 2174 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 2175 * @soc: opaque soc handle 2176 * @dp_handle: opaque pointer for dp_txrx_handle 2177 * 2178 * Return: void 2179 */ 2180 static inline void 2181 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 2182 { 2183 if (!soc || !soc->ops) { 2184 dp_cdp_debug("Invalid Instance:"); 2185 QDF_BUG(0); 2186 return; 2187 } 2188 2189 if (!soc->ops->cmn_drv_ops || 2190 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 2191 return; 2192 2193 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 2194 dp_handle); 2195 } 2196 2197 /** 2198 * cdp_soc_handle_mode_change() - Update pdev_id to lmac_id mapping 2199 * @soc: opaque soc handle 2200 * @pdev_id: id of data path pdev handle 2201 * @lmac_id: lmac id 2202 * 2203 * Return: QDF_STATUS 2204 */ 2205 static inline QDF_STATUS 2206 cdp_soc_handle_mode_change(ol_txrx_soc_handle soc, uint8_t pdev_id, 2207 uint32_t lmac_id) 2208 { 2209 if (!soc || !soc->ops) { 2210 dp_cdp_debug("Invalid Instance:"); 2211 QDF_BUG(0); 2212 return QDF_STATUS_E_FAILURE; 2213 } 2214 2215 if (!soc->ops->cmn_drv_ops || 2216 !soc->ops->cmn_drv_ops->handle_mode_change) 2217 return QDF_STATUS_E_FAILURE; 2218 2219 return soc->ops->cmn_drv_ops->handle_mode_change(soc, pdev_id, 2220 lmac_id); 2221 } 2222 2223 /** 2224 * cdp_soc_map_pdev_to_lmac() - Save pdev_id to lmac_id mapping 2225 * @soc: opaque soc handle 2226 * @pdev_id: id of data path pdev handle 2227 * @lmac_id: lmac id 2228 * Return: QDF_STATUS 2229 */ 2230 static inline QDF_STATUS 2231 cdp_soc_map_pdev_to_lmac(ol_txrx_soc_handle soc, uint8_t pdev_id, 2232 uint32_t lmac_id) 2233 { 2234 if (!soc || !soc->ops) { 2235 dp_cdp_debug("Invalid Instance:"); 2236 QDF_BUG(0); 2237 return QDF_STATUS_E_FAILURE; 2238 } 2239 2240 if (!soc->ops->cmn_drv_ops || 2241 !soc->ops->cmn_drv_ops->map_pdev_to_lmac) 2242 return QDF_STATUS_E_FAILURE; 2243 2244 return soc->ops->cmn_drv_ops->map_pdev_to_lmac(soc, pdev_id, 2245 lmac_id); 2246 } 2247 2248 /** 2249 * cdp_txrx_set_pdev_status_down() - set pdev down/up status 2250 * @soc: soc opaque handle 2251 * @pdev_id: id of data path pdev handle 2252 * @is_pdev_down: pdev down/up status 2253 * 2254 * return: QDF_STATUS 2255 */ 2256 static inline QDF_STATUS 2257 cdp_txrx_set_pdev_status_down(ol_txrx_soc_handle soc, 2258 uint8_t pdev_id, 2259 bool is_pdev_down) 2260 { 2261 if (!soc || !soc->ops) { 2262 dp_cdp_debug("Invalid Instance:"); 2263 QDF_BUG(0); 2264 return QDF_STATUS_E_FAILURE; 2265 } 2266 2267 if (!soc->ops->cmn_drv_ops || 2268 !soc->ops->cmn_drv_ops->set_pdev_status_down) 2269 return QDF_STATUS_E_FAILURE; 2270 2271 return soc->ops->cmn_drv_ops->set_pdev_status_down(soc, pdev_id, 2272 is_pdev_down); 2273 } 2274 2275 /** 2276 * cdp_set_tx_pause() - Pause or resume tx path 2277 * @soc: Datapath soc handle 2278 * @flag: set or clear is_tx_pause 2279 * 2280 * Return: None. 2281 */ 2282 static inline 2283 void cdp_set_tx_pause(ol_txrx_soc_handle soc, bool flag) 2284 { 2285 if (!soc || !soc->ops) { 2286 dp_cdp_debug("Invalid Instance:"); 2287 QDF_BUG(0); 2288 return; 2289 } 2290 2291 if (!soc->ops->cmn_drv_ops || 2292 !soc->ops->cmn_drv_ops->set_tx_pause) 2293 return; 2294 2295 soc->ops->cmn_drv_ops->set_tx_pause(soc, flag); 2296 } 2297 2298 /** 2299 * cdp_tx_send() - enqueue frame for transmission 2300 * @soc: soc opaque handle 2301 * @vdev_id: id of VAP device 2302 * @nbuf: nbuf to be enqueued 2303 * 2304 * This API is used by Extended Datapath modules to enqueue frame for 2305 * transmission 2306 * 2307 * Return: void 2308 */ 2309 static inline void 2310 cdp_tx_send(ol_txrx_soc_handle soc, uint8_t vdev_id, qdf_nbuf_t nbuf) 2311 { 2312 if (!soc || !soc->ops) { 2313 dp_cdp_debug("Invalid Instance:"); 2314 QDF_BUG(0); 2315 return; 2316 } 2317 2318 if (!soc->ops->cmn_drv_ops || 2319 !soc->ops->cmn_drv_ops->tx_send) 2320 return; 2321 2322 soc->ops->cmn_drv_ops->tx_send(soc, vdev_id, nbuf); 2323 } 2324 2325 /** 2326 * cdp_set_pdev_pcp_tid_map() - set pdev pcp-tid-map 2327 * @soc: opaque soc handle 2328 * @pdev_id: id of data path pdev handle 2329 * @pcp: pcp value 2330 * @tid: tid value 2331 * 2332 * This API is used to configure the pcp-to-tid mapping for a pdev. 2333 * 2334 * Return: QDF_STATUS_SUCCESS if value set successfully 2335 * QDF_STATUS_E_INVAL false if error 2336 */ 2337 static inline 2338 QDF_STATUS cdp_set_pdev_pcp_tid_map(ol_txrx_soc_handle soc, 2339 uint8_t pdev_id, 2340 uint32_t pcp, uint32_t tid) 2341 { 2342 if (!soc || !soc->ops) { 2343 dp_cdp_debug("Invalid Instance"); 2344 return QDF_STATUS_E_INVAL; 2345 } 2346 2347 if (!soc->ops->cmn_drv_ops || 2348 !soc->ops->cmn_drv_ops->set_pdev_pcp_tid_map) 2349 return QDF_STATUS_E_INVAL; 2350 2351 return soc->ops->cmn_drv_ops->set_pdev_pcp_tid_map(soc, pdev_id, 2352 pcp, tid); 2353 } 2354 2355 /** 2356 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 2357 * @soc: opaque soc handle 2358 * @peer_id: data path peer id 2359 * @peer_mac: peer_mac 2360 * 2361 * Return: QDF_STATUS 2362 */ 2363 static inline 2364 QDF_STATUS cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 2365 uint32_t peer_id, uint8_t *peer_mac) 2366 { 2367 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 2368 return soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 2369 soc, peer_id, peer_mac); 2370 2371 return QDF_STATUS_E_INVAL; 2372 } 2373 2374 /** 2375 * cdp_vdev_tx_lock() - acquire lock 2376 * @soc: opaque soc handle 2377 * @vdev_id: id of data path vdev handle 2378 * 2379 * Return: void 2380 */ 2381 static inline 2382 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 2383 uint8_t vdev_id) 2384 { 2385 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 2386 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(soc, vdev_id); 2387 } 2388 2389 /** 2390 * cdp_vdev_tx_unlock() - release lock 2391 * @soc: opaque soc handle 2392 * @vdev_id: id of data path vdev handle 2393 * 2394 * Return: void 2395 */ 2396 static inline 2397 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 2398 uint8_t vdev_id) 2399 { 2400 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 2401 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(soc, vdev_id); 2402 } 2403 2404 /** 2405 * cdp_ath_getstats() - get updated athstats 2406 * @soc: opaque soc handle 2407 * @id: vdev_id/pdev_id based on type 2408 * @stats: cdp network device stats structure 2409 * @type: device type pdev/vdev 2410 * 2411 * Return: QDF_STATUS 2412 */ 2413 static inline QDF_STATUS 2414 cdp_ath_getstats(ol_txrx_soc_handle soc, 2415 uint8_t id, struct cdp_dev_stats *stats, 2416 uint8_t type) 2417 { 2418 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 2419 return soc->ops->cmn_drv_ops->txrx_ath_getstats(soc, id, 2420 stats, type); 2421 2422 return QDF_STATUS_E_FAILURE; 2423 } 2424 2425 /** 2426 * cdp_set_gid_flag() - set groupid flag 2427 * @soc: opaque soc handle 2428 * @pdev_id: id of data path pdev handle 2429 * @mem_status: member status from grp management frame 2430 * @user_position: user position from grp management frame 2431 * 2432 * Return: QDF_STATUS 2433 */ 2434 static inline QDF_STATUS 2435 cdp_set_gid_flag(ol_txrx_soc_handle soc, 2436 uint8_t pdev_id, u_int8_t *mem_status, 2437 u_int8_t *user_position) 2438 { 2439 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 2440 return soc->ops->cmn_drv_ops->txrx_set_gid_flag(soc, pdev_id, 2441 mem_status, 2442 user_position); 2443 return QDF_STATUS_E_FAILURE; 2444 } 2445 2446 /** 2447 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 2448 * @soc: opaque soc handle 2449 * @pdev_id: id of data path pdev handle 2450 * 2451 */ 2452 static inline 2453 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 2454 uint8_t pdev_id) 2455 { 2456 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 2457 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(soc, pdev_id); 2458 return 0; 2459 } 2460 2461 /** 2462 * cdp_if_mgmt_drain() - Drain management frames 2463 * @soc: opaque soc handle 2464 * @vdev_id: id of vdev device 2465 * @force: number of frame in SW queue 2466 * 2467 * Return: void 2468 */ 2469 static inline 2470 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 2471 uint8_t vdev_id, int force) 2472 { 2473 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 2474 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(soc, vdev_id, force); 2475 } 2476 2477 /** 2478 * cdp_peer_map_attach() - CDP API to allocate PEER map memory 2479 * @soc: opaque soc handle 2480 * @max_peers: number of peers created in FW 2481 * @max_ast_index: max number of AST index supported in FW 2482 * @peer_map_unmap_v: Indicates HTT peer map/unmap versions enabled in FW 2483 * 2484 * Return: QDF_STATUS 2485 */ 2486 static inline QDF_STATUS 2487 cdp_peer_map_attach(ol_txrx_soc_handle soc, uint32_t max_peers, 2488 uint32_t max_ast_index, uint8_t peer_map_unmap_v) 2489 { 2490 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2491 soc->ops->cmn_drv_ops->txrx_peer_map_attach) 2492 return soc->ops->cmn_drv_ops->txrx_peer_map_attach(soc, 2493 max_peers, 2494 max_ast_index, 2495 peer_map_unmap_v); 2496 2497 return QDF_STATUS_SUCCESS; 2498 } 2499 2500 /** 2501 * cdp_soc_set_param() - CDP API to set soc parameters 2502 * @soc: opaque soc handle 2503 * @param: parameter type 2504 * @value: parameter value 2505 * 2506 * 2507 * Return: QDF_STATUS 2508 */ 2509 static inline QDF_STATUS 2510 cdp_soc_set_param(ol_txrx_soc_handle soc, enum cdp_soc_param_t param, 2511 uint32_t value) 2512 { 2513 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2514 soc->ops->cmn_drv_ops->set_soc_param) 2515 return soc->ops->cmn_drv_ops->set_soc_param(soc, param, 2516 value); 2517 2518 return QDF_STATUS_SUCCESS; 2519 } 2520 2521 /** 2522 * cdp_txrx_classify_and_update() - To classify the packet and update stats 2523 * @soc: opaque soc handle 2524 * @vdev_id: vdev id 2525 * @skb: data 2526 * @dir: rx or tx packet 2527 * @nbuf_class: packet classification object 2528 * 2529 * Return: 1 on success else return 0 2530 */ 2531 static inline int 2532 cdp_txrx_classify_and_update(ol_txrx_soc_handle soc, 2533 uint8_t vdev_id, qdf_nbuf_t skb, 2534 enum txrx_direction dir, 2535 struct ol_txrx_nbuf_classify *nbuf_class) 2536 { 2537 if (!soc || !soc->ops) { 2538 dp_cdp_debug("Invalid Instance"); 2539 QDF_BUG(0); 2540 return 0; 2541 } 2542 2543 if (!soc->ops->cmn_drv_ops || 2544 !soc->ops->cmn_drv_ops->txrx_classify_update) 2545 return 0; 2546 2547 return soc->ops->cmn_drv_ops->txrx_classify_update(soc, vdev_id, 2548 skb, 2549 dir, nbuf_class); 2550 } 2551 2552 /** 2553 * cdp_get_dp_capabilities() - get DP capabilities 2554 * @soc: opaque soc handle 2555 * @dp_caps: enum of DP capabilities 2556 * 2557 * Return: bool 2558 */ 2559 static inline bool 2560 cdp_get_dp_capabilities(struct cdp_soc_t *soc, enum cdp_capabilities dp_caps) 2561 { 2562 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2563 soc->ops->cmn_drv_ops->get_dp_capabilities) 2564 return soc->ops->cmn_drv_ops->get_dp_capabilities(soc, dp_caps); 2565 2566 qdf_err("invalid instance"); 2567 return false; 2568 } 2569 2570 #ifdef RECEIVE_OFFLOAD 2571 /** 2572 * cdp_register_rx_offld_flush_cb() - register LRO/GRO flush cb function pointer 2573 * @soc: data path soc handle 2574 * @rx_ol_flush_cb: Flush callback function 2575 * 2576 * register rx offload flush callback function pointer 2577 * 2578 * Return: none 2579 */ 2580 static inline void cdp_register_rx_offld_flush_cb(ol_txrx_soc_handle soc, 2581 void (rx_ol_flush_cb)(void *)) 2582 { 2583 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2584 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2585 "%s invalid instance", __func__); 2586 return; 2587 } 2588 2589 if (soc->ops->rx_offld_ops->register_rx_offld_flush_cb) 2590 return soc->ops->rx_offld_ops->register_rx_offld_flush_cb( 2591 rx_ol_flush_cb); 2592 } 2593 2594 /** 2595 * cdp_deregister_rx_offld_flush_cb() - deregister Rx offld flush cb function 2596 * @soc: data path soc handle 2597 * 2598 * deregister rx offload flush callback function pointer 2599 * 2600 * Return: none 2601 */ 2602 static inline void cdp_deregister_rx_offld_flush_cb(ol_txrx_soc_handle soc) 2603 { 2604 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2605 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2606 "%s invalid instance", __func__); 2607 return; 2608 } 2609 2610 if (soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb) 2611 return soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb(); 2612 } 2613 #endif /* RECEIVE_OFFLOAD */ 2614 2615 /** 2616 * cdp_set_ba_timeout() - set ba aging timeout per AC 2617 * 2618 * @soc: pointer to the soc 2619 * @value: timeout value in millisec 2620 * @ac: Access category 2621 * 2622 * Return: void 2623 */ 2624 static inline void cdp_set_ba_timeout(ol_txrx_soc_handle soc, 2625 uint8_t ac, uint32_t value) 2626 { 2627 if (!soc || !soc->ops) { 2628 dp_cdp_debug("Invalid Instance"); 2629 QDF_BUG(0); 2630 return; 2631 } 2632 2633 if (!soc->ops->cmn_drv_ops || 2634 !soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout) 2635 return; 2636 2637 soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout(soc, ac, value); 2638 } 2639 2640 /** 2641 * cdp_get_ba_timeout() - return ba aging timeout per AC 2642 * 2643 * @soc: pointer to the soc 2644 * @ac: access category 2645 * @value: timeout value in millisec 2646 * 2647 * Return: void 2648 */ 2649 static inline void cdp_get_ba_timeout(ol_txrx_soc_handle soc, 2650 uint8_t ac, uint32_t *value) 2651 { 2652 if (!soc || !soc->ops) { 2653 dp_cdp_debug("Invalid Instance"); 2654 QDF_BUG(0); 2655 return; 2656 } 2657 2658 if (!soc->ops->cmn_drv_ops || 2659 !soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout) 2660 return; 2661 2662 soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout(soc, ac, value); 2663 } 2664 2665 /** 2666 * cdp_cfg_get() - get cfg for dp enum 2667 * 2668 * @soc: pointer to the soc 2669 * @cfg: cfg enum 2670 * 2671 * Return: cfg value 2672 */ 2673 static inline uint32_t cdp_cfg_get(ol_txrx_soc_handle soc, enum cdp_dp_cfg cfg) 2674 { 2675 if (!soc || !soc->ops) { 2676 dp_cdp_debug("Invalid Instance"); 2677 return 0; 2678 } 2679 2680 if (!soc->ops->cmn_drv_ops || !soc->ops->cmn_drv_ops->txrx_get_cfg) 2681 return 0; 2682 2683 return soc->ops->cmn_drv_ops->txrx_get_cfg(soc, cfg); 2684 } 2685 2686 /** 2687 * cdp_soc_set_rate_stats_ctx() - set rate stats context in soc 2688 * @soc: opaque soc handle 2689 * @ctx: rate stats context 2690 * 2691 * Return: void 2692 */ 2693 static inline void 2694 cdp_soc_set_rate_stats_ctx(ol_txrx_soc_handle soc, 2695 void *ctx) 2696 { 2697 if (!soc || !soc->ops) { 2698 dp_cdp_debug("Invalid Instance:"); 2699 QDF_BUG(0); 2700 return; 2701 } 2702 2703 if (!soc->ops->cmn_drv_ops || 2704 !soc->ops->cmn_drv_ops->set_rate_stats_ctx) 2705 return; 2706 2707 soc->ops->cmn_drv_ops->set_rate_stats_ctx((struct cdp_soc_t *)soc, 2708 ctx); 2709 } 2710 2711 /** 2712 * cdp_soc_get_rate_stats_ctx() - get rate stats context in soc 2713 * @soc: opaque soc handle 2714 * 2715 * Return: void 2716 */ 2717 static inline void* 2718 cdp_soc_get_rate_stats_ctx(ol_txrx_soc_handle soc) 2719 { 2720 if (!soc || !soc->ops) { 2721 dp_cdp_debug("Invalid Instance:"); 2722 QDF_BUG(0); 2723 return NULL; 2724 } 2725 2726 if (!soc->ops->cmn_drv_ops || 2727 !soc->ops->cmn_drv_ops->get_rate_stats_ctx) 2728 return NULL; 2729 2730 return soc->ops->cmn_drv_ops->get_rate_stats_ctx(soc); 2731 } 2732 2733 /** 2734 * cdp_peer_flush_rate_stats() - flush peer rate statistics 2735 * @soc: opaque soc handle 2736 * @pdev_id: id of pdev handle 2737 * @buf: stats buffer 2738 */ 2739 static inline void 2740 cdp_peer_flush_rate_stats(ol_txrx_soc_handle soc, uint8_t pdev_id, 2741 void *buf) 2742 { 2743 if (!soc || !soc->ops) { 2744 dp_cdp_debug("Invalid Instance:"); 2745 QDF_BUG(0); 2746 return; 2747 } 2748 2749 if (!soc->ops->cmn_drv_ops || 2750 !soc->ops->cmn_drv_ops->txrx_peer_flush_rate_stats) 2751 return; 2752 2753 soc->ops->cmn_drv_ops->txrx_peer_flush_rate_stats(soc, pdev_id, buf); 2754 } 2755 2756 /** 2757 * cdp_peer_get_peerstats_ctx() - get peer stats context 2758 * @soc: opaque soc handle 2759 * @vdev_id: id of vdev handle 2760 * @mac_addr: peer mac address 2761 */ 2762 static inline void 2763 *cdp_peer_get_peerstats_ctx(ol_txrx_soc_handle soc, uint8_t vdev_id, 2764 uint8_t *mac_addr) 2765 { 2766 if (!soc || !soc->ops) { 2767 dp_cdp_debug("Invalid Instance:"); 2768 QDF_BUG(0); 2769 return NULL; 2770 } 2771 2772 if (!soc->ops->cmn_drv_ops || 2773 !soc->ops->cmn_drv_ops->txrx_peer_get_peerstats_ctx) 2774 return NULL; 2775 2776 return soc->ops->cmn_drv_ops->txrx_peer_get_peerstats_ctx(soc, 2777 vdev_id, 2778 mac_addr); 2779 } 2780 2781 /** 2782 * cdp_flush_rate_stats_request() - request flush rate statistics 2783 * @soc: opaque soc handle 2784 * @pdev_id: id of pdev handle 2785 */ 2786 static inline QDF_STATUS 2787 cdp_flush_rate_stats_request(struct cdp_soc_t *soc, uint8_t pdev_id) 2788 { 2789 if (!soc || !soc->ops) { 2790 dp_cdp_debug("Invalid Instance:"); 2791 QDF_BUG(0); 2792 return QDF_STATUS_E_FAILURE; 2793 } 2794 2795 if (!soc->ops->cmn_drv_ops || 2796 !soc->ops->cmn_drv_ops->txrx_flush_rate_stats_request) 2797 return QDF_STATUS_E_FAILURE; 2798 2799 return soc->ops->cmn_drv_ops->txrx_flush_rate_stats_request(soc, 2800 pdev_id); 2801 } 2802 2803 /** 2804 * cdp_set_vdev_pcp_tid_map() - set vdev pcp-tid-map 2805 * @soc: opaque soc handle 2806 * @vdev_id: id of data path vdev handle 2807 * @pcp: pcp value 2808 * @tid: tid value 2809 * 2810 * This API is used to configure the pcp-to-tid mapping for a pdev. 2811 * 2812 * Return: QDF_STATUS_SUCCESS if value set successfully 2813 * QDF_STATUS_E_INVAL false if error 2814 */ 2815 static inline 2816 QDF_STATUS cdp_set_vdev_pcp_tid_map(ol_txrx_soc_handle soc, 2817 uint8_t vdev_id, 2818 uint8_t pcp, uint8_t tid) 2819 { 2820 if (!soc || !soc->ops) { 2821 dp_cdp_debug("Invalid Instance"); 2822 return QDF_STATUS_E_INVAL; 2823 } 2824 2825 if (!soc->ops->cmn_drv_ops || 2826 !soc->ops->cmn_drv_ops->set_vdev_pcp_tid_map) 2827 return QDF_STATUS_E_INVAL; 2828 2829 return soc->ops->cmn_drv_ops->set_vdev_pcp_tid_map(soc, vdev_id, 2830 pcp, tid); 2831 } 2832 2833 /** 2834 * cdp_tx_send_exc() - Transmit a frame on a given vdev in exception path 2835 * 2836 * @soc: opaque soc handle 2837 * @vdev_id: vdev id 2838 * @nbuf: skb 2839 * @tx_exc_metadata: Handle that holds exception path meta data 2840 * 2841 * Return: NULL on success 2842 * nbuf when it fails to send 2843 */ 2844 static inline qdf_nbuf_t 2845 cdp_tx_send_exc(ol_txrx_soc_handle soc, 2846 uint8_t vdev_id, 2847 qdf_nbuf_t nbuf, 2848 struct cdp_tx_exception_metadata *tx_exc_metadata) 2849 { 2850 if (!soc || !soc->ops) { 2851 dp_cdp_debug("Invalid Instance"); 2852 QDF_BUG(0); 2853 return 0; 2854 } 2855 2856 if (!soc->ops->cmn_drv_ops || 2857 !soc->ops->cmn_drv_ops->tx_send_exc) 2858 return 0; 2859 2860 return soc->ops->cmn_drv_ops->tx_send_exc 2861 (soc, vdev_id, nbuf, tx_exc_metadata); 2862 } 2863 2864 /** 2865 * cdp_vdev_get_peer_mac_list(): function to get peer mac list of vdev 2866 * @soc: Datapath soc handle 2867 * @vdev_id: vdev id 2868 * @newmac: Table of the clients mac 2869 * @mac_cnt: No. of MACs required 2870 * @limit: Limit the number of clients 2871 * 2872 * return: no of clients 2873 */ 2874 static inline uint16_t 2875 cdp_vdev_get_peer_mac_list(ol_txrx_soc_handle soc, 2876 uint8_t vdev_id, 2877 uint8_t newmac[][QDF_MAC_ADDR_SIZE], 2878 uint16_t mac_cnt, bool limit) 2879 { 2880 if (!soc || !soc->ops) { 2881 dp_cdp_debug("Invalid Instance"); 2882 QDF_BUG(0); 2883 return 0; 2884 } 2885 2886 if (!soc->ops->cmn_drv_ops || 2887 !soc->ops->cmn_drv_ops->get_peer_mac_list) 2888 return 0; 2889 2890 return soc->ops->cmn_drv_ops->get_peer_mac_list 2891 (soc, vdev_id, newmac, mac_cnt, limit); 2892 } 2893 2894 /** 2895 * cdp_soc_config_full_mon_mode () - Configure Full monitor mode 2896 * 2897 * @soc: dp soc handle 2898 * @val: value to be configured val should be 0 or 1 2899 * 2900 * This API is used to enable/disable support for Full monitor mode feature 2901 * 2902 * Return: QDF_STATUS_SUCCESS if value set successfully 2903 * QDF_STATUS_E_INVAL false if error 2904 */ 2905 static inline QDF_STATUS 2906 cdp_soc_config_full_mon_mode(ol_txrx_soc_handle soc, uint8_t val) 2907 { 2908 if (!soc || !soc->ops) { 2909 dp_cdp_debug("Invalid Instance"); 2910 return QDF_STATUS_E_INVAL; 2911 } 2912 2913 if (!soc->ops->mon_ops || 2914 !soc->ops->mon_ops->config_full_mon_mode) 2915 return QDF_STATUS_E_INVAL; 2916 2917 return soc->ops->mon_ops->config_full_mon_mode(soc, val); 2918 } 2919 2920 /** 2921 * cdp_rx_get_pending() - Get number of pending frames of RX threads 2922 * @soc: opaque soc handle 2923 * Return: number of pending frames 2924 */ 2925 static inline int 2926 cdp_rx_get_pending(ol_txrx_soc_handle soc) 2927 { 2928 if (!soc || !soc->ol_ops || 2929 !soc->ol_ops->dp_rx_get_pending) 2930 return 0; 2931 2932 if (cdp_cfg_get(soc, cfg_dp_wow_check_rx_pending)) 2933 return soc->ol_ops->dp_rx_get_pending(soc); 2934 else 2935 return 0; 2936 } 2937 2938 static inline uint16_t 2939 cdp_get_peer_id(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac) 2940 { 2941 if (!soc || !soc->ops) { 2942 dp_cdp_debug("Invalid Instance"); 2943 QDF_BUG(0); 2944 return 0; 2945 } 2946 2947 if (!soc->ops->cmn_drv_ops || 2948 !soc->ops->cmn_drv_ops->get_peer_id) 2949 return 0; 2950 2951 return soc->ops->cmn_drv_ops->get_peer_id 2952 (soc, vdev_id, mac); 2953 } 2954 2955 #ifdef QCA_SUPPORT_WDS_EXTENDED 2956 static inline QDF_STATUS 2957 cdp_wds_ext_set_peer_rx(ol_txrx_soc_handle soc, uint8_t vdev_id, 2958 uint8_t *mac, ol_txrx_rx_fp rx, 2959 ol_osif_peer_handle osif_peer) 2960 { 2961 if (!soc || !soc->ops) { 2962 dp_cdp_debug("Invalid Instance"); 2963 QDF_BUG(0); 2964 return QDF_STATUS_E_FAULT; 2965 } 2966 2967 if (!soc->ops->cmn_drv_ops || 2968 !soc->ops->cmn_drv_ops->set_wds_ext_peer_rx) 2969 return QDF_STATUS_E_FAULT; 2970 2971 return soc->ops->cmn_drv_ops->set_wds_ext_peer_rx 2972 (soc, vdev_id, mac, rx, osif_peer); 2973 } 2974 2975 static inline QDF_STATUS 2976 cdp_wds_ext_get_peer_osif_handle( 2977 ol_txrx_soc_handle soc, uint8_t vdev_id, 2978 uint8_t *mac, 2979 ol_osif_peer_handle *osif_peer) 2980 { 2981 if (!soc || !soc->ops) { 2982 dp_cdp_debug("Invalid Instance"); 2983 QDF_BUG(0); 2984 return QDF_STATUS_E_FAULT; 2985 } 2986 2987 if (!soc->ops->cmn_drv_ops || 2988 !soc->ops->cmn_drv_ops->get_wds_ext_peer_osif_handle) 2989 return QDF_STATUS_E_FAULT; 2990 2991 return soc->ops->cmn_drv_ops->get_wds_ext_peer_osif_handle 2992 (soc, vdev_id, mac, osif_peer); 2993 } 2994 2995 /** 2996 * cdp_wds_ext_set_bit() - set wds-ext peer bit 2997 * @soc: soc handle 2998 * @mac: peer mac address 2999 * 3000 * Return: QDF_STATUS 3001 */ 3002 static inline QDF_STATUS 3003 cdp_wds_ext_set_bit(ol_txrx_soc_handle soc, uint8_t *mac) 3004 { 3005 if (!soc || !soc->ops) { 3006 dp_cdp_debug("Invalid Instance"); 3007 QDF_BUG(0); 3008 return QDF_STATUS_E_FAULT; 3009 } 3010 3011 if (!soc->ops->cmn_drv_ops || 3012 !soc->ops->cmn_drv_ops->set_wds_ext_peer_bit) 3013 return QDF_STATUS_E_FAULT; 3014 3015 return soc->ops->cmn_drv_ops->set_wds_ext_peer_bit(soc, mac); 3016 } 3017 #endif /* QCA_SUPPORT_WDS_EXTENDED */ 3018 3019 /** 3020 * cdp_drain_txrx() - drain TX/RX SRNGs 3021 * @soc: opaque soc handle 3022 */ 3023 static inline void 3024 cdp_drain_txrx(ol_txrx_soc_handle soc) 3025 { 3026 if (!soc || !soc->ops) { 3027 dp_cdp_debug("Invalid Instance"); 3028 QDF_BUG(0); 3029 return; 3030 } 3031 3032 if (!soc->ops->cmn_drv_ops || 3033 !soc->ops->cmn_drv_ops->txrx_drain) 3034 return; 3035 3036 return soc->ops->cmn_drv_ops->txrx_drain(soc); 3037 } 3038 3039 /** 3040 * cdp_get_free_desc_poolsize() - get free desc pool size 3041 * @soc: opaque soc handle 3042 */ 3043 static inline int 3044 cdp_get_free_desc_poolsize(ol_txrx_soc_handle soc) 3045 { 3046 if (!soc || !soc->ops) { 3047 dp_cdp_debug("Invalid Instance"); 3048 QDF_BUG(0); 3049 return 0; 3050 } 3051 3052 if (!soc->ops->cmn_drv_ops || 3053 !soc->ops->cmn_drv_ops->get_free_desc_poolsize) 3054 return 0; 3055 3056 return soc->ops->cmn_drv_ops->get_free_desc_poolsize(soc); 3057 } 3058 3059 #ifdef WLAN_FEATURE_PKT_CAPTURE_V2 3060 /** 3061 * cdp_set_pkt_capture_mode() - set pkt capture mode in dp ctx 3062 * @soc: opaque soc handle 3063 * @val: value to be set 3064 */ 3065 static inline void 3066 cdp_set_pkt_capture_mode(ol_txrx_soc_handle soc, bool val) 3067 { 3068 if (!soc || !soc->ops) { 3069 dp_cdp_debug("Invalid Instance"); 3070 QDF_BUG(0); 3071 return; 3072 } 3073 3074 if (!soc->ops->cmn_drv_ops || 3075 !soc->ops->cmn_drv_ops->set_pkt_capture_mode) 3076 return; 3077 3078 soc->ops->cmn_drv_ops->set_pkt_capture_mode(soc, val); 3079 } 3080 #else 3081 static inline void 3082 cdp_set_pkt_capture_mode(ol_txrx_soc_handle soc, bool val) 3083 { 3084 } 3085 #endif 3086 3087 /** 3088 * cdp_get_tx_inqueue() - Get number of Tx frames that are queued 3089 * @soc: opaque soc handle 3090 * 3091 * Return: number of queued frames 3092 */ 3093 static inline uint32_t 3094 cdp_get_tx_inqueue(ol_txrx_soc_handle soc) 3095 { 3096 if (!soc || !soc->ol_ops || 3097 !soc->ol_ops->dp_get_tx_inqueue) 3098 return 0; 3099 3100 return soc->ol_ops->dp_get_tx_inqueue(soc); 3101 } 3102 3103 #ifdef FEATURE_RUNTIME_PM 3104 3105 /** 3106 * cdp_set_rtpm_tput_policy_requirement() - Set RTPM throughput policy 3107 * @soc: opaque soc handle 3108 * @is_high_tput: flag indicating whether throughput requirement is high or not 3109 * 3110 * The functions sets RTPM throughput policy requirement. If 'is_high_tput' is 3111 * set, the expectation is that runtime_pm APIs will not be invoked per packet. 3112 */ 3113 3114 static inline 3115 void cdp_set_rtpm_tput_policy_requirement(ol_txrx_soc_handle soc, 3116 bool is_high_tput) 3117 { 3118 if (!soc || !soc->ops) { 3119 dp_cdp_debug("Invalid Instance"); 3120 QDF_BUG(0); 3121 return; 3122 } 3123 3124 if (!soc->ops->cmn_drv_ops || 3125 !soc->ops->cmn_drv_ops->set_rtpm_tput_policy) 3126 return; 3127 3128 soc->ops->cmn_drv_ops->set_rtpm_tput_policy(soc, is_high_tput); 3129 } 3130 #else 3131 static inline 3132 void cdp_set_rtpm_tput_policy_requirement(ol_txrx_soc_handle soc, 3133 bool is_high_tput) 3134 { 3135 } 3136 3137 #endif /* FEATURE_RUNTIME_PM */ 3138 3139 /** 3140 * cdp_enable_mon_reap_timer() - enable/disable reap timer 3141 * @soc: Datapath soc handle 3142 * @source: monitor reap source 3143 * @enable: enable/disable reap timer of monitor status ring 3144 * 3145 * Return: true if timer start/stop is performed, false otherwise. 3146 */ 3147 static inline bool 3148 cdp_enable_mon_reap_timer(ol_txrx_soc_handle soc, 3149 enum cdp_mon_reap_source source, 3150 bool enable) 3151 { 3152 if (!soc || !soc->ops) { 3153 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 3154 "%s invalid instance", __func__); 3155 QDF_BUG(0); 3156 return false; 3157 } 3158 3159 if (!soc->ops->mon_ops || 3160 !soc->ops->mon_ops->txrx_enable_mon_reap_timer) 3161 return false; 3162 3163 return soc->ops->mon_ops->txrx_enable_mon_reap_timer(soc, source, 3164 enable); 3165 } 3166 3167 /** 3168 * cdp_get_tsf_time() - get tsf time 3169 * @soc: Datapath soc handle 3170 * @tsf_id: 3171 * @mac_id: mac_id 3172 * @tsf: pointer to update tsf value 3173 * @tsf_sync_soc_time: pointer to update tsf sync time 3174 * 3175 * Return: None. 3176 */ 3177 static inline void 3178 cdp_get_tsf_time(ol_txrx_soc_handle soc, uint32_t tsf_id, uint32_t mac_id, 3179 uint64_t *tsf, uint64_t *tsf_sync_soc_time) 3180 { 3181 if (!soc) { 3182 dp_cdp_debug("Invalid Instance"); 3183 return; 3184 } 3185 if (!soc->ops->cmn_drv_ops || !soc->ops->cmn_drv_ops->txrx_get_tsf_time) 3186 return; 3187 3188 soc->ops->cmn_drv_ops->txrx_get_tsf_time(soc, tsf_id, mac_id, tsf, 3189 tsf_sync_soc_time); 3190 } 3191 3192 /** 3193 * cdp_get_tsf2_offset() - get tsf2 offset 3194 * @soc: Datapath soc handle 3195 * @mac_id: mac_id 3196 * @value: pointer to update tsf2 value 3197 * 3198 * Return: None. 3199 */ 3200 static inline void 3201 cdp_get_tsf2_offset(ol_txrx_soc_handle soc, uint8_t mac_id, uint64_t *value) 3202 { 3203 if (!soc) { 3204 dp_cdp_debug("Invalid Instance"); 3205 return; 3206 } 3207 if (!soc->ops->cmn_drv_ops || 3208 !soc->ops->cmn_drv_ops->txrx_get_tsf2_offset) 3209 return; 3210 3211 soc->ops->cmn_drv_ops->txrx_get_tsf2_offset(soc, mac_id, value); 3212 } 3213 3214 /** 3215 * cdp_get_tqm_offset() - get tqm offset 3216 * @soc: Datapath soc handle 3217 * @value: pointer to update tqm value 3218 * 3219 * Return: None. 3220 */ 3221 static inline void 3222 cdp_get_tqm_offset(ol_txrx_soc_handle soc, uint64_t *value) 3223 { 3224 if (!soc) { 3225 dp_cdp_debug("Invalid Instance"); 3226 return; 3227 } 3228 if (!soc->ops->cmn_drv_ops || 3229 !soc->ops->cmn_drv_ops->txrx_get_tqm_offset) 3230 return; 3231 3232 soc->ops->cmn_drv_ops->txrx_get_tqm_offset(soc, value); 3233 } 3234 3235 static inline uint64_t cdp_get_fst_cem_base(ol_txrx_soc_handle soc, 3236 uint64_t size) 3237 { 3238 if (!soc) { 3239 dp_cdp_debug("Invalid Instance"); 3240 return 0; 3241 } 3242 3243 if (!soc->ops->cmn_drv_ops || 3244 !soc->ops->cmn_drv_ops->get_fst_cmem_base) 3245 return 0; 3246 3247 return soc->ops->cmn_drv_ops->get_fst_cmem_base(soc, size); 3248 } 3249 3250 #if defined(WLAN_FEATURE_11BE_MLO) 3251 /* 3252 * cdp_mlo_dev_ctxt_create - DP MLO Device context create 3253 * @soc: soc handle 3254 * @mld_mac_addr: MLD MAC Address 3255 * 3256 * return: QDF_STATUS 3257 */ 3258 static inline 3259 QDF_STATUS cdp_mlo_dev_ctxt_create(ol_txrx_soc_handle soc, 3260 uint8_t *mld_mac_addr) 3261 { 3262 if (!soc || !soc->ops) { 3263 QDF_BUG(0); 3264 return QDF_STATUS_E_FAILURE; 3265 } 3266 3267 if (!soc->ops->cmn_mlo_ops || 3268 !soc->ops->cmn_mlo_ops->mlo_dev_ctxt_create) 3269 return QDF_STATUS_E_FAILURE; 3270 3271 return soc->ops->cmn_mlo_ops->mlo_dev_ctxt_create(soc, mld_mac_addr); 3272 } 3273 3274 /* 3275 * cdp_mlo_dev_ctxt_destroy - DP MLO Device context destroy 3276 * @soc: soc handle 3277 * @mld_mac_addr: MLD MAC Address 3278 * 3279 * return: QDF_STATUS 3280 */ 3281 static inline 3282 QDF_STATUS cdp_mlo_dev_ctxt_destroy(ol_txrx_soc_handle soc, 3283 uint8_t *mld_mac_addr) 3284 { 3285 if (!soc || !soc->ops) { 3286 QDF_BUG(0); 3287 return QDF_STATUS_E_FAILURE; 3288 } 3289 3290 if (!soc->ops->cmn_mlo_ops || 3291 !soc->ops->cmn_mlo_ops->mlo_dev_ctxt_destroy) 3292 return QDF_STATUS_E_FAILURE; 3293 3294 return soc->ops->cmn_mlo_ops->mlo_dev_ctxt_destroy(soc, mld_mac_addr); 3295 } 3296 3297 /* 3298 * cdp_mlo_dev_ctxt_attach - DP MLO Device context attach vdev 3299 * @soc: soc handle 3300 * @vdev_id: vdev id 3301 * @mld_mac_addr: MLD MAC Address 3302 * 3303 * return: QDF_STATUS 3304 */ 3305 static inline 3306 QDF_STATUS cdp_mlo_dev_ctxt_attach(ol_txrx_soc_handle soc, 3307 uint8_t vdev_id, 3308 uint8_t *mld_mac_addr) 3309 { 3310 if (!soc || !soc->ops) { 3311 QDF_BUG(0); 3312 return QDF_STATUS_E_FAILURE; 3313 } 3314 3315 if (!soc->ops->cmn_mlo_ops || 3316 !soc->ops->cmn_mlo_ops->mlo_dev_ctxt_attach) 3317 return QDF_STATUS_E_FAILURE; 3318 3319 return soc->ops->cmn_mlo_ops->mlo_dev_ctxt_attach(soc, vdev_id, 3320 mld_mac_addr); 3321 } 3322 3323 /* 3324 * cdp_mlo_dev_ctxt_detach - DP MLO Device context detach vdev 3325 * @soc: soc handle 3326 * @vdev_id: vdev id 3327 * @mld_mac_addr: MLD MAC Address 3328 * 3329 * return: QDF_STATUS 3330 */ 3331 static inline 3332 QDF_STATUS cdp_mlo_dev_ctxt_detach(ol_txrx_soc_handle soc, 3333 uint8_t vdev_id, 3334 uint8_t *mld_mac_addr) 3335 { 3336 if (!soc || !soc->ops) { 3337 QDF_BUG(0); 3338 return QDF_STATUS_E_FAILURE; 3339 } 3340 3341 if (!soc->ops->cmn_mlo_ops || 3342 !soc->ops->cmn_mlo_ops->mlo_dev_ctxt_detach) 3343 return QDF_STATUS_E_FAILURE; 3344 3345 return soc->ops->cmn_mlo_ops->mlo_dev_ctxt_detach(soc, vdev_id, 3346 mld_mac_addr); 3347 } 3348 #else 3349 static inline 3350 QDF_STATUS cdp_mlo_dev_ctxt_create(ol_txrx_soc_handle soc, 3351 uint8_t *mld_mac_addr) 3352 { 3353 return QDF_STATUS_SUCCESS; 3354 } 3355 3356 static inline 3357 QDF_STATUS cdp_mlo_dev_ctxt_destroy(ol_txrx_soc_handle soc, 3358 uint8_t *mld_mac_addr) 3359 { 3360 return QDF_STATUS_SUCCESS; 3361 } 3362 3363 static inline 3364 QDF_STATUS cdp_mlo_dev_ctxt_attach(ol_txrx_soc_handle soc, 3365 uint8_t vdev_id, 3366 uint8_t *mld_mac_addr) 3367 { 3368 return QDF_STATUS_SUCCESS; 3369 } 3370 3371 static inline 3372 QDF_STATUS cdp_mlo_dev_ctxt_detach(ol_txrx_soc_handle soc, 3373 uint8_t vdev_id, 3374 uint8_t *mld_mac_addr) 3375 { 3376 return QDF_STATUS_SUCCESS; 3377 } 3378 #endif /* WLAN_FEATURE_11BE_MLO */ 3379 #endif /* _CDP_TXRX_CMN_H_ */ 3380