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