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