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_ppeds_stop(): function to stop ppeds 1722 * @soc: soc handle 1723 */ 1724 static inline void cdp_txrx_ppeds_stop(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_ppeds_stop) 1734 return; 1735 1736 soc->ops->cmn_drv_ops->txrx_ppeds_stop(soc); 1737 } 1738 1739 /** 1740 * cdp_txrx_umac_reset_deinit(): De-initialize UMAC HW reset module 1741 * @soc: soc handle 1742 */ 1743 static inline void cdp_txrx_umac_reset_deinit(ol_txrx_soc_handle soc) 1744 { 1745 if (!soc || !soc->ops) { 1746 dp_cdp_debug("Invalid Instance:"); 1747 QDF_BUG(0); 1748 return; 1749 } 1750 1751 if (!soc->ops->cmn_drv_ops || 1752 !soc->ops->cmn_drv_ops->txrx_umac_reset_deinit) 1753 return; 1754 1755 soc->ops->cmn_drv_ops->txrx_umac_reset_deinit(soc); 1756 } 1757 1758 /** 1759 * cdp_display_stats(): function to map to dump stats 1760 * @soc: soc handle 1761 * @value: statistics option 1762 */ 1763 static inline QDF_STATUS 1764 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1765 enum qdf_stats_verbosity_level level) 1766 { 1767 if (!soc || !soc->ops) { 1768 dp_cdp_debug("Invalid Instance:"); 1769 QDF_BUG(0); 1770 return 0; 1771 } 1772 1773 if (!soc->ops->cmn_drv_ops || 1774 !soc->ops->cmn_drv_ops->display_stats) 1775 return 0; 1776 1777 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1778 } 1779 1780 1781 /** 1782 * cdp_set_pn_check(): function to set pn check 1783 * @soc: soc handle 1784 * @vdev_id: id of virtual device 1785 * @peer_mac: mac address of peer 1786 * @sec_type: security type 1787 * @rx_pn: receive pn 1788 */ 1789 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1790 uint8_t vdev_id, uint8_t *peer_mac, 1791 enum cdp_sec_type sec_type, uint32_t *rx_pn) 1792 { 1793 if (!soc || !soc->ops) { 1794 dp_cdp_debug("Invalid Instance:"); 1795 QDF_BUG(0); 1796 return 0; 1797 } 1798 1799 if (!soc->ops->cmn_drv_ops || 1800 !soc->ops->cmn_drv_ops->set_pn_check) 1801 return 0; 1802 1803 soc->ops->cmn_drv_ops->set_pn_check(soc, vdev_id, peer_mac, 1804 sec_type, rx_pn); 1805 return 0; 1806 } 1807 1808 /** 1809 * cdp_set_key_sec_type(): function to set sec mode of key 1810 * @soc: soc handle 1811 * @vdev_id: id of virtual device 1812 * @peer_mac: mac address of peer 1813 * @sec_type: security type 1814 * #is_unicast: ucast or mcast 1815 */ 1816 static inline int cdp_set_key_sec_type(ol_txrx_soc_handle soc, 1817 uint8_t vdev_id, 1818 uint8_t *peer_mac, 1819 enum cdp_sec_type sec_type, 1820 bool is_unicast) 1821 { 1822 if (!soc || !soc->ops) { 1823 dp_cdp_debug("Invalid Instance:"); 1824 QDF_BUG(0); 1825 return 0; 1826 } 1827 1828 if (!soc->ops->cmn_drv_ops || 1829 !soc->ops->cmn_drv_ops->set_key_sec_type) 1830 return 0; 1831 1832 soc->ops->cmn_drv_ops->set_key_sec_type(soc, vdev_id, 1833 peer_mac, sec_type, is_unicast); 1834 return 0; 1835 } 1836 1837 static inline QDF_STATUS 1838 cdp_set_key(ol_txrx_soc_handle soc, 1839 uint8_t vdev_id, 1840 uint8_t *mac, 1841 bool is_unicast, uint32_t *key) 1842 { 1843 if (!soc || !soc->ops) { 1844 dp_cdp_debug("Invalid Instance:"); 1845 QDF_BUG(0); 1846 return QDF_STATUS_E_FAILURE; 1847 } 1848 1849 if (!soc->ops->ctrl_ops || 1850 !soc->ops->ctrl_ops->set_key) 1851 return QDF_STATUS_E_FAILURE; 1852 1853 return soc->ops->ctrl_ops->set_key(soc, vdev_id, mac, 1854 is_unicast, key); 1855 } 1856 1857 /** 1858 * cdp_update_config_parameters(): function to propagate configuration 1859 * parameters to datapath 1860 * @soc: opaque soc handle 1861 * @cfg: configuration handle 1862 * 1863 * Return: status: 0 - Success, non-zero: Failure 1864 */ 1865 static inline 1866 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 1867 struct cdp_config_params *cfg) 1868 { 1869 struct cdp_soc *psoc = (struct cdp_soc *)soc; 1870 1871 if (!soc || !soc->ops) { 1872 dp_cdp_debug("Invalid Instance:"); 1873 QDF_BUG(0); 1874 return 0; 1875 } 1876 1877 if (!soc->ops->cmn_drv_ops || 1878 !soc->ops->cmn_drv_ops->update_config_parameters) 1879 return QDF_STATUS_SUCCESS; 1880 1881 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 1882 cfg); 1883 } 1884 1885 /** 1886 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 1887 * @soc: opaque soc handle 1888 * @pdev_id: id of data path pdev handle 1889 * 1890 * Return: opaque dp handle 1891 */ 1892 static inline void * 1893 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, uint8_t pdev_id) 1894 { 1895 if (!soc || !soc->ops) { 1896 dp_cdp_debug("Invalid Instance:"); 1897 QDF_BUG(0); 1898 return 0; 1899 } 1900 1901 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 1902 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(soc, pdev_id); 1903 1904 return 0; 1905 } 1906 1907 /** 1908 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 1909 * @soc: opaque soc handle 1910 * @pdev_id: id of data path pdev handle 1911 * @dp_hdl: opaque pointer for dp_txrx_handle 1912 * 1913 * Return: void 1914 */ 1915 static inline void 1916 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, uint8_t pdev_id, 1917 void *dp_hdl) 1918 { 1919 if (!soc || !soc->ops) { 1920 dp_cdp_debug("Invalid Instance:"); 1921 QDF_BUG(0); 1922 return; 1923 } 1924 1925 if (!soc->ops->cmn_drv_ops || 1926 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 1927 return; 1928 1929 soc->ops->cmn_drv_ops->set_dp_txrx_handle(soc, pdev_id, dp_hdl); 1930 } 1931 1932 /** 1933 * cdp_vdev_get_dp_ext_txrx_handle() - get extended dp handle from vdev 1934 * @soc: opaque soc handle 1935 * @vdev_id: vdev id 1936 * 1937 * Return: opaque dp handle 1938 */ 1939 static inline void * 1940 cdp_vdev_get_dp_ext_txrx_handle(ol_txrx_soc_handle soc, uint8_t vdev_id) 1941 { 1942 if (!soc || !soc->ops) { 1943 dp_cdp_debug("Invalid Instance:"); 1944 QDF_BUG(0); 1945 return 0; 1946 } 1947 1948 if (soc->ops->cmn_drv_ops->get_vdev_dp_ext_txrx_handle) 1949 return soc->ops->cmn_drv_ops->get_vdev_dp_ext_txrx_handle( 1950 soc, vdev_id); 1951 1952 return 0; 1953 } 1954 1955 /** 1956 * cdp_vdev_set_dp_ext_txrx_handle() - set extended dp handle in vdev 1957 * @soc: opaque soc handle 1958 * @vdev_id: vdev id 1959 * @size: size of the advance dp handle 1960 * 1961 * Return: QDF_STATUS 1962 */ 1963 static inline QDF_STATUS 1964 cdp_vdev_set_dp_ext_txrx_handle(ol_txrx_soc_handle soc, uint8_t vdev_id, 1965 uint16_t size) 1966 { 1967 if (!soc || !soc->ops) { 1968 dp_cdp_debug("Invalid Instance:"); 1969 QDF_BUG(0); 1970 return QDF_STATUS_E_FAILURE; 1971 } 1972 1973 if (!soc->ops->cmn_drv_ops || 1974 !soc->ops->cmn_drv_ops->set_vdev_dp_ext_txrx_handle) 1975 return QDF_STATUS_E_FAILURE; 1976 1977 return soc->ops->cmn_drv_ops->set_vdev_dp_ext_txrx_handle(soc, 1978 vdev_id, 1979 size); 1980 } 1981 1982 /* 1983 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 1984 * @soc: opaque soc handle 1985 * 1986 * Return: opaque extended dp handle 1987 */ 1988 static inline void * 1989 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 1990 { 1991 if (!soc || !soc->ops) { 1992 dp_cdp_debug("Invalid Instance:"); 1993 QDF_BUG(0); 1994 return NULL; 1995 } 1996 1997 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 1998 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 1999 (struct cdp_soc *) soc); 2000 2001 return NULL; 2002 } 2003 2004 /** 2005 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 2006 * @soc: opaque soc handle 2007 * @dp_hdl: opaque pointer for dp_txrx_handle 2008 * 2009 * Return: void 2010 */ 2011 static inline void 2012 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 2013 { 2014 if (!soc || !soc->ops) { 2015 dp_cdp_debug("Invalid Instance:"); 2016 QDF_BUG(0); 2017 return; 2018 } 2019 2020 if (!soc->ops->cmn_drv_ops || 2021 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 2022 return; 2023 2024 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 2025 dp_handle); 2026 } 2027 2028 /** 2029 * cdp_soc_handle_mode_change() - Update pdev_id to lmac_id mapping 2030 * @soc: opaque soc handle 2031 * @pdev_id: id of data path pdev handle 2032 * @lmac_id: lmac id 2033 * Return: QDF_STATUS 2034 */ 2035 static inline QDF_STATUS 2036 cdp_soc_handle_mode_change(ol_txrx_soc_handle soc, uint8_t pdev_id, 2037 uint32_t lmac_id) 2038 { 2039 if (!soc || !soc->ops) { 2040 dp_cdp_debug("Invalid Instance:"); 2041 QDF_BUG(0); 2042 return QDF_STATUS_E_FAILURE; 2043 } 2044 2045 if (!soc->ops->cmn_drv_ops || 2046 !soc->ops->cmn_drv_ops->handle_mode_change) 2047 return QDF_STATUS_E_FAILURE; 2048 2049 return soc->ops->cmn_drv_ops->handle_mode_change(soc, pdev_id, 2050 lmac_id); 2051 } 2052 2053 /** 2054 * cdp_soc_map_pdev_to_lmac() - Save pdev_id to lmac_id mapping 2055 * @soc: opaque soc handle 2056 * @pdev_id: id of data path pdev handle 2057 * @lmac_id: lmac id 2058 * Return: QDF_STATUS 2059 */ 2060 static inline QDF_STATUS 2061 cdp_soc_map_pdev_to_lmac(ol_txrx_soc_handle soc, uint8_t pdev_id, 2062 uint32_t lmac_id) 2063 { 2064 if (!soc || !soc->ops) { 2065 dp_cdp_debug("Invalid Instance:"); 2066 QDF_BUG(0); 2067 return QDF_STATUS_E_FAILURE; 2068 } 2069 2070 if (!soc->ops->cmn_drv_ops || 2071 !soc->ops->cmn_drv_ops->map_pdev_to_lmac) 2072 return QDF_STATUS_E_FAILURE; 2073 2074 return soc->ops->cmn_drv_ops->map_pdev_to_lmac(soc, pdev_id, 2075 lmac_id); 2076 } 2077 2078 /** 2079 * cdp_txrx_set_pdev_status_down() - set pdev down/up status 2080 * @soc: soc opaque handle 2081 * @pdev_id: id of data path pdev handle 2082 * @is_pdev_down: pdev down/up status 2083 * 2084 * return: QDF_STATUS 2085 */ 2086 static inline QDF_STATUS 2087 cdp_txrx_set_pdev_status_down(ol_txrx_soc_handle soc, 2088 uint8_t pdev_id, 2089 bool is_pdev_down) 2090 { 2091 if (!soc || !soc->ops) { 2092 dp_cdp_debug("Invalid Instance:"); 2093 QDF_BUG(0); 2094 return QDF_STATUS_E_FAILURE; 2095 } 2096 2097 if (!soc->ops->cmn_drv_ops || 2098 !soc->ops->cmn_drv_ops->set_pdev_status_down) 2099 return QDF_STATUS_E_FAILURE; 2100 2101 return soc->ops->cmn_drv_ops->set_pdev_status_down(soc, pdev_id, 2102 is_pdev_down); 2103 } 2104 2105 /** 2106 * cdp_set_tx_pause() - Pause or resume tx path 2107 * @soc_hdl: Datapath soc handle 2108 * @flag: set or clear is_tx_pause 2109 * 2110 * Return: None. 2111 */ 2112 static inline 2113 void cdp_set_tx_pause(ol_txrx_soc_handle soc, bool flag) 2114 { 2115 if (!soc || !soc->ops) { 2116 dp_cdp_debug("Invalid Instance:"); 2117 QDF_BUG(0); 2118 return; 2119 } 2120 2121 if (!soc->ops->cmn_drv_ops || 2122 !soc->ops->cmn_drv_ops->set_tx_pause) 2123 return; 2124 2125 soc->ops->cmn_drv_ops->set_tx_pause(soc, flag); 2126 } 2127 2128 /** 2129 * cdp_tx_send() - enqueue frame for transmission 2130 * @soc: soc opaque handle 2131 * @vdev_id: id of VAP device 2132 * @nbuf: nbuf to be enqueued 2133 * 2134 * This API is used by Extended Datapath modules to enqueue frame for 2135 * transmission 2136 * 2137 * Return: void 2138 */ 2139 static inline void 2140 cdp_tx_send(ol_txrx_soc_handle soc, uint8_t vdev_id, qdf_nbuf_t nbuf) 2141 { 2142 if (!soc || !soc->ops) { 2143 dp_cdp_debug("Invalid Instance:"); 2144 QDF_BUG(0); 2145 return; 2146 } 2147 2148 if (!soc->ops->cmn_drv_ops || 2149 !soc->ops->cmn_drv_ops->tx_send) 2150 return; 2151 2152 soc->ops->cmn_drv_ops->tx_send(soc, vdev_id, nbuf); 2153 } 2154 2155 /** 2156 * cdp_set_pdev_pcp_tid_map() - set pdev pcp-tid-map 2157 * @soc: opaque soc handle 2158 * @pdev_id: id of data path pdev handle 2159 * @pcp: pcp value 2160 * @tid: tid value 2161 * 2162 * This API is used to configure the pcp-to-tid mapping for a pdev. 2163 * 2164 * Return: QDF_STATUS_SUCCESS if value set successfully 2165 * QDF_STATUS_E_INVAL false if error 2166 */ 2167 static inline 2168 QDF_STATUS cdp_set_pdev_pcp_tid_map(ol_txrx_soc_handle soc, 2169 uint8_t pdev_id, 2170 uint32_t pcp, uint32_t tid) 2171 { 2172 if (!soc || !soc->ops) { 2173 dp_cdp_debug("Invalid Instance"); 2174 return QDF_STATUS_E_INVAL; 2175 } 2176 2177 if (!soc->ops->cmn_drv_ops || 2178 !soc->ops->cmn_drv_ops->set_pdev_pcp_tid_map) 2179 return QDF_STATUS_E_INVAL; 2180 2181 return soc->ops->cmn_drv_ops->set_pdev_pcp_tid_map(soc, pdev_id, 2182 pcp, tid); 2183 } 2184 2185 /** 2186 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 2187 * @soc: opaque soc handle 2188 * @pdev_id: id of data path pdev handle 2189 * @peer_id: data path peer id 2190 * @peer_mac: peer_mac 2191 * 2192 * Return: QDF_STATUS 2193 */ 2194 static inline 2195 QDF_STATUS cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 2196 uint32_t peer_id, uint8_t *peer_mac) 2197 { 2198 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 2199 return soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 2200 soc, peer_id, peer_mac); 2201 2202 return QDF_STATUS_E_INVAL; 2203 } 2204 2205 /** 2206 * cdp_vdev_tx_lock() - acquire lock 2207 * @soc: opaque soc handle 2208 * @vdev: data path vdev handle 2209 * 2210 * Return: void 2211 */ 2212 static inline 2213 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 2214 uint8_t vdev_id) 2215 { 2216 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 2217 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(soc, vdev_id); 2218 } 2219 2220 /** 2221 * cdp_vdev_tx_unlock() - release lock 2222 * @soc: opaque soc handle 2223 * @vdev_id: id of data path vdev handle 2224 * 2225 * Return: void 2226 */ 2227 static inline 2228 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 2229 uint8_t vdev_id) 2230 { 2231 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 2232 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(soc, vdev_id); 2233 } 2234 2235 /** 2236 * cdp_ath_getstats() - get updated athstats 2237 * @soc: opaque soc handle 2238 * @id: vdev_id/pdev_id based on type 2239 * @stats: cdp network device stats structure 2240 * @type: device type pdev/vdev 2241 * 2242 * Return: QDF_STATUS 2243 */ 2244 static inline QDF_STATUS 2245 cdp_ath_getstats(ol_txrx_soc_handle soc, 2246 uint8_t id, struct cdp_dev_stats *stats, 2247 uint8_t type) 2248 { 2249 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 2250 return soc->ops->cmn_drv_ops->txrx_ath_getstats(soc, id, 2251 stats, type); 2252 2253 return QDF_STATUS_E_FAILURE; 2254 } 2255 2256 /** 2257 * cdp_set_gid_flag() - set groupid flag 2258 * @soc: opaque soc handle 2259 * @pdev_id: id of data path pdev handle 2260 * @mem_status: member status from grp management frame 2261 * @user_position: user position from grp management frame 2262 * 2263 * Return: QDF_STATUS 2264 */ 2265 static inline QDF_STATUS 2266 cdp_set_gid_flag(ol_txrx_soc_handle soc, 2267 uint8_t pdev_id, u_int8_t *mem_status, 2268 u_int8_t *user_position) 2269 { 2270 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 2271 return soc->ops->cmn_drv_ops->txrx_set_gid_flag(soc, pdev_id, 2272 mem_status, 2273 user_position); 2274 return QDF_STATUS_E_FAILURE; 2275 } 2276 2277 /** 2278 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 2279 * @soc: opaque soc handle 2280 * @pdev_id: id of data path pdev handle 2281 * 2282 */ 2283 static inline 2284 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 2285 uint8_t pdev_id) 2286 { 2287 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 2288 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(soc, pdev_id); 2289 return 0; 2290 } 2291 2292 /** 2293 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 2294 * @soc: opaque soc handle 2295 * @vdev_id: id of vdev device 2296 * @force: number of frame in SW queue 2297 * Return: void 2298 */ 2299 static inline 2300 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 2301 uint8_t vdev_id, int force) 2302 { 2303 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 2304 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(soc, vdev_id, force); 2305 } 2306 2307 /* cdp_peer_map_attach() - CDP API to allocate PEER map memory 2308 * @soc: opaque soc handle 2309 * @max_peers: number of peers created in FW 2310 * @max_ast_index: max number of AST index supported in FW 2311 * @peer_map_unmap_v: Indicates HTT peer map/unmap versions enabled in FW 2312 * 2313 * 2314 * Return: QDF_STATUS 2315 */ 2316 static inline QDF_STATUS 2317 cdp_peer_map_attach(ol_txrx_soc_handle soc, uint32_t max_peers, 2318 uint32_t max_ast_index, uint8_t peer_map_unmap_v) 2319 { 2320 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2321 soc->ops->cmn_drv_ops->txrx_peer_map_attach) 2322 return soc->ops->cmn_drv_ops->txrx_peer_map_attach(soc, 2323 max_peers, 2324 max_ast_index, 2325 peer_map_unmap_v); 2326 2327 return QDF_STATUS_SUCCESS; 2328 } 2329 2330 /* cdp_soc_set_param() - CDP API to set soc parameters 2331 * @soc: opaque soc handle 2332 * @param: parameter type 2333 * @value: parameter value 2334 * 2335 * 2336 * Return: QDF_STATUS 2337 */ 2338 static inline QDF_STATUS 2339 cdp_soc_set_param(ol_txrx_soc_handle soc, enum cdp_soc_param_t param, 2340 uint32_t value) 2341 { 2342 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2343 soc->ops->cmn_drv_ops->set_soc_param) 2344 return soc->ops->cmn_drv_ops->set_soc_param(soc, param, 2345 value); 2346 2347 return QDF_STATUS_SUCCESS; 2348 } 2349 2350 /* cdp_txrx_classify_and_update() - To classify the packet and update stats 2351 * @soc: opaque soc handle 2352 * @vdev: opaque dp vdev handle 2353 * @skb: data 2354 * @dir: rx or tx packet 2355 * @nbuf_classify: packet classification object 2356 * 2357 * Return: 1 on success else return 0 2358 */ 2359 static inline int 2360 cdp_txrx_classify_and_update(ol_txrx_soc_handle soc, 2361 uint8_t vdev_id, qdf_nbuf_t skb, 2362 enum txrx_direction dir, 2363 struct ol_txrx_nbuf_classify *nbuf_class) 2364 { 2365 if (!soc || !soc->ops) { 2366 dp_cdp_debug("Invalid Instance"); 2367 QDF_BUG(0); 2368 return 0; 2369 } 2370 2371 if (!soc->ops->cmn_drv_ops || 2372 !soc->ops->cmn_drv_ops->txrx_classify_update) 2373 return 0; 2374 2375 return soc->ops->cmn_drv_ops->txrx_classify_update(soc, vdev_id, 2376 skb, 2377 dir, nbuf_class); 2378 } 2379 2380 /** 2381 * cdp_get_dp_capabilities() - get DP capabilities 2382 * @soc: opaque soc handle 2383 * @dp_cap: enum of DP capabilities 2384 * 2385 * Return: bool 2386 */ 2387 static inline bool 2388 cdp_get_dp_capabilities(struct cdp_soc_t *soc, enum cdp_capabilities dp_caps) 2389 { 2390 if (soc && soc->ops && soc->ops->cmn_drv_ops && 2391 soc->ops->cmn_drv_ops->get_dp_capabilities) 2392 return soc->ops->cmn_drv_ops->get_dp_capabilities(soc, dp_caps); 2393 2394 qdf_err("invalid instance"); 2395 return false; 2396 } 2397 2398 #ifdef RECEIVE_OFFLOAD 2399 /** 2400 * cdp_register_rx_offld_flush_cb() - register LRO/GRO flush cb function pointer 2401 * @soc - data path soc handle 2402 * @pdev - device instance pointer 2403 * 2404 * register rx offload flush callback function pointer 2405 * 2406 * return none 2407 */ 2408 static inline void cdp_register_rx_offld_flush_cb(ol_txrx_soc_handle soc, 2409 void (rx_ol_flush_cb)(void *)) 2410 { 2411 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2412 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2413 "%s invalid instance", __func__); 2414 return; 2415 } 2416 2417 if (soc->ops->rx_offld_ops->register_rx_offld_flush_cb) 2418 return soc->ops->rx_offld_ops->register_rx_offld_flush_cb( 2419 rx_ol_flush_cb); 2420 } 2421 2422 /** 2423 * cdp_deregister_rx_offld_flush_cb() - deregister Rx offld flush cb function 2424 * @soc - data path soc handle 2425 * 2426 * deregister rx offload flush callback function pointer 2427 * 2428 * return none 2429 */ 2430 static inline void cdp_deregister_rx_offld_flush_cb(ol_txrx_soc_handle soc) 2431 { 2432 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 2433 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2434 "%s invalid instance", __func__); 2435 return; 2436 } 2437 2438 if (soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb) 2439 return soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb(); 2440 } 2441 #endif /* RECEIVE_OFFLOAD */ 2442 2443 /** 2444 * @cdp_set_ba_timeout() - set ba aging timeout per AC 2445 * 2446 * @soc - pointer to the soc 2447 * @value - timeout value in millisec 2448 * @ac - Access category 2449 * 2450 * @return - void 2451 */ 2452 static inline void cdp_set_ba_timeout(ol_txrx_soc_handle soc, 2453 uint8_t ac, uint32_t value) 2454 { 2455 if (!soc || !soc->ops) { 2456 dp_cdp_debug("Invalid Instance"); 2457 QDF_BUG(0); 2458 return; 2459 } 2460 2461 if (!soc->ops->cmn_drv_ops || 2462 !soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout) 2463 return; 2464 2465 soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout(soc, ac, value); 2466 } 2467 2468 /** 2469 * @cdp_get_ba_timeout() - return ba aging timeout per AC 2470 * 2471 * @soc - pointer to the soc 2472 * @ac - access category 2473 * @value - timeout value in millisec 2474 * 2475 * @return - void 2476 */ 2477 static inline void cdp_get_ba_timeout(ol_txrx_soc_handle soc, 2478 uint8_t ac, uint32_t *value) 2479 { 2480 if (!soc || !soc->ops) { 2481 dp_cdp_debug("Invalid Instance"); 2482 QDF_BUG(0); 2483 return; 2484 } 2485 2486 if (!soc->ops->cmn_drv_ops || 2487 !soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout) 2488 return; 2489 2490 soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout(soc, ac, value); 2491 } 2492 2493 /** 2494 * cdp_cfg_get() - get cfg for dp enum 2495 * 2496 * @soc: pointer to the soc 2497 * @cfg: cfg enum 2498 * 2499 * Return - cfg value 2500 */ 2501 static inline uint32_t cdp_cfg_get(ol_txrx_soc_handle soc, enum cdp_dp_cfg cfg) 2502 { 2503 if (!soc || !soc->ops) { 2504 dp_cdp_debug("Invalid Instance"); 2505 return 0; 2506 } 2507 2508 if (!soc->ops->cmn_drv_ops || !soc->ops->cmn_drv_ops->txrx_get_cfg) 2509 return 0; 2510 2511 return soc->ops->cmn_drv_ops->txrx_get_cfg(soc, cfg); 2512 } 2513 2514 /** 2515 * cdp_soc_set_rate_stats_ctx() - set rate stats context in soc 2516 * @soc: opaque soc handle 2517 * @ctx: rate stats context 2518 * 2519 * Return: void 2520 */ 2521 static inline void 2522 cdp_soc_set_rate_stats_ctx(ol_txrx_soc_handle soc, 2523 void *ctx) 2524 { 2525 if (!soc || !soc->ops) { 2526 dp_cdp_debug("Invalid Instance:"); 2527 QDF_BUG(0); 2528 return; 2529 } 2530 2531 if (!soc->ops->cmn_drv_ops || 2532 !soc->ops->cmn_drv_ops->set_rate_stats_ctx) 2533 return; 2534 2535 soc->ops->cmn_drv_ops->set_rate_stats_ctx((struct cdp_soc_t *)soc, 2536 ctx); 2537 } 2538 2539 /** 2540 * cdp_soc_get_rate_stats_ctx() - get rate stats context in soc 2541 * @soc: opaque soc handle 2542 * 2543 * Return: void 2544 */ 2545 static inline void* 2546 cdp_soc_get_rate_stats_ctx(ol_txrx_soc_handle soc) 2547 { 2548 if (!soc || !soc->ops) { 2549 dp_cdp_debug("Invalid Instance:"); 2550 QDF_BUG(0); 2551 return NULL; 2552 } 2553 2554 if (!soc->ops->cmn_drv_ops || 2555 !soc->ops->cmn_drv_ops->get_rate_stats_ctx) 2556 return NULL; 2557 2558 return soc->ops->cmn_drv_ops->get_rate_stats_ctx(soc); 2559 } 2560 2561 /** 2562 * cdp_peer_flush_rate_stats() - flush peer rate statistics 2563 * @soc: opaque soc handle 2564 * @pdev_id: id of pdev handle 2565 * @buf: stats buffer 2566 */ 2567 static inline void 2568 cdp_peer_flush_rate_stats(ol_txrx_soc_handle soc, uint8_t pdev_id, 2569 void *buf) 2570 { 2571 if (!soc || !soc->ops) { 2572 dp_cdp_debug("Invalid Instance:"); 2573 QDF_BUG(0); 2574 return; 2575 } 2576 2577 if (!soc->ops->cmn_drv_ops || 2578 !soc->ops->cmn_drv_ops->txrx_peer_flush_rate_stats) 2579 return; 2580 2581 soc->ops->cmn_drv_ops->txrx_peer_flush_rate_stats(soc, pdev_id, buf); 2582 } 2583 2584 /** 2585 * cdp_peer_get_peerstats_ctx() - get peer stats context 2586 * @soc: opaque soc handle 2587 * @vdev_id: id of vdev handle 2588 * @mac: peer mac address 2589 */ 2590 static inline void 2591 *cdp_peer_get_peerstats_ctx(ol_txrx_soc_handle soc, uint8_t vdev_id, 2592 uint8_t *mac_addr) 2593 { 2594 if (!soc || !soc->ops) { 2595 dp_cdp_debug("Invalid Instance:"); 2596 QDF_BUG(0); 2597 return NULL; 2598 } 2599 2600 if (!soc->ops->cmn_drv_ops || 2601 !soc->ops->cmn_drv_ops->txrx_peer_get_peerstats_ctx) 2602 return NULL; 2603 2604 return soc->ops->cmn_drv_ops->txrx_peer_get_peerstats_ctx(soc, 2605 vdev_id, 2606 mac_addr); 2607 } 2608 2609 /** 2610 * cdp_flush_rate_stats_request() - request flush rate statistics 2611 * @soc: opaque soc handle 2612 * @pdev_id: id of pdev handle 2613 */ 2614 static inline QDF_STATUS 2615 cdp_flush_rate_stats_request(struct cdp_soc_t *soc, uint8_t pdev_id) 2616 { 2617 if (!soc || !soc->ops) { 2618 dp_cdp_debug("Invalid Instance:"); 2619 QDF_BUG(0); 2620 return QDF_STATUS_E_FAILURE; 2621 } 2622 2623 if (!soc->ops->cmn_drv_ops || 2624 !soc->ops->cmn_drv_ops->txrx_flush_rate_stats_request) 2625 return QDF_STATUS_E_FAILURE; 2626 2627 return soc->ops->cmn_drv_ops->txrx_flush_rate_stats_request(soc, 2628 pdev_id); 2629 } 2630 2631 /** 2632 * cdp_set_vdev_pcp_tid_map() - set vdev pcp-tid-map 2633 * @soc: opaque soc handle 2634 * @vdev: id of data path vdev handle 2635 * @pcp: pcp value 2636 * @tid: tid value 2637 * 2638 * This API is used to configure the pcp-to-tid mapping for a pdev. 2639 * 2640 * Return: QDF_STATUS_SUCCESS if value set successfully 2641 * QDF_STATUS_E_INVAL false if error 2642 */ 2643 static inline 2644 QDF_STATUS cdp_set_vdev_pcp_tid_map(ol_txrx_soc_handle soc, 2645 uint8_t vdev_id, 2646 uint8_t pcp, uint8_t tid) 2647 { 2648 if (!soc || !soc->ops) { 2649 dp_cdp_debug("Invalid Instance"); 2650 return QDF_STATUS_E_INVAL; 2651 } 2652 2653 if (!soc->ops->cmn_drv_ops || 2654 !soc->ops->cmn_drv_ops->set_vdev_pcp_tid_map) 2655 return QDF_STATUS_E_INVAL; 2656 2657 return soc->ops->cmn_drv_ops->set_vdev_pcp_tid_map(soc, vdev_id, 2658 pcp, tid); 2659 } 2660 2661 /** 2662 * cdp_tx_send_exc() - Transmit a frame on a given vdev in exception path 2663 * 2664 * @soc: opaque soc handle 2665 * @vdev_id: vdev id 2666 * @nbuf: skb 2667 * @tx_exc_metadata: Handle that holds exception path meta data 2668 * 2669 * Return: NULL on success 2670 * nbuf when it fails to send 2671 */ 2672 static inline qdf_nbuf_t 2673 cdp_tx_send_exc(ol_txrx_soc_handle soc, 2674 uint8_t vdev_id, 2675 qdf_nbuf_t nbuf, 2676 struct cdp_tx_exception_metadata *tx_exc_metadata) 2677 { 2678 if (!soc || !soc->ops) { 2679 dp_cdp_debug("Invalid Instance"); 2680 QDF_BUG(0); 2681 return 0; 2682 } 2683 2684 if (!soc->ops->cmn_drv_ops || 2685 !soc->ops->cmn_drv_ops->tx_send_exc) 2686 return 0; 2687 2688 return soc->ops->cmn_drv_ops->tx_send_exc 2689 (soc, vdev_id, nbuf, tx_exc_metadata); 2690 } 2691 2692 /** 2693 * cdp_vdev_get_peer_mac_list(): function to get peer mac list of vdev 2694 * @soc: Datapath soc handle 2695 * @vdev_id: vdev id 2696 * @newmac: Table of the clients mac 2697 * @mac_cnt: No. of MACs required 2698 * @limit: Limit the number of clients 2699 * 2700 * return: no of clients 2701 */ 2702 static inline uint16_t 2703 cdp_vdev_get_peer_mac_list(ol_txrx_soc_handle soc, 2704 uint8_t vdev_id, 2705 uint8_t newmac[][QDF_MAC_ADDR_SIZE], 2706 uint16_t mac_cnt, bool limit) 2707 { 2708 if (!soc || !soc->ops) { 2709 dp_cdp_debug("Invalid Instance"); 2710 QDF_BUG(0); 2711 return 0; 2712 } 2713 2714 if (!soc->ops->cmn_drv_ops || 2715 !soc->ops->cmn_drv_ops->get_peer_mac_list) 2716 return 0; 2717 2718 return soc->ops->cmn_drv_ops->get_peer_mac_list 2719 (soc, vdev_id, newmac, mac_cnt, limit); 2720 } 2721 2722 /* 2723 * cdp_soc_config_full_mon_mode () - Configure Full monitor mode 2724 * 2725 *@soc: dp soc handle 2726 *@val: value to be configured val should be 0 or 1 2727 * 2728 * This API is used to enable/disable support for Full monitor mode feature 2729 * 2730 * Return: QDF_STATUS_SUCCESS if value set successfully 2731 * QDF_STATUS_E_INVAL false if error 2732 */ 2733 static inline QDF_STATUS 2734 cdp_soc_config_full_mon_mode(ol_txrx_soc_handle soc, uint8_t val) 2735 { 2736 if (!soc || !soc->ops) { 2737 dp_cdp_debug("Invalid Instance"); 2738 return QDF_STATUS_E_INVAL; 2739 } 2740 2741 if (!soc->ops->mon_ops || 2742 !soc->ops->mon_ops->config_full_mon_mode) 2743 return QDF_STATUS_E_INVAL; 2744 2745 return soc->ops->mon_ops->config_full_mon_mode(soc, val); 2746 } 2747 2748 /** 2749 * cdp_rx_get_pending() - Get number of pending frames of RX threads 2750 * @soc: opaque soc handle 2751 * Return: number of pending frames 2752 */ 2753 static inline int 2754 cdp_rx_get_pending(ol_txrx_soc_handle soc) 2755 { 2756 if (!soc || !soc->ol_ops || 2757 !soc->ol_ops->dp_rx_get_pending) 2758 return 0; 2759 2760 if (cdp_cfg_get(soc, cfg_dp_wow_check_rx_pending)) 2761 return soc->ol_ops->dp_rx_get_pending(soc); 2762 else 2763 return 0; 2764 } 2765 2766 static inline uint16_t 2767 cdp_get_peer_id(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac) 2768 { 2769 if (!soc || !soc->ops) { 2770 dp_cdp_debug("Invalid Instance"); 2771 QDF_BUG(0); 2772 return 0; 2773 } 2774 2775 if (!soc->ops->cmn_drv_ops || 2776 !soc->ops->cmn_drv_ops->get_peer_id) 2777 return 0; 2778 2779 return soc->ops->cmn_drv_ops->get_peer_id 2780 (soc, vdev_id, mac); 2781 } 2782 2783 #ifdef QCA_SUPPORT_WDS_EXTENDED 2784 static inline QDF_STATUS 2785 cdp_wds_ext_set_peer_rx(ol_txrx_soc_handle soc, uint8_t vdev_id, 2786 uint8_t *mac, ol_txrx_rx_fp rx, 2787 ol_osif_peer_handle osif_peer) 2788 { 2789 if (!soc || !soc->ops) { 2790 dp_cdp_debug("Invalid Instance"); 2791 QDF_BUG(0); 2792 return QDF_STATUS_E_FAULT; 2793 } 2794 2795 if (!soc->ops->cmn_drv_ops || 2796 !soc->ops->cmn_drv_ops->set_wds_ext_peer_rx) 2797 return QDF_STATUS_E_FAULT; 2798 2799 return soc->ops->cmn_drv_ops->set_wds_ext_peer_rx 2800 (soc, vdev_id, mac, rx, osif_peer); 2801 } 2802 #endif /* QCA_SUPPORT_WDS_EXTENDED */ 2803 2804 /** 2805 * cdp_drain_txrx() - drain TX/RX SRNGs 2806 * @soc: opaque soc handle 2807 */ 2808 static inline void 2809 cdp_drain_txrx(ol_txrx_soc_handle soc) 2810 { 2811 if (!soc || !soc->ops) { 2812 dp_cdp_debug("Invalid Instance"); 2813 QDF_BUG(0); 2814 return; 2815 } 2816 2817 if (!soc->ops->cmn_drv_ops || 2818 !soc->ops->cmn_drv_ops->txrx_drain) 2819 return; 2820 2821 return soc->ops->cmn_drv_ops->txrx_drain(soc); 2822 } 2823 2824 /** 2825 * cdp_get_free_desc_poolsize() - get free desc pool size 2826 * @soc: opaque soc handle 2827 */ 2828 static inline int 2829 cdp_get_free_desc_poolsize(ol_txrx_soc_handle soc) 2830 { 2831 if (!soc || !soc->ops) { 2832 dp_cdp_debug("Invalid Instance"); 2833 QDF_BUG(0); 2834 return 0; 2835 } 2836 2837 if (!soc->ops->cmn_drv_ops || 2838 !soc->ops->cmn_drv_ops->get_free_desc_poolsize) 2839 return 0; 2840 2841 return soc->ops->cmn_drv_ops->get_free_desc_poolsize(soc); 2842 } 2843 2844 #ifdef WLAN_FEATURE_PKT_CAPTURE_V2 2845 /** 2846 * cdp_set_pkt_capture_mode() - set pkt capture mode in dp ctx 2847 * @soc: opaque soc handle 2848 * @val: value to be set 2849 */ 2850 static inline void 2851 cdp_set_pkt_capture_mode(ol_txrx_soc_handle soc, bool val) 2852 { 2853 if (!soc || !soc->ops) { 2854 dp_cdp_debug("Invalid Instance"); 2855 QDF_BUG(0); 2856 return; 2857 } 2858 2859 if (!soc->ops->cmn_drv_ops || 2860 !soc->ops->cmn_drv_ops->set_pkt_capture_mode) 2861 return; 2862 2863 soc->ops->cmn_drv_ops->set_pkt_capture_mode(soc, val); 2864 } 2865 #else 2866 static inline void 2867 cdp_set_pkt_capture_mode(ol_txrx_soc_handle soc, bool val) 2868 { 2869 } 2870 #endif 2871 2872 /** 2873 * cdp_rx_get_pending() - Get number of pending frames of RX threads 2874 * @soc: opaque soc handle 2875 * Return: number of pending frames 2876 */ 2877 static inline uint32_t 2878 cdp_get_tx_inqueue(ol_txrx_soc_handle soc) 2879 { 2880 if (!soc || !soc->ol_ops || 2881 !soc->ol_ops->dp_get_tx_inqueue) 2882 return 0; 2883 2884 return soc->ol_ops->dp_get_tx_inqueue(soc); 2885 } 2886 2887 #ifdef FEATURE_RUNTIME_PM 2888 2889 /** 2890 * cdp_set_rtpm_tput_policy_requirement() - Set RTPM throughput policy 2891 * @soc: opaque soc handle 2892 * @is_high_tput: flag indicating whether throughput requirement is high or not 2893 * 2894 * The functions sets RTPM throughput policy requirement. If 'is_high_tput' is 2895 * set, the expectation is that runtime_pm APIs will not be invoked per packet. 2896 */ 2897 2898 static inline 2899 void cdp_set_rtpm_tput_policy_requirement(ol_txrx_soc_handle soc, 2900 bool is_high_tput) 2901 { 2902 if (!soc || !soc->ops) { 2903 dp_cdp_debug("Invalid Instance"); 2904 QDF_BUG(0); 2905 return; 2906 } 2907 2908 if (!soc->ops->cmn_drv_ops || 2909 !soc->ops->cmn_drv_ops->set_rtpm_tput_policy) 2910 return; 2911 2912 soc->ops->cmn_drv_ops->set_rtpm_tput_policy(soc, is_high_tput); 2913 } 2914 #else 2915 static inline 2916 void cdp_set_rtpm_tput_policy_requirement(ol_txrx_soc_handle soc, 2917 bool is_high_tput) 2918 { 2919 } 2920 2921 #endif /* FEATURE_RUNTIME_PM */ 2922 2923 /** 2924 * cdp_enable_mon_reap_timer() - enable/disable reap timer 2925 * @soc: Datapath soc handle 2926 * @pdev_id: id of objmgr pdev 2927 * @enable: enable/disable reap timer of monitor status ring 2928 * 2929 * Return: true if timer start/stop is performed, false otherwise. 2930 */ 2931 static inline bool 2932 cdp_enable_mon_reap_timer(ol_txrx_soc_handle soc, 2933 enum cdp_mon_reap_source source, 2934 bool enable) 2935 { 2936 if (!soc || !soc->ops) { 2937 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 2938 "%s invalid instance", __func__); 2939 QDF_BUG(0); 2940 return false; 2941 } 2942 2943 if (!soc->ops->mon_ops || 2944 !soc->ops->mon_ops->txrx_enable_mon_reap_timer) 2945 return false; 2946 2947 return soc->ops->mon_ops->txrx_enable_mon_reap_timer(soc, source, 2948 enable); 2949 } 2950 2951 /** 2952 * cdp_get_tsf_time() - get tsf time 2953 * @soc: Datapath soc handle 2954 * @mac_id: mac_id 2955 * @tsf: pointer to update tsf value 2956 * @tsf_sync_soc_time: pointer to update tsf sync time 2957 * 2958 * Return: None. 2959 */ 2960 static inline void 2961 cdp_get_tsf_time(ol_txrx_soc_handle soc, uint32_t tsf_id, uint32_t mac_id, 2962 uint64_t *tsf, uint64_t *tsf_sync_soc_time) 2963 { 2964 if (!soc) { 2965 dp_cdp_debug("Invalid Instance"); 2966 return; 2967 } 2968 if (!soc->ops->cmn_drv_ops || !soc->ops->cmn_drv_ops->txrx_get_tsf_time) 2969 return; 2970 2971 soc->ops->cmn_drv_ops->txrx_get_tsf_time(soc, tsf_id, mac_id, tsf, 2972 tsf_sync_soc_time); 2973 } 2974 2975 /** 2976 * cdp_get_tsf2_offset() - get tsf2 offset 2977 * @soc: Datapath soc handle 2978 * @mac_id: mac_id 2979 * @value: pointer to update tsf2 value 2980 * 2981 * Return: None. 2982 */ 2983 static inline void 2984 cdp_get_tsf2_offset(ol_txrx_soc_handle soc, uint8_t mac_id, uint64_t *value) 2985 { 2986 if (!soc) { 2987 dp_cdp_debug("Invalid Instance"); 2988 return; 2989 } 2990 if (!soc->ops->cmn_drv_ops || 2991 !soc->ops->cmn_drv_ops->txrx_get_tsf2_offset) 2992 return; 2993 2994 soc->ops->cmn_drv_ops->txrx_get_tsf2_offset(soc, mac_id, value); 2995 } 2996 2997 /** 2998 * cdp_get_tqm_offset() - get tqm offset 2999 * @soc: Datapath soc handle 3000 * @value: pointer to update tqm value 3001 * 3002 * Return: None. 3003 */ 3004 static inline void 3005 cdp_get_tqm_offset(ol_txrx_soc_handle soc, uint64_t *value) 3006 { 3007 if (!soc) { 3008 dp_cdp_debug("Invalid Instance"); 3009 return; 3010 } 3011 if (!soc->ops->cmn_drv_ops || 3012 !soc->ops->cmn_drv_ops->txrx_get_tqm_offset) 3013 return; 3014 3015 soc->ops->cmn_drv_ops->txrx_get_tqm_offset(soc, value); 3016 } 3017 #endif /* _CDP_TXRX_CMN_H_ */ 3018