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