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