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