1 /* 2 * Copyright (c) 2011-2018 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 * 34 * Common Data Path Header File 35 * 36 *****************************************************************************/ 37 #define dp_alert(params...) QDF_TRACE_FATAL(QDF_MODULE_ID_DP, params) 38 #define dp_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_DP, params) 39 #define dp_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_DP, params) 40 #define dp_info(params...) QDF_TRACE_INFO(QDF_MODULE_ID_DP, params) 41 #define dp_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_DP, params) 42 43 static inline int 44 cdp_soc_attach_target(ol_txrx_soc_handle soc) 45 { 46 if (!soc || !soc->ops) { 47 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 48 "%s: Invalid Instance:", __func__); 49 QDF_BUG(0); 50 return 0; 51 } 52 53 if (!soc->ops->cmn_drv_ops || 54 !soc->ops->cmn_drv_ops->txrx_soc_attach_target) 55 return 0; 56 57 return soc->ops->cmn_drv_ops->txrx_soc_attach_target(soc); 58 59 } 60 61 static inline int 62 cdp_soc_get_nss_cfg(ol_txrx_soc_handle soc) 63 { 64 if (!soc || !soc->ops) { 65 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 66 "%s: Invalid Instance:", __func__); 67 QDF_BUG(0); 68 return 0; 69 } 70 71 if (!soc->ops->cmn_drv_ops || 72 !soc->ops->cmn_drv_ops->txrx_soc_get_nss_cfg) 73 return 0; 74 75 return soc->ops->cmn_drv_ops->txrx_soc_get_nss_cfg(soc); 76 } 77 78 static inline void 79 cdp_soc_set_nss_cfg(ol_txrx_soc_handle soc, uint32_t config) 80 { 81 if (!soc || !soc->ops) { 82 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 83 "%s: Invalid Instance:", __func__); 84 QDF_BUG(0); 85 return; 86 } 87 88 if (!soc->ops->cmn_drv_ops || 89 !soc->ops->cmn_drv_ops->txrx_soc_set_nss_cfg) 90 return; 91 92 soc->ops->cmn_drv_ops->txrx_soc_set_nss_cfg(soc, config); 93 } 94 95 static inline struct cdp_vdev * 96 cdp_vdev_attach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 97 uint8_t *vdev_mac_addr, uint8_t vdev_id, enum wlan_op_mode op_mode) 98 { 99 if (!soc || !soc->ops) { 100 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 101 "%s: Invalid Instance:", __func__); 102 QDF_BUG(0); 103 return NULL; 104 } 105 106 if (!soc->ops->cmn_drv_ops || 107 !soc->ops->cmn_drv_ops->txrx_vdev_attach) 108 return NULL; 109 110 return soc->ops->cmn_drv_ops->txrx_vdev_attach(pdev, 111 vdev_mac_addr, vdev_id, op_mode); 112 } 113 #ifndef CONFIG_WIN 114 /** 115 * cdp_flow_pool_map() - Create flow pool for vdev 116 * @soc - data path soc handle 117 * @pdev 118 * @vdev_id - vdev_id corresponding to vdev start 119 * 120 * Create per vdev flow pool. 121 * 122 * return none 123 */ 124 static inline QDF_STATUS cdp_flow_pool_map(ol_txrx_soc_handle soc, 125 struct cdp_pdev *pdev, uint8_t vdev_id) 126 { 127 if (!soc || !soc->ops) { 128 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 129 "%s: Invalid Instance:", __func__); 130 QDF_BUG(0); 131 return QDF_STATUS_E_INVAL; 132 } 133 134 if (!soc->ops->flowctl_ops || 135 !soc->ops->flowctl_ops->flow_pool_map_handler) 136 return QDF_STATUS_E_INVAL; 137 138 return soc->ops->flowctl_ops->flow_pool_map_handler(soc, pdev, vdev_id); 139 } 140 141 /** 142 * cdp_flow_pool_unmap() - Delete flow pool 143 * @soc - data path soc handle 144 * @pdev 145 * @vdev_id - vdev_id corresponding to vdev start 146 * 147 * Delete flow pool 148 * 149 * return none 150 */ 151 static inline void cdp_flow_pool_unmap(ol_txrx_soc_handle soc, 152 struct cdp_pdev *pdev, uint8_t vdev_id) 153 { 154 if (!soc || !soc->ops) { 155 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 156 "%s: Invalid Instance:", __func__); 157 QDF_BUG(0); 158 return; 159 } 160 161 if (!soc->ops->flowctl_ops || 162 !soc->ops->flowctl_ops->flow_pool_unmap_handler) 163 return; 164 165 return soc->ops->flowctl_ops->flow_pool_unmap_handler(soc, pdev, 166 vdev_id); 167 } 168 #endif 169 170 static inline void 171 cdp_vdev_detach(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 172 ol_txrx_vdev_delete_cb callback, void *cb_context) 173 { 174 if (!soc || !soc->ops) { 175 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 176 "%s: Invalid Instance:", __func__); 177 QDF_BUG(0); 178 return; 179 } 180 181 if (!soc->ops->cmn_drv_ops || 182 !soc->ops->cmn_drv_ops->txrx_vdev_detach) 183 return; 184 185 soc->ops->cmn_drv_ops->txrx_vdev_detach(vdev, 186 callback, cb_context); 187 } 188 189 static inline int 190 cdp_pdev_attach_target(ol_txrx_soc_handle soc, struct cdp_pdev *pdev) 191 { 192 if (!soc || !soc->ops) { 193 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 194 "%s: Invalid Instance:", __func__); 195 QDF_BUG(0); 196 return 0; 197 } 198 199 if (!soc->ops->cmn_drv_ops || 200 !soc->ops->cmn_drv_ops->txrx_pdev_attach_target) 201 return 0; 202 203 return soc->ops->cmn_drv_ops->txrx_pdev_attach_target(pdev); 204 } 205 206 static inline struct cdp_pdev *cdp_pdev_attach 207 (ol_txrx_soc_handle soc, struct cdp_ctrl_objmgr_pdev *ctrl_pdev, 208 HTC_HANDLE htc_pdev, qdf_device_t osdev, uint8_t pdev_id) 209 { 210 if (!soc || !soc->ops) { 211 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 212 "%s: Invalid Instance:", __func__); 213 QDF_BUG(0); 214 return NULL; 215 } 216 217 if (!soc->ops->cmn_drv_ops || 218 !soc->ops->cmn_drv_ops->txrx_pdev_attach) 219 return NULL; 220 221 return soc->ops->cmn_drv_ops->txrx_pdev_attach(soc, ctrl_pdev, 222 htc_pdev, osdev, pdev_id); 223 } 224 225 static inline int cdp_pdev_post_attach(ol_txrx_soc_handle soc, 226 struct cdp_pdev *pdev) 227 { 228 if (!soc || !soc->ops) { 229 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 230 "%s: Invalid Instance:", __func__); 231 QDF_BUG(0); 232 return 0; 233 } 234 235 if (!soc->ops->cmn_drv_ops || 236 !soc->ops->cmn_drv_ops->txrx_pdev_post_attach) 237 return 0; 238 239 return soc->ops->cmn_drv_ops->txrx_pdev_post_attach(pdev); 240 } 241 242 static inline void 243 cdp_pdev_pre_detach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, int force) 244 { 245 if (!soc || !soc->ops) { 246 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 247 "%s: Invalid Instance:", __func__); 248 QDF_BUG(0); 249 return; 250 } 251 252 if (!soc->ops->cmn_drv_ops || 253 !soc->ops->cmn_drv_ops->txrx_pdev_pre_detach) 254 return; 255 256 soc->ops->cmn_drv_ops->txrx_pdev_pre_detach(pdev, force); 257 } 258 259 static inline void 260 cdp_pdev_detach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, int force) 261 { 262 if (!soc || !soc->ops) { 263 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 264 "%s: Invalid Instance:", __func__); 265 QDF_BUG(0); 266 return; 267 } 268 269 if (!soc->ops->cmn_drv_ops || 270 !soc->ops->cmn_drv_ops->txrx_pdev_detach) 271 return; 272 273 soc->ops->cmn_drv_ops->txrx_pdev_detach(pdev, force); 274 } 275 276 static inline void *cdp_peer_create 277 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 278 uint8_t *peer_mac_addr, struct cdp_ctrl_objmgr_peer *ctrl_peer) 279 { 280 if (!soc || !soc->ops) { 281 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 282 "%s: Invalid Instance:", __func__); 283 QDF_BUG(0); 284 return NULL; 285 } 286 287 if (!soc->ops->cmn_drv_ops || 288 !soc->ops->cmn_drv_ops->txrx_peer_create) 289 return NULL; 290 291 return soc->ops->cmn_drv_ops->txrx_peer_create(vdev, 292 peer_mac_addr, ctrl_peer); 293 } 294 295 static inline void cdp_peer_setup 296 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, void *peer) 297 { 298 if (!soc || !soc->ops) { 299 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 300 "%s: Invalid Instance:", __func__); 301 QDF_BUG(0); 302 return; 303 } 304 305 if (!soc->ops->cmn_drv_ops || 306 !soc->ops->cmn_drv_ops->txrx_peer_setup) 307 return; 308 309 soc->ops->cmn_drv_ops->txrx_peer_setup(vdev, 310 peer); 311 } 312 313 static inline void *cdp_peer_ast_hash_find 314 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr) 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 NULL; 321 } 322 323 if (!soc->ops->cmn_drv_ops || 324 !soc->ops->cmn_drv_ops->txrx_peer_ast_hash_find) 325 return NULL; 326 327 return soc->ops->cmn_drv_ops->txrx_peer_ast_hash_find(soc, 328 ast_mac_addr); 329 } 330 331 static inline int cdp_peer_add_ast 332 (ol_txrx_soc_handle soc, struct cdp_peer *peer_handle, 333 uint8_t *mac_addr, enum cdp_txrx_ast_entry_type type, uint32_t flags) 334 { 335 if (!soc || !soc->ops) { 336 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 337 "%s: Invalid Instance:", __func__); 338 QDF_BUG(0); 339 return 0; 340 } 341 342 if (!soc->ops->cmn_drv_ops || 343 !soc->ops->cmn_drv_ops->txrx_peer_add_ast) 344 return 0; 345 346 return soc->ops->cmn_drv_ops->txrx_peer_add_ast(soc, 347 peer_handle, 348 mac_addr, 349 type, 350 flags); 351 } 352 353 static inline void cdp_peer_reset_ast 354 (ol_txrx_soc_handle soc, uint8_t *wds_macaddr, void *vdev_hdl) 355 { 356 357 if (!soc || !soc->ops) { 358 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 359 "%s: Invalid Instance:", __func__); 360 QDF_BUG(0); 361 return; 362 } 363 if (!soc->ops->cmn_drv_ops || 364 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast) 365 return; 366 367 soc->ops->cmn_drv_ops->txrx_peer_reset_ast(soc, wds_macaddr, vdev_hdl); 368 } 369 370 static inline void cdp_peer_reset_ast_table 371 (ol_txrx_soc_handle soc, void *vdev_hdl) 372 { 373 if (!soc || !soc->ops) { 374 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 375 "%s: Invalid Instance:", __func__); 376 QDF_BUG(0); 377 return; 378 } 379 380 if (!soc->ops->cmn_drv_ops || 381 !soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table) 382 return; 383 384 soc->ops->cmn_drv_ops->txrx_peer_reset_ast_table(soc, vdev_hdl); 385 } 386 387 static inline void cdp_peer_flush_ast_table 388 (ol_txrx_soc_handle soc) 389 { 390 if (!soc || !soc->ops) { 391 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 392 "%s: Invalid Instance:", __func__); 393 QDF_BUG(0); 394 return; 395 } 396 397 if (!soc->ops->cmn_drv_ops || 398 !soc->ops->cmn_drv_ops->txrx_peer_flush_ast_table) 399 return; 400 401 soc->ops->cmn_drv_ops->txrx_peer_flush_ast_table(soc); 402 } 403 404 static inline int cdp_peer_update_ast 405 (ol_txrx_soc_handle soc, uint8_t *wds_macaddr, 406 struct cdp_peer *peer_handle, uint32_t flags) 407 { 408 if (!soc || !soc->ops) { 409 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 410 "%s: Invalid Instance:", __func__); 411 QDF_BUG(0); 412 return 0; 413 } 414 415 if (!soc->ops->cmn_drv_ops || 416 !soc->ops->cmn_drv_ops->txrx_peer_update_ast) 417 return 0; 418 419 420 return soc->ops->cmn_drv_ops->txrx_peer_update_ast(soc, 421 peer_handle, 422 wds_macaddr, 423 flags); 424 } 425 426 static inline void cdp_peer_del_ast 427 (ol_txrx_soc_handle soc, void *ast_handle) 428 { 429 if (!soc || !soc->ops) { 430 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 431 "%s: Invalid Instance:", __func__); 432 QDF_BUG(0); 433 return; 434 } 435 436 if (!soc->ops->cmn_drv_ops || 437 !soc->ops->cmn_drv_ops->txrx_peer_del_ast) 438 return; 439 440 soc->ops->cmn_drv_ops->txrx_peer_del_ast(soc, ast_handle); 441 } 442 443 444 static inline uint8_t cdp_peer_ast_get_pdev_id 445 (ol_txrx_soc_handle soc, void *ast_handle) 446 { 447 if (!soc || !soc->ops) { 448 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 449 "%s: Invalid Instance:", __func__); 450 QDF_BUG(0); 451 return 0xff; 452 } 453 454 if (!soc->ops->cmn_drv_ops || 455 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_pdev_id) 456 return 0xff; 457 458 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_pdev_id(soc, 459 ast_handle); 460 } 461 462 static inline uint8_t cdp_peer_ast_get_next_hop 463 (ol_txrx_soc_handle soc, void *ast_handle) 464 { 465 if (!soc || !soc->ops) { 466 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 467 "%s: Invalid Instance:", __func__); 468 QDF_BUG(0); 469 return 0xff; 470 } 471 472 if (!soc->ops->cmn_drv_ops || 473 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_next_hop) 474 return 0xff; 475 476 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_next_hop(soc, 477 ast_handle); 478 } 479 480 /** 481 * cdp_peer_ast_get_type() - Return type (Static, WDS, MEC) of AST entry 482 * @soc: DP SoC handle 483 * @ast_handle: Opaque handle to AST entry 484 * 485 * Return: AST entry type (Static/WDS/MEC) 486 */ 487 static inline enum cdp_txrx_ast_entry_type cdp_peer_ast_get_type 488 (ol_txrx_soc_handle soc, void *ast_handle) 489 490 { 491 if (!soc || !soc->ops) { 492 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 493 "%s: Invalid Instance:", __func__); 494 QDF_BUG(0); 495 return 0; 496 } 497 498 if (!soc->ops->cmn_drv_ops || 499 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_type) 500 return 0; 501 502 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_type(soc, ast_handle); 503 } 504 505 static inline void cdp_peer_ast_set_type 506 (ol_txrx_soc_handle soc, void *ast_handle, 507 enum cdp_txrx_ast_entry_type type) 508 { 509 if (!soc || !soc->ops) { 510 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 511 "%s: Invalid Instance:", __func__); 512 QDF_BUG(0); 513 return; 514 } 515 516 if (!soc->ops->cmn_drv_ops || 517 !soc->ops->cmn_drv_ops->txrx_peer_ast_set_type) 518 return; 519 520 soc->ops->cmn_drv_ops->txrx_peer_ast_set_type(soc, ast_handle, type); 521 } 522 523 #if defined(FEATURE_AST) && defined(AST_HKV1_WORKAROUND) 524 static inline void cdp_peer_ast_set_cp_ctx(struct cdp_soc_t *soc, 525 void *ast_handle, 526 void *cp_ctx) 527 { 528 if (!soc || !soc->ops) { 529 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 530 "Invalid Instance:"); 531 QDF_BUG(0); 532 return; 533 } 534 535 if (!soc->ops->cmn_drv_ops || 536 !soc->ops->cmn_drv_ops->txrx_peer_ast_set_cp_ctx) 537 return; 538 539 soc->ops->cmn_drv_ops->txrx_peer_ast_set_cp_ctx(soc, ast_handle, 540 cp_ctx); 541 } 542 543 static inline void *cdp_peer_ast_get_cp_ctx(struct cdp_soc_t *soc, 544 void *ast_handle) 545 { 546 if (!soc || !soc->ops) { 547 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 548 "Invalid Instance:"); 549 QDF_BUG(0); 550 return NULL; 551 } 552 553 if (!soc->ops->cmn_drv_ops || 554 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_cp_ctx) 555 return NULL; 556 557 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_cp_ctx(soc, ast_handle); 558 } 559 560 static inline bool cdp_peer_ast_get_wmi_sent(struct cdp_soc_t *soc, 561 void *ast_handle) 562 { 563 if (!soc || !soc->ops) { 564 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 565 "Invalid Instance:"); 566 QDF_BUG(0); 567 return false; 568 } 569 570 if (!soc->ops->cmn_drv_ops || 571 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_wmi_sent) 572 return false; 573 574 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_wmi_sent(soc, 575 ast_handle); 576 } 577 578 static inline 579 void cdp_peer_ast_free_entry(struct cdp_soc_t *soc, 580 void *ast_handle) 581 { 582 if (!soc || !soc->ops) { 583 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 584 "Invalid Instance:"); 585 QDF_BUG(0); 586 return; 587 } 588 589 if (!soc->ops->cmn_drv_ops || 590 !soc->ops->cmn_drv_ops->txrx_peer_ast_free_entry) 591 return; 592 593 soc->ops->cmn_drv_ops->txrx_peer_ast_free_entry(soc, ast_handle); 594 } 595 #endif 596 597 static inline void cdp_peer_teardown 598 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, void *peer) 599 { 600 if (!soc || !soc->ops) { 601 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 602 "%s: Invalid Instance:", __func__); 603 QDF_BUG(0); 604 return; 605 } 606 607 if (!soc->ops->cmn_drv_ops || 608 !soc->ops->cmn_drv_ops->txrx_peer_teardown) 609 return; 610 611 soc->ops->cmn_drv_ops->txrx_peer_teardown(vdev, peer); 612 } 613 614 static inline void 615 cdp_peer_delete(ol_txrx_soc_handle soc, void *peer, uint32_t bitmap) 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; 622 } 623 624 if (!soc->ops->cmn_drv_ops || 625 !soc->ops->cmn_drv_ops->txrx_peer_delete) 626 return; 627 628 soc->ops->cmn_drv_ops->txrx_peer_delete(peer, bitmap); 629 } 630 631 static inline int 632 cdp_set_monitor_mode(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 633 uint8_t smart_monitor) 634 { 635 if (!soc || !soc->ops) { 636 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 637 "%s: Invalid Instance:", __func__); 638 QDF_BUG(0); 639 return 0; 640 } 641 642 if (!soc->ops->cmn_drv_ops || 643 !soc->ops->cmn_drv_ops->txrx_set_monitor_mode) 644 return 0; 645 646 return soc->ops->cmn_drv_ops->txrx_set_monitor_mode(vdev, 647 smart_monitor); 648 } 649 650 static inline void 651 cdp_set_curchan(ol_txrx_soc_handle soc, 652 struct cdp_pdev *pdev, 653 uint32_t chan_mhz) 654 { 655 if (!soc || !soc->ops) { 656 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 657 "%s: Invalid Instance:", __func__); 658 QDF_BUG(0); 659 return; 660 } 661 662 if (!soc->ops->cmn_drv_ops || 663 !soc->ops->cmn_drv_ops->txrx_set_curchan) 664 return; 665 666 soc->ops->cmn_drv_ops->txrx_set_curchan(pdev, chan_mhz); 667 } 668 669 static inline void 670 cdp_set_privacy_filters(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 671 void *filter, uint32_t num) 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_set_privacy_filters) 682 return; 683 684 soc->ops->cmn_drv_ops->txrx_set_privacy_filters(vdev, 685 filter, num); 686 } 687 688 static inline int 689 cdp_set_monitor_filter(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 690 struct cdp_monitor_filter *filter_val) 691 { 692 if (soc->ops->mon_ops->txrx_set_advance_monitor_filter) 693 return soc->ops->mon_ops->txrx_set_advance_monitor_filter(pdev, 694 filter_val); 695 return 0; 696 } 697 698 699 /****************************************************************************** 700 * Data Interface (B Interface) 701 *****************************************************************************/ 702 static inline void 703 cdp_vdev_register(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 704 void *osif_vdev, struct cdp_ctrl_objmgr_vdev *ctrl_vdev, 705 struct ol_txrx_ops *txrx_ops) 706 { 707 if (!soc || !soc->ops) { 708 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 709 "%s: Invalid Instance:", __func__); 710 QDF_BUG(0); 711 return; 712 } 713 714 if (!soc->ops->cmn_drv_ops || 715 !soc->ops->cmn_drv_ops->txrx_vdev_register) 716 return; 717 718 soc->ops->cmn_drv_ops->txrx_vdev_register(vdev, 719 osif_vdev, ctrl_vdev, txrx_ops); 720 } 721 722 static inline int 723 cdp_mgmt_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 724 qdf_nbuf_t tx_mgmt_frm, uint8_t type) 725 { 726 if (!soc || !soc->ops) { 727 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 728 "%s: Invalid Instance:", __func__); 729 QDF_BUG(0); 730 return 0; 731 } 732 733 if (!soc->ops->cmn_drv_ops || 734 !soc->ops->cmn_drv_ops->txrx_mgmt_send) 735 return 0; 736 737 return soc->ops->cmn_drv_ops->txrx_mgmt_send(vdev, 738 tx_mgmt_frm, type); 739 } 740 741 static inline int 742 cdp_mgmt_send_ext(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 743 qdf_nbuf_t tx_mgmt_frm, uint8_t type, 744 uint8_t use_6mbps, uint16_t chanfreq) 745 { 746 if (!soc || !soc->ops) { 747 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 748 "%s: Invalid Instance:", __func__); 749 QDF_BUG(0); 750 return 0; 751 } 752 753 if (!soc->ops->cmn_drv_ops || 754 !soc->ops->cmn_drv_ops->txrx_mgmt_send_ext) 755 return 0; 756 757 return soc->ops->cmn_drv_ops->txrx_mgmt_send_ext 758 (vdev, tx_mgmt_frm, type, use_6mbps, chanfreq); 759 } 760 761 762 static inline void 763 cdp_mgmt_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 764 uint8_t type, ol_txrx_mgmt_tx_cb download_cb, 765 ol_txrx_mgmt_tx_cb ota_ack_cb, void *ctxt) 766 { 767 if (!soc || !soc->ops) { 768 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 769 "%s: Invalid Instance:", __func__); 770 QDF_BUG(0); 771 return; 772 } 773 774 if (!soc->ops->cmn_drv_ops || 775 !soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set) 776 return; 777 778 soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set 779 (pdev, type, download_cb, ota_ack_cb, ctxt); 780 } 781 782 static inline int cdp_get_tx_pending(ol_txrx_soc_handle soc, 783 struct cdp_pdev *pdev) 784 { 785 if (!soc || !soc->ops) { 786 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 787 "%s: Invalid Instance:", __func__); 788 QDF_BUG(0); 789 return 0; 790 } 791 792 if (!soc->ops->cmn_drv_ops || 793 !soc->ops->cmn_drv_ops->txrx_get_tx_pending) 794 return 0; 795 796 797 return soc->ops->cmn_drv_ops->txrx_get_tx_pending(pdev); 798 } 799 800 static inline void 801 cdp_data_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_vdev *data_vdev, 802 ol_txrx_data_tx_cb callback, void *ctxt) 803 { 804 if (!soc || !soc->ops) { 805 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 806 "%s: Invalid Instance:", __func__); 807 QDF_BUG(0); 808 return; 809 } 810 811 if (!soc->ops->cmn_drv_ops || 812 !soc->ops->cmn_drv_ops->txrx_data_tx_cb_set) 813 return; 814 815 soc->ops->cmn_drv_ops->txrx_data_tx_cb_set(data_vdev, 816 callback, ctxt); 817 } 818 819 /****************************************************************************** 820 * Statistics and Debugging Interface (C Interface) 821 *****************************************************************************/ 822 /** 823 * External Device physical address types 824 * 825 * Currently, both MAC and IPA uController use the same size addresses 826 * and descriptors are exchanged between these two depending on the mode. 827 * 828 * Rationale: qdf_dma_addr_t is the type used internally on the host for DMA 829 * operations. However, external device physical address sizes 830 * may be different from host-specific physical address sizes. 831 * This calls for the following definitions for target devices 832 * (MAC, IPA uc). 833 */ 834 #if HTT_PADDR64 835 typedef uint64_t target_paddr_t; 836 #else 837 typedef uint32_t target_paddr_t; 838 #endif /*HTT_PADDR64 */ 839 840 static inline int 841 cdp_aggr_cfg(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 842 int max_subfrms_ampdu, 843 int max_subfrms_amsdu) 844 { 845 if (!soc || !soc->ops) { 846 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 847 "%s: Invalid Instance:", __func__); 848 QDF_BUG(0); 849 return 0; 850 } 851 852 if (!soc->ops->cmn_drv_ops || 853 !soc->ops->cmn_drv_ops->txrx_aggr_cfg) 854 return 0; 855 856 return soc->ops->cmn_drv_ops->txrx_aggr_cfg(vdev, 857 max_subfrms_ampdu, max_subfrms_amsdu); 858 } 859 860 static inline int 861 cdp_fw_stats_get(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 862 struct ol_txrx_stats_req *req, bool per_vdev, 863 bool response_expected) 864 { 865 if (!soc || !soc->ops) { 866 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 867 "%s: Invalid Instance:", __func__); 868 QDF_BUG(0); 869 return 0; 870 } 871 872 if (!soc->ops->cmn_drv_ops || 873 !soc->ops->cmn_drv_ops->txrx_fw_stats_get) 874 return 0; 875 876 return soc->ops->cmn_drv_ops->txrx_fw_stats_get(vdev, req, 877 per_vdev, response_expected); 878 } 879 880 static inline int 881 cdp_debug(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, int debug_specs) 882 { 883 if (!soc || !soc->ops) { 884 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 885 "%s: Invalid Instance:", __func__); 886 QDF_BUG(0); 887 return 0; 888 } 889 890 if (!soc->ops->cmn_drv_ops || 891 !soc->ops->cmn_drv_ops->txrx_debug) 892 return 0; 893 894 return soc->ops->cmn_drv_ops->txrx_debug(vdev, debug_specs); 895 } 896 897 static inline void cdp_fw_stats_cfg(ol_txrx_soc_handle soc, 898 struct cdp_vdev *vdev, uint8_t cfg_stats_type, uint32_t cfg_val) 899 { 900 if (!soc || !soc->ops) { 901 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 902 "%s: Invalid Instance:", __func__); 903 QDF_BUG(0); 904 return; 905 } 906 907 if (!soc->ops->cmn_drv_ops || 908 !soc->ops->cmn_drv_ops->txrx_fw_stats_cfg) 909 return; 910 911 soc->ops->cmn_drv_ops->txrx_fw_stats_cfg(vdev, 912 cfg_stats_type, cfg_val); 913 } 914 915 static inline void cdp_print_level_set(ol_txrx_soc_handle soc, unsigned level) 916 { 917 if (!soc || !soc->ops) { 918 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 919 "%s: Invalid Instance:", __func__); 920 QDF_BUG(0); 921 return; 922 } 923 924 if (!soc->ops->cmn_drv_ops || 925 !soc->ops->cmn_drv_ops->txrx_print_level_set) 926 return; 927 928 soc->ops->cmn_drv_ops->txrx_print_level_set(level); 929 } 930 931 static inline uint8_t * 932 cdp_get_vdev_mac_addr(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 933 { 934 if (!soc || !soc->ops) { 935 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 936 "%s: Invalid Instance:", __func__); 937 QDF_BUG(0); 938 return NULL; 939 } 940 941 if (!soc->ops->cmn_drv_ops || 942 !soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr) 943 return NULL; 944 945 return soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr(vdev); 946 947 } 948 949 /** 950 * cdp_get_vdev_struct_mac_addr() - Return handle to struct qdf_mac_addr of 951 * vdev 952 * @vdev: vdev handle 953 * 954 * Return: Handle to struct qdf_mac_addr 955 */ 956 static inline struct qdf_mac_addr *cdp_get_vdev_struct_mac_addr 957 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 958 { 959 if (!soc || !soc->ops) { 960 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 961 "%s: Invalid Instance:", __func__); 962 QDF_BUG(0); 963 return NULL; 964 } 965 966 if (!soc->ops->cmn_drv_ops || 967 !soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr) 968 return NULL; 969 970 return soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr 971 (vdev); 972 973 } 974 975 /** 976 * cdp_get_pdev_from_vdev() - Return handle to pdev of vdev 977 * @vdev: vdev handle 978 * 979 * Return: Handle to pdev 980 */ 981 static inline struct cdp_pdev *cdp_get_pdev_from_vdev 982 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 983 { 984 if (!soc || !soc->ops) { 985 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 986 "%s: Invalid Instance:", __func__); 987 QDF_BUG(0); 988 return NULL; 989 } 990 991 if (!soc->ops->cmn_drv_ops || 992 !soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev) 993 return NULL; 994 995 return soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev(vdev); 996 } 997 998 /** 999 * cdp_get_os_rx_handles_from_vdev() - Return os rx handles for a vdev 1000 * @soc: ol_txrx_soc_handle handle 1001 * @vdev: vdev for which os rx handles are needed 1002 * @stack_fn_p: pointer to stack function pointer 1003 * @osif_handle_p: pointer to ol_osif_vdev_handle 1004 * 1005 * Return: void 1006 */ 1007 static inline 1008 void cdp_get_os_rx_handles_from_vdev(ol_txrx_soc_handle soc, 1009 struct cdp_vdev *vdev, 1010 ol_txrx_rx_fp *stack_fn_p, 1011 ol_osif_vdev_handle *osif_handle_p) 1012 { 1013 if (!soc || !soc->ops) { 1014 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1015 "%s: Invalid Instance:", __func__); 1016 QDF_BUG(0); 1017 return; 1018 } 1019 1020 if (!soc->ops->cmn_drv_ops || 1021 !soc->ops->cmn_drv_ops->txrx_get_os_rx_handles_from_vdev) 1022 return; 1023 1024 soc->ops->cmn_drv_ops->txrx_get_os_rx_handles_from_vdev(vdev, 1025 stack_fn_p, 1026 osif_handle_p); 1027 } 1028 1029 /** 1030 * cdp_get_ctrl_pdev_from_vdev() - Return control pdev of vdev 1031 * @vdev: vdev handle 1032 * 1033 * Return: Handle to control pdev 1034 */ 1035 static inline struct cdp_cfg * 1036 cdp_get_ctrl_pdev_from_vdev(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 1037 { 1038 if (!soc || !soc->ops) { 1039 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1040 "%s: Invalid Instance:", __func__); 1041 QDF_BUG(0); 1042 return NULL; 1043 } 1044 1045 if (!soc->ops->cmn_drv_ops || 1046 !soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev) 1047 return NULL; 1048 1049 return soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev 1050 (vdev); 1051 } 1052 1053 static inline struct cdp_vdev * 1054 cdp_get_vdev_from_vdev_id(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 1055 uint8_t vdev_id) 1056 { 1057 if (!soc || !soc->ops) { 1058 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1059 "%s: Invalid Instance:", __func__); 1060 QDF_BUG(0); 1061 return NULL; 1062 } 1063 1064 if (!soc->ops->cmn_drv_ops || 1065 !soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id) 1066 return NULL; 1067 1068 return soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id 1069 (pdev, vdev_id); 1070 } 1071 1072 static inline void 1073 cdp_soc_detach(ol_txrx_soc_handle soc) 1074 { 1075 if (!soc || !soc->ops) { 1076 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1077 "%s: Invalid Instance:", __func__); 1078 QDF_BUG(0); 1079 return; 1080 } 1081 1082 if (!soc->ops->cmn_drv_ops || 1083 !soc->ops->cmn_drv_ops->txrx_soc_detach) 1084 return; 1085 1086 soc->ops->cmn_drv_ops->txrx_soc_detach((void *)soc); 1087 } 1088 1089 /** 1090 * cdp_addba_resp_tx_completion() - Indicate addba response tx 1091 * completion to dp to change tid state. 1092 * @soc: soc handle 1093 * @peer_handle: peer handle 1094 * @tid: tid 1095 * @status: Tx completion status 1096 * 1097 * Return: success/failure of tid update 1098 */ 1099 static inline int cdp_addba_resp_tx_completion(ol_txrx_soc_handle soc, 1100 void *peer_handle, 1101 uint8_t tid, int status) 1102 { 1103 if (!soc || !soc->ops) { 1104 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1105 "%s: Invalid Instance:", __func__); 1106 QDF_BUG(0); 1107 return 0; 1108 } 1109 1110 if (!soc->ops->cmn_drv_ops || 1111 !soc->ops->cmn_drv_ops->addba_resp_tx_completion) 1112 return 0; 1113 1114 return soc->ops->cmn_drv_ops->addba_resp_tx_completion(peer_handle, tid, 1115 status); 1116 } 1117 1118 static inline int cdp_addba_requestprocess(ol_txrx_soc_handle soc, 1119 void *peer_handle, uint8_t dialogtoken, uint16_t tid, 1120 uint16_t batimeout, uint16_t buffersize, uint16_t startseqnum) 1121 { 1122 if (!soc || !soc->ops) { 1123 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1124 "%s: Invalid Instance:", __func__); 1125 QDF_BUG(0); 1126 return 0; 1127 } 1128 1129 if (!soc->ops->cmn_drv_ops || 1130 !soc->ops->cmn_drv_ops->addba_requestprocess) 1131 return 0; 1132 1133 return soc->ops->cmn_drv_ops->addba_requestprocess(peer_handle, 1134 dialogtoken, tid, batimeout, buffersize, startseqnum); 1135 } 1136 1137 static inline void cdp_addba_responsesetup(ol_txrx_soc_handle soc, 1138 void *peer_handle, uint8_t tid, uint8_t *dialogtoken, 1139 uint16_t *statuscode, uint16_t *buffersize, uint16_t *batimeout) 1140 { 1141 if (!soc || !soc->ops) { 1142 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1143 "%s: Invalid Instance:", __func__); 1144 QDF_BUG(0); 1145 return; 1146 } 1147 1148 if (!soc->ops->cmn_drv_ops || 1149 !soc->ops->cmn_drv_ops->addba_responsesetup) 1150 return; 1151 1152 soc->ops->cmn_drv_ops->addba_responsesetup(peer_handle, tid, 1153 dialogtoken, statuscode, buffersize, batimeout); 1154 } 1155 1156 static inline int cdp_delba_process(ol_txrx_soc_handle soc, 1157 void *peer_handle, int tid, uint16_t reasoncode) 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 0; 1164 } 1165 1166 if (!soc->ops->cmn_drv_ops || 1167 !soc->ops->cmn_drv_ops->delba_process) 1168 return 0; 1169 1170 return soc->ops->cmn_drv_ops->delba_process(peer_handle, 1171 tid, reasoncode); 1172 } 1173 1174 /** 1175 * cdp_delba_tx_completion() - Handle delba tx completion 1176 * to update stats and retry transmission if failed. 1177 * @soc: soc handle 1178 * @peer_handle: peer handle 1179 * @tid: Tid number 1180 * @status: Tx completion status 1181 * 1182 * Return: 0 on Success, 1 on failure 1183 */ 1184 1185 static inline int cdp_delba_tx_completion(ol_txrx_soc_handle soc, 1186 void *peer_handle, 1187 uint8_t tid, int status) 1188 { 1189 if (!soc || !soc->ops) { 1190 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1191 "%s: Invalid Instance:", __func__); 1192 QDF_BUG(0); 1193 return 0; 1194 } 1195 1196 if (!soc->ops->cmn_drv_ops || 1197 !soc->ops->cmn_drv_ops->delba_tx_completion) 1198 return 0; 1199 1200 return soc->ops->cmn_drv_ops->delba_tx_completion(peer_handle, 1201 tid, status); 1202 } 1203 1204 static inline void cdp_set_addbaresponse(ol_txrx_soc_handle soc, 1205 void *peer_handle, int tid, uint16_t statuscode) 1206 { 1207 if (!soc || !soc->ops) { 1208 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1209 "%s: Invalid Instance:", __func__); 1210 QDF_BUG(0); 1211 return; 1212 } 1213 1214 if (!soc->ops->cmn_drv_ops || 1215 !soc->ops->cmn_drv_ops->set_addba_response) 1216 return; 1217 1218 soc->ops->cmn_drv_ops->set_addba_response(peer_handle, tid, statuscode); 1219 } 1220 1221 /** 1222 * cdp_get_peer_mac_addr_frm_id: function to return vdev id and and peer 1223 * mac address 1224 * @soc: SOC handle 1225 * @peer_id: peer id of the peer for which mac_address is required 1226 * @mac_addr: reference to mac address 1227 * 1228 * reutm: vdev_id of the vap 1229 */ 1230 static inline uint8_t 1231 cdp_get_peer_mac_addr_frm_id(ol_txrx_soc_handle soc, uint16_t peer_id, 1232 uint8_t *mac_addr) 1233 { 1234 if (!soc || !soc->ops) { 1235 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1236 "%s: Invalid Instance:", __func__); 1237 QDF_BUG(0); 1238 return CDP_INVALID_VDEV_ID; 1239 } 1240 1241 if (!soc->ops->cmn_drv_ops || 1242 !soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id) 1243 return CDP_INVALID_VDEV_ID; 1244 1245 return soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id(soc, 1246 peer_id, mac_addr); 1247 } 1248 1249 /** 1250 * cdp_set_vdev_dscp_tid_map(): function to set DSCP-tid map in the vap 1251 * @vdev: vdev handle 1252 * @map_id: id of the tid map 1253 * 1254 * Return: void 1255 */ 1256 static inline void cdp_set_vdev_dscp_tid_map(ol_txrx_soc_handle soc, 1257 struct cdp_vdev *vdev, uint8_t map_id) 1258 { 1259 if (!soc || !soc->ops) { 1260 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1261 "%s: Invalid Instance:", __func__); 1262 QDF_BUG(0); 1263 return; 1264 } 1265 1266 if (!soc->ops->cmn_drv_ops || 1267 !soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map) 1268 return; 1269 1270 soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map(vdev, 1271 map_id); 1272 } 1273 1274 /** 1275 * cdp_set_pdev_dscp_tid_map(): function to change tid values in DSCP-tid map 1276 * @pdev: pdev handle 1277 * @map_id: id of the tid map 1278 * @tos: index value in map that needs to be changed 1279 * @tid: tid value passed by user 1280 * 1281 * Return: void 1282 */ 1283 static inline void cdp_set_pdev_dscp_tid_map(ol_txrx_soc_handle soc, 1284 struct cdp_pdev *pdev, uint8_t map_id, uint8_t tos, uint8_t tid) 1285 { 1286 if (!soc || !soc->ops) { 1287 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1288 "%s: Invalid Instance:", __func__); 1289 QDF_BUG(0); 1290 return; 1291 } 1292 1293 if (!soc->ops->cmn_drv_ops || 1294 !soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map) 1295 return; 1296 1297 soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map(pdev, 1298 map_id, tos, tid); 1299 } 1300 1301 /** 1302 * cdp_flush_cache_rx_queue() - flush cache rx queue frame 1303 * 1304 * Return: None 1305 */ 1306 static inline void cdp_flush_cache_rx_queue(ol_txrx_soc_handle soc) 1307 { 1308 if (!soc || !soc->ops) { 1309 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1310 "%s: Invalid Instance:", __func__); 1311 QDF_BUG(0); 1312 return; 1313 } 1314 1315 if (!soc->ops->cmn_drv_ops || 1316 !soc->ops->cmn_drv_ops->flush_cache_rx_queue) 1317 return; 1318 soc->ops->cmn_drv_ops->flush_cache_rx_queue(); 1319 } 1320 1321 /** 1322 * cdp_txrx_stats_request(): function to map to host and firmware statistics 1323 * @soc: soc handle 1324 * @vdev: virtual device 1325 * @req: stats request container 1326 * 1327 * return: status 1328 */ 1329 static inline 1330 int cdp_txrx_stats_request(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 1331 struct cdp_txrx_stats_req *req) 1332 { 1333 if (!soc || !soc->ops || !soc->ops->cmn_drv_ops || !req) { 1334 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1335 "%s: Invalid Instance:", __func__); 1336 QDF_ASSERT(0); 1337 return 0; 1338 } 1339 1340 if (soc->ops->cmn_drv_ops->txrx_stats_request) 1341 return soc->ops->cmn_drv_ops->txrx_stats_request(vdev, req); 1342 1343 return 0; 1344 } 1345 1346 /** 1347 * cdp_txrx_intr_attach(): function to attach and configure interrupt 1348 * @soc: soc handle 1349 */ 1350 static inline QDF_STATUS cdp_txrx_intr_attach(ol_txrx_soc_handle soc) 1351 { 1352 if (!soc || !soc->ops) { 1353 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1354 "%s: Invalid Instance:", __func__); 1355 QDF_BUG(0); 1356 return 0; 1357 } 1358 1359 if (!soc->ops->cmn_drv_ops || 1360 !soc->ops->cmn_drv_ops->txrx_intr_attach) 1361 return 0; 1362 1363 return soc->ops->cmn_drv_ops->txrx_intr_attach(soc); 1364 } 1365 1366 /** 1367 * cdp_txrx_intr_detach(): function to detach interrupt 1368 * @soc: soc handle 1369 */ 1370 static inline void cdp_txrx_intr_detach(ol_txrx_soc_handle soc) 1371 { 1372 if (!soc || !soc->ops) { 1373 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1374 "%s: Invalid Instance:", __func__); 1375 QDF_BUG(0); 1376 return; 1377 } 1378 1379 if (!soc->ops->cmn_drv_ops || 1380 !soc->ops->cmn_drv_ops->txrx_intr_detach) 1381 return; 1382 1383 soc->ops->cmn_drv_ops->txrx_intr_detach(soc); 1384 } 1385 1386 /** 1387 * cdp_display_stats(): function to map to dump stats 1388 * @soc: soc handle 1389 * @value: statistics option 1390 */ 1391 static inline QDF_STATUS 1392 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1393 enum qdf_stats_verbosity_level level) 1394 { 1395 if (!soc || !soc->ops) { 1396 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1397 "%s: Invalid Instance:", __func__); 1398 QDF_BUG(0); 1399 return 0; 1400 } 1401 1402 if (!soc->ops->cmn_drv_ops || 1403 !soc->ops->cmn_drv_ops->display_stats) 1404 return 0; 1405 1406 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1407 } 1408 1409 1410 /** 1411 * cdp_set_pn_check(): function to set pn check 1412 * @soc: soc handle 1413 * @sec_type: security type 1414 * #rx_pn: receive pn 1415 */ 1416 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1417 struct cdp_vdev *vdev, struct cdp_peer *peer_handle, enum cdp_sec_type sec_type, uint32_t *rx_pn) 1418 { 1419 if (!soc || !soc->ops) { 1420 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1421 "%s: Invalid Instance:", __func__); 1422 QDF_BUG(0); 1423 return 0; 1424 } 1425 1426 if (!soc->ops->cmn_drv_ops || 1427 !soc->ops->cmn_drv_ops->set_pn_check) 1428 return 0; 1429 1430 soc->ops->cmn_drv_ops->set_pn_check(vdev, peer_handle, 1431 sec_type, rx_pn); 1432 return 0; 1433 } 1434 1435 static inline int cdp_set_key(ol_txrx_soc_handle soc, 1436 struct cdp_peer *peer_handle, 1437 bool is_unicast, uint32_t *key) 1438 { 1439 if (!soc || !soc->ops) { 1440 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1441 "%s: Invalid Instance:", __func__); 1442 QDF_BUG(0); 1443 return 0; 1444 } 1445 1446 if (!soc->ops->ctrl_ops || 1447 !soc->ops->ctrl_ops->set_key) 1448 return 0; 1449 1450 soc->ops->ctrl_ops->set_key(peer_handle, 1451 is_unicast, key); 1452 return 0; 1453 } 1454 1455 /** 1456 * cdp_update_config_parameters(): function to propagate configuration 1457 * parameters to datapath 1458 * @soc: opaque soc handle 1459 * @cfg: configuration handle 1460 * 1461 * Return: status: 0 - Success, non-zero: Failure 1462 */ 1463 static inline 1464 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 1465 struct cdp_config_params *cfg) 1466 { 1467 struct cdp_soc *psoc = (struct cdp_soc *)soc; 1468 1469 if (!soc || !soc->ops) { 1470 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1471 "%s: Invalid Instance:", __func__); 1472 QDF_BUG(0); 1473 return 0; 1474 } 1475 1476 if (!soc->ops->cmn_drv_ops || 1477 !soc->ops->cmn_drv_ops->update_config_parameters) 1478 return QDF_STATUS_SUCCESS; 1479 1480 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 1481 cfg); 1482 } 1483 1484 /** 1485 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 1486 * @soc: opaque soc handle 1487 * @pdev: data path pdev handle 1488 * 1489 * Return: opaque dp handle 1490 */ 1491 static inline void * 1492 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev) 1493 { 1494 if (!soc || !soc->ops) { 1495 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1496 "%s: Invalid Instance:", __func__); 1497 QDF_BUG(0); 1498 return 0; 1499 } 1500 1501 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 1502 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(pdev); 1503 1504 return 0; 1505 } 1506 1507 /** 1508 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 1509 * @soc: opaque soc handle 1510 * @pdev: data path pdev handle 1511 * @dp_hdl: opaque pointer for dp_txrx_handle 1512 * 1513 * Return: void 1514 */ 1515 static inline void 1516 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev, void *dp_hdl) 1517 { 1518 if (!soc || !soc->ops) { 1519 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1520 "%s: Invalid Instance:", __func__); 1521 QDF_BUG(0); 1522 return; 1523 } 1524 1525 if (!soc->ops->cmn_drv_ops || 1526 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 1527 return; 1528 1529 soc->ops->cmn_drv_ops->set_dp_txrx_handle(pdev, dp_hdl); 1530 } 1531 1532 /* 1533 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 1534 * @soc: opaque soc handle 1535 * 1536 * Return: opaque extended dp handle 1537 */ 1538 static inline void * 1539 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 1540 { 1541 if (!soc || !soc->ops) { 1542 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1543 "%s: Invalid Instance:", __func__); 1544 QDF_BUG(0); 1545 return NULL; 1546 } 1547 1548 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 1549 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 1550 (struct cdp_soc *) soc); 1551 1552 return NULL; 1553 } 1554 1555 /** 1556 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 1557 * @soc: opaque soc handle 1558 * @dp_hdl: opaque pointer for dp_txrx_handle 1559 * 1560 * Return: void 1561 */ 1562 static inline void 1563 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 1564 { 1565 if (!soc || !soc->ops) { 1566 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1567 "%s: Invalid Instance:", __func__); 1568 QDF_BUG(0); 1569 return; 1570 } 1571 1572 if (!soc->ops->cmn_drv_ops || 1573 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 1574 return; 1575 1576 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 1577 dp_handle); 1578 } 1579 1580 /** 1581 * cdp_tx_send() - enqueue frame for transmission 1582 * @soc: soc opaque handle 1583 * @vdev: VAP device 1584 * @nbuf: nbuf to be enqueued 1585 * 1586 * This API is used by Extended Datapath modules to enqueue frame for 1587 * transmission 1588 * 1589 * Return: void 1590 */ 1591 static inline void 1592 cdp_tx_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, qdf_nbuf_t nbuf) 1593 { 1594 if (!soc || !soc->ops) { 1595 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1596 "%s: Invalid Instance:", __func__); 1597 QDF_BUG(0); 1598 return; 1599 } 1600 1601 if (!soc->ops->cmn_drv_ops || 1602 !soc->ops->cmn_drv_ops->tx_send) 1603 return; 1604 1605 soc->ops->cmn_drv_ops->tx_send(vdev, nbuf); 1606 } 1607 1608 /* 1609 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1610 * @soc: opaque soc handle 1611 * @pdev: data path pdev handle 1612 * 1613 * Return: pdev_id 1614 */ 1615 static inline 1616 uint8_t cdp_get_pdev_id_frm_pdev(ol_txrx_soc_handle soc, 1617 struct cdp_pdev *pdev) 1618 { 1619 if (soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev) 1620 return soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev(pdev); 1621 return 0; 1622 } 1623 1624 /** 1625 * cdp_pdev_set_chan_noise_floor() - Set channel noise floor to DP layer 1626 * @soc: opaque soc handle 1627 * @pdev: data path pdev handle 1628 * @chan_noise_floor: Channel Noise Floor (in dbM) obtained from control path 1629 * 1630 * Return: None 1631 */ 1632 static inline 1633 void cdp_pdev_set_chan_noise_floor(ol_txrx_soc_handle soc, 1634 struct cdp_pdev *pdev, 1635 int16_t chan_noise_floor) 1636 { 1637 if (soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor) 1638 return soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor( 1639 pdev, chan_noise_floor); 1640 } 1641 1642 /** 1643 * cdp_set_nac() - set nac 1644 * @soc: opaque soc handle 1645 * @peer: data path peer handle 1646 * 1647 */ 1648 static inline 1649 void cdp_set_nac(ol_txrx_soc_handle soc, 1650 struct cdp_peer *peer) 1651 { 1652 if (soc->ops->cmn_drv_ops->txrx_set_nac) 1653 soc->ops->cmn_drv_ops->txrx_set_nac(peer); 1654 } 1655 1656 /** 1657 * cdp_set_pdev_tx_capture() - set pdev tx_capture 1658 * @soc: opaque soc handle 1659 * @pdev: data path pdev handle 1660 * @val: value of pdev_tx_capture 1661 * 1662 * Return: void 1663 */ 1664 static inline 1665 void cdp_set_pdev_tx_capture(ol_txrx_soc_handle soc, 1666 struct cdp_pdev *pdev, int val) 1667 { 1668 if (soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture) 1669 return soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture(pdev, 1670 val); 1671 1672 } 1673 1674 /** 1675 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 1676 * @soc: opaque soc handle 1677 * @pdev: data path pdev handle 1678 * @peer_id: data path peer id 1679 * @peer_mac: peer_mac 1680 * 1681 * Return: void 1682 */ 1683 static inline 1684 void cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 1685 struct cdp_pdev *pdev_handle, 1686 uint32_t peer_id, uint8_t *peer_mac) 1687 { 1688 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 1689 soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 1690 pdev_handle, peer_id, peer_mac); 1691 } 1692 1693 /** 1694 * cdp_vdev_tx_lock() - acquire lock 1695 * @soc: opaque soc handle 1696 * @vdev: data path vdev handle 1697 * 1698 * Return: void 1699 */ 1700 static inline 1701 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 1702 struct cdp_vdev *vdev) 1703 { 1704 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 1705 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(vdev); 1706 } 1707 1708 /** 1709 * cdp_vdev_tx_unlock() - release lock 1710 * @soc: opaque soc handle 1711 * @vdev: data path vdev handle 1712 * 1713 * Return: void 1714 */ 1715 static inline 1716 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 1717 struct cdp_vdev *vdev) 1718 { 1719 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 1720 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(vdev); 1721 } 1722 1723 /** 1724 * cdp_ath_getstats() - get updated athstats 1725 * @soc: opaque soc handle 1726 * @dev: dp interface handle 1727 * @stats: cdp network device stats structure 1728 * @type: device type pdev/vdev 1729 * 1730 * Return: void 1731 */ 1732 static inline void cdp_ath_getstats(ol_txrx_soc_handle soc, 1733 void *dev, struct cdp_dev_stats *stats, 1734 uint8_t type) 1735 { 1736 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 1737 soc->ops->cmn_drv_ops->txrx_ath_getstats(dev, stats, type); 1738 } 1739 1740 /** 1741 * cdp_set_gid_flag() - set groupid flag 1742 * @soc: opaque soc handle 1743 * @pdev: data path pdev handle 1744 * @mem_status: member status from grp management frame 1745 * @user_position: user position from grp management frame 1746 * 1747 * Return: void 1748 */ 1749 static inline 1750 void cdp_set_gid_flag(ol_txrx_soc_handle soc, 1751 struct cdp_pdev *pdev, u_int8_t *mem_status, 1752 u_int8_t *user_position) 1753 { 1754 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 1755 soc->ops->cmn_drv_ops->txrx_set_gid_flag(pdev, mem_status, user_position); 1756 } 1757 1758 /** 1759 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 1760 * @soc: opaque soc handle 1761 * @pdev: data path pdev handle 1762 * 1763 */ 1764 static inline 1765 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 1766 struct cdp_pdev *pdev) 1767 { 1768 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 1769 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(pdev); 1770 return 0; 1771 } 1772 1773 /** 1774 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1775 * @soc: opaque soc handle 1776 * @ni: associated node 1777 * @force: number of frame in SW queue 1778 * Return: void 1779 */ 1780 static inline 1781 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 1782 void *ni, int force) 1783 { 1784 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 1785 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(ni, force); 1786 } 1787 1788 /* cdp_peer_map_attach() - CDP API to allocate PEER map memory 1789 * @soc: opaque soc handle 1790 * @max_peers: number of peers created in FW 1791 * @peer_map_unmap_v2: flag indicates HTT peer map v2 is enabled in FW 1792 * 1793 * 1794 * Return: void 1795 */ 1796 static inline void 1797 cdp_peer_map_attach(ol_txrx_soc_handle soc, uint32_t max_peers, 1798 bool peer_map_unmap_v2) 1799 { 1800 if (soc && soc->ops && soc->ops->cmn_drv_ops && 1801 soc->ops->cmn_drv_ops->txrx_peer_map_attach) 1802 soc->ops->cmn_drv_ops->txrx_peer_map_attach(soc, max_peers, 1803 peer_map_unmap_v2); 1804 } 1805 1806 /** 1807 1808 * cdp_pdev_set_ctrl_pdev() - set UMAC ctrl pdev to dp pdev 1809 * @soc: opaque soc handle 1810 * @pdev: opaque dp pdev handle 1811 * @ctrl_pdev: opaque ctrl pdev handle 1812 * 1813 * Return: void 1814 */ 1815 static inline void 1816 cdp_pdev_set_ctrl_pdev(ol_txrx_soc_handle soc, struct cdp_pdev *dp_pdev, 1817 struct cdp_ctrl_objmgr_pdev *ctrl_pdev) 1818 { 1819 if (soc && soc->ops && soc->ops->cmn_drv_ops && 1820 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev) 1821 soc->ops->cmn_drv_ops->txrx_pdev_set_ctrl_pdev(dp_pdev, 1822 ctrl_pdev); 1823 } 1824 1825 /* cdp_txrx_classify_and_update() - To classify the packet and update stats 1826 * @soc: opaque soc handle 1827 * @vdev: opaque dp vdev handle 1828 * @skb: data 1829 * @dir: rx or tx packet 1830 * @nbuf_classify: packet classification object 1831 * 1832 * Return: 1 on success else return 0 1833 */ 1834 static inline int 1835 cdp_txrx_classify_and_update(ol_txrx_soc_handle soc, 1836 struct cdp_vdev *vdev, qdf_nbuf_t skb, 1837 enum txrx_direction dir, 1838 struct ol_txrx_nbuf_classify *nbuf_class) 1839 { 1840 if (!soc || !soc->ops) { 1841 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1842 "%s: Invalid Instance", __func__); 1843 QDF_BUG(0); 1844 return 0; 1845 } 1846 1847 if (!soc->ops->cmn_drv_ops || 1848 !soc->ops->cmn_drv_ops->txrx_classify_update) 1849 return 0; 1850 1851 return soc->ops->cmn_drv_ops->txrx_classify_update(vdev, 1852 skb, 1853 dir, nbuf_class); 1854 } 1855 1856 #ifdef RECEIVE_OFFLOAD 1857 /** 1858 * cdp_register_rx_offld_flush_cb() - register LRO/GRO flush cb function pointer 1859 * @soc - data path soc handle 1860 * @pdev - device instance pointer 1861 * 1862 * register rx offload flush callback function pointer 1863 * 1864 * return none 1865 */ 1866 static inline void cdp_register_rx_offld_flush_cb(ol_txrx_soc_handle soc, 1867 void (rx_ol_flush_cb)(void *)) 1868 { 1869 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 1870 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 1871 "%s invalid instance", __func__); 1872 return; 1873 } 1874 1875 if (soc->ops->rx_offld_ops->register_rx_offld_flush_cb) 1876 return soc->ops->rx_offld_ops->register_rx_offld_flush_cb( 1877 rx_ol_flush_cb); 1878 } 1879 1880 /** 1881 * cdp_deregister_rx_offld_flush_cb() - deregister Rx offld flush cb function 1882 * @soc - data path soc handle 1883 * 1884 * deregister rx offload flush callback function pointer 1885 * 1886 * return none 1887 */ 1888 static inline void cdp_deregister_rx_offld_flush_cb(ol_txrx_soc_handle soc) 1889 { 1890 if (!soc || !soc->ops || !soc->ops->rx_offld_ops) { 1891 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, 1892 "%s invalid instance", __func__); 1893 return; 1894 } 1895 1896 if (soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb) 1897 return soc->ops->rx_offld_ops->deregister_rx_offld_flush_cb(); 1898 } 1899 #endif /* RECEIVE_OFFLOAD */ 1900 1901 /** 1902 * @cdp_set_ba_timeout() - set ba aging timeout per AC 1903 * 1904 * @soc - pointer to the soc 1905 * @value - timeout value in millisec 1906 * @ac - Access category 1907 * 1908 * @return - void 1909 */ 1910 static inline void cdp_set_ba_timeout(ol_txrx_soc_handle soc, 1911 uint8_t ac, uint32_t value) 1912 { 1913 if (!soc || !soc->ops) { 1914 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1915 "%s: Invalid Instance", __func__); 1916 QDF_BUG(0); 1917 return; 1918 } 1919 1920 if (!soc->ops->cmn_drv_ops || 1921 !soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout) 1922 return; 1923 1924 soc->ops->cmn_drv_ops->txrx_set_ba_aging_timeout(soc, ac, value); 1925 } 1926 1927 /** 1928 * @cdp_get_ba_timeout() - return ba aging timeout per AC 1929 * 1930 * @soc - pointer to the soc 1931 * @ac - access category 1932 * @value - timeout value in millisec 1933 * 1934 * @return - void 1935 */ 1936 static inline void cdp_get_ba_timeout(ol_txrx_soc_handle soc, 1937 uint8_t ac, uint32_t *value) 1938 { 1939 if (!soc || !soc->ops) { 1940 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1941 "%s: Invalid Instance", __func__); 1942 QDF_BUG(0); 1943 return; 1944 } 1945 1946 if (!soc->ops->cmn_drv_ops || 1947 !soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout) 1948 return; 1949 1950 soc->ops->cmn_drv_ops->txrx_get_ba_aging_timeout(soc, ac, value); 1951 } 1952 #endif /* _CDP_TXRX_CMN_H_ */ 1953