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