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