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