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