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