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