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 * @delete_in_fw: flag to indicate AST entry deletion in FW 692 * 693 * Return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete 694 * is sent 695 * QDF_STATUS_E_INVAL false if ast entry not found 696 */ 697 static inline QDF_STATUS cdp_peer_HMWDS_ast_delete 698 (ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *dest_mac, 699 uint8_t type, uint8_t delete_in_fw) 700 { 701 if (!soc || !soc->ops) { 702 dp_cdp_debug("Invalid Instance:"); 703 QDF_BUG(0); 704 return QDF_STATUS_E_INVAL; 705 } 706 707 if (!soc->ops->cmn_drv_ops || 708 !soc->ops->cmn_drv_ops->txrx_peer_HMWDS_ast_delete) 709 return QDF_STATUS_E_INVAL; 710 711 return soc->ops->cmn_drv_ops->txrx_peer_HMWDS_ast_delete 712 (soc, 713 vdev_id, 714 dest_mac, 715 type, 716 delete_in_fw); 717 } 718 719 static inline int cdp_peer_add_ast 720 (ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *peer_mac, 721 uint8_t *mac_addr, 722 enum cdp_txrx_ast_entry_type type, uint32_t flags) 723 { 724 if (!soc || !soc->ops) { 725 dp_cdp_debug("Invalid Instance:"); 726 QDF_BUG(0); 727 return 0; 728 } 729 730 if (!soc->ops->cmn_drv_ops || 731 !soc->ops->cmn_drv_ops->txrx_peer_add_ast) 732 return 0; 733 734 return soc->ops->cmn_drv_ops->txrx_peer_add_ast(soc, 735 vdev_id, 736 peer_mac, 737 mac_addr, 738 type, 739 flags); 740 } 741 742 static inline QDF_STATUS cdp_peer_reset_ast 743 (ol_txrx_soc_handle soc, uint8_t *wds_macaddr, uint8_t *peer_macaddr, 744 uint8_t vdev_id) 745 { 746 747 if (!soc || !soc->ops) { 748 dp_cdp_debug("Invalid Instance:"); 749 QDF_BUG(0); 750 return QDF_STATUS_E_FAILURE; 751 } 752 if (!soc->ops->cmn_drv_ops || 753 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast) 754 return QDF_STATUS_E_FAILURE; 755 756 return soc->ops->cmn_drv_ops->txrx_peer_reset_ast(soc, wds_macaddr, 757 peer_macaddr, vdev_id); 758 } 759 760 static inline QDF_STATUS cdp_peer_reset_ast_table 761 (ol_txrx_soc_handle soc, uint8_t vdev_id) 762 { 763 if (!soc || !soc->ops) { 764 dp_cdp_debug("Invalid Instance:"); 765 QDF_BUG(0); 766 return QDF_STATUS_E_FAILURE; 767 } 768 769 if (!soc->ops->cmn_drv_ops || 770 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table) 771 return QDF_STATUS_E_FAILURE; 772 773 return soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table(soc, vdev_id); 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_display_stats(): function to map to dump stats 1868 * @soc: soc handle 1869 * @value: statistics option 1870 * @level: verbosity level 1871 */ 1872 static inline QDF_STATUS 1873 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1874 enum qdf_stats_verbosity_level level) 1875 { 1876 if (!soc || !soc->ops) { 1877 dp_cdp_debug("Invalid Instance:"); 1878 QDF_BUG(0); 1879 return 0; 1880 } 1881 1882 if (!soc->ops->cmn_drv_ops || 1883 !soc->ops->cmn_drv_ops->display_stats) 1884 return 0; 1885 1886 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1887 } 1888 1889 1890 /** 1891 * cdp_set_pn_check(): function to set pn check 1892 * @soc: soc handle 1893 * @vdev_id: id of virtual device 1894 * @peer_mac: mac address of peer 1895 * @sec_type: security type 1896 * @rx_pn: receive pn 1897 */ 1898 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1899 uint8_t vdev_id, uint8_t *peer_mac, 1900 enum cdp_sec_type sec_type, uint32_t *rx_pn) 1901 { 1902 if (!soc || !soc->ops) { 1903 dp_cdp_debug("Invalid Instance:"); 1904 QDF_BUG(0); 1905 return 0; 1906 } 1907 1908 if (!soc->ops->cmn_drv_ops || 1909 !soc->ops->cmn_drv_ops->set_pn_check) 1910 return 0; 1911 1912 soc->ops->cmn_drv_ops->set_pn_check(soc, vdev_id, peer_mac, 1913 sec_type, rx_pn); 1914 return 0; 1915 } 1916 1917 /** 1918 * cdp_set_key_sec_type(): function to set sec mode of key 1919 * @soc: soc handle 1920 * @vdev_id: id of virtual device 1921 * @peer_mac: mac address of peer 1922 * @sec_type: security type 1923 * @is_unicast: ucast or mcast 1924 */ 1925 static inline int cdp_set_key_sec_type(ol_txrx_soc_handle soc, 1926 uint8_t vdev_id, 1927 uint8_t *peer_mac, 1928 enum cdp_sec_type sec_type, 1929 bool is_unicast) 1930 { 1931 if (!soc || !soc->ops) { 1932 dp_cdp_debug("Invalid Instance:"); 1933 QDF_BUG(0); 1934 return 0; 1935 } 1936 1937 if (!soc->ops->cmn_drv_ops || 1938 !soc->ops->cmn_drv_ops->set_key_sec_type) 1939 return 0; 1940 1941 soc->ops->cmn_drv_ops->set_key_sec_type(soc, vdev_id, 1942 peer_mac, sec_type, is_unicast); 1943 return 0; 1944 } 1945 1946 static inline QDF_STATUS 1947 cdp_set_key(ol_txrx_soc_handle soc, 1948 uint8_t vdev_id, 1949 uint8_t *mac, 1950 bool is_unicast, uint32_t *key) 1951 { 1952 if (!soc || !soc->ops) { 1953 dp_cdp_debug("Invalid Instance:"); 1954 QDF_BUG(0); 1955 return QDF_STATUS_E_FAILURE; 1956 } 1957 1958 if (!soc->ops->ctrl_ops || 1959 !soc->ops->ctrl_ops->set_key) 1960 return QDF_STATUS_E_FAILURE; 1961 1962 return soc->ops->ctrl_ops->set_key(soc, vdev_id, mac, 1963 is_unicast, key); 1964 } 1965 1966 /** 1967 * cdp_update_config_parameters(): function to propagate configuration 1968 * parameters to datapath 1969 * @soc: opaque soc handle 1970 * @cfg: configuration handle 1971 * 1972 * Return: status: 0 - Success, non-zero: Failure 1973 */ 1974 static inline 1975 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 1976 struct cdp_config_params *cfg) 1977 { 1978 struct cdp_soc *psoc = (struct cdp_soc *)soc; 1979 1980 if (!soc || !soc->ops) { 1981 dp_cdp_debug("Invalid Instance:"); 1982 QDF_BUG(0); 1983 return 0; 1984 } 1985 1986 if (!soc->ops->cmn_drv_ops || 1987 !soc->ops->cmn_drv_ops->update_config_parameters) 1988 return QDF_STATUS_SUCCESS; 1989 1990 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 1991 cfg); 1992 } 1993 1994 /** 1995 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 1996 * @soc: opaque soc handle 1997 * @pdev_id: id of data path pdev handle 1998 * 1999 * Return: opaque dp handle 2000 */ 2001 static inline void * 2002 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, uint8_t pdev_id) 2003 { 2004 if (!soc || !soc->ops) { 2005 dp_cdp_debug("Invalid Instance:"); 2006 QDF_BUG(0); 2007 return 0; 2008 } 2009 2010 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 2011 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(soc, pdev_id); 2012 2013 return 0; 2014 } 2015 2016 /** 2017 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 2018 * @soc: opaque soc handle 2019 * @pdev_id: id of data path pdev handle 2020 * @dp_hdl: opaque pointer for dp_txrx_handle 2021 * 2022 * Return: void 2023 */ 2024 static inline void 2025 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, uint8_t pdev_id, 2026 void *dp_hdl) 2027 { 2028 if (!soc || !soc->ops) { 2029 dp_cdp_debug("Invalid Instance:"); 2030 QDF_BUG(0); 2031 return; 2032 } 2033 2034 if (!soc->ops->cmn_drv_ops || 2035 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 2036 return; 2037 2038 soc->ops->cmn_drv_ops->set_dp_txrx_handle(soc, pdev_id, dp_hdl); 2039 } 2040 2041 /** 2042 * cdp_vdev_get_dp_ext_txrx_handle() - get extended dp handle from vdev 2043 * @soc: opaque soc handle 2044 * @vdev_id: vdev id 2045 * 2046 * Return: opaque dp handle 2047 */ 2048 static inline void * 2049 cdp_vdev_get_dp_ext_txrx_handle(ol_txrx_soc_handle soc, uint8_t vdev_id) 2050 { 2051 if (!soc || !soc->ops) { 2052 dp_cdp_debug("Invalid Instance:"); 2053 QDF_BUG(0); 2054 return 0; 2055 } 2056 2057 if (soc->ops->cmn_drv_ops->get_vdev_dp_ext_txrx_handle) 2058 return soc->ops->cmn_drv_ops->get_vdev_dp_ext_txrx_handle( 2059 soc, vdev_id); 2060 2061 return 0; 2062 } 2063 2064 /** 2065 * cdp_vdev_set_dp_ext_txrx_handle() - set extended dp handle in vdev 2066 * @soc: opaque soc handle 2067 * @vdev_id: vdev id 2068 * @size: size of the advance dp handle 2069 * 2070 * Return: QDF_STATUS 2071 */ 2072 static inline QDF_STATUS 2073 cdp_vdev_set_dp_ext_txrx_handle(ol_txrx_soc_handle soc, uint8_t vdev_id, 2074 uint16_t size) 2075 { 2076 if (!soc || !soc->ops) { 2077 dp_cdp_debug("Invalid Instance:"); 2078 QDF_BUG(0); 2079 return QDF_STATUS_E_FAILURE; 2080 } 2081 2082 if (!soc->ops->cmn_drv_ops || 2083 !soc->ops->cmn_drv_ops->set_vdev_dp_ext_txrx_handle) 2084 return QDF_STATUS_E_FAILURE; 2085 2086 return soc->ops->cmn_drv_ops->set_vdev_dp_ext_txrx_handle(soc, 2087 vdev_id, 2088 size); 2089 } 2090 2091 /** 2092 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 2093 * @soc: opaque soc handle 2094 * 2095 * Return: opaque extended dp handle 2096 */ 2097 static inline void * 2098 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 2099 { 2100 if (!soc || !soc->ops) { 2101 dp_cdp_debug("Invalid Instance:"); 2102 QDF_BUG(0); 2103 return NULL; 2104 } 2105 2106 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 2107 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 2108 (struct cdp_soc *) soc); 2109 2110 return NULL; 2111 } 2112 2113 /** 2114 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 2115 * @soc: opaque soc handle 2116 * @dp_handle: opaque pointer for dp_txrx_handle 2117 * 2118 * Return: void 2119 */ 2120 static inline void 2121 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 2122 { 2123 if (!soc || !soc->ops) { 2124 dp_cdp_debug("Invalid Instance:"); 2125 QDF_BUG(0); 2126 return; 2127 } 2128 2129 if (!soc->ops->cmn_drv_ops || 2130 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 2131 return; 2132 2133 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 2134 dp_handle); 2135 } 2136 2137 /** 2138 * cdp_soc_handle_mode_change() - Update pdev_id to lmac_id mapping 2139 * @soc: opaque soc handle 2140 * @pdev_id: id of data path pdev handle 2141 * @lmac_id: lmac id 2142 * 2143 * Return: QDF_STATUS 2144 */ 2145 static inline QDF_STATUS 2146 cdp_soc_handle_mode_change(ol_txrx_soc_handle soc, uint8_t pdev_id, 2147 uint32_t lmac_id) 2148 { 2149 if (!soc || !soc->ops) { 2150 dp_cdp_debug("Invalid Instance:"); 2151 QDF_BUG(0); 2152 return QDF_STATUS_E_FAILURE; 2153 } 2154 2155 if (!soc->ops->cmn_drv_ops || 2156 !soc->ops->cmn_drv_ops->handle_mode_change) 2157 return QDF_STATUS_E_FAILURE; 2158 2159 return soc->ops->cmn_drv_ops->handle_mode_change(soc, pdev_id, 2160 lmac_id); 2161 } 2162 2163 /** 2164 * cdp_soc_map_pdev_to_lmac() - Save pdev_id to lmac_id mapping 2165 * @soc: opaque soc handle 2166 * @pdev_id: id of data path pdev handle 2167 * @lmac_id: lmac id 2168 * Return: QDF_STATUS 2169 */ 2170 static inline QDF_STATUS 2171 cdp_soc_map_pdev_to_lmac(ol_txrx_soc_handle soc, uint8_t pdev_id, 2172 uint32_t lmac_id) 2173 { 2174 if (!soc || !soc->ops) { 2175 dp_cdp_debug("Invalid Instance:"); 2176 QDF_BUG(0); 2177 return QDF_STATUS_E_FAILURE; 2178 } 2179 2180 if (!soc->ops->cmn_drv_ops || 2181 !soc->ops->cmn_drv_ops->map_pdev_to_lmac) 2182 return QDF_STATUS_E_FAILURE; 2183 2184 return soc->ops->cmn_drv_ops->map_pdev_to_lmac(soc, pdev_id, 2185 lmac_id); 2186 } 2187 2188 /** 2189 * cdp_txrx_set_pdev_status_down() - set pdev down/up status 2190 * @soc: soc opaque handle 2191 * @pdev_id: id of data path pdev handle 2192 * @is_pdev_down: pdev down/up status 2193 * 2194 * return: QDF_STATUS 2195 */ 2196 static inline QDF_STATUS 2197 cdp_txrx_set_pdev_status_down(ol_txrx_soc_handle soc, 2198 uint8_t pdev_id, 2199 bool is_pdev_down) 2200 { 2201 if (!soc || !soc->ops) { 2202 dp_cdp_debug("Invalid Instance:"); 2203 QDF_BUG(0); 2204 return QDF_STATUS_E_FAILURE; 2205 } 2206 2207 if (!soc->ops->cmn_drv_ops || 2208 !soc->ops->cmn_drv_ops->set_pdev_status_down) 2209 return QDF_STATUS_E_FAILURE; 2210 2211 return soc->ops->cmn_drv_ops->set_pdev_status_down(soc, pdev_id, 2212 is_pdev_down); 2213 } 2214 2215 /** 2216 * cdp_set_tx_pause() - Pause or resume tx path 2217 * @soc: Datapath soc handle 2218 * @flag: set or clear is_tx_pause 2219 * 2220 * Return: None. 2221 */ 2222 static inline 2223 void cdp_set_tx_pause(ol_txrx_soc_handle soc, bool flag) 2224 { 2225 if (!soc || !soc->ops) { 2226 dp_cdp_debug("Invalid Instance:"); 2227 QDF_BUG(0); 2228 return; 2229 } 2230 2231 if (!soc->ops->cmn_drv_ops || 2232 !soc->ops->cmn_drv_ops->set_tx_pause) 2233 return; 2234 2235 soc->ops->cmn_drv_ops->set_tx_pause(soc, flag); 2236 } 2237 2238 /** 2239 * cdp_tx_send() - enqueue frame for transmission 2240 * @soc: soc opaque handle 2241 * @vdev_id: id of VAP device 2242 * @nbuf: nbuf to be enqueued 2243 * 2244 * This API is used by Extended Datapath modules to enqueue frame for 2245 * transmission 2246 * 2247 * Return: void 2248 */ 2249 static inline void 2250 cdp_tx_send(ol_txrx_soc_handle soc, uint8_t vdev_id, qdf_nbuf_t nbuf) 2251 { 2252 if (!soc || !soc->ops) { 2253 dp_cdp_debug("Invalid Instance:"); 2254 QDF_BUG(0); 2255 return; 2256 } 2257 2258 if (!soc->ops->cmn_drv_ops || 2259 !soc->ops->cmn_drv_ops->tx_send) 2260 return; 2261 2262 soc->ops->cmn_drv_ops->tx_send(soc, vdev_id, nbuf); 2263 } 2264 2265 /** 2266 * cdp_set_pdev_pcp_tid_map() - set pdev pcp-tid-map 2267 * @soc: opaque soc handle 2268 * @pdev_id: id of data path pdev handle 2269 * @pcp: pcp value 2270 * @tid: tid value 2271 * 2272 * This API is used to configure the pcp-to-tid mapping for a pdev. 2273 * 2274 * Return: QDF_STATUS_SUCCESS if value set successfully 2275 * QDF_STATUS_E_INVAL false if error 2276 */ 2277 static inline 2278 QDF_STATUS cdp_set_pdev_pcp_tid_map(ol_txrx_soc_handle soc, 2279 uint8_t pdev_id, 2280 uint32_t pcp, uint32_t tid) 2281 { 2282 if (!soc || !soc->ops) { 2283 dp_cdp_debug("Invalid Instance"); 2284 return QDF_STATUS_E_INVAL; 2285 } 2286 2287 if (!soc->ops->cmn_drv_ops || 2288 !soc->ops->cmn_drv_ops->set_pdev_pcp_tid_map) 2289 return QDF_STATUS_E_INVAL; 2290 2291 return soc->ops->cmn_drv_ops->set_pdev_pcp_tid_map(soc, pdev_id, 2292 pcp, tid); 2293 } 2294 2295 /** 2296 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 2297 * @soc: opaque soc handle 2298 * @peer_id: data path peer id 2299 * @peer_mac: peer_mac 2300 * 2301 * Return: QDF_STATUS 2302 */ 2303 static inline 2304 QDF_STATUS cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 2305 uint32_t peer_id, uint8_t *peer_mac) 2306 { 2307 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 2308 return soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 2309 soc, peer_id, peer_mac); 2310 2311 return QDF_STATUS_E_INVAL; 2312 } 2313 2314 /** 2315 * cdp_vdev_tx_lock() - acquire lock 2316 * @soc: opaque soc handle 2317 * @vdev_id: id of data path vdev handle 2318 * 2319 * Return: void 2320 */ 2321 static inline 2322 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 2323 uint8_t vdev_id) 2324 { 2325 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 2326 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(soc, vdev_id); 2327 } 2328 2329 /** 2330 * cdp_vdev_tx_unlock() - release lock 2331 * @soc: opaque soc handle 2332 * @vdev_id: id of data path vdev handle 2333 * 2334 * Return: void 2335 */ 2336 static inline 2337 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 2338 uint8_t vdev_id) 2339 { 2340 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 2341 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(soc, vdev_id); 2342 } 2343 2344 /** 2345 * cdp_ath_getstats() - get updated athstats 2346 * @soc: opaque soc handle 2347 * @id: vdev_id/pdev_id based on type 2348 * @stats: cdp network device stats structure 2349 * @type: device type pdev/vdev 2350 * 2351 * Return: QDF_STATUS 2352 */ 2353 static inline QDF_STATUS 2354 cdp_ath_getstats(ol_txrx_soc_handle soc, 2355 uint8_t id, struct cdp_dev_stats *stats, 2356 uint8_t type) 2357 { 2358 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 2359 return soc->ops->cmn_drv_ops->txrx_ath_getstats(soc, id, 2360 stats, type); 2361 2362 return QDF_STATUS_E_FAILURE; 2363 } 2364 2365 /** 2366 * cdp_set_gid_flag() - set groupid flag 2367 * @soc: opaque soc handle 2368 * @pdev_id: id of data path pdev handle 2369 * @mem_status: member status from grp management frame 2370 * @user_position: user position from grp management frame 2371 * 2372 * Return: QDF_STATUS 2373 */ 2374 static inline QDF_STATUS 2375 cdp_set_gid_flag(ol_txrx_soc_handle soc, 2376 uint8_t pdev_id, u_int8_t *mem_status, 2377 u_int8_t *user_position) 2378 { 2379 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 2380 return soc->ops->cmn_drv_ops->txrx_set_gid_flag(soc, pdev_id, 2381 mem_status, 2382 user_position); 2383 return QDF_STATUS_E_FAILURE; 2384 } 2385 2386 /** 2387 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 2388 * @soc: opaque soc handle 2389 * @pdev_id: id of data path pdev handle 2390 * 2391 */ 2392 static inline 2393 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 2394 uint8_t pdev_id) 2395 { 2396 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 2397 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(soc, pdev_id); 2398 return 0; 2399 } 2400 2401 /** 2402 * cdp_if_mgmt_drain() - Drain management frames 2403 * @soc: opaque soc handle 2404 * @vdev_id: id of vdev device 2405 * @force: number of frame in SW queue 2406 * 2407 * Return: void 2408 */ 2409 static inline 2410 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 2411 uint8_t vdev_id, int force) 2412 { 2413 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 2414 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(soc, vdev_id, force); 2415 } 2416 2417 /** 2418 * cdp_peer_map_attach() - CDP API to allocate PEER map memory 2419 * @soc: opaque soc handle 2420 * @max_peers: number of peers created in FW 2421 * @max_ast_index: max number of AST index supported in FW 2422 * @peer_map_unmap_v: Indicates HTT peer map/unmap versions enabled in FW 2423 * 2424 * Return: QDF_STATUS 2425 */ 2426 static inline QDF_STATUS 2427 cdp_peer_map_attach(ol_txrx_soc_handle soc, uint32_t max_peers, 2428 uint32_t max_ast_index, uint8_t peer_map_unmap_v) 2429 { 2430 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2431 soc->ops->cmn_drv_ops->txrx_peer_map_attach) 2432 return soc->ops->cmn_drv_ops->txrx_peer_map_attach(soc, 2433 max_peers, 2434 max_ast_index, 2435 peer_map_unmap_v); 2436 2437 return QDF_STATUS_SUCCESS; 2438 } 2439 2440 /** 2441 * cdp_soc_set_param() - CDP API to set soc parameters 2442 * @soc: opaque soc handle 2443 * @param: parameter type 2444 * @value: parameter value 2445 * 2446 * 2447 * Return: QDF_STATUS 2448 */ 2449 static inline QDF_STATUS 2450 cdp_soc_set_param(ol_txrx_soc_handle soc, enum cdp_soc_param_t param, 2451 uint32_t value) 2452 { 2453 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2454 soc->ops->cmn_drv_ops->set_soc_param) 2455 return soc->ops->cmn_drv_ops->set_soc_param(soc, param, 2456 value); 2457 2458 return QDF_STATUS_SUCCESS; 2459 } 2460 2461 /** 2462 * cdp_txrx_classify_and_update() - To classify the packet and update stats 2463 * @soc: opaque soc handle 2464 * @vdev_id: vdev id 2465 * @skb: data 2466 * @dir: rx or tx packet 2467 * @nbuf_class: packet classification object 2468 * 2469 * Return: 1 on success else return 0 2470 */ 2471 static inline int 2472 cdp_txrx_classify_and_update(ol_txrx_soc_handle soc, 2473 uint8_t vdev_id, qdf_nbuf_t skb, 2474 enum txrx_direction dir, 2475 struct ol_txrx_nbuf_classify *nbuf_class) 2476 { 2477 if (!soc || !soc->ops) { 2478 dp_cdp_debug("Invalid Instance"); 2479 QDF_BUG(0); 2480 return 0; 2481 } 2482 2483 if (!soc->ops->cmn_drv_ops || 2484 !soc->ops->cmn_drv_ops->txrx_classify_update) 2485 return 0; 2486 2487 return soc->ops->cmn_drv_ops->txrx_classify_update(soc, vdev_id, 2488 skb, 2489 dir, nbuf_class); 2490 } 2491 2492 /** 2493 * cdp_get_dp_capabilities() - get DP capabilities 2494 * @soc: opaque soc handle 2495 * @dp_caps: enum of DP capabilities 2496 * 2497 * Return: bool 2498 */ 2499 static inline bool 2500 cdp_get_dp_capabilities(struct cdp_soc_t *soc, enum cdp_capabilities dp_caps) 2501 { 2502 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2503 soc->ops->cmn_drv_ops->get_dp_capabilities) 2504 return soc->ops->cmn_drv_ops->get_dp_capabilities(soc, dp_caps); 2505 2506 qdf_err("invalid instance"); 2507 return false; 2508 } 2509 2510 #ifdef RECEIVE_OFFLOAD 2511 /** 2512 * cdp_register_rx_offld_flush_cb() - register LRO/GRO flush cb function pointer 2513 * @soc: data path soc handle 2514 * @rx_ol_flush_cb: Flush callback function 2515 * 2516 * register rx offload flush callback function pointer 2517 * 2518 * Return: none 2519 */ 2520 static inline void cdp_register_rx_offld_flush_cb(ol_txrx_soc_handle soc, 2521 void (rx_ol_flush_cb)(void *)) 2522 { 2523 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2524 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2525 "%s invalid instance", __func__); 2526 return; 2527 } 2528 2529 if (soc->ops->rx_offld_ops->register_rx_offld_flush_cb) 2530 return soc->ops->rx_offld_ops->register_rx_offld_flush_cb( 2531 rx_ol_flush_cb); 2532 } 2533 2534 /** 2535 * cdp_deregister_rx_offld_flush_cb() - deregister Rx offld flush cb function 2536 * @soc: data path soc handle 2537 * 2538 * deregister rx offload flush callback function pointer 2539 * 2540 * Return: none 2541 */ 2542 static inline void cdp_deregister_rx_offld_flush_cb(ol_txrx_soc_handle soc) 2543 { 2544 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2545 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2546 "%s invalid instance", __func__); 2547 return; 2548 } 2549 2550 if (soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb) 2551 return soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb(); 2552 } 2553 #endif /* RECEIVE_OFFLOAD */ 2554 2555 /** 2556 * cdp_set_ba_timeout() - set ba aging timeout per AC 2557 * 2558 * @soc: pointer to the soc 2559 * @value: timeout value in millisec 2560 * @ac: Access category 2561 * 2562 * Return: void 2563 */ 2564 static inline void cdp_set_ba_timeout(ol_txrx_soc_handle soc, 2565 uint8_t ac, uint32_t value) 2566 { 2567 if (!soc || !soc->ops) { 2568 dp_cdp_debug("Invalid Instance"); 2569 QDF_BUG(0); 2570 return; 2571 } 2572 2573 if (!soc->ops->cmn_drv_ops || 2574 !soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout) 2575 return; 2576 2577 soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout(soc, ac, value); 2578 } 2579 2580 /** 2581 * cdp_get_ba_timeout() - return ba aging timeout per AC 2582 * 2583 * @soc: pointer to the soc 2584 * @ac: access category 2585 * @value: timeout value in millisec 2586 * 2587 * Return: void 2588 */ 2589 static inline void cdp_get_ba_timeout(ol_txrx_soc_handle soc, 2590 uint8_t ac, uint32_t *value) 2591 { 2592 if (!soc || !soc->ops) { 2593 dp_cdp_debug("Invalid Instance"); 2594 QDF_BUG(0); 2595 return; 2596 } 2597 2598 if (!soc->ops->cmn_drv_ops || 2599 !soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout) 2600 return; 2601 2602 soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout(soc, ac, value); 2603 } 2604 2605 /** 2606 * cdp_cfg_get() - get cfg for dp enum 2607 * 2608 * @soc: pointer to the soc 2609 * @cfg: cfg enum 2610 * 2611 * Return: cfg value 2612 */ 2613 static inline uint32_t cdp_cfg_get(ol_txrx_soc_handle soc, enum cdp_dp_cfg cfg) 2614 { 2615 if (!soc || !soc->ops) { 2616 dp_cdp_debug("Invalid Instance"); 2617 return 0; 2618 } 2619 2620 if (!soc->ops->cmn_drv_ops || !soc->ops->cmn_drv_ops->txrx_get_cfg) 2621 return 0; 2622 2623 return soc->ops->cmn_drv_ops->txrx_get_cfg(soc, cfg); 2624 } 2625 2626 /** 2627 * cdp_soc_set_rate_stats_ctx() - set rate stats context in soc 2628 * @soc: opaque soc handle 2629 * @ctx: rate stats context 2630 * 2631 * Return: void 2632 */ 2633 static inline void 2634 cdp_soc_set_rate_stats_ctx(ol_txrx_soc_handle soc, 2635 void *ctx) 2636 { 2637 if (!soc || !soc->ops) { 2638 dp_cdp_debug("Invalid Instance:"); 2639 QDF_BUG(0); 2640 return; 2641 } 2642 2643 if (!soc->ops->cmn_drv_ops || 2644 !soc->ops->cmn_drv_ops->set_rate_stats_ctx) 2645 return; 2646 2647 soc->ops->cmn_drv_ops->set_rate_stats_ctx((struct cdp_soc_t *)soc, 2648 ctx); 2649 } 2650 2651 /** 2652 * cdp_soc_get_rate_stats_ctx() - get rate stats context in soc 2653 * @soc: opaque soc handle 2654 * 2655 * Return: void 2656 */ 2657 static inline void* 2658 cdp_soc_get_rate_stats_ctx(ol_txrx_soc_handle soc) 2659 { 2660 if (!soc || !soc->ops) { 2661 dp_cdp_debug("Invalid Instance:"); 2662 QDF_BUG(0); 2663 return NULL; 2664 } 2665 2666 if (!soc->ops->cmn_drv_ops || 2667 !soc->ops->cmn_drv_ops->get_rate_stats_ctx) 2668 return NULL; 2669 2670 return soc->ops->cmn_drv_ops->get_rate_stats_ctx(soc); 2671 } 2672 2673 /** 2674 * cdp_peer_flush_rate_stats() - flush peer rate statistics 2675 * @soc: opaque soc handle 2676 * @pdev_id: id of pdev handle 2677 * @buf: stats buffer 2678 */ 2679 static inline void 2680 cdp_peer_flush_rate_stats(ol_txrx_soc_handle soc, uint8_t pdev_id, 2681 void *buf) 2682 { 2683 if (!soc || !soc->ops) { 2684 dp_cdp_debug("Invalid Instance:"); 2685 QDF_BUG(0); 2686 return; 2687 } 2688 2689 if (!soc->ops->cmn_drv_ops || 2690 !soc->ops->cmn_drv_ops->txrx_peer_flush_rate_stats) 2691 return; 2692 2693 soc->ops->cmn_drv_ops->txrx_peer_flush_rate_stats(soc, pdev_id, buf); 2694 } 2695 2696 /** 2697 * cdp_peer_get_peerstats_ctx() - get peer stats context 2698 * @soc: opaque soc handle 2699 * @vdev_id: id of vdev handle 2700 * @mac_addr: peer mac address 2701 */ 2702 static inline void 2703 *cdp_peer_get_peerstats_ctx(ol_txrx_soc_handle soc, uint8_t vdev_id, 2704 uint8_t *mac_addr) 2705 { 2706 if (!soc || !soc->ops) { 2707 dp_cdp_debug("Invalid Instance:"); 2708 QDF_BUG(0); 2709 return NULL; 2710 } 2711 2712 if (!soc->ops->cmn_drv_ops || 2713 !soc->ops->cmn_drv_ops->txrx_peer_get_peerstats_ctx) 2714 return NULL; 2715 2716 return soc->ops->cmn_drv_ops->txrx_peer_get_peerstats_ctx(soc, 2717 vdev_id, 2718 mac_addr); 2719 } 2720 2721 /** 2722 * cdp_flush_rate_stats_request() - request flush rate statistics 2723 * @soc: opaque soc handle 2724 * @pdev_id: id of pdev handle 2725 */ 2726 static inline QDF_STATUS 2727 cdp_flush_rate_stats_request(struct cdp_soc_t *soc, uint8_t pdev_id) 2728 { 2729 if (!soc || !soc->ops) { 2730 dp_cdp_debug("Invalid Instance:"); 2731 QDF_BUG(0); 2732 return QDF_STATUS_E_FAILURE; 2733 } 2734 2735 if (!soc->ops->cmn_drv_ops || 2736 !soc->ops->cmn_drv_ops->txrx_flush_rate_stats_request) 2737 return QDF_STATUS_E_FAILURE; 2738 2739 return soc->ops->cmn_drv_ops->txrx_flush_rate_stats_request(soc, 2740 pdev_id); 2741 } 2742 2743 /** 2744 * cdp_set_vdev_pcp_tid_map() - set vdev pcp-tid-map 2745 * @soc: opaque soc handle 2746 * @vdev_id: id of data path vdev handle 2747 * @pcp: pcp value 2748 * @tid: tid value 2749 * 2750 * This API is used to configure the pcp-to-tid mapping for a pdev. 2751 * 2752 * Return: QDF_STATUS_SUCCESS if value set successfully 2753 * QDF_STATUS_E_INVAL false if error 2754 */ 2755 static inline 2756 QDF_STATUS cdp_set_vdev_pcp_tid_map(ol_txrx_soc_handle soc, 2757 uint8_t vdev_id, 2758 uint8_t pcp, uint8_t tid) 2759 { 2760 if (!soc || !soc->ops) { 2761 dp_cdp_debug("Invalid Instance"); 2762 return QDF_STATUS_E_INVAL; 2763 } 2764 2765 if (!soc->ops->cmn_drv_ops || 2766 !soc->ops->cmn_drv_ops->set_vdev_pcp_tid_map) 2767 return QDF_STATUS_E_INVAL; 2768 2769 return soc->ops->cmn_drv_ops->set_vdev_pcp_tid_map(soc, vdev_id, 2770 pcp, tid); 2771 } 2772 2773 /** 2774 * cdp_tx_send_exc() - Transmit a frame on a given vdev in exception path 2775 * 2776 * @soc: opaque soc handle 2777 * @vdev_id: vdev id 2778 * @nbuf: skb 2779 * @tx_exc_metadata: Handle that holds exception path meta data 2780 * 2781 * Return: NULL on success 2782 * nbuf when it fails to send 2783 */ 2784 static inline qdf_nbuf_t 2785 cdp_tx_send_exc(ol_txrx_soc_handle soc, 2786 uint8_t vdev_id, 2787 qdf_nbuf_t nbuf, 2788 struct cdp_tx_exception_metadata *tx_exc_metadata) 2789 { 2790 if (!soc || !soc->ops) { 2791 dp_cdp_debug("Invalid Instance"); 2792 QDF_BUG(0); 2793 return 0; 2794 } 2795 2796 if (!soc->ops->cmn_drv_ops || 2797 !soc->ops->cmn_drv_ops->tx_send_exc) 2798 return 0; 2799 2800 return soc->ops->cmn_drv_ops->tx_send_exc 2801 (soc, vdev_id, nbuf, tx_exc_metadata); 2802 } 2803 2804 /** 2805 * cdp_vdev_get_peer_mac_list(): function to get peer mac list of vdev 2806 * @soc: Datapath soc handle 2807 * @vdev_id: vdev id 2808 * @newmac: Table of the clients mac 2809 * @mac_cnt: No. of MACs required 2810 * @limit: Limit the number of clients 2811 * 2812 * return: no of clients 2813 */ 2814 static inline uint16_t 2815 cdp_vdev_get_peer_mac_list(ol_txrx_soc_handle soc, 2816 uint8_t vdev_id, 2817 uint8_t newmac[][QDF_MAC_ADDR_SIZE], 2818 uint16_t mac_cnt, bool limit) 2819 { 2820 if (!soc || !soc->ops) { 2821 dp_cdp_debug("Invalid Instance"); 2822 QDF_BUG(0); 2823 return 0; 2824 } 2825 2826 if (!soc->ops->cmn_drv_ops || 2827 !soc->ops->cmn_drv_ops->get_peer_mac_list) 2828 return 0; 2829 2830 return soc->ops->cmn_drv_ops->get_peer_mac_list 2831 (soc, vdev_id, newmac, mac_cnt, limit); 2832 } 2833 2834 /** 2835 * cdp_soc_config_full_mon_mode () - Configure Full monitor mode 2836 * 2837 * @soc: dp soc handle 2838 * @val: value to be configured val should be 0 or 1 2839 * 2840 * This API is used to enable/disable support for Full monitor mode feature 2841 * 2842 * Return: QDF_STATUS_SUCCESS if value set successfully 2843 * QDF_STATUS_E_INVAL false if error 2844 */ 2845 static inline QDF_STATUS 2846 cdp_soc_config_full_mon_mode(ol_txrx_soc_handle soc, uint8_t val) 2847 { 2848 if (!soc || !soc->ops) { 2849 dp_cdp_debug("Invalid Instance"); 2850 return QDF_STATUS_E_INVAL; 2851 } 2852 2853 if (!soc->ops->mon_ops || 2854 !soc->ops->mon_ops->config_full_mon_mode) 2855 return QDF_STATUS_E_INVAL; 2856 2857 return soc->ops->mon_ops->config_full_mon_mode(soc, val); 2858 } 2859 2860 /** 2861 * cdp_rx_get_pending() - Get number of pending frames of RX threads 2862 * @soc: opaque soc handle 2863 * Return: number of pending frames 2864 */ 2865 static inline int 2866 cdp_rx_get_pending(ol_txrx_soc_handle soc) 2867 { 2868 if (!soc || !soc->ol_ops || 2869 !soc->ol_ops->dp_rx_get_pending) 2870 return 0; 2871 2872 if (cdp_cfg_get(soc, cfg_dp_wow_check_rx_pending)) 2873 return soc->ol_ops->dp_rx_get_pending(soc); 2874 else 2875 return 0; 2876 } 2877 2878 static inline uint16_t 2879 cdp_get_peer_id(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac) 2880 { 2881 if (!soc || !soc->ops) { 2882 dp_cdp_debug("Invalid Instance"); 2883 QDF_BUG(0); 2884 return 0; 2885 } 2886 2887 if (!soc->ops->cmn_drv_ops || 2888 !soc->ops->cmn_drv_ops->get_peer_id) 2889 return 0; 2890 2891 return soc->ops->cmn_drv_ops->get_peer_id 2892 (soc, vdev_id, mac); 2893 } 2894 2895 #ifdef QCA_SUPPORT_WDS_EXTENDED 2896 static inline QDF_STATUS 2897 cdp_wds_ext_set_peer_rx(ol_txrx_soc_handle soc, uint8_t vdev_id, 2898 uint8_t *mac, ol_txrx_rx_fp rx, 2899 ol_osif_peer_handle osif_peer) 2900 { 2901 if (!soc || !soc->ops) { 2902 dp_cdp_debug("Invalid Instance"); 2903 QDF_BUG(0); 2904 return QDF_STATUS_E_FAULT; 2905 } 2906 2907 if (!soc->ops->cmn_drv_ops || 2908 !soc->ops->cmn_drv_ops->set_wds_ext_peer_rx) 2909 return QDF_STATUS_E_FAULT; 2910 2911 return soc->ops->cmn_drv_ops->set_wds_ext_peer_rx 2912 (soc, vdev_id, mac, rx, osif_peer); 2913 } 2914 2915 static inline QDF_STATUS 2916 cdp_wds_ext_get_peer_osif_handle( 2917 ol_txrx_soc_handle soc, uint8_t vdev_id, 2918 uint8_t *mac, 2919 ol_osif_peer_handle *osif_peer) 2920 { 2921 if (!soc || !soc->ops) { 2922 dp_cdp_debug("Invalid Instance"); 2923 QDF_BUG(0); 2924 return QDF_STATUS_E_FAULT; 2925 } 2926 2927 if (!soc->ops->cmn_drv_ops || 2928 !soc->ops->cmn_drv_ops->get_wds_ext_peer_osif_handle) 2929 return QDF_STATUS_E_FAULT; 2930 2931 return soc->ops->cmn_drv_ops->get_wds_ext_peer_osif_handle 2932 (soc, vdev_id, mac, osif_peer); 2933 } 2934 2935 #endif /* QCA_SUPPORT_WDS_EXTENDED */ 2936 2937 /** 2938 * cdp_drain_txrx() - drain TX/RX SRNGs 2939 * @soc: opaque soc handle 2940 */ 2941 static inline void 2942 cdp_drain_txrx(ol_txrx_soc_handle soc) 2943 { 2944 if (!soc || !soc->ops) { 2945 dp_cdp_debug("Invalid Instance"); 2946 QDF_BUG(0); 2947 return; 2948 } 2949 2950 if (!soc->ops->cmn_drv_ops || 2951 !soc->ops->cmn_drv_ops->txrx_drain) 2952 return; 2953 2954 return soc->ops->cmn_drv_ops->txrx_drain(soc); 2955 } 2956 2957 /** 2958 * cdp_get_free_desc_poolsize() - get free desc pool size 2959 * @soc: opaque soc handle 2960 */ 2961 static inline int 2962 cdp_get_free_desc_poolsize(ol_txrx_soc_handle soc) 2963 { 2964 if (!soc || !soc->ops) { 2965 dp_cdp_debug("Invalid Instance"); 2966 QDF_BUG(0); 2967 return 0; 2968 } 2969 2970 if (!soc->ops->cmn_drv_ops || 2971 !soc->ops->cmn_drv_ops->get_free_desc_poolsize) 2972 return 0; 2973 2974 return soc->ops->cmn_drv_ops->get_free_desc_poolsize(soc); 2975 } 2976 2977 #ifdef WLAN_FEATURE_PKT_CAPTURE_V2 2978 /** 2979 * cdp_set_pkt_capture_mode() - set pkt capture mode in dp ctx 2980 * @soc: opaque soc handle 2981 * @val: value to be set 2982 */ 2983 static inline void 2984 cdp_set_pkt_capture_mode(ol_txrx_soc_handle soc, bool val) 2985 { 2986 if (!soc || !soc->ops) { 2987 dp_cdp_debug("Invalid Instance"); 2988 QDF_BUG(0); 2989 return; 2990 } 2991 2992 if (!soc->ops->cmn_drv_ops || 2993 !soc->ops->cmn_drv_ops->set_pkt_capture_mode) 2994 return; 2995 2996 soc->ops->cmn_drv_ops->set_pkt_capture_mode(soc, val); 2997 } 2998 #else 2999 static inline void 3000 cdp_set_pkt_capture_mode(ol_txrx_soc_handle soc, bool val) 3001 { 3002 } 3003 #endif 3004 3005 /** 3006 * cdp_get_tx_inqueue() - Get number of Tx frames that are queued 3007 * @soc: opaque soc handle 3008 * 3009 * Return: number of queued frames 3010 */ 3011 static inline uint32_t 3012 cdp_get_tx_inqueue(ol_txrx_soc_handle soc) 3013 { 3014 if (!soc || !soc->ol_ops || 3015 !soc->ol_ops->dp_get_tx_inqueue) 3016 return 0; 3017 3018 return soc->ol_ops->dp_get_tx_inqueue(soc); 3019 } 3020 3021 #ifdef FEATURE_RUNTIME_PM 3022 3023 /** 3024 * cdp_set_rtpm_tput_policy_requirement() - Set RTPM throughput policy 3025 * @soc: opaque soc handle 3026 * @is_high_tput: flag indicating whether throughput requirement is high or not 3027 * 3028 * The functions sets RTPM throughput policy requirement. If 'is_high_tput' is 3029 * set, the expectation is that runtime_pm APIs will not be invoked per packet. 3030 */ 3031 3032 static inline 3033 void cdp_set_rtpm_tput_policy_requirement(ol_txrx_soc_handle soc, 3034 bool is_high_tput) 3035 { 3036 if (!soc || !soc->ops) { 3037 dp_cdp_debug("Invalid Instance"); 3038 QDF_BUG(0); 3039 return; 3040 } 3041 3042 if (!soc->ops->cmn_drv_ops || 3043 !soc->ops->cmn_drv_ops->set_rtpm_tput_policy) 3044 return; 3045 3046 soc->ops->cmn_drv_ops->set_rtpm_tput_policy(soc, is_high_tput); 3047 } 3048 #else 3049 static inline 3050 void cdp_set_rtpm_tput_policy_requirement(ol_txrx_soc_handle soc, 3051 bool is_high_tput) 3052 { 3053 } 3054 3055 #endif /* FEATURE_RUNTIME_PM */ 3056 3057 /** 3058 * cdp_enable_mon_reap_timer() - enable/disable reap timer 3059 * @soc: Datapath soc handle 3060 * @source: monitor reap source 3061 * @enable: enable/disable reap timer of monitor status ring 3062 * 3063 * Return: true if timer start/stop is performed, false otherwise. 3064 */ 3065 static inline bool 3066 cdp_enable_mon_reap_timer(ol_txrx_soc_handle soc, 3067 enum cdp_mon_reap_source source, 3068 bool enable) 3069 { 3070 if (!soc || !soc->ops) { 3071 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 3072 "%s invalid instance", __func__); 3073 QDF_BUG(0); 3074 return false; 3075 } 3076 3077 if (!soc->ops->mon_ops || 3078 !soc->ops->mon_ops->txrx_enable_mon_reap_timer) 3079 return false; 3080 3081 return soc->ops->mon_ops->txrx_enable_mon_reap_timer(soc, source, 3082 enable); 3083 } 3084 3085 /** 3086 * cdp_get_tsf_time() - get tsf time 3087 * @soc: Datapath soc handle 3088 * @tsf_id: 3089 * @mac_id: mac_id 3090 * @tsf: pointer to update tsf value 3091 * @tsf_sync_soc_time: pointer to update tsf sync time 3092 * 3093 * Return: None. 3094 */ 3095 static inline void 3096 cdp_get_tsf_time(ol_txrx_soc_handle soc, uint32_t tsf_id, uint32_t mac_id, 3097 uint64_t *tsf, uint64_t *tsf_sync_soc_time) 3098 { 3099 if (!soc) { 3100 dp_cdp_debug("Invalid Instance"); 3101 return; 3102 } 3103 if (!soc->ops->cmn_drv_ops || !soc->ops->cmn_drv_ops->txrx_get_tsf_time) 3104 return; 3105 3106 soc->ops->cmn_drv_ops->txrx_get_tsf_time(soc, tsf_id, mac_id, tsf, 3107 tsf_sync_soc_time); 3108 } 3109 3110 /** 3111 * cdp_get_tsf2_offset() - get tsf2 offset 3112 * @soc: Datapath soc handle 3113 * @mac_id: mac_id 3114 * @value: pointer to update tsf2 value 3115 * 3116 * Return: None. 3117 */ 3118 static inline void 3119 cdp_get_tsf2_offset(ol_txrx_soc_handle soc, uint8_t mac_id, uint64_t *value) 3120 { 3121 if (!soc) { 3122 dp_cdp_debug("Invalid Instance"); 3123 return; 3124 } 3125 if (!soc->ops->cmn_drv_ops || 3126 !soc->ops->cmn_drv_ops->txrx_get_tsf2_offset) 3127 return; 3128 3129 soc->ops->cmn_drv_ops->txrx_get_tsf2_offset(soc, mac_id, value); 3130 } 3131 3132 /** 3133 * cdp_get_tqm_offset() - get tqm offset 3134 * @soc: Datapath soc handle 3135 * @value: pointer to update tqm value 3136 * 3137 * Return: None. 3138 */ 3139 static inline void 3140 cdp_get_tqm_offset(ol_txrx_soc_handle soc, uint64_t *value) 3141 { 3142 if (!soc) { 3143 dp_cdp_debug("Invalid Instance"); 3144 return; 3145 } 3146 if (!soc->ops->cmn_drv_ops || 3147 !soc->ops->cmn_drv_ops->txrx_get_tqm_offset) 3148 return; 3149 3150 soc->ops->cmn_drv_ops->txrx_get_tqm_offset(soc, value); 3151 } 3152 #endif /* _CDP_TXRX_CMN_H_ */ 3153