1 /* 2 * Copyright (c) 2011-2018 The Linux Foundation. All rights reserved. 3 * 4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc. 5 * 6 * 7 * Permission to use, copy, modify, and/or distribute this software for 8 * any purpose with or without fee is hereby granted, provided that the 9 * above copyright notice and this permission notice appear in all 10 * copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 19 * PERFORMANCE OF THIS SOFTWARE. 20 */ 21 22 /* 23 * This file was originally distributed by Qualcomm Atheros, Inc. 24 * under proprietary terms before Copyright ownership was assigned 25 * to the Linux Foundation. 26 */ 27 /** 28 * @file cdp_txrx_cmn.h 29 * @brief Define the host data path converged API functions 30 * called by the host control SW and the OS interface module 31 */ 32 #ifndef _CDP_TXRX_CMN_H_ 33 #define _CDP_TXRX_CMN_H_ 34 35 #include "qdf_types.h" 36 #include "qdf_nbuf.h" 37 #include "cdp_txrx_ops.h" 38 #include "cdp_txrx_handle.h" 39 #include "cdp_txrx_cmn_struct.h" 40 /****************************************************************************** 41 * 42 * Common Data Path Header File 43 * 44 *****************************************************************************/ 45 46 static inline int 47 cdp_soc_attach_target(ol_txrx_soc_handle soc) 48 { 49 if (!soc || !soc->ops) { 50 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 51 "%s: Invalid Instance:", __func__); 52 QDF_BUG(0); 53 return 0; 54 } 55 56 if (!soc->ops->cmn_drv_ops || 57 !soc->ops->cmn_drv_ops->txrx_soc_attach_target) 58 return 0; 59 60 return soc->ops->cmn_drv_ops->txrx_soc_attach_target(soc); 61 62 } 63 64 static inline int 65 cdp_soc_get_nss_cfg(ol_txrx_soc_handle soc) 66 { 67 if (!soc || !soc->ops) { 68 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 69 "%s: Invalid Instance:", __func__); 70 QDF_BUG(0); 71 return 0; 72 } 73 74 if (!soc->ops->cmn_drv_ops || 75 !soc->ops->cmn_drv_ops->txrx_soc_get_nss_cfg) 76 return 0; 77 78 return soc->ops->cmn_drv_ops->txrx_soc_get_nss_cfg(soc); 79 } 80 81 static inline void 82 cdp_soc_set_nss_cfg(ol_txrx_soc_handle soc, uint32_t config) 83 { 84 if (!soc || !soc->ops) { 85 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 86 "%s: Invalid Instance:", __func__); 87 QDF_BUG(0); 88 return; 89 } 90 91 if (!soc->ops->cmn_drv_ops || 92 !soc->ops->cmn_drv_ops->txrx_soc_set_nss_cfg) 93 return; 94 95 soc->ops->cmn_drv_ops->txrx_soc_set_nss_cfg(soc, config); 96 } 97 98 static inline struct cdp_vdev * 99 cdp_vdev_attach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 100 uint8_t *vdev_mac_addr, uint8_t vdev_id, enum wlan_op_mode op_mode) 101 { 102 if (!soc || !soc->ops) { 103 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 104 "%s: Invalid Instance:", __func__); 105 QDF_BUG(0); 106 return NULL; 107 } 108 109 if (!soc->ops->cmn_drv_ops || 110 !soc->ops->cmn_drv_ops->txrx_vdev_attach) 111 return NULL; 112 113 return soc->ops->cmn_drv_ops->txrx_vdev_attach(pdev, 114 vdev_mac_addr, vdev_id, op_mode); 115 } 116 117 static inline void 118 cdp_vdev_detach(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 119 ol_txrx_vdev_delete_cb callback, void *cb_context) 120 { 121 if (!soc || !soc->ops) { 122 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 123 "%s: Invalid Instance:", __func__); 124 QDF_BUG(0); 125 return; 126 } 127 128 if (!soc->ops->cmn_drv_ops || 129 !soc->ops->cmn_drv_ops->txrx_vdev_detach) 130 return; 131 132 soc->ops->cmn_drv_ops->txrx_vdev_detach(vdev, 133 callback, cb_context); 134 } 135 136 static inline int 137 cdp_pdev_attach_target(ol_txrx_soc_handle soc, struct cdp_pdev *pdev) 138 { 139 if (!soc || !soc->ops) { 140 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 141 "%s: Invalid Instance:", __func__); 142 QDF_BUG(0); 143 return 0; 144 } 145 146 if (!soc->ops->cmn_drv_ops || 147 !soc->ops->cmn_drv_ops->txrx_pdev_attach_target) 148 return 0; 149 150 return soc->ops->cmn_drv_ops->txrx_pdev_attach_target(pdev); 151 } 152 153 static inline struct cdp_pdev *cdp_pdev_attach 154 (ol_txrx_soc_handle soc, struct cdp_cfg *ctrl_pdev, 155 HTC_HANDLE htc_pdev, qdf_device_t osdev, uint8_t pdev_id) 156 { 157 if (!soc || !soc->ops) { 158 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 159 "%s: Invalid Instance:", __func__); 160 QDF_BUG(0); 161 return NULL; 162 } 163 164 if (!soc->ops->cmn_drv_ops || 165 !soc->ops->cmn_drv_ops->txrx_pdev_attach) 166 return NULL; 167 168 return soc->ops->cmn_drv_ops->txrx_pdev_attach(soc, ctrl_pdev, 169 htc_pdev, osdev, pdev_id); 170 } 171 172 static inline int cdp_pdev_post_attach(ol_txrx_soc_handle soc, 173 struct cdp_pdev *pdev) 174 { 175 if (!soc || !soc->ops) { 176 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 177 "%s: Invalid Instance:", __func__); 178 QDF_BUG(0); 179 return 0; 180 } 181 182 if (!soc->ops->cmn_drv_ops || 183 !soc->ops->cmn_drv_ops->txrx_pdev_post_attach) 184 return 0; 185 186 return soc->ops->cmn_drv_ops->txrx_pdev_post_attach(pdev); 187 } 188 189 static inline void 190 cdp_pdev_pre_detach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, int force) 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; 197 } 198 199 if (!soc->ops->cmn_drv_ops || 200 !soc->ops->cmn_drv_ops->txrx_pdev_pre_detach) 201 return; 202 203 soc->ops->cmn_drv_ops->txrx_pdev_pre_detach(pdev, force); 204 } 205 206 static inline void 207 cdp_pdev_detach(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, int force) 208 { 209 if (!soc || !soc->ops) { 210 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 211 "%s: Invalid Instance:", __func__); 212 QDF_BUG(0); 213 return; 214 } 215 216 if (!soc->ops->cmn_drv_ops || 217 !soc->ops->cmn_drv_ops->txrx_pdev_detach) 218 return; 219 220 soc->ops->cmn_drv_ops->txrx_pdev_detach(pdev, force); 221 } 222 223 static inline void *cdp_peer_create 224 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 225 uint8_t *peer_mac_addr) 226 { 227 if (!soc || !soc->ops) { 228 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 229 "%s: Invalid Instance:", __func__); 230 QDF_BUG(0); 231 return NULL; 232 } 233 234 if (!soc->ops->cmn_drv_ops || 235 !soc->ops->cmn_drv_ops->txrx_peer_create) 236 return NULL; 237 238 return soc->ops->cmn_drv_ops->txrx_peer_create(vdev, 239 peer_mac_addr); 240 } 241 242 static inline void cdp_peer_setup 243 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, void *peer) 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_peer_setup) 254 return; 255 256 soc->ops->cmn_drv_ops->txrx_peer_setup(vdev, 257 peer); 258 } 259 260 static inline int cdp_peer_add_ast 261 (ol_txrx_soc_handle soc, struct cdp_peer *peer_handle, 262 uint8_t *mac_addr, enum cdp_txrx_ast_entry_type type, uint32_t flags) 263 { 264 if (!soc || !soc->ops) { 265 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 266 "%s: Invalid Instance:", __func__); 267 QDF_BUG(0); 268 return 0; 269 } 270 271 if (!soc->ops->cmn_drv_ops || 272 !soc->ops->cmn_drv_ops->txrx_peer_add_ast) 273 return 0; 274 275 return soc->ops->cmn_drv_ops->txrx_peer_add_ast(soc, 276 peer_handle, 277 mac_addr, 278 type, 279 flags); 280 } 281 282 static inline int cdp_peer_update_ast 283 (ol_txrx_soc_handle soc, void *ast_handle, 284 struct cdp_peer *peer_handle, uint32_t flags) 285 { 286 if (!soc || !soc->ops) { 287 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 288 "%s: Invalid Instance:", __func__); 289 QDF_BUG(0); 290 return 0; 291 } 292 293 if (!soc->ops->cmn_drv_ops || 294 !soc->ops->cmn_drv_ops->txrx_peer_update_ast) 295 return 0; 296 297 return soc->ops->cmn_drv_ops->txrx_peer_update_ast(soc, 298 peer_handle, 299 ast_handle, 300 flags); 301 } 302 303 static inline void cdp_peer_del_ast 304 (ol_txrx_soc_handle soc, void *ast_handle) 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_peer_del_ast) 315 return; 316 317 soc->ops->cmn_drv_ops->txrx_peer_del_ast(soc, ast_handle); 318 } 319 320 static inline void *cdp_peer_ast_hash_find 321 (ol_txrx_soc_handle soc, uint8_t *ast_mac_addr) 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 NULL; 328 } 329 330 if (!soc->ops->cmn_drv_ops || 331 !soc->ops->cmn_drv_ops->txrx_peer_ast_hash_find) 332 return NULL; 333 334 return soc->ops->cmn_drv_ops->txrx_peer_ast_hash_find(soc, 335 ast_mac_addr); 336 } 337 338 static inline uint8_t cdp_peer_ast_get_pdev_id 339 (ol_txrx_soc_handle soc, void *ast_handle) 340 { 341 if (!soc || !soc->ops) { 342 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 343 "%s: Invalid Instance:", __func__); 344 QDF_BUG(0); 345 return 0xff; 346 } 347 348 if (!soc->ops->cmn_drv_ops || 349 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_pdev_id) 350 return 0xff; 351 352 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_pdev_id(soc, 353 ast_handle); 354 } 355 356 static inline uint8_t cdp_peer_ast_get_next_hop 357 (ol_txrx_soc_handle soc, void *ast_handle) 358 { 359 if (!soc || !soc->ops) { 360 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 361 "%s: Invalid Instance:", __func__); 362 QDF_BUG(0); 363 return 0xff; 364 } 365 366 if (!soc->ops->cmn_drv_ops || 367 !soc->ops->cmn_drv_ops->txrx_peer_ast_get_next_hop) 368 return 0xff; 369 370 return soc->ops->cmn_drv_ops->txrx_peer_ast_get_next_hop(soc, 371 ast_handle); 372 } 373 374 static inline void cdp_peer_ast_set_type 375 (ol_txrx_soc_handle soc, void *ast_handle, 376 enum cdp_txrx_ast_entry_type type) 377 { 378 if (!soc || !soc->ops) { 379 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 380 "%s: Invalid Instance:", __func__); 381 QDF_BUG(0); 382 return; 383 } 384 385 if (!soc->ops->cmn_drv_ops || 386 !soc->ops->cmn_drv_ops->txrx_peer_ast_set_type) 387 return; 388 389 soc->ops->cmn_drv_ops->txrx_peer_ast_set_type(soc, ast_handle, type); 390 } 391 392 static inline void cdp_peer_teardown 393 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev, void *peer) 394 { 395 if (!soc || !soc->ops) { 396 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 397 "%s: Invalid Instance:", __func__); 398 QDF_BUG(0); 399 return; 400 } 401 402 if (!soc->ops->cmn_drv_ops || 403 !soc->ops->cmn_drv_ops->txrx_peer_teardown) 404 return; 405 406 soc->ops->cmn_drv_ops->txrx_peer_teardown(vdev, peer); 407 } 408 409 static inline void 410 cdp_peer_delete(ol_txrx_soc_handle soc, void *peer, uint32_t bitmap) 411 { 412 if (!soc || !soc->ops) { 413 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 414 "%s: Invalid Instance:", __func__); 415 QDF_BUG(0); 416 return; 417 } 418 419 if (!soc->ops->cmn_drv_ops || 420 !soc->ops->cmn_drv_ops->txrx_peer_delete) 421 return; 422 423 soc->ops->cmn_drv_ops->txrx_peer_delete(peer, bitmap); 424 } 425 426 static inline int 427 cdp_set_monitor_mode(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 428 uint8_t smart_monitor) 429 { 430 if (!soc || !soc->ops) { 431 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 432 "%s: Invalid Instance:", __func__); 433 QDF_BUG(0); 434 return 0; 435 } 436 437 if (!soc->ops->cmn_drv_ops || 438 !soc->ops->cmn_drv_ops->txrx_set_monitor_mode) 439 return 0; 440 441 return soc->ops->cmn_drv_ops->txrx_set_monitor_mode(vdev, 442 smart_monitor); 443 } 444 445 static inline void 446 cdp_set_curchan(ol_txrx_soc_handle soc, 447 struct cdp_pdev *pdev, 448 uint32_t chan_mhz) 449 { 450 if (!soc || !soc->ops) { 451 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 452 "%s: Invalid Instance:", __func__); 453 QDF_BUG(0); 454 return; 455 } 456 457 if (!soc->ops->cmn_drv_ops || 458 !soc->ops->cmn_drv_ops->txrx_set_curchan) 459 return; 460 461 soc->ops->cmn_drv_ops->txrx_set_curchan(pdev, chan_mhz); 462 } 463 464 static inline void 465 cdp_set_privacy_filters(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 466 void *filter, uint32_t num) 467 { 468 if (!soc || !soc->ops) { 469 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 470 "%s: Invalid Instance:", __func__); 471 QDF_BUG(0); 472 return; 473 } 474 475 if (!soc->ops->cmn_drv_ops || 476 !soc->ops->cmn_drv_ops->txrx_set_privacy_filters) 477 return; 478 479 soc->ops->cmn_drv_ops->txrx_set_privacy_filters(vdev, 480 filter, num); 481 } 482 483 static inline int 484 cdp_set_monitor_filter(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 485 struct cdp_monitor_filter *filter_val) 486 { 487 if (soc->ops->mon_ops->txrx_set_advance_monitor_filter) 488 return soc->ops->mon_ops->txrx_set_advance_monitor_filter(pdev, 489 filter_val); 490 return 0; 491 } 492 493 494 /****************************************************************************** 495 * Data Interface (B Interface) 496 *****************************************************************************/ 497 static inline void 498 cdp_vdev_register(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 499 void *osif_vdev, struct ol_txrx_ops *txrx_ops) 500 { 501 if (!soc || !soc->ops) { 502 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 503 "%s: Invalid Instance:", __func__); 504 QDF_BUG(0); 505 return; 506 } 507 508 if (!soc->ops->cmn_drv_ops || 509 !soc->ops->cmn_drv_ops->txrx_vdev_register) 510 return; 511 512 soc->ops->cmn_drv_ops->txrx_vdev_register(vdev, 513 osif_vdev, txrx_ops); 514 } 515 516 static inline int 517 cdp_mgmt_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 518 qdf_nbuf_t tx_mgmt_frm, uint8_t type) 519 { 520 if (!soc || !soc->ops) { 521 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 522 "%s: Invalid Instance:", __func__); 523 QDF_BUG(0); 524 return 0; 525 } 526 527 if (!soc->ops->cmn_drv_ops || 528 !soc->ops->cmn_drv_ops->txrx_mgmt_send) 529 return 0; 530 531 return soc->ops->cmn_drv_ops->txrx_mgmt_send(vdev, 532 tx_mgmt_frm, type); 533 } 534 535 static inline int 536 cdp_mgmt_send_ext(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 537 qdf_nbuf_t tx_mgmt_frm, uint8_t type, 538 uint8_t use_6mbps, uint16_t chanfreq) 539 { 540 if (!soc || !soc->ops) { 541 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 542 "%s: Invalid Instance:", __func__); 543 QDF_BUG(0); 544 return 0; 545 } 546 547 if (!soc->ops->cmn_drv_ops || 548 !soc->ops->cmn_drv_ops->txrx_mgmt_send_ext) 549 return 0; 550 551 return soc->ops->cmn_drv_ops->txrx_mgmt_send_ext 552 (vdev, tx_mgmt_frm, type, use_6mbps, chanfreq); 553 } 554 555 556 static inline void 557 cdp_mgmt_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 558 uint8_t type, ol_txrx_mgmt_tx_cb download_cb, 559 ol_txrx_mgmt_tx_cb ota_ack_cb, void *ctxt) 560 { 561 if (!soc || !soc->ops) { 562 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 563 "%s: Invalid Instance:", __func__); 564 QDF_BUG(0); 565 return; 566 } 567 568 if (!soc->ops->cmn_drv_ops || 569 !soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set) 570 return; 571 572 soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set 573 (pdev, type, download_cb, ota_ack_cb, ctxt); 574 } 575 576 static inline int cdp_get_tx_pending(ol_txrx_soc_handle soc, 577 struct cdp_pdev *pdev) 578 { 579 if (!soc || !soc->ops) { 580 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 581 "%s: Invalid Instance:", __func__); 582 QDF_BUG(0); 583 return 0; 584 } 585 586 if (!soc->ops->cmn_drv_ops || 587 !soc->ops->cmn_drv_ops->txrx_get_tx_pending) 588 return 0; 589 590 591 return soc->ops->cmn_drv_ops->txrx_get_tx_pending(pdev); 592 } 593 594 static inline void 595 cdp_data_tx_cb_set(ol_txrx_soc_handle soc, struct cdp_vdev *data_vdev, 596 ol_txrx_data_tx_cb callback, void *ctxt) 597 { 598 if (!soc || !soc->ops) { 599 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 600 "%s: Invalid Instance:", __func__); 601 QDF_BUG(0); 602 return; 603 } 604 605 if (!soc->ops->cmn_drv_ops || 606 !soc->ops->cmn_drv_ops->txrx_data_tx_cb_set) 607 return; 608 609 soc->ops->cmn_drv_ops->txrx_data_tx_cb_set(data_vdev, 610 callback, ctxt); 611 } 612 613 /****************************************************************************** 614 * Statistics and Debugging Interface (C Inteface) 615 *****************************************************************************/ 616 /** 617 * External Device physical address types 618 * 619 * Currently, both MAC and IPA uController use the same size addresses 620 * and descriptors are exchanged between these two depending on the mode. 621 * 622 * Rationale: qdf_dma_addr_t is the type used internally on the host for DMA 623 * operations. However, external device physical address sizes 624 * may be different from host-specific physical address sizes. 625 * This calls for the following definitions for target devices 626 * (MAC, IPA uc). 627 */ 628 #if HTT_PADDR64 629 typedef uint64_t target_paddr_t; 630 #else 631 typedef uint32_t target_paddr_t; 632 #endif /*HTT_PADDR64 */ 633 634 static inline int 635 cdp_aggr_cfg(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 636 int max_subfrms_ampdu, 637 int max_subfrms_amsdu) 638 { 639 if (!soc || !soc->ops) { 640 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 641 "%s: Invalid Instance:", __func__); 642 QDF_BUG(0); 643 return 0; 644 } 645 646 if (!soc->ops->cmn_drv_ops || 647 !soc->ops->cmn_drv_ops->txrx_aggr_cfg) 648 return 0; 649 650 return soc->ops->cmn_drv_ops->txrx_aggr_cfg(vdev, 651 max_subfrms_ampdu, max_subfrms_amsdu); 652 } 653 654 static inline int 655 cdp_fw_stats_get(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 656 struct ol_txrx_stats_req *req, bool per_vdev, 657 bool response_expected) 658 { 659 if (!soc || !soc->ops) { 660 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 661 "%s: Invalid Instance:", __func__); 662 QDF_BUG(0); 663 return 0; 664 } 665 666 if (!soc->ops->cmn_drv_ops || 667 !soc->ops->cmn_drv_ops->txrx_fw_stats_get) 668 return 0; 669 670 return soc->ops->cmn_drv_ops->txrx_fw_stats_get(vdev, req, 671 per_vdev, response_expected); 672 } 673 674 static inline int 675 cdp_debug(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, int debug_specs) 676 { 677 if (!soc || !soc->ops) { 678 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 679 "%s: Invalid Instance:", __func__); 680 QDF_BUG(0); 681 return 0; 682 } 683 684 if (!soc->ops->cmn_drv_ops || 685 !soc->ops->cmn_drv_ops->txrx_debug) 686 return 0; 687 688 return soc->ops->cmn_drv_ops->txrx_debug(vdev, debug_specs); 689 } 690 691 static inline void cdp_fw_stats_cfg(ol_txrx_soc_handle soc, 692 struct cdp_vdev *vdev, uint8_t cfg_stats_type, uint32_t cfg_val) 693 { 694 if (!soc || !soc->ops) { 695 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 696 "%s: Invalid Instance:", __func__); 697 QDF_BUG(0); 698 return; 699 } 700 701 if (!soc->ops->cmn_drv_ops || 702 !soc->ops->cmn_drv_ops->txrx_fw_stats_cfg) 703 return; 704 705 soc->ops->cmn_drv_ops->txrx_fw_stats_cfg(vdev, 706 cfg_stats_type, cfg_val); 707 } 708 709 static inline void cdp_print_level_set(ol_txrx_soc_handle soc, unsigned level) 710 { 711 if (!soc || !soc->ops) { 712 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 713 "%s: Invalid Instance:", __func__); 714 QDF_BUG(0); 715 return; 716 } 717 718 if (!soc->ops->cmn_drv_ops || 719 !soc->ops->cmn_drv_ops->txrx_print_level_set) 720 return; 721 722 soc->ops->cmn_drv_ops->txrx_print_level_set(level); 723 } 724 725 static inline uint8_t * 726 cdp_get_vdev_mac_addr(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 727 { 728 if (!soc || !soc->ops) { 729 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 730 "%s: Invalid Instance:", __func__); 731 QDF_BUG(0); 732 return NULL; 733 } 734 735 if (!soc->ops->cmn_drv_ops || 736 !soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr) 737 return NULL; 738 739 return soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr(vdev); 740 741 } 742 743 /** 744 * cdp_get_vdev_struct_mac_addr() - Return handle to struct qdf_mac_addr of 745 * vdev 746 * @vdev: vdev handle 747 * 748 * Return: Handle to struct qdf_mac_addr 749 */ 750 static inline struct qdf_mac_addr *cdp_get_vdev_struct_mac_addr 751 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 752 { 753 if (!soc || !soc->ops) { 754 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 755 "%s: Invalid Instance:", __func__); 756 QDF_BUG(0); 757 return NULL; 758 } 759 760 if (!soc->ops->cmn_drv_ops || 761 !soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr) 762 return NULL; 763 764 return soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr 765 (vdev); 766 767 } 768 769 /** 770 * cdp_get_pdev_from_vdev() - Return handle to pdev of vdev 771 * @vdev: vdev handle 772 * 773 * Return: Handle to pdev 774 */ 775 static inline struct cdp_pdev *cdp_get_pdev_from_vdev 776 (ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 777 { 778 if (!soc || !soc->ops) { 779 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 780 "%s: Invalid Instance:", __func__); 781 QDF_BUG(0); 782 return NULL; 783 } 784 785 if (!soc->ops->cmn_drv_ops || 786 !soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev) 787 return NULL; 788 789 return soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev(vdev); 790 } 791 792 /** 793 * cdp_get_ctrl_pdev_from_vdev() - Return control pdev of vdev 794 * @vdev: vdev handle 795 * 796 * Return: Handle to control pdev 797 */ 798 static inline struct cdp_cfg * 799 cdp_get_ctrl_pdev_from_vdev(ol_txrx_soc_handle soc, struct cdp_vdev *vdev) 800 { 801 if (!soc || !soc->ops) { 802 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 803 "%s: Invalid Instance:", __func__); 804 QDF_BUG(0); 805 return NULL; 806 } 807 808 if (!soc->ops->cmn_drv_ops || 809 !soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev) 810 return NULL; 811 812 return soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev 813 (vdev); 814 } 815 816 static inline struct cdp_vdev * 817 cdp_get_vdev_from_vdev_id(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, 818 uint8_t vdev_id) 819 { 820 if (!soc || !soc->ops) { 821 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 822 "%s: Invalid Instance:", __func__); 823 QDF_BUG(0); 824 return NULL; 825 } 826 827 if (!soc->ops->cmn_drv_ops || 828 !soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id) 829 return NULL; 830 831 return soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id 832 (pdev, vdev_id); 833 } 834 835 static inline void 836 cdp_soc_detach(ol_txrx_soc_handle soc) 837 { 838 if (!soc || !soc->ops) { 839 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 840 "%s: Invalid Instance:", __func__); 841 QDF_BUG(0); 842 return; 843 } 844 845 if (!soc->ops->cmn_drv_ops || 846 !soc->ops->cmn_drv_ops->txrx_soc_detach) 847 return; 848 849 soc->ops->cmn_drv_ops->txrx_soc_detach((void *)soc); 850 } 851 852 static inline int cdp_addba_requestprocess(ol_txrx_soc_handle soc, 853 void *peer_handle, uint8_t dialogtoken, uint16_t tid, 854 uint16_t batimeout, uint16_t buffersize, uint16_t startseqnum) 855 { 856 if (!soc || !soc->ops) { 857 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 858 "%s: Invalid Instance:", __func__); 859 QDF_BUG(0); 860 return 0; 861 } 862 863 if (!soc->ops->cmn_drv_ops || 864 !soc->ops->cmn_drv_ops->addba_requestprocess) 865 return 0; 866 867 return soc->ops->cmn_drv_ops->addba_requestprocess(peer_handle, 868 dialogtoken, tid, batimeout, buffersize, startseqnum); 869 } 870 871 static inline void cdp_addba_responsesetup(ol_txrx_soc_handle soc, 872 void *peer_handle, uint8_t tid, uint8_t *dialogtoken, 873 uint16_t *statuscode, uint16_t *buffersize, uint16_t *batimeout) 874 { 875 if (!soc || !soc->ops) { 876 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 877 "%s: Invalid Instance:", __func__); 878 QDF_BUG(0); 879 return; 880 } 881 882 if (!soc->ops->cmn_drv_ops || 883 !soc->ops->cmn_drv_ops->addba_responsesetup) 884 return; 885 886 soc->ops->cmn_drv_ops->addba_responsesetup(peer_handle, tid, 887 dialogtoken, statuscode, buffersize, batimeout); 888 } 889 890 static inline int cdp_delba_process(ol_txrx_soc_handle soc, 891 void *peer_handle, int tid, uint16_t reasoncode) 892 { 893 if (!soc || !soc->ops) { 894 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 895 "%s: Invalid Instance:", __func__); 896 QDF_BUG(0); 897 return 0; 898 } 899 900 if (!soc->ops->cmn_drv_ops || 901 !soc->ops->cmn_drv_ops->delba_process) 902 return 0; 903 904 return soc->ops->cmn_drv_ops->delba_process(peer_handle, 905 tid, reasoncode); 906 } 907 908 static inline void cdp_set_addbaresponse(ol_txrx_soc_handle soc, 909 void *peer_handle, int tid, uint16_t statuscode) 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; 916 } 917 918 if (!soc->ops->cmn_drv_ops || 919 !soc->ops->cmn_drv_ops->set_addba_response) 920 return; 921 922 soc->ops->cmn_drv_ops->set_addba_response(peer_handle, tid, statuscode); 923 } 924 925 /** 926 * cdp_get_peer_mac_addr_frm_id: function to return vdev id and and peer 927 * mac address 928 * @soc: SOC handle 929 * @peer_id: peer id of the peer for which mac_address is required 930 * @mac_addr: reference to mac address 931 * 932 * reutm: vdev_id of the vap 933 */ 934 static inline uint8_t 935 cdp_get_peer_mac_addr_frm_id(ol_txrx_soc_handle soc, uint16_t peer_id, 936 uint8_t *mac_addr) 937 { 938 if (!soc || !soc->ops) { 939 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 940 "%s: Invalid Instance:", __func__); 941 QDF_BUG(0); 942 return CDP_INVALID_VDEV_ID; 943 } 944 945 if (!soc->ops->cmn_drv_ops || 946 !soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id) 947 return CDP_INVALID_VDEV_ID; 948 949 return soc->ops->cmn_drv_ops->get_peer_mac_addr_frm_id(soc, 950 peer_id, mac_addr); 951 } 952 953 /** 954 * cdp_set_vdev_dscp_tid_map(): function to set DSCP-tid map in the vap 955 * @vdev: vdev handle 956 * @map_id: id of the tid map 957 * 958 * Return: void 959 */ 960 static inline void cdp_set_vdev_dscp_tid_map(ol_txrx_soc_handle soc, 961 struct cdp_vdev *vdev, uint8_t map_id) 962 { 963 if (!soc || !soc->ops) { 964 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 965 "%s: Invalid Instance:", __func__); 966 QDF_BUG(0); 967 return; 968 } 969 970 if (!soc->ops->cmn_drv_ops || 971 !soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map) 972 return; 973 974 soc->ops->cmn_drv_ops->set_vdev_dscp_tid_map(vdev, 975 map_id); 976 } 977 978 /** 979 * cdp_set_pdev_dscp_tid_map(): function to change tid values in DSCP-tid map 980 * @pdev: pdev handle 981 * @map_id: id of the tid map 982 * @tos: index value in map that needs to be changed 983 * @tid: tid value passed by user 984 * 985 * Return: void 986 */ 987 static inline void cdp_set_pdev_dscp_tid_map(ol_txrx_soc_handle soc, 988 struct cdp_pdev *pdev, uint8_t map_id, uint8_t tos, uint8_t tid) 989 { 990 if (!soc || !soc->ops) { 991 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 992 "%s: Invalid Instance:", __func__); 993 QDF_BUG(0); 994 return; 995 } 996 997 if (!soc->ops->cmn_drv_ops || 998 !soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map) 999 return; 1000 1001 soc->ops->cmn_drv_ops->set_pdev_dscp_tid_map(pdev, 1002 map_id, tos, tid); 1003 } 1004 1005 /** 1006 * cdp_flush_cache_rx_queue() - flush cache rx queue frame 1007 * 1008 * Return: None 1009 */ 1010 static inline void cdp_flush_cache_rx_queue(ol_txrx_soc_handle soc) 1011 { 1012 if (!soc || !soc->ops) { 1013 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1014 "%s: Invalid Instance:", __func__); 1015 QDF_BUG(0); 1016 return; 1017 } 1018 1019 if (!soc->ops->cmn_drv_ops || 1020 !soc->ops->cmn_drv_ops->flush_cache_rx_queue) 1021 return; 1022 soc->ops->cmn_drv_ops->flush_cache_rx_queue(); 1023 } 1024 1025 /** 1026 * cdp_txrx_stats_request(): function to map to host and firmware statistics 1027 * @soc: soc handle 1028 * @vdev: virtual device 1029 * @req: stats request container 1030 * 1031 * return: status 1032 */ 1033 static inline 1034 int cdp_txrx_stats_request(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, 1035 struct cdp_txrx_stats_req *req) 1036 { 1037 if (!soc || !soc->ops || !soc->ops->cmn_drv_ops || !req) { 1038 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1039 "%s: Invalid Instance:", __func__); 1040 QDF_ASSERT(0); 1041 return 0; 1042 } 1043 1044 if (soc->ops->cmn_drv_ops->txrx_stats_request) 1045 return soc->ops->cmn_drv_ops->txrx_stats_request(vdev, req); 1046 1047 return 0; 1048 } 1049 1050 /** 1051 * cdp_txrx_intr_attach(): function to attach and configure interrupt 1052 * @soc: soc handle 1053 */ 1054 static inline QDF_STATUS cdp_txrx_intr_attach(ol_txrx_soc_handle soc) 1055 { 1056 if (!soc || !soc->ops) { 1057 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1058 "%s: Invalid Instance:", __func__); 1059 QDF_BUG(0); 1060 return 0; 1061 } 1062 1063 if (!soc->ops->cmn_drv_ops || 1064 !soc->ops->cmn_drv_ops->txrx_intr_attach) 1065 return 0; 1066 1067 return soc->ops->cmn_drv_ops->txrx_intr_attach(soc); 1068 } 1069 1070 /** 1071 * cdp_txrx_intr_detach(): function to detach interrupt 1072 * @soc: soc handle 1073 */ 1074 static inline void cdp_txrx_intr_detach(ol_txrx_soc_handle soc) 1075 { 1076 if (!soc || !soc->ops) { 1077 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1078 "%s: Invalid Instance:", __func__); 1079 QDF_BUG(0); 1080 return; 1081 } 1082 1083 if (!soc->ops->cmn_drv_ops || 1084 !soc->ops->cmn_drv_ops->txrx_intr_detach) 1085 return; 1086 1087 soc->ops->cmn_drv_ops->txrx_intr_detach(soc); 1088 } 1089 1090 /** 1091 * cdp_display_stats(): function to map to dump stats 1092 * @soc: soc handle 1093 * @value: statistics option 1094 */ 1095 static inline QDF_STATUS 1096 cdp_display_stats(ol_txrx_soc_handle soc, uint16_t value, 1097 enum qdf_stats_verbosity_level level) 1098 { 1099 if (!soc || !soc->ops) { 1100 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1101 "%s: Invalid Instance:", __func__); 1102 QDF_BUG(0); 1103 return 0; 1104 } 1105 1106 if (!soc->ops->cmn_drv_ops || 1107 !soc->ops->cmn_drv_ops->display_stats) 1108 return 0; 1109 1110 return soc->ops->cmn_drv_ops->display_stats(soc, value, level); 1111 } 1112 1113 1114 /** 1115 * cdp_set_pn_check(): function to set pn check 1116 * @soc: soc handle 1117 * @sec_type: security type 1118 * #rx_pn: receive pn 1119 */ 1120 static inline int cdp_set_pn_check(ol_txrx_soc_handle soc, 1121 struct cdp_vdev *vdev, struct cdp_peer *peer_handle, enum cdp_sec_type sec_type, uint32_t *rx_pn) 1122 { 1123 if (!soc || !soc->ops) { 1124 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1125 "%s: Invalid Instance:", __func__); 1126 QDF_BUG(0); 1127 return 0; 1128 } 1129 1130 if (!soc->ops->cmn_drv_ops || 1131 !soc->ops->cmn_drv_ops->set_pn_check) 1132 return 0; 1133 1134 soc->ops->cmn_drv_ops->set_pn_check(vdev, peer_handle, 1135 sec_type, rx_pn); 1136 return 0; 1137 } 1138 1139 /** 1140 * cdp_update_config_parameters(): function to propagate configuration 1141 * parameters to datapath 1142 * @soc: opaque soc handle 1143 * @cfg: configuration handle 1144 * 1145 * Return: status: 0 - Success, non-zero: Failure 1146 */ 1147 static inline 1148 QDF_STATUS cdp_update_config_parameters(ol_txrx_soc_handle soc, 1149 struct cdp_config_params *cfg) 1150 { 1151 struct cdp_soc *psoc = (struct cdp_soc *)soc; 1152 1153 if (!soc || !soc->ops) { 1154 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1155 "%s: Invalid Instance:", __func__); 1156 QDF_BUG(0); 1157 return 0; 1158 } 1159 1160 if (!soc->ops->cmn_drv_ops || 1161 !soc->ops->cmn_drv_ops->update_config_parameters) 1162 return QDF_STATUS_SUCCESS; 1163 1164 return soc->ops->cmn_drv_ops->update_config_parameters(psoc, 1165 cfg); 1166 } 1167 1168 /** 1169 * cdp_pdev_get_dp_txrx_handle() - get advanced dp handle from pdev 1170 * @soc: opaque soc handle 1171 * @pdev: data path pdev handle 1172 * 1173 * Return: opaque dp handle 1174 */ 1175 static inline void * 1176 cdp_pdev_get_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev) 1177 { 1178 if (!soc || !soc->ops) { 1179 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1180 "%s: Invalid Instance:", __func__); 1181 QDF_BUG(0); 1182 return 0; 1183 } 1184 1185 if (soc->ops->cmn_drv_ops->get_dp_txrx_handle) 1186 return soc->ops->cmn_drv_ops->get_dp_txrx_handle(pdev); 1187 1188 return 0; 1189 } 1190 1191 /** 1192 * cdp_pdev_set_dp_txrx_handle() - set advanced dp handle in pdev 1193 * @soc: opaque soc handle 1194 * @pdev: data path pdev handle 1195 * @dp_hdl: opaque pointer for dp_txrx_handle 1196 * 1197 * Return: void 1198 */ 1199 static inline void 1200 cdp_pdev_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *pdev, void *dp_hdl) 1201 { 1202 if (!soc || !soc->ops) { 1203 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1204 "%s: Invalid Instance:", __func__); 1205 QDF_BUG(0); 1206 return; 1207 } 1208 1209 if (!soc->ops->cmn_drv_ops || 1210 !soc->ops->cmn_drv_ops->set_dp_txrx_handle) 1211 return; 1212 1213 soc->ops->cmn_drv_ops->set_dp_txrx_handle(pdev, dp_hdl); 1214 } 1215 1216 /* 1217 * cdp_soc_get_dp_txrx_handle() - get extended dp handle from soc 1218 * @soc: opaque soc handle 1219 * 1220 * Return: opaque extended dp handle 1221 */ 1222 static inline void * 1223 cdp_soc_get_dp_txrx_handle(ol_txrx_soc_handle soc) 1224 { 1225 if (!soc || !soc->ops) { 1226 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1227 "%s: Invalid Instance:", __func__); 1228 QDF_BUG(0); 1229 return NULL; 1230 } 1231 1232 if (soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle) 1233 return soc->ops->cmn_drv_ops->get_soc_dp_txrx_handle( 1234 (struct cdp_soc *) soc); 1235 1236 return NULL; 1237 } 1238 1239 /** 1240 * cdp_soc_set_dp_txrx_handle() - set advanced dp handle in soc 1241 * @soc: opaque soc handle 1242 * @dp_hdl: opaque pointer for dp_txrx_handle 1243 * 1244 * Return: void 1245 */ 1246 static inline void 1247 cdp_soc_set_dp_txrx_handle(ol_txrx_soc_handle soc, void *dp_handle) 1248 { 1249 if (!soc || !soc->ops) { 1250 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1251 "%s: Invalid Instance:", __func__); 1252 QDF_BUG(0); 1253 return; 1254 } 1255 1256 if (!soc->ops->cmn_drv_ops || 1257 !soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle) 1258 return; 1259 1260 soc->ops->cmn_drv_ops->set_soc_dp_txrx_handle((struct cdp_soc *)soc, 1261 dp_handle); 1262 } 1263 1264 /** 1265 * cdp_tx_send() - enqueue frame for transmission 1266 * @soc: soc opaque handle 1267 * @vdev: VAP device 1268 * @nbuf: nbuf to be enqueued 1269 * 1270 * This API is used by Extended Datapath modules to enqueue frame for 1271 * transmission 1272 * 1273 * Return: void 1274 */ 1275 static inline void 1276 cdp_tx_send(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, qdf_nbuf_t nbuf) 1277 { 1278 if (!soc || !soc->ops) { 1279 QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG, 1280 "%s: Invalid Instance:", __func__); 1281 QDF_BUG(0); 1282 return; 1283 } 1284 1285 if (!soc->ops->cmn_drv_ops || 1286 !soc->ops->cmn_drv_ops->tx_send) 1287 return; 1288 1289 soc->ops->cmn_drv_ops->tx_send(vdev, nbuf); 1290 } 1291 1292 /* 1293 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1294 * @soc: opaque soc handle 1295 * @pdev: data path pdev handle 1296 * 1297 * Return: pdev_id 1298 */ 1299 static inline 1300 uint8_t cdp_get_pdev_id_frm_pdev(ol_txrx_soc_handle soc, 1301 struct cdp_pdev *pdev) 1302 { 1303 if (soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev) 1304 return soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev(pdev); 1305 return 0; 1306 } 1307 1308 /** 1309 * cdp_set_nac() - set nac 1310 * @soc: opaque soc handle 1311 * @peer: data path peer handle 1312 * 1313 */ 1314 static inline 1315 void cdp_set_nac(ol_txrx_soc_handle soc, 1316 struct cdp_peer *peer) 1317 { 1318 if (soc->ops->cmn_drv_ops->txrx_set_nac) 1319 soc->ops->cmn_drv_ops->txrx_set_nac(peer); 1320 } 1321 1322 /** 1323 * cdp_set_pdev_tx_capture() - set pdev tx_capture 1324 * @soc: opaque soc handle 1325 * @pdev: data path pdev handle 1326 * @val: value of pdev_tx_capture 1327 * 1328 * Return: void 1329 */ 1330 static inline 1331 void cdp_set_pdev_tx_capture(ol_txrx_soc_handle soc, 1332 struct cdp_pdev *pdev, int val) 1333 { 1334 if (soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture) 1335 return soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture(pdev, 1336 val); 1337 1338 } 1339 1340 /** 1341 * cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id 1342 * @soc: opaque soc handle 1343 * @pdev: data path pdev handle 1344 * @peer_id: data path peer id 1345 * @peer_mac: peer_mac 1346 * 1347 * Return: void 1348 */ 1349 static inline 1350 void cdp_get_peer_mac_from_peer_id(ol_txrx_soc_handle soc, 1351 struct cdp_pdev *pdev_handle, 1352 uint32_t peer_id, uint8_t *peer_mac) 1353 { 1354 if (soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id) 1355 soc->ops->cmn_drv_ops->txrx_get_peer_mac_from_peer_id( 1356 pdev_handle, peer_id, peer_mac); 1357 } 1358 1359 /** 1360 * cdp_vdev_tx_lock() - acquire lock 1361 * @soc: opaque soc handle 1362 * @vdev: data path vdev handle 1363 * 1364 * Return: void 1365 */ 1366 static inline 1367 void cdp_vdev_tx_lock(ol_txrx_soc_handle soc, 1368 struct cdp_vdev *vdev) 1369 { 1370 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_lock) 1371 soc->ops->cmn_drv_ops->txrx_vdev_tx_lock(vdev); 1372 } 1373 1374 /** 1375 * cdp_vdev_tx_unlock() - release lock 1376 * @soc: opaque soc handle 1377 * @vdev: data path vdev handle 1378 * 1379 * Return: void 1380 */ 1381 static inline 1382 void cdp_vdev_tx_unlock(ol_txrx_soc_handle soc, 1383 struct cdp_vdev *vdev) 1384 { 1385 if (soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock) 1386 soc->ops->cmn_drv_ops->txrx_vdev_tx_unlock(vdev); 1387 } 1388 1389 /** 1390 * cdp_ath_getstats() - get updated athstats 1391 * @soc: opaque soc handle 1392 * @pdev: data path pdev handle 1393 * @net_device_stats: interface stats 1394 * @rtnl_link_stats64: device statistics structure 1395 * 1396 * Return: void 1397 */ 1398 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36) 1399 static inline void cdp_ath_getstats(ol_txrx_soc_handle soc, 1400 struct cdp_pdev *pdev, struct net_device_stats *stats) 1401 #else 1402 static inline void cdp_ath_getstats(ol_txrx_soc_handle soc, 1403 struct cdp_pdev *pdev, struct rtnl_link_stats64 *stats) 1404 #endif 1405 { 1406 if (soc && soc->ops && soc->ops->cmn_drv_ops->txrx_ath_getstats) 1407 soc->ops->cmn_drv_ops->txrx_ath_getstats(pdev, stats); 1408 } 1409 1410 /** 1411 * cdp_set_gid_flag() - set groupid flag 1412 * @soc: opaque soc handle 1413 * @pdev: data path pdev handle 1414 * @mem_status: member status from grp management frame 1415 * @user_position: user position from grp management frame 1416 * 1417 * Return: void 1418 */ 1419 static inline 1420 void cdp_set_gid_flag(ol_txrx_soc_handle soc, 1421 struct cdp_pdev *pdev, u_int8_t *mem_status, 1422 u_int8_t *user_position) 1423 { 1424 if (soc->ops->cmn_drv_ops->txrx_set_gid_flag) 1425 soc->ops->cmn_drv_ops->txrx_set_gid_flag(pdev, mem_status, user_position); 1426 } 1427 1428 /** 1429 * cdp_fw_supported_enh_stats_version() - returns the fw enhanced stats version 1430 * @soc: opaque soc handle 1431 * @pdev: data path pdev handle 1432 * 1433 */ 1434 static inline 1435 uint32_t cdp_fw_supported_enh_stats_version(ol_txrx_soc_handle soc, 1436 struct cdp_pdev *pdev) 1437 { 1438 if (soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version) 1439 return soc->ops->cmn_drv_ops->txrx_fw_supported_enh_stats_version(pdev); 1440 return 0; 1441 } 1442 1443 /** 1444 * cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev 1445 * @soc: opaque soc handle 1446 * @ni: associated node 1447 * @force: number of frame in SW queue 1448 * Return: void 1449 */ 1450 static inline 1451 void cdp_if_mgmt_drain(ol_txrx_soc_handle soc, 1452 void *ni, int force) 1453 { 1454 if (soc->ops->cmn_drv_ops->txrx_if_mgmt_drain) 1455 soc->ops->cmn_drv_ops->txrx_if_mgmt_drain(ni, force); 1456 } 1457 #endif /* _CDP_TXRX_CMN_H_ */ 1458